X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=bba0fb67fcf0859457e724f276a43dbc580bbc6f;hb=a3e3480951ad0d6f14ff1333f80f1c2c0d58402f;hp=510efcd5cd224df0ed4eb4f9a279f68fcf0fe88f;hpb=c93512af682a37c450da462f7856ea1c279223fa;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 510efcd5cd..bba0fb67fc 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -22,6 +22,7 @@ #include "data/dataset.h" #include "data/dictionary.h" #include "data/mrset.h" +#include "data/value-labels.h" #include "language/command.h" #include "language/lexer/format-parser.h" #include "language/lexer/lexer.h" @@ -171,6 +172,13 @@ struct ctables_domain double missing; }; +enum ctables_summary_variant + { + CSV_CELL, + CSV_TOTAL +#define N_CSVS 2 + }; + struct ctables_cell { /* In struct ctables's 'cells' hmap. Indexed by all the values in all the @@ -181,7 +189,7 @@ struct ctables_cell struct ctables_domain *domains[N_CTDTS]; bool hide; - bool total; + enum ctables_summary_variant sv; struct { @@ -270,13 +278,6 @@ struct ctables_postcompute_expr }; }; -enum ctables_label_position - { - CTLP_NORMAL, - CTLP_OPPOSITE, - CTLP_LAYER, - }; - struct ctables_summary_spec_set { struct ctables_summary_spec *specs; @@ -286,6 +287,8 @@ struct ctables_summary_spec_set struct variable *var; }; +static void ctables_summary_spec_set_clone (struct ctables_summary_spec_set *, + const struct ctables_summary_spec_set *); static void ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *); /* A nested sequence of variables, e.g. a > b > c. */ @@ -297,8 +300,7 @@ struct ctables_nest size_t *domains[N_CTDTS]; size_t n_domains[N_CTDTS]; - struct ctables_summary_spec_set cell_sss; - struct ctables_summary_spec_set total_sss; + struct ctables_summary_spec_set specs[N_CSVS]; }; /* A stack of nestings, e.g. nest1 + nest2 + ... + nestN. */ @@ -308,19 +310,40 @@ struct ctables_stack size_t n; }; +struct ctables_value + { + struct hmap_node node; + union value value; + }; + struct ctables_table { struct ctables_axis *axes[PIVOT_N_AXES]; struct ctables_stack stacks[PIVOT_N_AXES]; enum pivot_axis_type summary_axis; + struct ctables_summary_spec_set summary_specs; struct hmap cells; struct hmap domains[N_CTDTS]; - enum pivot_axis_type slabels_position; + const struct variable *clabels_example; + struct hmap clabels_values_map; + union value *clabels_values; + size_t n_clabels_values; + + enum pivot_axis_type slabels_axis; bool slabels_visible; - enum ctables_label_position row_labels; - enum ctables_label_position col_labels; + /* The innermost category labels for axis 'a' appear on axis label_axis[a]. + + Most commonly, label_axis[a] == a, and in particular we always have + label_axis{PIVOT_AXIS_LAYER] == PIVOT_AXIS_LAYER. + + If ROWLABELS or COLLABELS is specified, then one of + label_axis[PIVOT_AXIS_ROW] or label_axis[PIVOT_AXIS_COLUMN] can be the + 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; @@ -442,6 +465,46 @@ ctables_category_uninit (struct ctables_category *cat) } } +static bool +ctables_category_equal (const struct ctables_category *a, + const struct ctables_category *b) +{ + if (a->type != b->type) + return false; + + switch (a->type) + { + case CCT_NUMBER: + return a->number == b->number; + + case CCT_STRING: + return strcmp (a->string, b->string); + + case CCT_RANGE: + return a->range[0] == b->range[0] && a->range[1] == b->range[1]; + + case CCT_MISSING: + case CCT_OTHERNM: + return true; + + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + case CCT_TOTAL: + return !strcmp (a->total_label, b->total_label); + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + return (a->include_missing == b->include_missing + && a->sort_ascending == b->sort_ascending + && a->sort_function == b->sort_function + && a->sort_var == b->sort_var + && a->percentile == b->percentile); + } + + NOT_REACHED (); +} + static void ctables_categories_unref (struct ctables_categories *c) { @@ -458,6 +521,20 @@ ctables_categories_unref (struct ctables_categories *c) free (c); } +static bool +ctables_categories_equal (const struct ctables_categories *a, + const struct ctables_categories *b) +{ + if (a->n_cats != b->n_cats || a->show_empty != b->show_empty) + return false; + + for (size_t i = 0; i < a->n_cats; i++) + if (!ctables_category_equal (&a->cats[i], &b->cats[i])) + return false; + + return true; +} + /* Chi-square test (SIGTEST). */ struct ctables_chisq { @@ -500,8 +577,7 @@ struct ctables_axis { struct ctables_var var; bool scale; - struct ctables_summary_spec_set cell_sss; - struct ctables_summary_spec_set total_sss; + struct ctables_summary_spec_set specs[N_CSVS]; }; /* Nonterminals. */ @@ -533,8 +609,17 @@ struct ctables_summary_spec double percentile; /* CTSF_PTILE only. */ char *label; struct fmt_spec format; /* XXX extra CTABLES formats */ + size_t axis_idx; }; +static void +ctables_summary_spec_clone (struct ctables_summary_spec *dst, + const struct ctables_summary_spec *src) +{ + *dst = *src; + dst->label = xstrdup (src->label); +} + static void ctables_summary_spec_uninit (struct ctables_summary_spec *s) { @@ -542,6 +627,22 @@ ctables_summary_spec_uninit (struct ctables_summary_spec *s) free (s->label); } +static void +ctables_summary_spec_set_clone (struct ctables_summary_spec_set *dst, + const struct ctables_summary_spec_set *src) +{ + struct ctables_summary_spec *specs = xnmalloc (src->n, sizeof *specs); + for (size_t i = 0; i < src->n; i++) + ctables_summary_spec_clone (&specs[i], &src->specs[i]); + + *dst = (struct ctables_summary_spec_set) { + .specs = specs, + .n = src->n, + .allocated = src->n, + .var = src->var + }; +} + static void ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *set) { @@ -643,8 +744,8 @@ ctables_axis_destroy (struct ctables_axis *axis) switch (axis->op) { case CTAO_VAR: - ctables_summary_spec_set_uninit (&axis->cell_sss); - ctables_summary_spec_set_uninit (&axis->total_sss); + for (size_t i = 0; i < N_CSVS; i++) + ctables_summary_spec_set_uninit (&axis->specs[i]); break; case CTAO_STACK: @@ -735,7 +836,7 @@ static bool add_summary_spec (struct ctables_axis *axis, enum ctables_summary_function function, double percentile, const char *label, const struct fmt_spec *format, - const struct msg_location *loc, bool totals) + const struct msg_location *loc, enum ctables_summary_variant sv) { if (axis->op == CTAO_VAR) { @@ -770,8 +871,7 @@ add_summary_spec (struct ctables_axis *axis, break; } - struct ctables_summary_spec_set *set = (totals ? &axis->total_sss - : &axis->cell_sss); + struct ctables_summary_spec_set *set = &axis->specs[sv]; if (set->n >= set->allocated) set->specs = x2nrealloc (set->specs, &set->allocated, sizeof *set->specs); @@ -790,7 +890,7 @@ add_summary_spec (struct ctables_axis *axis, { for (size_t i = 0; i < 2; i++) if (!add_summary_spec (axis->subs[i], function, percentile, label, - format, loc, totals)) + format, loc, sv)) return false; return true; } @@ -864,6 +964,12 @@ ctables_axis_parse_primary (struct ctables_axis_parse_ctx *ctx) return axis; } +static bool +has_digit (const char *s) +{ + return s[strcspn (s, "0123456789")] != '\0'; +} + static struct ctables_axis * ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) { @@ -871,7 +977,7 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) if (!sub || !lex_match (ctx->lexer, T_LBRACK)) return sub; - bool totals = false; + enum ctables_summary_variant sv = CSV_CELL; for (;;) { int start_ofs = lex_ofs (ctx->lexer); @@ -904,7 +1010,8 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) /* Parse format. */ struct fmt_spec format; const struct fmt_spec *formatp; - if (lex_token (ctx->lexer) == T_ID) + if (lex_token (ctx->lexer) == T_ID + && has_digit (lex_tokcstr (ctx->lexer))) { if (!parse_format_specifier (ctx->lexer, &format) || !fmt_check_output (&format) @@ -920,28 +1027,23 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) struct msg_location *loc = lex_ofs_location (ctx->lexer, start_ofs, lex_ofs (ctx->lexer) - 1); - add_summary_spec (sub, function, percentile, label, formatp, loc, - totals); + add_summary_spec (sub, function, percentile, label, formatp, loc, sv); free (label); msg_location_destroy (loc); - if (lex_match (ctx->lexer, T_COMMA)) + lex_match (ctx->lexer, T_COMMA); + if (sv == CSV_CELL && lex_match_id (ctx->lexer, "TOTALS")) { - if (!totals && lex_match_id (ctx->lexer, "TOTALS")) - { - if (!lex_force_match (ctx->lexer, T_LBRACK)) - goto error; - totals = true; - } + if (!lex_force_match (ctx->lexer, T_LBRACK)) + goto error; + sv = CSV_TOTAL; } - else if (lex_force_match (ctx->lexer, T_RBRACK)) + else if (lex_match (ctx->lexer, T_RBRACK)) { - if (totals && !lex_force_match (ctx->lexer, T_RBRACK)) + if (sv == CSV_TOTAL && !lex_force_match (ctx->lexer, T_RBRACK)) goto error; return sub; } - else - goto error; } error: @@ -982,7 +1084,7 @@ find_categorical_summary_spec (const struct ctables_axis *axis) if (!axis) return NULL; else if (axis->op == CTAO_VAR) - return !axis->scale && axis->cell_sss.n ? axis : NULL; + return !axis->scale && axis->specs[CSV_CELL].n ? axis : NULL; else { for (size_t i = 0; i < 2; i++) @@ -1481,21 +1583,23 @@ nest_fts (struct ctables_stack s0, struct ctables_stack s1) assert (n == allocate); const struct ctables_nest *summary_src; - if (!a->cell_sss.var) + if (!a->specs[CSV_CELL].var) summary_src = b; - else if (!b->cell_sss.var) + else if (!b->specs[CSV_CELL].var) summary_src = a; else NOT_REACHED (); - stack.nests[stack.n++] = (struct ctables_nest) { + + struct ctables_nest *new = &stack.nests[stack.n++]; + *new = (struct ctables_nest) { .vars = vars, .scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx : SIZE_MAX), .n = n, - .cell_sss = summary_src->cell_sss, - .total_sss = summary_src->total_sss, }; + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + ctables_summary_spec_set_clone (&new->specs[sv], &summary_src->specs[sv]); } ctables_stack_uninit (&s0); ctables_stack_uninit (&s1); @@ -1536,13 +1640,12 @@ enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a) .n = 1, .scale_idx = a->scale ? 0 : SIZE_MAX, }; - if (a->cell_sss.n || a->scale) - { - nest->cell_sss = a->cell_sss; - nest->total_sss = a->total_sss; - nest->cell_sss.var = a->var.var; - nest->total_sss.var = a->var.var; - } + if (a->specs[CSV_CELL].n || a->scale) + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + { + ctables_summary_spec_set_clone (&nest->specs[sv], &a->specs[sv]); + nest->specs[sv].var = a->var.var; + } return (struct ctables_stack) { .nests = nest, .n = 1 }; case CTAO_STACK: @@ -1856,7 +1959,7 @@ ctables_summary_add (union ctables_summary *s, } } -static double +static double UNUSED ctables_summary_value (const struct ctables_cell *cell, union ctables_summary *s, const struct ctables_summary_spec *ss) @@ -2214,7 +2317,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; size_t hash = 0; - bool total = false; + enum ctables_summary_variant sv = CSV_CELL; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; @@ -2229,7 +2332,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, hash = value_hash (case_data (c, nest->vars[i]), var_get_width (nest->vars[i]), hash); else - total = true; + sv = CSV_TOTAL; } } @@ -2260,7 +2363,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, cell = xmalloc (sizeof *cell); cell->hide = false; - cell->total = total; + cell->sv = sv; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; @@ -2283,13 +2386,10 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, } } - { - const struct ctables_summary_spec_set *sss - = (cell->total ? &ss->total_sss : &ss->cell_sss); - cell->summaries = xmalloc (sss->n * sizeof *cell->summaries); - for (size_t i = 0; i < sss->n; i++) - ctables_summary_init (&cell->summaries[i], &sss->specs[i]); - } + const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv]; + cell->summaries = xmalloc (specs->n * sizeof *cell->summaries); + for (size_t i = 0; i < specs->n; i++) + ctables_summary_init (&cell->summaries[i], &specs->specs[i]); for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) cell->domains[dt] = ctables_domain_insert (t, cell, dt); hmap_insert (&t->cells, &cell->node, hash); @@ -2305,11 +2405,10 @@ ctables_cell_add__ (struct ctables_table *t, const struct ccase *c, 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]]; - const struct ctables_summary_spec_set *sss - = (cell->total ? &ss->total_sss : &ss->cell_sss); - for (size_t i = 0; i < sss->n; i++) - ctables_summary_add (&cell->summaries[i], &sss->specs[i], sss->var, - case_data (c, sss->var), weight); + 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; } @@ -2403,105 +2502,478 @@ ctables_cell_insert (struct ctables_table *t, } } -static bool -ctables_execute (struct dataset *ds, struct ctables *ct) +struct merge_item + { + const struct ctables_summary_spec_set *set; + size_t ofs; + }; + +static int +merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b) { - for (size_t i = 0; i < ct->n_tables; i++) + const struct ctables_summary_spec *as = &a->set->specs[a->ofs]; + const struct ctables_summary_spec *bs = &b->set->specs[b->ofs]; + if (as->function != bs->function) + return as->function > bs->function ? 1 : -1; + else if (as->percentile != bs->percentile) + return as->percentile < bs->percentile ? 1 : -1; + 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 void +ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t) +{ + 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)); + + if (t->summary_axis != t->slabels_axis) { - struct ctables_table *t = ct->tables[i]; - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - if (t->axes[a]) - { - t->stacks[a] = enumerate_fts (a, t->axes[a]); + struct pivot_dimension *d = pivot_dimension_create ( + pt, t->slabels_axis, N_("Summaries")); + const struct ctables_summary_spec_set *specs = &t->summary_specs; + for (size_t i = 0; i < specs->n; i++) + pivot_category_create_leaf ( + d->root, pivot_value_new_text (specs->specs[i].label)); + } + + if (t->clabels_example) + { + 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 union value *value = &t->clabels_values[i]; + const struct ctables_category *cat = ctables_categories_match (c, value, var); + if (!cat) + { + /* XXX probably missing */ + continue; + } + pivot_category_create_leaf (d->root, ctables_category_create_label ( + cat, t->clabels_example, 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++) + { + 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; + + assert (t->axes[a]); + + struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); + size_t n_sorted = 0; + + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) + if (!cell->hide) + sorted[n_sorted++] = cell; + assert (n_sorted <= t->cells.count); + + struct ctables_cell_sort_aux aux = { .t = t, .a = a }; + 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; + + /* 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_sorted; j++) + { + struct ctables_cell *cell = sorted[j]; + struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL; + const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx]; + + bool new_subtable = !prev || prev->axes[a].stack_idx != cell->axes[a].stack_idx; + if (new_subtable) + { + n_levels = 0; + printf ("%s levels:", pivot_axis_type_to_string (a)); + for (size_t k = 0; k < nest->n; k++) + { + enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])]; + if (vlabel != CTVL_NONE) + { + printf (" var(%s)", var_get_name (nest->vars[k])); + 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)) + { + printf (" category(%s)", var_get_name (nest->vars[k])); + levels[n_levels++] = (struct ctables_level) { + .type = CTL_CATEGORY, + .var_idx = k, + }; + } + } + + if (a == t->slabels_axis && a == t->summary_axis) + { + printf (" summary"); + levels[n_levels++] = (struct ctables_level) { + .type = CTL_SUMMARY, + .var_idx = SIZE_MAX, + }; + } + printf ("\n"); + } + + size_t n_common = 0; + if (!new_subtable) + { + 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; + if (prev->axes[a].cvs[var_idx].category + != cell->axes[a].cvs[var_idx].category) + { + break; + } + else if (!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 < n_levels; k++) + { + const struct ctables_level *level = &levels[k]; + struct pivot_category *parent = k ? groups[k - 1] : d[a]->root; + if (level->type == CTL_SUMMARY) + { + const struct ctables_summary_spec_set *specs = &t->summary_specs; + for (size_t m = 0; m < specs->n; m++) + pivot_category_create_leaf ( + parent, pivot_value_new_text (specs->specs[m].label)); + } + 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) + { + const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx]; + label = ctables_category_create_label (cv->category, + var, &cv->value); + } + else + NOT_REACHED (); + + if (k == n_levels - 1) + pivot_category_create_leaf (parent, label); + else + groups[k] = pivot_category_create_group__ (parent, label); + } + } + + cell->axes[a].leaf = prev_leaf; + } + free (sorted); + free (groups); + } + pivot_table_submit (pt); +} + - for (size_t j = 0; j < t->stacks[a].n; j++) +static void +ctables_prepare_table (struct ctables_table *t) +{ + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (t->axes[a]) + { + t->stacks[a] = enumerate_fts (a, t->axes[a]); + + for (size_t j = 0; j < t->stacks[a].n; j++) + { + struct ctables_nest *nest = &t->stacks[a].nests[j]; + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) { - struct ctables_nest *nest = &t->stacks[a].nests[j]; - for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); + nest->n_domains[dt] = 0; + + for (size_t k = 0; k < nest->n; k++) { - nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); - nest->n_domains[dt] = 0; + if (k == nest->scale_idx) + continue; - for (size_t k = 0; k < nest->n; k++) + switch (dt) { - if (k == nest->scale_idx) - continue; + case CTDT_TABLE: + continue; - switch (dt) + case CTDT_LAYER: + if (a != PIVOT_AXIS_LAYER) + continue; + break; + + case CTDT_SUBTABLE: + case CTDT_ROW: + case CTDT_COL: + if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER + : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN + : a == PIVOT_AXIS_ROW) { - case CTDT_TABLE: - continue; - - case CTDT_LAYER: - if (a != PIVOT_AXIS_LAYER) - continue; - break; - - case CTDT_SUBTABLE: - case CTDT_ROW: - case CTDT_COL: - if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER - : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN - : a == PIVOT_AXIS_ROW) - { - if (k == nest->n - 1 - || (nest->scale_idx == nest->n - 1 - && k == nest->n - 2)) - continue; - } - break; - - case CTDT_LAYERROW: - if (a == PIVOT_AXIS_COLUMN) + if (k == nest->n - 1 + || (nest->scale_idx == nest->n - 1 + && k == nest->n - 2)) continue; - break; - - case CTDT_LAYERCOL: - if (a == PIVOT_AXIS_ROW) - continue; - break; } + break; + + case CTDT_LAYERROW: + if (a == PIVOT_AXIS_COLUMN) + continue; + break; - nest->domains[dt][nest->n_domains[dt]++] = k; + case CTDT_LAYERCOL: + if (a == PIVOT_AXIS_ROW) + continue; + break; } + + nest->domains[dt][nest->n_domains[dt]++] = k; } } } - else - { - struct ctables_nest *nest = xmalloc (sizeof *nest); - *nest = (struct ctables_nest) { .n = 0 }; - t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 }; - } + } + else + { + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { .n = 0 }; + t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 }; + } - for (size_t i = 0; i < t->stacks[t->summary_axis].n; i++) + struct ctables_stack *stack = &t->stacks[t->summary_axis]; + for (size_t i = 0; i < stack->n; i++) + { + struct ctables_nest *nest = &stack->nests[i]; + if (!nest->specs[CSV_CELL].n) { - struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[i]; - if (!nest->cell_sss.n) - { - struct ctables_summary_spec_set *sss = &nest->cell_sss; - sss->specs = xmalloc (sizeof *sss->specs); - sss->n = 1; - - enum ctables_summary_function function - = sss->var ? CTSF_MEAN : CTSF_COUNT; - struct ctables_var var = { .is_mrset = false, .var = sss->var }; - - *sss->specs = (struct ctables_summary_spec) { - .function = function, - .format = ctables_summary_default_format (function, &var), - .label = ctables_summary_default_label (function, 0), - }; - if (!sss->var) - sss->var = nest->vars[0]; + struct ctables_summary_spec_set *specs = &nest->specs[CSV_CELL]; + specs->specs = xmalloc (sizeof *specs->specs); + specs->n = 1; + + enum ctables_summary_function function + = specs->var ? CTSF_MEAN : CTSF_COUNT; + struct ctables_var var = { .is_mrset = false, .var = specs->var }; + + *specs->specs = (struct ctables_summary_spec) { + .function = function, + .format = ctables_summary_default_format (function, &var), + .label = ctables_summary_default_label (function, 0), + }; + if (!specs->var) + specs->var = nest->vars[0]; + + ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], + &nest->specs[CSV_CELL]); + } + else if (!nest->specs[CSV_TOTAL].n) + ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], + &nest->specs[CSV_CELL]); + } + + struct ctables_summary_spec_set *merged = &t->summary_specs; + struct merge_item *items = xnmalloc (2 * stack->n, sizeof *items); + size_t n_left = 0; + for (size_t j = 0; j < stack->n; j++) + { + const struct ctables_nest *nest = &stack->nests[j]; + if (nest->n) + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + items[n_left++] = (struct merge_item) { .set = &nest->specs[sv] }; + } - nest->total_sss = nest->cell_sss; + while (n_left > 0) + { + struct merge_item min = items[0]; + for (size_t j = 1; j < n_left; j++) + if (merge_item_compare_3way (&items[j], &min) < 0) + min = items[j]; + + if (merged->n >= merged->allocated) + merged->specs = x2nrealloc (merged->specs, &merged->allocated, + sizeof *merged->specs); + merged->specs[merged->n++] = min.set->specs[min.ofs]; + + for (size_t j = 0; j < n_left; ) + { + if (merge_item_compare_3way (&items[j], &min) == 0) + { + struct merge_item *item = &items[j]; + item->set->specs[item->ofs].axis_idx = merged->n - 1; + if (++item->ofs >= item->set->n) + { + items[j] = items[--n_left]; + continue; + } } - else if (!nest->total_sss.n) - nest->total_sss = nest->cell_sss; + j++; + } + } + +#if 0 + for (size_t j = 0; j < merged->n; j++) + printf ("%s\n", ctables_summary_function_name (merged->specs[j].function)); + + for (size_t j = 0; j < stack->n; j++) + { + const struct ctables_nest *nest = &stack->nests[j]; + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + { + const struct ctables_summary_spec_set *specs = &nest->specs[sv]; + for (size_t k = 0; k < specs->n; k++) + printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function), + specs->specs[k].axis_idx); + printf ("\n"); } } +#endif +} + +static void +ctables_insert_clabels_values (struct ctables_table *t, const struct ccase *c, + enum pivot_axis_type a) +{ + struct ctables_stack *stack = &t->stacks[a]; + 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); + + 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; + + clv = xmalloc (sizeof *clv); + value_clone (&clv->value, value, width); + hmap_insert (&t->clabels_values_map, &clv->node, hash); + + next_stack: ; + } +} +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 int *width = width_; + return value_compare_3way (a, b, *width); +} + +static void +ctables_sort_clabels_values (struct ctables_table *t) +{ + int width = var_get_width (t->clabels_example); + + size_t n = hmap_count (&t->clabels_values_map); + t->clabels_values = xnmalloc (n, sizeof *t->clabels_values); + + const 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->n_clabels_values = n; + assert (i == n); + + sort (t->clabels_values, n, sizeof *t->clabels_values, + compare_clabels_values_3way, &width); +} + +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); @@ -2522,6 +2994,10 @@ ctables_execute (struct dataset *ds, struct ctables *ct) 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); + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (t->label_axis[a] != a) + ctables_insert_clabels_values (t, c, a); } } casereader_destroy (input); @@ -2530,184 +3006,99 @@ ctables_execute (struct dataset *ds, struct ctables *ct) { struct ctables_table *t = ct->tables[i]; - 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)); - - 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; - - assert (t->axes[a]); - - struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); + if (t->clabels_example) + ctables_sort_clabels_values (t); - 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); - - struct ctables_cell_sort_aux aux = { .t = t, .a = a }; - sort (sorted, n, 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; + ctables_table_output_different_axis (ct, ct->tables[i]); + } + return proc_commit (ds); +} - 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++) - { - struct ctables_cell *cell = sorted[j]; - const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx]; +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; - 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; + t->clabels_from_axis = a; - 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; - } + const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS"; + const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE"; - 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->summary_axis) - { - if (label) - parent = pivot_category_create_group__ (parent, label); - const struct ctables_summary_spec_set *sss - = cell->total ? &nest->total_sss : &nest->cell_sss; - for (size_t m = 0; m < sss->n; m++) - { - int leaf = pivot_category_create_leaf ( - parent, pivot_value_new_text (sss->specs[m].label)); - if (m == 0) - prev_leaf = leaf; - } - } - else - { - /* This assertion is true as long as the summary axis - is the axis where the summaries are displayed. */ - assert (label); + const struct ctables_stack *stack = &t->stacks[a]; + if (!stack->n) + return true; - prev_leaf = pivot_category_create_leaf (parent, label); - } - break; - } + 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; - if (label) - parent = pivot_category_create_group__ (parent, label); + 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; + } - 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; - } + 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)]; - cell->axes[a].leaf = prev_leaf; - } - free (sorted); - free (groups); + if (ni->n - 1 == ni->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 (vi)); + return false; } - struct ctables_cell *cell; - HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) + if (var_get_width (v0) != var_get_width (vi)) { - 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 *sss = cell->total ? &nest->total_sss : &nest->cell_sss; - for (size_t j = 0; j < sss->n; j++) - { - size_t dindexes[3]; - size_t n_dindexes = 0; - - 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) - leaf += j; - dindexes[n_dindexes++] = leaf; - } - - double d = ctables_summary_value (cell, &cell->summaries[j], &sss->specs[j]); - struct pivot_value *value = pivot_value_new_number (d); - value->numeric.format = sss->specs[j].format; - pivot_table_put (pt, dindexes, n_dindexes, value); - } + 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; } - - pivot_table_submit (pt); } - return proc_commit (ds); + return true; } int @@ -2945,10 +3336,15 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) struct ctables_table *t = xmalloc (sizeof *t); *t = (struct ctables_table) { .cells = HMAP_INITIALIZER (t->cells), - .slabels_position = PIVOT_AXIS_COLUMN, + .slabels_axis = PIVOT_AXIS_COLUMN, .slabels_visible = true, - .row_labels = CTLP_NORMAL, - .col_labels = CTLP_NORMAL, + .clabels_values_map = HMAP_INITIALIZER (t->clabels_values_map), + .label_axis = { + [PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW, + [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, @@ -3044,17 +3440,17 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) { if (lex_match_id (lexer, "SLABELS")) { - while (lex_token (lexer) != T_SLASH) + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) { if (lex_match_id (lexer, "POSITION")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "COLUMN")) - t->slabels_position = PIVOT_AXIS_COLUMN; + t->slabels_axis = PIVOT_AXIS_COLUMN; else if (lex_match_id (lexer, "ROW")) - t->slabels_position = PIVOT_AXIS_ROW; + t->slabels_axis = PIVOT_AXIS_ROW; else if (lex_match_id (lexer, "LAYER")) - t->slabels_position = PIVOT_AXIS_LAYER; + t->slabels_axis = PIVOT_AXIS_LAYER; else { lex_error_expecting (lexer, "COLUMN", "ROW", "LAYER"); @@ -3076,17 +3472,20 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) } else if (lex_match_id (lexer, "CLABELS")) { - while (lex_token (lexer) != T_SLASH) + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) { if (lex_match_id (lexer, "AUTO")) - t->row_labels = t->col_labels = CTLP_NORMAL; + { + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW; + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN; + } else if (lex_match_id (lexer, "ROWLABELS")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "OPPOSITE")) - t->row_labels = CTLP_OPPOSITE; + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_COLUMN; else if (lex_match_id (lexer, "LAYER")) - t->row_labels = CTLP_LAYER; + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_LAYER; else { lex_error_expecting (lexer, "OPPOSITE", "LAYER"); @@ -3097,9 +3496,9 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "OPPOSITE")) - t->col_labels = CTLP_OPPOSITE; + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_ROW; else if (lex_match_id (lexer, "LAYER")) - t->col_labels = CTLP_LAYER; + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_LAYER; else { lex_error_expecting (lexer, "OPPOSITE", "LAYER"); @@ -3374,12 +3773,17 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) break; } - if (t->row_labels != CTLP_NORMAL && t->col_labels != CTLP_NORMAL) + if (t->label_axis[PIVOT_AXIS_ROW] != PIVOT_AXIS_ROW + && t->label_axis[PIVOT_AXIS_COLUMN] != PIVOT_AXIS_COLUMN) { msg (SE, _("ROWLABELS and COLLABELS may not both be specified.")); goto error; } + ctables_prepare_table (t); + + ctables_check_label_position (t, PIVOT_AXIS_ROW); + ctables_check_label_position (t, PIVOT_AXIS_COLUMN); } while (lex_token (lexer) != T_ENDCMD);