← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gretl/trusty-proposed

« back to all changes in this revision

Viewing changes to lib/src/printout.c

  • Committer: Package Import Robot
  • Author(s): Dirk Eddelbuettel
  • Date: 2011-10-17 18:16:33 UTC
  • mfrom: (1.1.27 upstream)
  • Revision ID: package-import@ubuntu.com-20111017181633-xdwbyapx5x26hd7i
Tags: 1.9.6-1
* New upstream release

* debian/control: Added libgtksourceview2.0-dev to Build-Depends:

* debian/libgretl1.shlibs: Updated to minor number 1
* libgretl1.lintian-overrides: Updated accordingly

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/src/printout.c
220
220
 
221
221
/**
222
222
 * max_obs_label_length:
223
 
 * @pdinfo: dataset information.
 
223
 * @dset: dataset information.
224
224
 *
225
225
 * Returns: the length of the longest observation label
226
226
 * within the current sample range.
227
227
 */
228
228
 
229
 
int max_obs_label_length (const DATAINFO *pdinfo)
 
229
int max_obs_label_length (const DATASET *dset)
230
230
{
231
231
    char s[OBSLEN];
232
232
    int t, n, nmax = 0;
233
233
 
234
 
    if (pdinfo->S != NULL) {
 
234
    if (dset->S != NULL) {
235
235
        /* we have specific observation strings */
236
 
        for (t=pdinfo->t1; t<=pdinfo->t2; t++) {
237
 
            get_obs_string(s, t, pdinfo);
 
236
        for (t=dset->t1; t<=dset->t2; t++) {
 
237
            get_obs_string(s, t, dset);
238
238
            n = g_utf8_strlen(s, -1);
239
239
            if (n > nmax) {
240
240
                nmax = n;
243
243
                break;
244
244
            }
245
245
        }
246
 
    } else if (dated_daily_data(pdinfo)) {
247
 
        get_obs_string(s, pdinfo->t2, pdinfo);
 
246
    } else if (dated_daily_data(dset)) {
 
247
        get_obs_string(s, dset->t2, dset);
248
248
        nmax = strlen(s);
249
 
    } else if (dataset_is_time_series(pdinfo)) {
250
 
        switch (pdinfo->pd) {
 
249
    } else if (dataset_is_time_series(dset)) {
 
250
        switch (dset->pd) {
251
251
        case 1:   /* annual: YYYY */
252
252
        case 10:  /* decennial: YYYY */
253
253
            nmax = 4; 
262
262
            break;
263
263
        }
264
264
        if (nmax == 0) {
265
 
            get_obs_string(s, pdinfo->t2, pdinfo);
 
265
            get_obs_string(s, dset->t2, dset);
266
266
            nmax = strlen(s);
267
267
        }
268
268
    } else {
269
 
        int T = pdinfo->t2 - pdinfo->t1 + 1;
 
269
        int T = dset->t2 - dset->t1 + 1;
270
270
        int incr = (T < 120)? 1 : (T / 100.0);
271
271
 
272
 
        for (t=pdinfo->t1; t<=pdinfo->t2; t+=incr) {
273
 
            get_obs_string(s, t, pdinfo);
 
272
        for (t=dset->t1; t<=dset->t2; t+=incr) {
 
273
            get_obs_string(s, t, dset);
274
274
            n = strlen(s);
275
275
            if (n > nmax) {
276
276
                nmax = n;
373
373
        return;
374
374
    } 
375
375
 
376
 
    if (K == 0) {
377
 
        pprintf(prn, "\n constant: value = %g\n", freq->midpt[0]);
378
 
        return;
379
 
    }
380
 
 
381
376
    if (freq->discrete) {
382
377
        pputs(prn, _("\n          frequency    rel.     cum.\n\n"));
383
378
 
391
386
            f = 100.0 * freq->f[k] / valid;
392
387
            cumf += f;
393
388
            pprintf(prn, "  %6.2f%% %7.2f%% ", f, cumf);
394
 
            i = 0.36 * f;
395
 
            while (i--) {
396
 
                pputc(prn, '*');
 
389
            if (f < 100) {
 
390
                i = 0.36 * f;
 
391
                while (i--) {
 
392
                    pputc(prn, '*');
 
393
                }
397
394
            }
398
395
            pputc(prn, '\n');
399
396
        }
456
453
                pputs(prn, " - ");
457
454
            }
458
455
 
459
 
            x = (k == K)? freq->endpt[k] : freq->endpt[k+1];
 
456
            x = (k == K && K > 0)? freq->endpt[k] : freq->endpt[k+1];
460
457
            if (x > 0 && someneg) {
461
458
                sprintf(word, " %#.*g", digits, x);
462
459
            } else {
478
475
            cumf += f;
479
476
            pprintf(prn, "  %6.2f%% %7.2f%% ", f, cumf);
480
477
            i = 0.36 * f;
481
 
            while (i--) {
482
 
                pputc(prn, '*');
 
478
            if (K > 1) {
 
479
                while (i--) {
 
480
                    pputc(prn, '*');
 
481
                }
483
482
            }
484
483
            pputc(prn, '\n');
485
484
        }
627
626
 
628
627
/**
629
628
 * print_smpl:
630
 
 * @pdinfo: data information struct
 
629
 * @dset: data information struct
631
630
 * @fulln: full length of data series, if dataset is
632
631
 * subsampled, or 0 if not applicable/known.
633
632
 * @prn: gretl printing struct.
635
634
 * Prints the current sample information to @prn.
636
635
 */
637
636
 
638
 
void print_smpl (const DATAINFO *pdinfo, int fulln, PRN *prn)
 
637
void print_smpl (const DATASET *dset, int fulln, PRN *prn)
639
638
{
640
 
    if (!gretl_messages_on() || pdinfo->v == 0 || gretl_looping_quietly()) {
 
639
    if (!gretl_messages_on() || dset->v == 0 || gretl_looping_quietly()) {
641
640
        return;
642
641
    }
643
642
 
644
 
    if (fulln && !dataset_is_panel(pdinfo)) {
 
643
    if (fulln && !dataset_is_panel(dset)) {
645
644
        pprintf(prn, _("Full data set: %d observations\n"), fulln);
646
 
        if (sample_size(pdinfo) < pdinfo->n) {
647
 
            print_sample_obs(pdinfo, prn);
 
645
        if (sample_size(dset) < dset->n) {
 
646
            print_sample_obs(dset, prn);
648
647
        } else {
649
648
            pprintf(prn, _("Current sample: %d observations\n"),
650
 
                    pdinfo->n);
 
649
                    dset->n);
651
650
        }
652
651
        return;
653
652
    }
656
655
        pprintf(prn, _("Full data set: %d observations\n"), fulln);
657
656
    } else {
658
657
        pprintf(prn, "%s: %s - %s (n = %d)\n", _("Full data range"), 
659
 
                pdinfo->stobs, pdinfo->endobs, pdinfo->n);
 
658
                dset->stobs, dset->endobs, dset->n);
660
659
    }
661
660
 
662
 
    if (pdinfo->t1 > 0 || pdinfo->t2 < pdinfo->n - 1 ||
663
 
        (fulln && dataset_is_panel(pdinfo))) {
664
 
        print_sample_obs(pdinfo, prn);
 
661
    if (dset->t1 > 0 || dset->t2 < dset->n - 1 ||
 
662
        (fulln && dataset_is_panel(dset))) {
 
663
        print_sample_obs(dset, prn);
665
664
    }
666
665
 
667
666
    pputc(prn, '\n');
668
667
}
669
668
 
670
 
static void print_var_smpl (int v, const double **Z, 
671
 
                            const DATAINFO *pdinfo, 
672
 
                            PRN *prn)
 
669
static void print_var_smpl (int v, const DATASET *dset, PRN *prn)
673
670
{
674
671
    int t, n = 0;
675
672
 
676
 
    if (pdinfo->t1 > 0 || pdinfo->t2 < pdinfo->n - 1) {
 
673
    if (dset->t1 > 0 || dset->t2 < dset->n - 1) {
677
674
        char d1[OBSLEN], d2[OBSLEN];
678
 
        ntodate(d1, pdinfo->t1, pdinfo);
679
 
        ntodate(d2, pdinfo->t2, pdinfo);
 
675
        ntodate(d1, dset->t1, dset);
 
676
        ntodate(d2, dset->t2, dset);
680
677
 
681
678
        pprintf(prn, "%s:  %s - %s", _("Current sample"), d1, d2);
682
679
    } else {
683
680
        pprintf(prn, "%s: %s - %s", _("Full data range"), 
684
 
                pdinfo->stobs, pdinfo->endobs);
 
681
                dset->stobs, dset->endobs);
685
682
    }
686
683
 
687
 
    for (t=pdinfo->t1; t<=pdinfo->t2; t++) {
688
 
        if (!na(Z[v][t])) {
 
684
    for (t=dset->t1; t<=dset->t2; t++) {
 
685
        if (!na(dset->Z[v][t])) {
689
686
            n++;
690
687
        }
691
688
    }
728
725
   or %#.*g, with precision 'digits'
729
726
*/
730
727
 
731
 
static int max_number_length (int v, const double **Z, 
732
 
                              const DATAINFO *pdinfo,
 
728
static int max_number_length (int v, const DATASET *dset,
733
729
                              char fmt, int digits)
734
730
{
735
731
    double a, x, amax = 0.0, amin = 1.0e300;
736
732
    int t, n, maxsgn = 0, minsgn = 0;
737
733
 
738
 
    for (t=pdinfo->t1; t<=pdinfo->t2; t++) {
739
 
        x = Z[v][t];
 
734
    for (t=dset->t1; t<=dset->t2; t++) {
 
735
        x = dset->Z[v][t];
740
736
        if (!na(x)) {
741
737
            a = fabs(x);
742
738
            if (a > amax) {
780
776
    return n;
781
777
}
782
778
 
783
 
static int series_column_width (int v, const double **Z, 
784
 
                                const DATAINFO *pdinfo,
 
779
static int series_column_width (int v, const DATASET *dset,
785
780
                                char fmt, int digits)
786
781
{
787
 
    int namelen = strlen(pdinfo->varname[v]);
788
 
    int numlen = max_number_length(v, Z, pdinfo, fmt, digits);
 
782
    int namelen = strlen(dset->varname[v]);
 
783
    int numlen = max_number_length(v, dset, fmt, digits);
789
784
 
790
785
    return (namelen > numlen)? namelen : numlen;
791
786
}
1019
1014
/**
1020
1015
 * outcovmx:
1021
1016
 * @pmod: pointer to model.
1022
 
 * @pdinfo: data information struct.
 
1017
 * @dset: data information struct.
1023
1018
 * @prn: gretl printing struct.
1024
1019
 * 
1025
1020
 * Print to @prn the variance-covariance matrix for the parameter
1028
1023
 * Returns: 0 on successful completion, error code on error.
1029
1024
 */
1030
1025
 
1031
 
int outcovmx (MODEL *pmod, const DATAINFO *pdinfo, PRN *prn)
 
1026
int outcovmx (MODEL *pmod, const DATASET *dset, PRN *prn)
1032
1027
{
1033
1028
    VMatrix *vmat;
1034
1029
    int err = 0;
1035
1030
 
1036
 
    vmat = gretl_model_get_vcv(pmod, pdinfo);
 
1031
    vmat = gretl_model_get_vcv(pmod, dset);
1037
1032
 
1038
1033
    if (vmat == NULL) {
1039
1034
        err = E_ALLOC;
1157
1152
}
1158
1153
 
1159
1154
static void fit_resid_head (const FITRESID *fr, 
1160
 
                            const DATAINFO *pdinfo, 
 
1155
                            const DATASET *dset, 
1161
1156
                            PRN *prn)
1162
1157
{
1163
1158
    char label[16];
1166
1161
    int i;
1167
1162
 
1168
1163
    if (kstep) {
1169
 
        ntodate(obs1, fr->model_t1, pdinfo);   
 
1164
        ntodate(obs1, fr->model_t1, dset);   
1170
1165
        pprintf(prn, _("Recursive %d-step ahead forecasts"), fr->k);
1171
1166
        pputs(prn, "\n\n");
1172
1167
        pprintf(prn, _("The forecast for time t is based on (a) coefficients obtained by\n"
1177
1172
                     "are in fact lagged values."));
1178
1173
        pputs(prn, "\n\n");
1179
1174
    } else {
1180
 
        ntodate(obs1, fr->t1, pdinfo);
1181
 
        ntodate(obs2, fr->t2, pdinfo);
 
1175
        ntodate(obs1, fr->t1, dset);
 
1176
        ntodate(obs2, fr->t2, dset);
1182
1177
        pprintf(prn, _("Model estimation range: %s - %s"), obs1, obs2);
1183
1178
        pputc(prn, '\n');
1184
1179
 
1205
1200
/* prints a heading with the names of the variables in @list */
1206
1201
 
1207
1202
static void varheading (const int *list, int leader, int wid, 
1208
 
                        const DATAINFO *pdinfo, char delim, 
 
1203
                        const DATASET *dset, char delim, 
1209
1204
                        PRN *prn)
1210
1205
{
1211
1206
    int i, vi;
1214
1209
        pprintf(prn, "obs%c", delim);
1215
1210
        for (i=1; i<=list[0]; i++) { 
1216
1211
            vi = list[i];
1217
 
            pputs(prn, pdinfo->varname[vi]);
 
1212
            pputs(prn, dset->varname[vi]);
1218
1213
            if (i < list[0]) {
1219
 
                pputc(prn, pdinfo->delim);
 
1214
                pputc(prn, dset->delim);
1220
1215
            } 
1221
1216
        }
1222
1217
        pputc(prn, '\n');
1224
1219
        pputs(prn, "{obs\\cell ");
1225
1220
        for (i=1; i<=list[0]; i++) { 
1226
1221
            vi = list[i];
1227
 
            pprintf(prn, "%s\\cell ", pdinfo->varname[vi]);
 
1222
            pprintf(prn, "%s\\cell ", dset->varname[vi]);
1228
1223
        }
1229
1224
        pputs(prn, "}\n");      
1230
1225
    } else {
1232
1227
        bufspace(leader, prn);
1233
1228
        for (i=1; i<=list[0]; i++) { 
1234
1229
            vi = list[i];
1235
 
            pprintf(prn, "%*s", wid, pdinfo->varname[vi]);
 
1230
            pprintf(prn, "%*s", wid, dset->varname[vi]);
1236
1231
        }
1237
1232
        pputs(prn, "\n\n");
1238
1233
    }
1277
1272
 
1278
1273
/* prints series z from current sample t1 to t2 */
1279
1274
 
1280
 
static void print_series_by_var (const double *z, const DATAINFO *pdinfo, 
 
1275
static void print_series_by_var (const double *z, const DATASET *dset, 
1281
1276
                                 PRN *prn)
1282
1277
{
1283
1278
    char format[12];
1285
1280
    int anyneg = 0;
1286
1281
    double x;
1287
1282
 
1288
 
    for (t=pdinfo->t1; t<=pdinfo->t2; t++) {
 
1283
    for (t=dset->t1; t<=dset->t2; t++) {
1289
1284
        if (z[t] < 0) {
1290
1285
            anyneg = 1;
1291
1286
            break;
1298
1293
        sprintf(format, "%%#.%dg  ", GRETL_DIGITS);
1299
1294
    }
1300
1295
 
1301
 
    for (t=pdinfo->t1; t<=pdinfo->t2; t++) {
 
1296
    for (t=dset->t1; t<=dset->t2; t++) {
1302
1297
        char str[32];
1303
1298
        int n;
1304
1299
 
1550
1545
 
1551
1546
/**
1552
1547
 * obs_marker_init:
1553
 
 * @pdinfo: data information struct.
 
1548
 * @dset: data information struct.
1554
1549
 *
1555
1550
 * Check the length to which observation markers should
1556
1551
 * be printed, in a tabular context.  (We don't want to
1559
1554
 
1560
1555
static int oprintlen = 8;
1561
1556
 
1562
 
void obs_marker_init (const DATAINFO *pdinfo)
 
1557
void obs_marker_init (const DATASET *dset)
1563
1558
{
1564
1559
    int t, datestrs = 0;
1565
1560
 
1566
 
    if (pdinfo->markers) {
1567
 
        for (t=0; t<pdinfo->n; t++) {
1568
 
            if (strlen(pdinfo->S[t]) == 10 && 
1569
 
                isdigit(pdinfo->S[t][0]) &&
1570
 
                strchr(pdinfo->S[t], '/')) {
 
1561
    if (dset->markers) {
 
1562
        for (t=0; t<dset->n; t++) {
 
1563
            if (strlen(dset->S[t]) == 10 && 
 
1564
                isdigit(dset->S[t][0]) &&
 
1565
                strchr(dset->S[t], '/')) {
1571
1566
                datestrs = 1;
1572
1567
                break;
1573
1568
            }
1584
1579
/**
1585
1580
 * print_obs_marker:
1586
1581
 * @t: observation number.
1587
 
 * @pdinfo: data information struct.
 
1582
 * @dset: data information struct.
1588
1583
 * @prn: gretl printing struct.
1589
1584
 *
1590
1585
 * Print a string (label, date or obs number) representing the given @t.
1591
1586
 */
1592
1587
 
1593
 
void print_obs_marker (int t, const DATAINFO *pdinfo, PRN *prn)
 
1588
void print_obs_marker (int t, const DATASET *dset, PRN *prn)
1594
1589
{
1595
1590
    char tmp[OBSLEN] = {0};
1596
1591
 
1597
 
    if (pdinfo->markers) { 
1598
 
        strncat(tmp, pdinfo->S[t], oprintlen);
 
1592
    if (dset->markers) { 
 
1593
        strncat(tmp, dset->S[t], oprintlen);
1599
1594
        pprintf(prn, "%*s ", oprintlen, tmp); 
1600
1595
    } else {
1601
 
        ntodate(tmp, t, pdinfo);
 
1596
        ntodate(tmp, t, dset);
1602
1597
        pprintf(prn, "%8s ", tmp);
1603
1598
    }
1604
1599
}
1605
1600
 
1606
1601
/**
1607
1602
 * varlist:
1608
 
 * @pdinfo: data information struct.
 
1603
 * @dset: data information struct.
1609
1604
 * @prn: gretl printing struct
1610
1605
 *
1611
1606
 * Prints a list of the names of the variables currently defined.
1612
1607
 */
1613
1608
 
1614
 
void varlist (const DATAINFO *pdinfo, PRN *prn)
 
1609
void varlist (const DATASET *dset, PRN *prn)
1615
1610
{
1616
1611
    int level = gretl_function_depth();
1617
1612
    int len, maxlen = 0;
1618
1613
    int nv = 4;
1619
1614
    int i, j, n = 0;
1620
1615
 
1621
 
    if (pdinfo->v == 0) {
 
1616
    if (dset->v == 0) {
1622
1617
        pprintf(prn, _("No series are defined\n"));
1623
1618
        return;
1624
1619
    }
1625
1620
 
1626
 
    for (i=0; i<pdinfo->v; i++) {
1627
 
        if (STACK_LEVEL(pdinfo, i) == level) {
1628
 
            len = strlen(pdinfo->varname[i]);
 
1621
    for (i=0; i<dset->v; i++) {
 
1622
        if (STACK_LEVEL(dset, i) == level) {
 
1623
            len = strlen(dset->varname[i]);
1629
1624
            if (len > maxlen) {
1630
1625
                maxlen = len;
1631
1626
            }
1642
1637
    pprintf(prn, _("Listing %d variables:\n"), n);
1643
1638
 
1644
1639
    j = 1;
1645
 
    for (i=0; i<pdinfo->v; i++) {
1646
 
        if (level > 0 && STACK_LEVEL(pdinfo, i) != level) {
 
1640
    for (i=0; i<dset->v; i++) {
 
1641
        if (level > 0 && STACK_LEVEL(dset, i) != level) {
1647
1642
            continue;
1648
1643
        }
1649
 
        pprintf(prn, "%3d) %-*s", i, maxlen + 2, pdinfo->varname[i]);
 
1644
        pprintf(prn, "%3d) %-*s", i, maxlen + 2, dset->varname[i]);
1650
1645
        if (j % nv == 0) {
1651
1646
            pputc(prn, '\n');
1652
1647
        }
1662
1657
 
1663
1658
/**
1664
1659
 * maybe_list_vars:
1665
 
 * @pdinfo: data information struct.
 
1660
 * @dset: data information struct.
1666
1661
 * @prn: gretl printing struct
1667
1662
 *
1668
1663
 * Prints a list of the names of the variables currently defined,
1669
1664
 * unless gretl messaging is turned off.
1670
1665
 */
1671
1666
 
1672
 
void maybe_list_vars (const DATAINFO *pdinfo, PRN *prn)
 
1667
void maybe_list_vars (const DATASET *dset, PRN *prn)
1673
1668
{
1674
1669
    if (gretl_messages_on() && !gretl_looping_quietly()) {
1675
 
        varlist(pdinfo, prn);
 
1670
        varlist(dset, prn);
1676
1671
    }
1677
1672
}
1678
1673
 
1679
1674
static void print_varlist (const char *name, const int *list, 
1680
 
                           const DATAINFO *pdinfo, PRN *prn)
 
1675
                           const DATASET *dset, PRN *prn)
1681
1676
{
1682
1677
    int i, v, len = 0;
1683
1678
 
1689
1684
            v = list[i];
1690
1685
            if (v == LISTSEP) {
1691
1686
                len += pputs(prn, "; ");
1692
 
            } else if (v >= 0 && v < pdinfo->v) {
1693
 
                len += pprintf(prn, "%s ", pdinfo->varname[v]);
 
1687
            } else if (v >= 0 && v < dset->v) {
 
1688
                len += pprintf(prn, "%s ", dset->varname[v]);
1694
1689
            } else {
1695
1690
                len += pprintf(prn, "%d ", v);
1696
1691
            }
1704
1699
}
1705
1700
 
1706
1701
static void print_listed_objects (const char *s, 
1707
 
                                  const DATAINFO *pdinfo, 
 
1702
                                  const DATASET *dset, 
1708
1703
                                  PRN *prn)
1709
1704
{
1710
1705
    const gretl_matrix *m;
1719
1714
        } else if ((m = get_matrix_by_name(name)) != NULL) {
1720
1715
            gretl_matrix_print_to_prn(m, name, prn);
1721
1716
        } else if ((list = get_list_by_name(name)) != NULL) {
1722
 
            print_varlist(name, list, pdinfo, prn);
 
1717
            print_varlist(name, list, dset, prn);
1723
1718
        } else if ((b = get_gretl_bundle_by_name(name)) != NULL) {
1724
1719
            gretl_bundle_print(b, prn);
1725
1720
        } else if ((p = get_string_by_name(name)) != NULL) {
1763
1758
   buffer, pre-allocate a relatively big chunk of memory
1764
1759
*/
1765
1760
 
1766
 
static int check_prn_size (const int *list, const DATAINFO *pdinfo,
 
1761
static int check_prn_size (const int *list, const DATASET *dset,
1767
1762
                           PRN *prn)
1768
1763
{
1769
 
    int nx = list[0] * (pdinfo->t2 - pdinfo->t1 + 1);
 
1764
    int nx = list[0] * (dset->t2 - dset->t1 + 1);
1770
1765
    int err = 0;
1771
1766
 
1772
1767
    if (nx > 1000) {
1776
1771
    return err;
1777
1772
}
1778
1773
 
1779
 
static int *get_pmax_array (const int *list, const double **Z,
1780
 
                            const DATAINFO *pdinfo)
 
1774
static int *get_pmax_array (const int *list, const DATASET *dset)
1781
1775
{
1782
1776
    int *pmax = malloc(list[0] * sizeof *pmax);
1783
 
    int i, vi, T = sample_size(pdinfo);
 
1777
    int i, vi, T = sample_size(dset);
1784
1778
 
1785
1779
    if (pmax == NULL) {
1786
1780
        return NULL;
1790
1784
 
1791
1785
    for (i=1; i<=list[0]; i++) {
1792
1786
        vi = list[i];
1793
 
        pmax[i-1] = get_signif(Z[vi] + pdinfo->t1, T);
 
1787
        pmax[i-1] = get_signif(dset->Z[vi] + dset->t1, T);
1794
1788
    }
1795
1789
 
1796
1790
    return pmax;
1797
1791
}
1798
1792
 
1799
 
int column_width_from_list (const int *list, const DATAINFO *pdinfo)
 
1793
int column_width_from_list (const int *list, const DATASET *dset)
1800
1794
{
1801
1795
    int i, n, vi, w = 13;
1802
1796
 
1803
1797
    for (i=1; i<=list[0]; i++) {
1804
1798
        vi = list[i];
1805
 
        if (vi > 0 && vi < pdinfo->v) {
1806
 
            n = strlen(pdinfo->varname[vi]);
 
1799
        if (vi > 0 && vi < dset->v) {
 
1800
            n = strlen(dset->varname[vi]);
1807
1801
            if (n >= w) {
1808
1802
                w = n + 1;
1809
1803
            }
1817
1811
 
1818
1812
/* print the series referenced in 'list' by observation */
1819
1813
 
1820
 
static int print_by_obs (int *list, const double **Z, 
1821
 
                         const DATAINFO *pdinfo, 
 
1814
static int print_by_obs (int *list, 
 
1815
                         const DATASET *dset, 
1822
1816
                         gretlopt opt, int screenvar,
1823
1817
                         PRN *prn)
1824
1818
{
1832
1826
    double x;
1833
1827
    int err = 0;
1834
1828
 
1835
 
    pmax = get_pmax_array(list, Z, pdinfo);
 
1829
    pmax = get_pmax_array(list, dset);
1836
1830
    if (pmax == NULL) {
1837
1831
        return E_ALLOC;
1838
1832
    }
1839
1833
 
1840
1834
    if (opt & OPT_N) {
1841
 
        obslen = obslen_from_t(pdinfo->t2);
 
1835
        obslen = obslen_from_t(dset->t2);
1842
1836
    } else {
1843
 
        obslen = max_obs_label_length(pdinfo);
 
1837
        obslen = max_obs_label_length(dset);
1844
1838
    }
1845
1839
 
1846
 
    colwidth = column_width_from_list(list, pdinfo);
 
1840
    colwidth = column_width_from_list(list, dset);
1847
1841
 
1848
1842
    nrem = list[0];
1849
1843
    k = 1;
1858
1852
            nrem--;
1859
1853
        }
1860
1854
 
1861
 
        varheading(blist, obslen, colwidth, pdinfo, 0, prn);
 
1855
        varheading(blist, obslen, colwidth, dset, 0, prn);
1862
1856
        
1863
 
        for (t=pdinfo->t1; t<=pdinfo->t2; t++) {
 
1857
        for (t=dset->t1; t<=dset->t2; t++) {
1864
1858
            int thislen = obslen;
1865
1859
 
1866
 
            if (screenvar && Z[screenvar][t] == 0.0) {
 
1860
            if (screenvar && dset->Z[screenvar][t] == 0.0) {
1867
1861
                /* screened out by boolean */
1868
1862
                continue;
1869
1863
            }
1870
1864
 
1871
1865
            if (opt & OPT_N) {
1872
1866
                sprintf(obslabel, "%d", t + 1);
1873
 
            } else if (dataset_has_markers(pdinfo)) {
1874
 
                strcpy(obslabel, pdinfo->S[t]);
 
1867
            } else if (dataset_has_markers(dset)) {
 
1868
                strcpy(obslabel, dset->S[t]);
1875
1869
                thislen = get_utf_width(obslabel, obslen);
1876
1870
            } else {
1877
 
                ntodate(obslabel, t, pdinfo);
 
1871
                ntodate(obslabel, t, dset);
1878
1872
            }
1879
1873
 
1880
1874
            pprintf(prn, "%*s", thislen, obslabel);
1881
1875
 
1882
1876
            for (i=1, j=j0; i<=blist[0]; i++, j++) {
1883
 
                x = Z[blist[i]][t];
 
1877
                x = dset->Z[blist[i]][t];
1884
1878
                if (na(x)) {
1885
1879
                    bufspace(colwidth, prn);
1886
1880
                } else { 
1900
1894
    return err;
1901
1895
}
1902
1896
 
1903
 
static int print_by_var (const int *list, const double **Z,
1904
 
                         const DATAINFO *pdinfo, PRN *prn)
 
1897
static int print_by_var (const int *list, const DATASET *dset, 
 
1898
                         PRN *prn)
1905
1899
{
1906
1900
    int i, vi;
1907
1901
 
1909
1903
 
1910
1904
    for (i=1; i<=list[0]; i++) {
1911
1905
        vi = list[i];
1912
 
        if (vi > pdinfo->v) {
 
1906
        if (vi > dset->v) {
1913
1907
            continue;
1914
1908
        }
1915
1909
        if (list[0] > 1) {
1916
 
            pprintf(prn, "%s:\n", pdinfo->varname[vi]);
 
1910
            pprintf(prn, "%s:\n", dset->varname[vi]);
1917
1911
        }
1918
 
        print_var_smpl(vi, Z, pdinfo, prn);
 
1912
        print_var_smpl(vi, dset, prn);
1919
1913
        pputc(prn, '\n');
1920
 
        print_series_by_var(Z[vi], pdinfo, prn);
 
1914
        print_series_by_var(dset->Z[vi], dset, prn);
1921
1915
        pputc(prn, '\n');
1922
1916
    }
1923
1917
 
1928
1922
 * printdata:
1929
1923
 * @list: list of variables to print.
1930
1924
 * @mstr: optional string holding names of non-series objects to print.
1931
 
 * @Z: data matrix.
1932
 
 * @pdinfo: data information struct.
 
1925
 * @dset: dataset struct.
1933
1926
 * @opt: if OPT_O, print the data by observation (series in columns);
1934
1927
 * if OPT_N, use simple obs numbers, not dates.
1935
1928
 * @prn: gretl printing struct.
1941
1934
 */
1942
1935
 
1943
1936
int printdata (const int *list, const char *mstr, 
1944
 
               const double **Z, const DATAINFO *pdinfo, 
 
1937
               const DATASET *dset, 
1945
1938
               gretlopt opt, PRN *prn)
1946
1939
{
1947
1940
    int screenvar = 0;
1960
1953
        if (mstr == NULL) {
1961
1954
            int nvars = 0;
1962
1955
 
1963
 
            plist = full_var_list(pdinfo, &nvars);
 
1956
            plist = full_var_list(dset, &nvars);
1964
1957
            if (nvars == 0) {
1965
1958
                /* no-op */
1966
1959
                return 0;
1992
1985
    }
1993
1986
 
1994
1987
    if (gretl_print_has_buffer(prn)) {
1995
 
        err = check_prn_size(plist, pdinfo, prn);
 
1988
        err = check_prn_size(plist, dset, prn);
1996
1989
        if (err) {
1997
1990
            goto endprint;
1998
1991
        }
1999
1992
    }
2000
1993
 
2001
1994
    if (opt & OPT_O) {
2002
 
        err = print_by_obs(plist, Z, pdinfo, opt, screenvar, prn);
 
1995
        err = print_by_obs(plist, dset, opt, screenvar, prn);
2003
1996
    } else {
2004
 
        err = print_by_var(plist, Z, pdinfo, prn);
 
1997
        err = print_by_var(plist, dset, prn);
2005
1998
    }
2006
1999
 
2007
2000
 endprint:
2008
2001
 
2009
2002
    if (!err && mstr != NULL) {
2010
 
        print_listed_objects(mstr, pdinfo, prn);
 
2003
        print_listed_objects(mstr, dset, prn);
2011
2004
    }
2012
2005
 
2013
2006
    free(plist);
2015
2008
    return err;
2016
2009
}
2017
2010
 
2018
 
int print_series_with_format (const int *list, const double **Z, 
2019
 
                              const DATAINFO *pdinfo, 
2020
 
                              char fmt, int digits, PRN *prn)
 
2011
int print_series_with_format (const int *list, 
 
2012
                              const DATASET *dset, 
 
2013
                              char fmt, int digits, 
 
2014
                              PRN *prn)
2021
2015
{
2022
2016
    int i, j, j0, v, t, k, nrem = 0;
2023
2017
    int *colwidths, blist[BMAX+1];
2033
2027
    }
2034
2028
 
2035
2029
    for (i=1; i<=list[0]; i++) {
2036
 
        if (list[i] >= pdinfo->v) {
 
2030
        if (list[i] >= dset->v) {
2037
2031
            return E_DATA;
2038
2032
        }
2039
2033
    }
2047
2041
 
2048
2042
    buflen = 0;
2049
2043
    for (i=1; i<=list[0]; i++) {
2050
 
        colwidths[i] = series_column_width(list[i], Z, pdinfo, fmt, digits);
 
2044
        colwidths[i] = series_column_width(list[i], dset, fmt, digits);
2051
2045
        colwidths[i] += 3;
2052
2046
        if (colwidths[i] > buflen) {
2053
2047
            buflen = colwidths[i];
2061
2055
    }
2062
2056
 
2063
2057
    if (gretl_print_has_buffer(prn)) {
2064
 
        err = check_prn_size(list, pdinfo, prn);
 
2058
        err = check_prn_size(list, dset, prn);
2065
2059
        if (err) {
2066
2060
            goto bailout;
2067
2061
        }
2073
2067
        sprintf(format, "%%#.%dg", digits);
2074
2068
    }
2075
2069
 
2076
 
    obslen = max_obs_label_length(pdinfo);
 
2070
    obslen = max_obs_label_length(dset);
2077
2071
 
2078
2072
    k = 1;
2079
2073
 
2091
2085
        bufspace(obslen, prn);
2092
2086
        for (i=1, j=j0; i<=blist[0]; i++, j++) {
2093
2087
            v = blist[i];
2094
 
            pprintf(prn, "%*s", colwidths[j], pdinfo->varname[v]);
 
2088
            pprintf(prn, "%*s", colwidths[j], dset->varname[v]);
2095
2089
        }
2096
2090
        pputs(prn, "\n\n");
2097
2091
 
2098
2092
        /* print block observations */
2099
 
        for (t=pdinfo->t1; t<=pdinfo->t2; t++) {
2100
 
            get_obs_string(obslabel, t, pdinfo);
 
2093
        for (t=dset->t1; t<=dset->t2; t++) {
 
2094
            get_obs_string(obslabel, t, dset);
2101
2095
            pprintf(prn, "%*s", obslen, obslabel);
2102
2096
            for (i=1, j=j0; i<=blist[0]; i++, j++) {
2103
2097
                v = blist[i];
2104
 
                x = Z[v][t];
 
2098
                x = dset->Z[v][t];
2105
2099
                if (na(x)) {
2106
2100
                    bufspace(colwidths[j], prn);
2107
2101
                } else { 
2155
2149
 * print_data_in_columns:
2156
2150
 * @list: list of variables to print.
2157
2151
 * @obsvec: list of observation numbers (or %NULL)
2158
 
 * @Z: data matrix.
2159
 
 * @pdinfo: data information struct.
 
2152
 * @dset: dataset struct.
2160
2153
 * @prn: gretl printing struct.
2161
2154
 *
2162
2155
 * Print the data for the variables in @list.  If @obsvec is not %NULL,
2171
2164
 */
2172
2165
 
2173
2166
int print_data_in_columns (const int *list, const int *obsvec, 
2174
 
                           const double **Z, const DATAINFO *pdinfo, 
2175
 
                           PRN *prn)
 
2167
                           const DATASET *dset, PRN *prn)
2176
2168
{
2177
2169
    int delimited = prn_delimited(prn);
2178
2170
    int rtf = rtf_format(prn);
2189
2181
    if (obsvec != NULL) {
2190
2182
        T = obsvec[0];
2191
2183
    } else {
2192
 
        T = sample_size(pdinfo);
 
2184
        T = sample_size(dset);
2193
2185
    }
2194
2186
 
2195
2187
    /* must have a non-empty list of variables */
2199
2191
 
2200
2192
    /* ...with no bad variable numbers */
2201
2193
    for (i=1; i<=list[0]; i++) {
2202
 
        if (list[i] < 0 || list[i] >= pdinfo->v) {
 
2194
        if (list[i] < 0 || list[i] >= dset->v) {
2203
2195
            return E_DATA;
2204
2196
        }
2205
2197
    }
2206
2198
 
2207
2199
    /* and T must be in bounds */
2208
 
    if (T > pdinfo->n - pdinfo->t1) {
 
2200
    if (T > dset->n - dset->t1) {
2209
2201
        return E_DATA;
2210
2202
    }
2211
2203
 
2212
 
    pmax = get_pmax_array(list, Z, pdinfo);
 
2204
    pmax = get_pmax_array(list, dset);
2213
2205
    if (pmax == NULL) {
2214
2206
        return E_ALLOC;
2215
2207
    }
2218
2210
        if (csv_format(prn)) {
2219
2211
            gprec = 15;
2220
2212
        }
2221
 
        delim = pdinfo->delim;
 
2213
        delim = dset->delim;
2222
2214
        if (get_local_decpoint() == ',' && delim == ',') {
2223
2215
            delim = ';';
2224
2216
        }
2225
2217
    } else if (rtf) {
2226
2218
        ncols = list[0] + 1;
2227
2219
    } else {
2228
 
        colwidth = column_width_from_list(list, pdinfo);
2229
 
        obslen = max_obs_label_length(pdinfo);
 
2220
        colwidth = column_width_from_list(list, dset);
 
2221
        obslen = max_obs_label_length(dset);
2230
2222
    }
2231
2223
 
2232
2224
    if (rtf) {
2234
2226
        rtf_print_row_spec(ncols, RTF_HEADER, prn);
2235
2227
    }
2236
2228
 
2237
 
    varheading(list, obslen, colwidth, pdinfo, delim, prn);
 
2229
    varheading(list, obslen, colwidth, dset, delim, prn);
2238
2230
 
2239
2231
    if (rtf) {
2240
2232
        rtf_print_row_spec(ncols, RTF_TRAILER, prn);
2245
2237
        if (obsvec != NULL) {
2246
2238
            t = obsvec[s+1];
2247
2239
        } else {
2248
 
            t = pdinfo->t1 + s;
 
2240
            t = dset->t1 + s;
2249
2241
        }
2250
 
        if (t >= pdinfo->n) {
 
2242
        if (t >= dset->n) {
2251
2243
            continue;
2252
2244
        }
2253
2245
        if (rtf) {
2254
2246
            rtf_print_row_spec(ncols, RTF_HEADER, prn);
2255
2247
            pputc(prn, '{');
2256
2248
        }
2257
 
        get_obs_string(obs_string, t, pdinfo);
 
2249
        get_obs_string(obs_string, t, dset);
2258
2250
        if (delimited) {
2259
2251
            pprintf(prn, "%s%c", obs_string, delim);
2260
2252
        } else if (rtf) {
2263
2255
            pprintf(prn, "%*s", obslen, obs_string);
2264
2256
        }
2265
2257
        for (i=1; i<=list[0]; i++) {
2266
 
            xx = Z[list[i]][t];
 
2258
            xx = dset->Z[list[i]][t];
2267
2259
            if (na(xx)) {
2268
2260
                if (delimited) {
2269
2261
                    pputs(prn, "NA");
2381
2373
 
2382
2374
#define SIGMA_MIN 1.0e-18
2383
2375
 
2384
 
int text_print_fit_resid (const FITRESID *fr, const DATAINFO *pdinfo, 
 
2376
int text_print_fit_resid (const FITRESID *fr, const DATASET *dset, 
2385
2377
                          PRN *prn)
2386
2378
{
2387
2379
    int kstep = fr->method == FC_KSTEP;
2389
2381
    double yt, yf, et;
2390
2382
    int err = 0;
2391
2383
 
2392
 
    fit_resid_head(fr, pdinfo, prn); 
 
2384
    fit_resid_head(fr, dset, prn); 
2393
2385
 
2394
 
    obs_marker_init(pdinfo);
 
2386
    obs_marker_init(dset);
2395
2387
 
2396
2388
    for (t=fr->t1; t<=fr->t2; t++) {
2397
 
        print_obs_marker(t, pdinfo, prn);
 
2389
        print_obs_marker(t, dset, prn);
2398
2390
 
2399
2391
        yt = fr->actual[t];
2400
2392
        yf = fr->fitted[t];
2446
2438
    print_fcast_stats(fr, OPT_NONE, prn);
2447
2439
 
2448
2440
    if (kstep && fr->nobs > 0 && gretl_in_gui_mode()) {
2449
 
        err = plot_fcast_errs(fr, NULL, pdinfo, OPT_NONE);
 
2441
        err = plot_fcast_errs(fr, NULL, dset, OPT_NONE);
2450
2442
    }
2451
2443
 
2452
2444
    return err;
2455
2447
/**
2456
2448
 * text_print_forecast:
2457
2449
 * @fr: pointer to structure containing forecasts.
2458
 
 * @pdinfo: dataset information.
 
2450
 * @dset: dataset information.
2459
2451
 * @opt: if includes %OPT_P, make a plot of the forecasts;
2460
2452
 * if includes %OPT_N, skip printing of the forecast
2461
2453
 * evaluation statistics.
2471
2463
 * Returns: 0 on success, non-zero error code on error.
2472
2464
 */
2473
2465
 
2474
 
int text_print_forecast (const FITRESID *fr, DATAINFO *pdinfo, 
 
2466
int text_print_forecast (const FITRESID *fr, DATASET *dset, 
2475
2467
                         gretlopt opt, PRN *prn)
2476
2468
{
2477
2469
    int do_errs = (fr->sderr != NULL);
2536
2528
        }
2537
2529
    }
2538
2530
 
2539
 
    obs_marker_init(pdinfo);
 
2531
    obs_marker_init(dset);
2540
2532
 
2541
2533
    for (t=fr->t0; t<=fr->t2; t++) {
2542
 
        print_obs_marker(t, pdinfo, prn);
 
2534
        print_obs_marker(t, dset, prn);
2543
2535
        fcast_print_x(fr->actual[t], 15, pmax, prn);
2544
2536
 
2545
2537
        if (na(fr->fitted[t])) {
2572
2564
    /* do we really want a plot for non-time series? */
2573
2565
 
2574
2566
    if ((opt & OPT_P) && fr->nobs > 0) {
2575
 
        err = plot_fcast_errs(fr, maxerr, pdinfo, opt);
 
2567
        err = plot_fcast_errs(fr, maxerr, dset, opt);
2576
2568
        if (!err && (opt & OPT_U)) {
2577
2569
            /* specified output file for graph */
2578
2570
            report_plot_written(prn);
2589
2581
/**
2590
2582
 * print_fit_resid:
2591
2583
 * @pmod: pointer to gretl model.
2592
 
 * @Z: data array.
2593
 
 * @pdinfo: data information struct.
 
2584
 * @dset: dataset struct.
2594
2585
 * @prn: gretl printing struct.
2595
2586
 *
2596
2587
 * Print to @prn the fitted values and residuals from @pmod.
2598
2589
 * Returns: 0 on successful completion, 1 on error.
2599
2590
 */
2600
2591
 
2601
 
int print_fit_resid (const MODEL *pmod, const double **Z, 
2602
 
                     const DATAINFO *pdinfo, PRN *prn)
 
2592
int print_fit_resid (const MODEL *pmod, const DATASET *dset, 
 
2593
                     PRN *prn)
2603
2594
{
2604
2595
    FITRESID *fr;
2605
2596
    int err = 0;
2606
2597
 
2607
 
    fr = get_fit_resid(pmod, Z, pdinfo, &err);
 
2598
    fr = get_fit_resid(pmod, dset, &err);
2608
2599
 
2609
2600
    if (!err) {
2610
 
        text_print_fit_resid(fr, pdinfo, prn);
 
2601
        text_print_fit_resid(fr, dset, prn);
2611
2602
        free_fit_resid(fr);
2612
2603
    }
2613
2604