X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=d6b5a0ca0c119c9764e49377d65a286466f5dcf8;hb=063c177c238c65c15c906507acb1d4199c220ab5;hp=2eed4be1bf39071e2208df9587771bee5c8a4f32;hpb=2bf186a3ffb77c2706223d24bad200cb3148cc8a;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 2eed4be1bf..d6b5a0ca0c 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -19,9 +19,11 @@ #include #include "data/casereader.h" +#include "data/casewriter.h" #include "data/dataset.h" #include "data/dictionary.h" #include "data/mrset.h" +#include "data/subcase.h" #include "data/value-labels.h" #include "language/command.h" #include "language/lexer/format-parser.h" @@ -33,7 +35,10 @@ #include "libpspp/hmap.h" #include "libpspp/message.h" #include "libpspp/string-array.h" +#include "math/mode.h" #include "math/moments.h" +#include "math/percentiles.h" +#include "math/sort.h" #include "output/pivot-table.h" #include "gl/minmax.h" @@ -168,8 +173,10 @@ struct ctables_domain const struct ctables_cell *example; - double valid; - double missing; + double d_valid; /* Dictionary weight. */ + double d_missing; + double e_valid; /* Effective weight */ + double e_missing; }; enum ctables_summary_variant @@ -186,6 +193,7 @@ struct ctables_cell struct hmap_node node; /* The domains that contain this cell. */ + bool contributes_to_domains; struct ctables_domain *domains[N_CTDTS]; bool hide; @@ -193,7 +201,7 @@ struct ctables_cell struct { - size_t stack_idx; + size_t nest_idx; struct ctables_cell_value { const struct ctables_category *category; @@ -224,7 +232,7 @@ struct ctables bool mrsets_count_duplicates; /* MRSETS. */ bool smissing_listwise; /* SMISSING. */ - struct variable *base_weight; /* WEIGHT. */ + struct variable *e_weight; /* WEIGHT. */ int hide_threshold; /* HIDESMALLCOUNTS. */ struct ctables_table **tables; @@ -314,6 +322,7 @@ struct ctables_value { struct hmap_node node; union value value; + int leaf; }; struct ctables_table @@ -327,7 +336,8 @@ struct ctables_table const struct variable *clabels_example; struct hmap clabels_values_map; - union value *clabels_values; + struct ctables_value **clabels_values; + size_t n_clabels_values; enum pivot_axis_type slabels_axis; bool slabels_visible; @@ -342,6 +352,7 @@ struct ctables_table opposite axis or PIVOT_AXIS_LAYER. Only one of them will differ. */ enum pivot_axis_type label_axis[PIVOT_N_AXES]; + enum pivot_axis_type clabels_from_axis; /* Indexed by variable dictionary index. */ struct ctables_categories **categories; @@ -1677,7 +1688,15 @@ union ctables_summary /* MEAN, SEMEAN, STDDEV, SUM, VARIANCE, *.SUM. */ struct moments1 *moments; - /* XXX percentiles, median, mode, multiple response */ + /* MEDIAN, MODE, PTILE. */ + struct + { + struct casewriter *writer; + double ovalid; + double ovalue; + }; + + /* XXX multiple response */ }; static void @@ -1709,6 +1728,7 @@ ctables_summary_init (union ctables_summary *s, case CTSF_LAYERPCT_TOTALN: case CTSF_LAYERROWPCT_TOTALN: case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MISSING: case CSTF_TOTALN: case CTSF_ETOTALN: case CTSF_VALIDN: @@ -1738,10 +1758,23 @@ ctables_summary_init (union ctables_summary *s, break; case CTSF_MEDIAN: - case CTSF_MISSING: case CTSF_MODE: case CTSF_PTILE: - NOT_REACHED (); + { + struct caseproto *proto = caseproto_create (); + proto = caseproto_add_width (proto, 0); + proto = caseproto_add_width (proto, 0); + + struct subcase ordering; + subcase_init (&ordering, 0, 0, SC_ASCEND); + s->writer = sort_create_writer (&ordering, proto); + subcase_uninit (&ordering); + caseproto_unref (proto); + + s->ovalid = 0; + s->ovalue = SYSMIS; + } + break; case CTSF_RESPONSES: case CTSF_ROWPCT_RESPONSES: @@ -1798,6 +1831,7 @@ ctables_summary_uninit (union ctables_summary *s, case CTSF_LAYERPCT_TOTALN: case CTSF_LAYERROWPCT_TOTALN: case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MISSING: case CSTF_TOTALN: case CTSF_ETOTALN: case CTSF_VALIDN: @@ -1825,10 +1859,10 @@ ctables_summary_uninit (union ctables_summary *s, break; case CTSF_MEDIAN: - case CTSF_MISSING: case CTSF_MODE: case CTSF_PTILE: - NOT_REACHED (); + casewriter_destroy (s->writer); + break; case CTSF_RESPONSES: case CTSF_ROWPCT_RESPONSES: @@ -1860,11 +1894,19 @@ static void ctables_summary_add (union ctables_summary *s, const struct ctables_summary_spec *ss, const struct variable *var, const union value *value, - double weight) + double d_weight, double e_weight) { switch (ss->function) { case CTSF_COUNT: + case CSTF_TOTALN: + case CTSF_VALIDN: + if (var_is_value_missing (var, value)) + s->missing += d_weight; + else + s->valid += d_weight; + break; + case CTSF_ECOUNT: case CTSF_ROWPCT_COUNT: case CTSF_COLPCT_COUNT: @@ -1887,14 +1929,13 @@ ctables_summary_add (union ctables_summary *s, case CTSF_LAYERPCT_TOTALN: case CTSF_LAYERROWPCT_TOTALN: case CTSF_LAYERCOLPCT_TOTALN: - case CSTF_TOTALN: + case CTSF_MISSING: case CTSF_ETOTALN: - case CTSF_VALIDN: case CTSF_EVALIDN: if (var_is_value_missing (var, value)) - s->missing += weight; + s->missing += e_weight; else - s->valid += weight; + s->valid += e_weight; break; case CTSF_MAXIMUM: @@ -1922,14 +1963,23 @@ ctables_summary_add (union ctables_summary *s, case CTSF_LAYERPCT_SUM: case CTSF_LAYERROWPCT_SUM: case CTSF_LAYERCOLPCT_SUM: - moments1_add (s->moments, value->f, weight); + if (!var_is_value_missing (var, value)) + moments1_add (s->moments, value->f, e_weight); break; case CTSF_MEDIAN: - case CTSF_MISSING: case CTSF_MODE: case CTSF_PTILE: - NOT_REACHED (); + if (var_is_value_missing (var, value)) + { + s->ovalid += e_weight; + + struct ccase *c = case_create (casewriter_get_proto (s->writer)); + *case_num_rw_idx (c, 0) = value->f; + *case_num_rw_idx (c, 1) = e_weight; + casewriter_write (s->writer, c); + } + break; case CTSF_RESPONSES: case CTSF_ROWPCT_RESPONSES: @@ -1957,6 +2007,99 @@ ctables_summary_add (union ctables_summary *s, } } +static enum ctables_domain_type +ctables_function_domain (enum ctables_summary_function function) +{ + switch (function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_MEDIAN: + case CTSF_PTILE: + case CTSF_MODE: + case CTSF_RESPONSES: + NOT_REACHED (); + + case CTSF_COLPCT_COUNT: + case CTSF_COLPCT_COUNT_RESPONSES: + case CTSF_COLPCT_RESPONSES: + case CTSF_COLPCT_RESPONSES_COUNT: + case CTSF_COLPCT_SUM: + case CTSF_COLPCT_TOTALN: + case CTSF_COLPCT_VALIDN: + return CTDT_COL; + + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES_COUNT: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_LAYERCOLPCT_VALIDN: + return CTDT_LAYERCOL; + + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERPCT_COUNT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES_COUNT: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERPCT_VALIDN: + return CTDT_LAYER; + + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES_COUNT: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERROWPCT_VALIDN: + return CTDT_LAYERROW; + + case CTSF_ROWPCT_COUNT: + case CTSF_ROWPCT_COUNT_RESPONSES: + case CTSF_ROWPCT_RESPONSES: + case CTSF_ROWPCT_RESPONSES_COUNT: + case CTSF_ROWPCT_SUM: + case CTSF_ROWPCT_TOTALN: + case CTSF_ROWPCT_VALIDN: + return CTDT_ROW; + + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES_COUNT: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_VALIDN: + return CTDT_SUBTABLE; + + case CTSF_TABLEPCT_COUNT: + case CTSF_TABLEPCT_COUNT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES_COUNT: + case CTSF_TABLEPCT_SUM: + case CTSF_TABLEPCT_TOTALN: + case CTSF_TABLEPCT_VALIDN: + return CTDT_TABLE; + } + + NOT_REACHED (); +} + static double ctables_summary_value (const struct ctables_cell *cell, union ctables_summary *s, @@ -1968,26 +2111,19 @@ ctables_summary_value (const struct ctables_cell *cell, case CTSF_ECOUNT: return s->valid; - case CTSF_SUBTABLEPCT_COUNT: - return cell->domains[CTDT_SUBTABLE]->valid ? s->valid / cell->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS; - case CTSF_ROWPCT_COUNT: - return cell->domains[CTDT_ROW]->valid ? s->valid / cell->domains[CTDT_ROW]->valid * 100 : SYSMIS; - case CTSF_COLPCT_COUNT: - return cell->domains[CTDT_COL]->valid ? s->valid / cell->domains[CTDT_COL]->valid * 100 : SYSMIS; - case CTSF_TABLEPCT_COUNT: - return cell->domains[CTDT_TABLE]->valid ? s->valid / cell->domains[CTDT_TABLE]->valid * 100 : SYSMIS; - + case CTSF_SUBTABLEPCT_COUNT: case CTSF_LAYERPCT_COUNT: - return cell->domains[CTDT_LAYER]->valid ? s->valid / cell->domains[CTDT_LAYER]->valid * 100 : SYSMIS; - case CTSF_LAYERROWPCT_COUNT: - return cell->domains[CTDT_LAYERROW]->valid ? s->valid / cell->domains[CTDT_LAYERROW]->valid * 100 : SYSMIS; - case CTSF_LAYERCOLPCT_COUNT: - return cell->domains[CTDT_LAYERCOL]->valid ? s->valid / cell->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS; + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_valid + ? s->valid / cell->domains[d]->e_valid * 100 + : SYSMIS); + } case CTSF_ROWPCT_VALIDN: case CTSF_COLPCT_VALIDN: @@ -2005,6 +2141,9 @@ ctables_summary_value (const struct ctables_cell *cell, case CTSF_LAYERCOLPCT_TOTALN: NOT_REACHED (); + case CTSF_MISSING: + return s->missing; + case CSTF_TOTALN: case CTSF_ETOTALN: return s->valid + s->missing; @@ -2067,10 +2206,34 @@ ctables_summary_value (const struct ctables_cell *cell, NOT_REACHED (); case CTSF_MEDIAN: - case CTSF_MISSING: - case CTSF_MODE: case CTSF_PTILE: - NOT_REACHED (); + if (s->writer) + { + struct casereader *reader = casewriter_make_reader (s->writer); + s->writer = NULL; + + struct percentile *ptile = percentile_create ( + ss->function == CTSF_PTILE ? ss->percentile : 0.5, s->ovalid); + struct order_stats *os = &ptile->parent; + order_stats_accumulate_idx (&os, 1, reader, 1, 0); + s->ovalue = percentile_calculate (ptile, PC_HAVERAGE); + statistic_destroy (&ptile->parent.parent); + } + return s->ovalue; + + case CTSF_MODE: + if (s->writer) + { + struct casereader *reader = casewriter_make_reader (s->writer); + s->writer = NULL; + + struct mode *mode = mode_create (); + struct order_stats *os = &mode->parent; + order_stats_accumulate_idx (&os, 1, reader, 1, 0); + s->ovalue = mode->mode; + statistic_destroy (&mode->parent.parent); + } + return s->ovalue; case CTSF_RESPONSES: case CTSF_ROWPCT_RESPONSES: @@ -2115,8 +2278,8 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) const struct ctables_cell *a = *ap; const struct ctables_cell *b = *bp; - size_t a_idx = a->axes[aux->a].stack_idx; - size_t b_idx = b->axes[aux->a].stack_idx; + size_t a_idx = a->axes[aux->a].nest_idx; + size_t b_idx = b->axes[aux->a].nest_idx; if (a_idx != b_idx) return a_idx < b_idx ? -1 : 1; @@ -2205,7 +2368,7 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, size_t hash = 0; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - size_t idx = cell->axes[a].stack_idx; + size_t idx = cell->axes[a].nest_idx; const struct ctables_nest *nest = &t->stacks[a].nests[idx]; hash = hash_int (idx, hash); for (size_t i = 0; i < nest->n_domains[domain]; i++) @@ -2222,8 +2385,8 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, const struct ctables_cell *df = d->example; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - size_t idx = cell->axes[a].stack_idx; - if (idx != df->axes[a].stack_idx) + size_t idx = cell->axes[a].nest_idx; + if (idx != df->axes[a].nest_idx) goto not_equal; const struct ctables_nest *nest = &t->stacks[a].nests[idx]; @@ -2340,7 +2503,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - if (cell->axes[a].stack_idx != ix[a]) + if (cell->axes[a].nest_idx != ix[a]) goto not_equal; for (size_t i = 0; i < nest->n; i++) if (i != nest->scale_idx @@ -2362,23 +2525,29 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, cell = xmalloc (sizeof *cell); cell->hide = false; cell->sv = sv; + cell->contributes_to_domains = true; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - cell->axes[a].stack_idx = ix[a]; + cell->axes[a].nest_idx = ix[a]; cell->axes[a].cvs = (nest->n ? xnmalloc (nest->n, sizeof *cell->axes[a].cvs) : NULL); for (size_t i = 0; i < nest->n; i++) { + const struct ctables_category *cat = cats[a][i]; + if (i != nest->scale_idx) { - const struct ctables_category *subtotal = cats[a][i]->subtotal; + const struct ctables_category *subtotal = cat->subtotal; if (subtotal && subtotal->type == CCT_HSUBTOTAL) cell->hide = true; + + if (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL) + cell->contributes_to_domains = false; } - cell->axes[a].cvs[i].category = cats[a][i]; + cell->axes[a].cvs[i].category = cat; value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]), var_get_width (nest->vars[i])); } @@ -2398,7 +2567,7 @@ static void ctables_cell_add__ (struct ctables_table *t, const struct ccase *c, size_t ix[PIVOT_N_AXES], const struct ctables_category *cats[PIVOT_N_AXES][10], - double weight) + double d_weight, double e_weight) { struct ctables_cell *cell = ctables_cell_insert__ (t, c, ix, cats); const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; @@ -2406,16 +2575,22 @@ ctables_cell_add__ (struct ctables_table *t, const struct ccase *c, const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv]; for (size_t i = 0; i < specs->n; i++) ctables_summary_add (&cell->summaries[i], &specs->specs[i], specs->var, - case_data (c, specs->var), weight); - for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) - cell->domains[dt]->valid += weight; + case_data (c, specs->var), d_weight, e_weight); + if (cell->contributes_to_domains) + { + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + cell->domains[dt]->d_valid += d_weight; + cell->domains[dt]->e_valid += e_weight; + } + } } static void recurse_totals (struct ctables_table *t, const struct ccase *c, size_t ix[PIVOT_N_AXES], const struct ctables_category *cats[PIVOT_N_AXES][10], - double weight, + double d_weight, double e_weight, enum pivot_axis_type start_axis, size_t start_nest) { for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) @@ -2434,8 +2609,36 @@ recurse_totals (struct ctables_table *t, const struct ccase *c, { const struct ctables_category *save = cats[a][i]; cats[a][i] = total; - ctables_cell_add__ (t, c, ix, cats, weight); - recurse_totals (t, c, ix, cats, weight, a, i + 1); + ctables_cell_add__ (t, c, ix, cats, d_weight, e_weight); + recurse_totals (t, c, ix, cats, d_weight, e_weight, a, i + 1); + cats[a][i] = save; + } + } + start_nest = 0; + } +} + +static void +recurse_subtotals (struct ctables_table *t, const struct ccase *c, + size_t ix[PIVOT_N_AXES], + const struct ctables_category *cats[PIVOT_N_AXES][10], + double d_weight, double e_weight, + enum pivot_axis_type start_axis, size_t start_nest) +{ + for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + for (size_t i = start_nest; i < nest->n; i++) + { + if (i == nest->scale_idx) + continue; + + const struct ctables_category *save = cats[a][i]; + if (save->subtotal) + { + cats[a][i] = save->subtotal; + ctables_cell_add__ (t, c, ix, cats, d_weight, e_weight); + recurse_subtotals (t, c, ix, cats, d_weight, e_weight, a, i + 1); cats[a][i] = save; } } @@ -2446,15 +2649,9 @@ recurse_totals (struct ctables_table *t, const struct ccase *c, static void ctables_cell_insert (struct ctables_table *t, const struct ccase *c, - size_t ir, size_t ic, size_t il, - double weight) + size_t ix[PIVOT_N_AXES], + double d_weight, double e_weight) { - size_t ix[PIVOT_N_AXES] = { - [PIVOT_AXIS_ROW] = ir, - [PIVOT_AXIS_COLUMN] = ic, - [PIVOT_AXIS_LAYER] = il, - }; - const struct ctables_category *cats[PIVOT_N_AXES][10]; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { @@ -2477,27 +2674,10 @@ ctables_cell_insert (struct ctables_table *t, } } - ctables_cell_add__ (t, c, ix, cats, weight); - - recurse_totals (t, c, ix, cats, weight, 0, 0); - - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - for (size_t i = 0; i < nest->n; i++) - { - if (i == nest->scale_idx) - continue; + ctables_cell_add__ (t, c, ix, cats, d_weight, e_weight); - const struct ctables_category *save = cats[a][i]; - if (save->subtotal) - { - cats[a][i] = save->subtotal; - ctables_cell_add__ (t, c, ix, cats, weight); - cats[a][i] = save; - } - } - } + recurse_totals (t, c, ix, cats, d_weight, e_weight, 0, 0); + recurse_subtotals (t, c, ix, cats, d_weight, e_weight, 0, 0); } struct merge_item @@ -2518,8 +2698,38 @@ merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b) return strcmp (as->label, bs->label); } +static struct pivot_value * +ctables_category_create_label (const struct ctables_category *cat, + const struct variable *var, + const union value *value) +{ + return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL + ? pivot_value_new_user_text (cat->total_label, SIZE_MAX) + : pivot_value_new_var_value (var, value)); +} + +static struct ctables_value * +ctables_value_find__ (struct ctables_table *t, const union value *value, + int width, unsigned int hash) +{ + struct ctables_value *clv; + HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node, + hash, &t->clabels_values_map) + if (value_equal (value, &clv->value, width)) + return clv; + return NULL; +} + +static struct ctables_value * +ctables_value_find (struct ctables_table *t, + const union value *value, int width) +{ + return ctables_value_find__ (t, value, width, + value_hash (value, width, 0)); +} + static void -ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t) +ctables_table_output (struct ctables *ct, struct ctables_table *t) { struct pivot_table *pt = pivot_table_create__ ( (t->title @@ -2533,6 +2743,41 @@ ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t) pivot_table_set_caption ( pt, pivot_value_new_user_text (t->corner, SIZE_MAX)); + bool summary_dimension = (t->summary_axis != t->slabels_axis + || (!t->slabels_visible + && t->summary_specs.n > 1)); + if (summary_dimension) + { + struct pivot_dimension *d = pivot_dimension_create ( + pt, t->slabels_axis, N_("Statistics")); + const struct ctables_summary_spec_set *specs = &t->summary_specs; + if (!t->slabels_visible) + d->hide_all_labels = true; + for (size_t i = 0; i < specs->n; i++) + pivot_category_create_leaf ( + d->root, pivot_value_new_text (specs->specs[i].label)); + } + + bool categories_dimension = t->clabels_example != NULL; + if (categories_dimension) + { + struct pivot_dimension *d = pivot_dimension_create ( + pt, t->label_axis[t->clabels_from_axis], + t->clabels_from_axis == PIVOT_AXIS_ROW + ? N_("Row Categories") + : N_("Column Categories")); + const struct variable *var = t->clabels_example; + const struct ctables_categories *c = t->categories[var_get_dict_index (var)]; + for (size_t i = 0; i < t->n_clabels_values; i++) + { + const struct ctables_value *value = t->clabels_values[i]; + const struct ctables_category *cat = ctables_categories_match (c, &value->value, var); + assert (cat != NULL); + pivot_category_create_leaf (d->root, ctables_category_create_label ( + cat, t->clabels_example, &value->value)); + } + } + pivot_table_set_look (pt, ct->look); struct pivot_dimension *d[PIVOT_N_AXES]; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) @@ -2551,113 +2796,159 @@ ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t) assert (t->axes[a]); struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); + size_t n_sorted = 0; struct ctables_cell *cell; - size_t n = 0; HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) if (!cell->hide) - sorted[n++] = cell; - assert (n <= t->cells.count); + sorted[n_sorted++] = cell; + assert (n_sorted <= t->cells.count); struct ctables_cell_sort_aux aux = { .t = t, .a = a }; - sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux); + sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux); size_t max_depth = 0; for (size_t j = 0; j < t->stacks[a].n; j++) if (t->stacks[a].nests[j].n > max_depth) max_depth = t->stacks[a].nests[j].n; - struct pivot_category **groups = xnmalloc (max_depth, sizeof *groups); - struct pivot_category *top = NULL; + /* Pivot categories: + + - variable label for nest->vars[0], if vlabel != CTVL_NONE + - category for nest->vars[0], if nest->scale_idx != 0 + - variable label for nest->vars[1], if vlabel != CTVL_NONE + - category for nest->vars[1], if nest->scale_idx != 1 + ... + - variable label for nest->vars[n - 1], if vlabel != CTVL_NONE + - category for nest->vars[n - 1], if t->label_axis[a] == a && nest->scale_idx != n - 1. + - summary function, if 'a == t->slabels_axis && a == + t->summary_axis'. + + Additional dimensions: + + - If 'a == t->slabels_axis && a != t->summary_axis', add a summary + dimension. + - If 't->label_axis[b] == a' for some 'b != a', add a category + dimension to 'a'. + */ + + struct ctables_level + { + enum ctables_level_type + { + CTL_VAR, /* Variable label for nest->vars[var_idx]. */ + CTL_CATEGORY, /* Category for nest->vars[var_idx]. */ + CTL_SUMMARY, /* Summary functions. */ + } + type; + + size_t var_idx; + }; + struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels); + size_t n_levels = 0; + + struct pivot_category **groups = xnmalloc (1 + 2 * max_depth, sizeof *groups); int prev_leaf = 0; - for (size_t j = 0; j < n; j++) + for (size_t j = 0; j < n_sorted; j++) { struct ctables_cell *cell = sorted[j]; - const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx]; + struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL; + const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].nest_idx]; - size_t n_common = 0; - bool new_subtable = false; - if (j > 0) + bool new_subtable = !prev || prev->axes[a].nest_idx != cell->axes[a].nest_idx; + if (new_subtable) { - struct ctables_cell *prev = sorted[j - 1]; - if (prev->axes[a].stack_idx == cell->axes[a].stack_idx) + n_levels = 0; + for (size_t k = 0; k < nest->n; k++) { - for (; n_common < nest->n; n_common++) - if (n_common != nest->scale_idx - && (prev->axes[a].cvs[n_common].category - != cell->axes[a].cvs[n_common].category - || !value_equal (&prev->axes[a].cvs[n_common].value, - &cell->axes[a].cvs[n_common].value, - var_get_type (nest->vars[n_common])))) - break; + enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])]; + if (vlabel != CTVL_NONE) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_VAR, + .var_idx = k, + }; + } + + if (nest->scale_idx != k + && (k != nest->n - 1 || t->label_axis[a] == a)) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_CATEGORY, + .var_idx = k, + }; + } } - else - new_subtable = true; - } - else - new_subtable = true; - if (new_subtable) - { - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[0])]; - top = d[a]->root; - if (vlabel != CTVL_NONE) - top = pivot_category_create_group__ ( - top, pivot_value_new_variable (nest->vars[0])); + if (!summary_dimension && a == t->slabels_axis) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_SUMMARY, + .var_idx = SIZE_MAX, + }; + } } - if (n_common == nest->n) + + size_t n_common = 0; + if (!new_subtable) { - cell->axes[a].leaf = prev_leaf; - continue; + for (; n_common < n_levels; n_common++) + { + const struct ctables_level *level = &levels[n_common]; + if (level->type == CTL_CATEGORY) + { + size_t var_idx = level->var_idx; + const struct ctables_category *c = cell->axes[a].cvs[var_idx].category; + if (prev->axes[a].cvs[var_idx].category != c) + break; + else if (c->type != CCT_SUBTOTAL + && c->type != CCT_HSUBTOTAL + && c->type != CCT_TOTAL + && !value_equal (&prev->axes[a].cvs[var_idx].value, + &cell->axes[a].cvs[var_idx].value, + var_get_type (nest->vars[var_idx]))) + break; + } + } } - for (size_t k = n_common; k < nest->n; k++) + for (size_t k = n_common; k < n_levels; k++) { - struct pivot_category *parent = k > 0 ? groups[k - 1] : top; - - struct pivot_value *label - = (k == nest->scale_idx ? NULL - : (cell->axes[a].cvs[k].category->type == CCT_TOTAL - || cell->axes[a].cvs[k].category->type == CCT_SUBTOTAL - || cell->axes[a].cvs[k].category->type == CCT_HSUBTOTAL) - ? pivot_value_new_user_text (cell->axes[a].cvs[k].category->total_label, - SIZE_MAX) - : pivot_value_new_var_value (nest->vars[k], - &cell->axes[a].cvs[k].value)); - if (k == nest->n - 1) + const struct ctables_level *level = &levels[k]; + struct pivot_category *parent = k ? groups[k - 1] : d[a]->root; + if (level->type == CTL_SUMMARY) { - if (a == t->summary_axis) + assert (k == n_levels - 1); + + const struct ctables_summary_spec_set *specs = &t->summary_specs; + for (size_t m = 0; m < specs->n; m++) { - if (label) - parent = pivot_category_create_group__ (parent, label); - const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv]; - for (size_t m = 0; m < specs->n; m++) - { - int leaf = pivot_category_create_leaf ( - parent, pivot_value_new_text (specs->specs[m].label)); - if (m == 0) - prev_leaf = leaf; - } + int leaf = pivot_category_create_leaf ( + parent, pivot_value_new_text (specs->specs[m].label)); + if (!m) + prev_leaf = leaf; } - else + } + else + { + const struct variable *var = nest->vars[level->var_idx]; + struct pivot_value *label; + if (level->type == CTL_VAR) + label = pivot_value_new_variable (var); + else if (level->type == CTL_CATEGORY) { - /* This assertion is true as long as the summary axis - is the axis where the summaries are displayed. */ - assert (label); - - prev_leaf = pivot_category_create_leaf (parent, label); + const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx]; + label = ctables_category_create_label (cv->category, + var, &cv->value); } - break; - } - - if (label) - parent = pivot_category_create_group__ (parent, label); + else + NOT_REACHED (); - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k + 1])]; - if (vlabel != CTVL_NONE) - parent = pivot_category_create_group__ ( - parent, pivot_value_new_variable (nest->vars[k + 1])); - groups[k] = parent; + if (k == n_levels - 1) + prev_leaf = pivot_category_create_leaf (parent, label); + else + groups[k] = pivot_category_create_group__ (parent, label); + } } cell->axes[a].leaf = prev_leaf; @@ -2665,24 +2956,38 @@ ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t) free (sorted); free (groups); } + struct ctables_cell *cell; HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) { if (cell->hide) continue; - const struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].stack_idx]; - const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv]; + const struct ctables_nest *specs_nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].nest_idx]; + const struct ctables_summary_spec_set *specs = &specs_nest->specs[cell->sv]; for (size_t j = 0; j < specs->n; j++) { - size_t dindexes[3]; + size_t dindexes[5]; size_t n_dindexes = 0; + if (summary_dimension) + dindexes[n_dindexes++] = specs->specs[j].axis_idx; + + if (categories_dimension) + { + const struct ctables_nest *clabels_nest = &t->stacks[t->clabels_from_axis].nests[cell->axes[t->clabels_from_axis].nest_idx]; + const struct variable *var = clabels_nest->vars[clabels_nest->n - 1]; + const union value *value = &cell->axes[t->clabels_from_axis].cvs[clabels_nest->n - 1].value; + const struct ctables_value *ctv = ctables_value_find (t, value, var_get_width (var)); + assert (ctv != NULL); + dindexes[n_dindexes++] = ctv->leaf; + } + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) if (d[a]) { int leaf = cell->axes[a].leaf; - if (a == t->summary_axis) + if (a == t->summary_axis && !summary_dimension) leaf += j; dindexes[n_dindexes++] = leaf; } @@ -2697,174 +3002,94 @@ ctables_table_output_same_axis (struct ctables *ct, struct ctables_table *t) pivot_table_submit (pt); } -static void -ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t) +static bool +ctables_check_label_position (struct ctables_table *t, enum pivot_axis_type a) { - struct pivot_table *pt = pivot_table_create__ ( - (t->title - ? pivot_value_new_user_text (t->title, SIZE_MAX) - : pivot_value_new_text (N_("Custom Tables"))), - "Custom Tables"); - if (t->caption) - pivot_table_set_caption ( - pt, pivot_value_new_user_text (t->caption, SIZE_MAX)); - if (t->corner) - pivot_table_set_caption ( - pt, pivot_value_new_user_text (t->corner, SIZE_MAX)); + enum pivot_axis_type label_pos = t->label_axis[a]; + if (label_pos == a) + return true; - pivot_table_set_look (pt, ct->look); - struct pivot_dimension *d[PIVOT_N_AXES]; - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - { - static const char *names[] = { - [PIVOT_AXIS_ROW] = N_("Rows"), - [PIVOT_AXIS_COLUMN] = N_("Columns"), - [PIVOT_AXIS_LAYER] = N_("Layers"), - }; - d[a] = (t->axes[a] || a == t->summary_axis - ? pivot_dimension_create (pt, a, names[a]) - : NULL); - if (!d[a]) - continue; + t->clabels_from_axis = a; - assert (t->axes[a]); + const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS"; + const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE"; - struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); + const struct ctables_stack *stack = &t->stacks[a]; + if (!stack->n) + return true; - struct ctables_cell *cell; - size_t n = 0; - HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) - if (!cell->hide) - sorted[n++] = cell; - assert (n <= t->cells.count); + const struct ctables_nest *n0 = &stack->nests[0]; + assert (n0->n > 0); + const struct variable *v0 = n0->vars[n0->n - 1]; + struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)]; + t->clabels_example = v0; - struct ctables_cell_sort_aux aux = { .t = t, .a = a }; - sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux); + for (size_t i = 0; i < c0->n_cats; i++) + if (c0->cats[i].type == CCT_FUNCTION) + { + msg (SE, _("%s=%s is not allowed with sorting based " + "on a summary function."), + subcommand_name, pos_name); + return false; + } + if (n0->n - 1 == n0->scale_idx) + { + msg (SE, _("%s=%s requires the variables to be moved to be categorical, " + "but %s is a scale variable."), + subcommand_name, pos_name, var_get_name (v0)); + return false; + } - size_t max_depth = 0; - for (size_t j = 0; j < t->stacks[a].n; j++) - if (t->stacks[a].nests[j].n > max_depth) - max_depth = t->stacks[a].nests[j].n; + for (size_t i = 1; i < stack->n; i++) + { + const struct ctables_nest *ni = &stack->nests[i]; + assert (ni->n > 0); + const struct variable *vi = ni->vars[ni->n - 1]; + struct ctables_categories *ci = t->categories[var_get_dict_index (vi)]; - struct pivot_category **groups = xnmalloc (max_depth, sizeof *groups); - struct pivot_category *top = NULL; - int prev_leaf = 0; - for (size_t j = 0; j < n; j++) + if (ni->n - 1 == ni->scale_idx) { - struct ctables_cell *cell = sorted[j]; - const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx]; - - /* Pivot categories: - - - variable label for nest->vars[0], if vlabel != CTVL_NONE - - category for nest->vars[0] - - variable label for nest->vars[1], if vlabel != CTVL_NONE - - category for nest->vars[1] - ... - - variable label for nest->vars[nest->n - 1], if vlabel != CTVL_NONE - - category for nest->vars[nest->n - 1], unless t->label_axis[a] != a. - - summary function, if 'a == t->slabels_axis && a == - t->summary_axis'. - - Additional dimensions: - - - If 'a == t->slabels_axis && a != t->summary_axis', add a summary - dimension. - - If 't->label_axis[b] == a' for some 'b != a', add a category - dimension to 'a'. - */ - - size_t n_common = 0; - bool new_subtable = false; - if (j > 0) - { - struct ctables_cell *prev = sorted[j - 1]; - if (prev->axes[a].stack_idx == cell->axes[a].stack_idx) - { - for (; n_common < nest->n; n_common++) - if (n_common != nest->scale_idx - && (prev->axes[a].cvs[n_common].category - != cell->axes[a].cvs[n_common].category - || !value_equal (&prev->axes[a].cvs[n_common].value, - &cell->axes[a].cvs[n_common].value, - var_get_type (nest->vars[n_common])))) - break; - } - else - new_subtable = true; - } - else - new_subtable = true; - - if (new_subtable) - { - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[0])]; - top = d[a]->root; - if (vlabel != CTVL_NONE) - top = pivot_category_create_group__ ( - top, pivot_value_new_variable (nest->vars[0])); - } - if (n_common == nest->n) - { - cell->axes[a].leaf = prev_leaf; - continue; - } - - for (size_t k = n_common; k < nest->n; k++) - { - struct pivot_category *parent = k > 0 ? groups[k - 1] : top; - - struct pivot_value *label - = (k == nest->scale_idx ? NULL - : (cell->axes[a].cvs[k].category->type == CCT_TOTAL - || cell->axes[a].cvs[k].category->type == CCT_SUBTOTAL - || cell->axes[a].cvs[k].category->type == CCT_HSUBTOTAL) - ? pivot_value_new_user_text (cell->axes[a].cvs[k].category->total_label, - SIZE_MAX) - : pivot_value_new_var_value (nest->vars[k], - &cell->axes[a].cvs[k].value)); - if (k == nest->n - 1) - { - if (a == t->slabels_axis) - { - if (label) - parent = pivot_category_create_group__ (parent, label); - const struct ctables_summary_spec_set *specs = &t->summary_specs; - for (size_t m = 0; m < specs->n; m++) - { - int leaf = pivot_category_create_leaf ( - parent, pivot_value_new_text (specs->specs[m].label)); - if (m == 0) - prev_leaf = leaf; - } - } - else - { - prev_leaf = pivot_category_create_leaf (parent, label ? label : pivot_value_new_user_text ("text", SIZE_MAX)); - } - break; - } - - if (label) - parent = pivot_category_create_group__ (parent, label); - - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k + 1])]; - if (vlabel != CTVL_NONE) - parent = pivot_category_create_group__ ( - parent, pivot_value_new_variable (nest->vars[k + 1])); - groups[k] = parent; - } - - cell->axes[a].leaf = prev_leaf; + msg (SE, _("%s=%s requires the variables to be moved to be " + "categorical, but %s is a scale variable."), + subcommand_name, pos_name, var_get_name (vi)); + return false; + } + if (var_get_width (v0) != var_get_width (vi)) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same width, but %s has " + "width %d and %s has width %d."), + subcommand_name, pos_name, + var_get_name (v0), var_get_width (v0), + var_get_name (vi), var_get_width (vi)); + return false; + } + if (!val_labs_equal (var_get_value_labels (v0), + var_get_value_labels (vi))) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same value labels, but %s " + "and %s have different value labels."), + subcommand_name, pos_name, + var_get_name (v0), var_get_name (vi)); + return false; + } + if (!ctables_categories_equal (c0, ci)) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same category " + "specifications, but %s and %s have different " + "category specifications."), + subcommand_name, pos_name, + var_get_name (v0), var_get_name (vi)); + return false; } - free (sorted); - free (groups); } - pivot_table_submit (pt); -} + return true; +} -static void +static bool ctables_prepare_table (struct ctables_table *t) { for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) @@ -3018,6 +3243,9 @@ ctables_prepare_table (struct ctables_table *t) } } #endif + + return (ctables_check_label_position (t, PIVOT_AXIS_ROW) + && ctables_check_label_position (t, PIVOT_AXIS_COLUMN)); } static void @@ -3028,32 +3256,38 @@ ctables_insert_clabels_values (struct ctables_table *t, const struct ccase *c, for (size_t i = 0; i < stack->n; i++) { const struct ctables_nest *nest = &stack->nests[i]; - const struct variable *v = nest->vars[nest->n - 1]; - int width = var_get_width (v); - const union value *value = case_data (c, v); - unsigned int hash = value_hash (value, width, 0); + const struct variable *var = nest->vars[nest->n - 1]; + int width = var_get_width (var); + const union value *value = case_data (c, var); - struct ctables_value *clv; - HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node, hash, - &t->clabels_values_map) - if (value_equal (value, &clv->value, width)) - goto next_stack; + if (var_is_numeric (var) && value->f == SYSMIS) + continue; + + if (!ctables_categories_match (t->categories [var_get_dict_index (var)], + value, var)) + continue; - clv = xmalloc (sizeof *clv); - value_clone (&clv->value, value, width); - hmap_insert (&t->clabels_values_map, &clv->node, hash); + unsigned int hash = value_hash (value, width, 0); - next_stack: ; + struct ctables_value *clv = ctables_value_find__ (t, value, width, hash); + if (!clv) + { + clv = xmalloc (sizeof *clv); + value_clone (&clv->value, value, width); + hmap_insert (&t->clabels_values_map, &clv->node, hash); + } } } static int compare_clabels_values_3way (const void *a_, const void *b_, const void *width_) { - const union value *a = a_; - const union value *b = b_; + const struct ctables_value *const *ap = a_; + const struct ctables_value *const *bp = b_; + const struct ctables_value *a = *ap; + const struct ctables_value *b = *bp; const int *width = width_; - return value_compare_3way (a, b, *width); + return value_compare_3way (&a->value, &b->value, *width); } static void @@ -3064,30 +3298,35 @@ ctables_sort_clabels_values (struct ctables_table *t) size_t n = hmap_count (&t->clabels_values_map); t->clabels_values = xnmalloc (n, sizeof *t->clabels_values); - const struct ctables_value *clv; + struct ctables_value *clv; size_t i = 0; HMAP_FOR_EACH (clv, struct ctables_value, node, &t->clabels_values_map) - t->clabels_values[i++] = clv->value; + t->clabels_values[i++] = clv; + t->n_clabels_values = n; assert (i == n); sort (t->clabels_values, n, sizeof *t->clabels_values, compare_clabels_values_3way, &width); + + for (size_t i = 0; i < n; i++) + t->clabels_values[i]->leaf = i; } static bool ctables_execute (struct dataset *ds, struct ctables *ct) { - struct casereader *input = casereader_create_filter_weight (proc_open (ds), - dataset_dict (ds), - NULL, NULL); + struct casereader *input = proc_open (ds); bool warn_on_invalid = true; - double total_weight = 0; for (struct ccase *c = casereader_read (input); c; case_unref (c), c = casereader_read (input)) { - double weight = dict_get_case_weight (dataset_dict (ds), c, - &warn_on_invalid); - total_weight += weight; + double d_weight = dict_get_case_weight (dataset_dict (ds), c, + &warn_on_invalid); + double e_weight = (ct->e_weight + ? var_force_valid_weight (ct->e_weight, + case_num (c, ct->e_weight), + &warn_on_invalid) + : d_weight); for (size_t i = 0; i < ct->n_tables; i++) { @@ -3096,7 +3335,15 @@ ctables_execute (struct dataset *ds, struct ctables *ct) for (size_t ir = 0; ir < t->stacks[PIVOT_AXIS_ROW].n; ir++) for (size_t ic = 0; ic < t->stacks[PIVOT_AXIS_COLUMN].n; ic++) for (size_t il = 0; il < t->stacks[PIVOT_AXIS_LAYER].n; il++) - ctables_cell_insert (t, c, ir, ic, il, weight); + { + size_t ix[PIVOT_N_AXES] = { + [PIVOT_AXIS_ROW] = ir, + [PIVOT_AXIS_COLUMN] = ic, + [PIVOT_AXIS_LAYER] = il, + }; + + ctables_cell_insert (t, c, ix, d_weight, e_weight); + } for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) if (t->label_axis[a] != a) @@ -3112,85 +3359,11 @@ ctables_execute (struct dataset *ds, struct ctables *ct) if (t->clabels_example) ctables_sort_clabels_values (t); - if (t->summary_axis == t->slabels_axis) - ctables_table_output_same_axis (ct, ct->tables[i]); - else - ctables_table_output_different_axis (ct, ct->tables[i]); + ctables_table_output (ct, ct->tables[i]); } return proc_commit (ds); } -static bool -ctables_check_label_position (struct ctables_table *t, enum pivot_axis_type a) -{ - enum pivot_axis_type label_pos = t->label_axis[a]; - if (label_pos == a) - return true; - - const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS"; - const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE"; - - const struct ctables_stack *stack = &t->stacks[a]; - if (!stack->n) - return true; - - const struct ctables_nest *n0 = &stack->nests[0]; - assert (n0->n > 0); - const struct variable *v0 = n0->vars[n0->n - 1]; - struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)]; - t->clabels_example = v0; - - for (size_t i = 0; i < c0->n_cats; i++) - if (c0->cats[i].type == CCT_FUNCTION) - { - msg (SE, _("%s=%s is not allowed with sorting based " - "on a summary function."), - subcommand_name, pos_name); - return false; - } - - for (size_t i = 1; i < stack->n; i++) - { - const struct ctables_nest *ni = &stack->nests[i]; - assert (ni->n > 0); - const struct variable *vi = ni->vars[ni->n - 1]; - struct ctables_categories *ci = t->categories[var_get_dict_index (vi)]; - - if (var_get_width (v0) != var_get_width (vi)) - { - msg (SE, _("%s=%s requires the variables to be " - "moved to have the same width, but %s has " - "width %d and %s has width %d."), - subcommand_name, pos_name, - var_get_name (v0), var_get_width (v0), - var_get_name (vi), var_get_width (vi)); - return false; - } - if (!val_labs_equal (var_get_value_labels (v0), - var_get_value_labels (vi))) - { - msg (SE, _("%s=%s requires the variables to be " - "moved to have the same value labels, but %s " - "and %s have different value labels."), - subcommand_name, pos_name, - var_get_name (v0), var_get_name (vi)); - return false; - } - if (!ctables_categories_equal (c0, ci)) - { - msg (SE, _("%s=%s requires the variables to be " - "moved to have the same category " - "specifications, but %s and %s have different " - "category specifications."), - subcommand_name, pos_name, - var_get_name (v0), var_get_name (vi)); - return false; - } - } - - return true; -} - int cmd_ctables (struct lexer *lexer, struct dataset *ds) { @@ -3370,8 +3543,8 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) if (!lex_force_match_id (lexer, "VARIABLE")) goto error; lex_match (lexer, T_EQUALS); - ct->base_weight = parse_variable (lexer, dataset_dict (ds)); - if (!ct->base_weight) + ct->e_weight = parse_variable (lexer, dataset_dict (ds)); + if (!ct->e_weight) goto error; } else if (lex_match_id (lexer, "HIDESMALLCOUNTS")) @@ -3434,6 +3607,7 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) [PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN, [PIVOT_AXIS_LAYER] = PIVOT_AXIS_LAYER, }, + .clabels_from_axis = PIVOT_AXIS_LAYER, .categories = categories, .n_categories = n_vars, .cilevel = 95, @@ -3521,7 +3695,11 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) } if (lex_token (lexer) == T_ENDCMD) - break; + { + if (!ctables_prepare_table (t)) + goto error; + break; + } if (!lex_force_match (lexer, T_SLASH)) break; @@ -3869,10 +4047,8 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) goto error; } - ctables_prepare_table (t); - - ctables_check_label_position (t, PIVOT_AXIS_ROW); - ctables_check_label_position (t, PIVOT_AXIS_COLUMN); + if (!ctables_prepare_table (t)) + goto error; } while (lex_token (lexer) != T_ENDCMD);