X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=c982f19cf63ad431faaf532c0637133daf43b574;hb=b09f1b74d89c58a78e347262540cc61824607f85;hp=96d12e03fcd4d94c4c5dbddbdf3547b315e560cf;hpb=ef021e75a037983212b4f8143ba01628e546a4be;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 96d12e03fc..c982f19cf6 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -16,20 +16,24 @@ #include +#include + #include "data/casereader.h" #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" #include "language/lexer/variable-parser.h" -#include "language/stats/freq.h" #include "libpspp/array.h" #include "libpspp/assertion.h" +#include "libpspp/hash-functions.h" #include "libpspp/hmap.h" #include "libpspp/message.h" #include "libpspp/string-array.h" +#include "math/moments.h" #include "output/pivot-table.h" #include "gl/minmax.h" @@ -41,26 +45,11 @@ enum ctables_vlabel { - CTVL_DEFAULT = SETTINGS_VALUE_SHOW_DEFAULT, + CTVL_NONE = SETTINGS_VALUE_SHOW_DEFAULT, CTVL_NAME = SETTINGS_VALUE_SHOW_VALUE, CTVL_LABEL = SETTINGS_VALUE_SHOW_LABEL, CTVL_BOTH = SETTINGS_VALUE_SHOW_BOTH, - CTVL_NONE, }; -static void UNUSED -ctables_vlabel_unique (enum ctables_vlabel vlabel) -{ - /* This ensures that all of the values are unique. */ - switch (vlabel) - { - case CTVL_DEFAULT: - case CTVL_NAME: - case CTVL_LABEL: - case CTVL_BOTH: - case CTVL_NONE: - abort (); - } -} /* XXX: - unweighted summaries (U*) @@ -156,6 +145,68 @@ enum { #undef S }; +enum ctables_domain_type + { + /* Within a section, where stacked variables divide one section from + another. */ + CTDT_TABLE, /* All layers of a whole section. */ + CTDT_LAYER, /* One layer within a section. */ + CTDT_LAYERROW, /* Row in one layer within a section. */ + CTDT_LAYERCOL, /* Column in one layer within a section. */ + + /* Within a subtable, where a subtable pairs an innermost row variable with + an innermost column variable within a single layer. */ + CTDT_SUBTABLE, /* Whole subtable. */ + CTDT_ROW, /* Row within a subtable. */ + CTDT_COL, /* Column within a subtable. */ +#define N_CTDTS 7 + }; + +struct ctables_domain + { + struct hmap_node node; + + const struct ctables_cell *example; + + double valid; + 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 + axes (except the scalar variable, if any). */ + struct hmap_node node; + + /* The domains that contain this cell. */ + struct ctables_domain *domains[N_CTDTS]; + + bool hide; + enum ctables_summary_variant sv; + + struct + { + size_t nest_idx; + struct ctables_cell_value + { + const struct ctables_category *category; + union value value; + } + *cvs; + int leaf; + } + axes[PIVOT_N_AXES]; + + union ctables_summary *summaries; + }; + struct ctables { struct pivot_table_look *look; @@ -176,7 +227,7 @@ struct ctables struct variable *base_weight; /* WEIGHT. */ int hide_threshold; /* HIDESMALLCOUNTS. */ - struct ctables_table *tables; + struct ctables_table **tables; size_t n_tables; }; @@ -227,22 +278,73 @@ struct ctables_postcompute_expr }; }; -enum ctables_label_position +struct ctables_summary_spec_set + { + struct ctables_summary_spec *specs; + size_t n; + size_t allocated; + + 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. */ +struct ctables_nest + { + struct variable **vars; + size_t n; + size_t scale_idx; + size_t *domains[N_CTDTS]; + size_t n_domains[N_CTDTS]; + + struct ctables_summary_spec_set specs[N_CSVS]; + }; + +/* A stack of nestings, e.g. nest1 + nest2 + ... + nestN. */ +struct ctables_stack + { + struct ctables_nest *nests; + size_t n; + }; + +struct ctables_value { - CTLP_NORMAL, - CTLP_OPPOSITE, - CTLP_LAYER, + struct hmap_node node; + union value value; + int leaf; }; struct ctables_table { struct ctables_axis *axes[PIVOT_N_AXES]; - - enum pivot_axis_type slabels_position; + 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]; + + const struct variable *clabels_example; + struct hmap clabels_values_map; + struct ctables_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; @@ -256,9 +358,6 @@ struct ctables_table struct ctables_chisq *chisq; struct ctables_pairwise *pairwise; - - struct ctables_freqtab **fts; - size_t n_fts; }; struct ctables_var @@ -288,73 +387,123 @@ ctables_var_name (const struct ctables_var *var) struct ctables_categories { size_t n_refs; - - /* Explicit categories. */ - struct ctables_cat_value *values; - size_t n_values; - - /* Implicit categories. */ - bool sort_ascending; - bool include_missing; - enum { CTCS_VALUE, CTCS_LABEL, CTCS_FUNCTION } key; - enum ctables_summary_function sort_func; - struct variable *sort_func_var; - double percentile; - - /* Totals. */ - bool show_totals; - bool totals_before; - char *total_label; - - /* Empty categories. */ + struct ctables_category *cats; + size_t n_cats; bool show_empty; }; -struct ctables_cat_value +struct ctables_category { - enum ctables_cat_value_type + enum ctables_category_type { - CCVT_NUMBER, - CCVT_STRING, - CCVT_RANGE, - CCVT_MISSING, - CCVT_OTHERNM, - CCVT_SUBTOTAL, - CCVT_HSUBTOTAL, + CCT_NUMBER, + CCT_STRING, + CCT_RANGE, + CCT_MISSING, + CCT_OTHERNM, + + CCT_SUBTOTAL, + CCT_HSUBTOTAL, + CCT_TOTAL, + + CCT_VALUE, + CCT_LABEL, + CCT_FUNCTION, } type; + struct ctables_category *subtotal; + union { - double number; /* CCVT_NUMBER. */ - char *string; /* CCVT_STRING. */ - double range[2]; /* CCVT_RANGE. */ - char *subtotal_label; /* CCVT_SUBTOTAL, CCVT_HSUBTOTAL. */ + double number; /* CCT_NUMBER. */ + char *string; /* CCT_STRING. */ + double range[2]; /* CCT_RANGE. */ + char *total_label; /* CCT_SUBTOTAL, CCT_HSUBTOTAL, CCT_TOTAL. */ + + /* CCT_VALUE, CCT_LABEL, CCT_FUNCTION. */ + struct + { + bool include_missing; + bool sort_ascending; + + /* CCT_FUNCTION. */ + enum ctables_summary_function sort_function; + struct variable *sort_var; + double percentile; + }; }; }; static void -ctables_cat_value_uninit (struct ctables_cat_value *cv) +ctables_category_uninit (struct ctables_category *cat) { - if (!cv) + if (!cat) return; - switch (cv->type) + switch (cat->type) { - case CCVT_NUMBER: - case CCVT_RANGE: - case CCVT_MISSING: - case CCVT_OTHERNM: + case CCT_NUMBER: + case CCT_RANGE: + case CCT_MISSING: + case CCT_OTHERNM: + break; + + case CCT_STRING: + free (cat->string); + break; + + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + case CCT_TOTAL: + free (cat->total_label); break; - case CCVT_STRING: - free (cv->string); + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: break; + } +} + +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 CCVT_SUBTOTAL: - case CCVT_HSUBTOTAL: - free (cv->subtotal_label); + 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 @@ -367,13 +516,26 @@ ctables_categories_unref (struct ctables_categories *c) if (--c->n_refs) return; - for (size_t i = 0; i < c->n_values; i++) - ctables_cat_value_uninit (&c->values[i]); - free (c->values); - free (c->total_label); + for (size_t i = 0; i < c->n_cats; i++) + ctables_category_uninit (&c->cats[i]); + free (c->cats); 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 { @@ -416,9 +578,7 @@ struct ctables_axis { struct ctables_var var; bool scale; - struct ctables_summary *summaries; - size_t n_summaries; - size_t allocated_summaries; + struct ctables_summary_spec_set specs[N_CSVS]; }; /* Nonterminals. */ @@ -444,21 +604,54 @@ enum ctables_function_availability CTFA_MRSETS, /* Only multiple-response sets */ }; -struct ctables_summary +struct ctables_summary_spec { enum ctables_summary_function function; double percentile; /* CTSF_PTILE only. */ char *label; struct fmt_spec format; /* XXX extra CTABLES formats */ + size_t axis_idx; }; static void -ctables_summary_uninit (struct ctables_summary *s) +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) { if (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) +{ + for (size_t i = 0; i < set->n; i++) + ctables_summary_spec_uninit (&set->specs[i]); + free (set->specs); +} + static bool parse_col_width (struct lexer *lexer, const char *name, double *width) { @@ -552,9 +745,8 @@ ctables_axis_destroy (struct ctables_axis *axis) switch (axis->op) { case CTAO_VAR: - for (size_t i = 0; i < axis->n_summaries; i++) - ctables_summary_uninit (&axis->summaries[i]); - free (axis->summaries); + for (size_t i = 0; i < N_CSVS; i++) + ctables_summary_spec_set_uninit (&axis->specs[i]); break; case CTAO_STACK: @@ -615,6 +807,21 @@ ctables_summary_default_format (enum ctables_summary_function function, } } +static char * +ctables_summary_default_label (enum ctables_summary_function function, + double percentile) +{ + static const char *default_labels[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = LABEL, + SUMMARIES +#undef S + }; + + return (function == CTSF_PTILE + ? xasprintf (_("Percentile %.2f"), percentile) + : xstrdup (gettext (default_labels[function]))); +} + static const char * ctables_summary_function_name (enum ctables_summary_function function) { @@ -627,18 +834,13 @@ ctables_summary_function_name (enum ctables_summary_function function) } static bool -add_summary (struct ctables_axis *axis, - enum ctables_summary_function function, double percentile, - const char *label, const struct fmt_spec *format, - const struct msg_location *loc) +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, enum ctables_summary_variant sv) { if (axis->op == CTAO_VAR) { - if (axis->n_summaries >= axis->allocated_summaries) - axis->summaries = x2nrealloc (axis->summaries, - &axis->allocated_summaries, - sizeof *axis->summaries); - const char *function_name = ctables_summary_function_name (function); const char *var_name = ctables_var_name (&axis->var); switch (ctables_function_availability (function)) @@ -670,8 +872,13 @@ add_summary (struct ctables_axis *axis, break; } - struct ctables_summary *dst = &axis->summaries[axis->n_summaries++]; - *dst = (struct ctables_summary) { + struct ctables_summary_spec_set *set = &axis->specs[sv]; + if (set->n >= set->allocated) + set->specs = x2nrealloc (set->specs, &set->allocated, + sizeof *set->specs); + + struct ctables_summary_spec *dst = &set->specs[set->n++]; + *dst = (struct ctables_summary_spec) { .function = function, .percentile = percentile, .label = xstrdup (label), @@ -683,8 +890,8 @@ add_summary (struct ctables_axis *axis, else { for (size_t i = 0; i < 2; i++) - if (!add_summary (axis->subs[i], function, percentile, label, format, - loc)) + if (!add_summary_spec (axis->subs[i], function, percentile, label, + format, loc, sv)) return false; return true; } @@ -758,6 +965,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) { @@ -765,7 +978,8 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) if (!sub || !lex_match (ctx->lexer, T_LBRACK)) return sub; - do + enum ctables_summary_variant sv = CSV_CELL; + for (;;) { int start_ofs = lex_ofs (ctx->lexer); @@ -791,22 +1005,14 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) label = ss_xstrdup (lex_tokss (ctx->lexer)); lex_get (ctx->lexer); } - else if (function == CTSF_PTILE) - label = xasprintf (_("Percentile %.2f"), percentile); else - { - static const char *default_labels[] = { -#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = LABEL, - SUMMARIES -#undef S - }; - label = xstrdup (gettext (default_labels[function])); - } + label = ctables_summary_default_label (function, percentile); /* 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) @@ -822,15 +1028,24 @@ 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 (sub, function, percentile, label, formatp, loc); + add_summary_spec (sub, function, percentile, label, formatp, loc, sv); free (label); msg_location_destroy (loc); lex_match (ctx->lexer, T_COMMA); + if (sv == CSV_CELL && lex_match_id (ctx->lexer, "TOTALS")) + { + if (!lex_force_match (ctx->lexer, T_LBRACK)) + goto error; + sv = CSV_TOTAL; + } + else if (lex_match (ctx->lexer, T_RBRACK)) + { + if (sv == CSV_TOTAL && !lex_force_match (ctx->lexer, T_RBRACK)) + goto error; + return sub; + } } - while (!lex_match (ctx->lexer, T_RBRACK)); - - return sub; error: ctables_axis_destroy (sub); @@ -865,18 +1080,18 @@ find_scale (const struct ctables_axis *axis) } static const struct ctables_axis * -find_categorical_summary (const struct ctables_axis *axis) +find_categorical_summary_spec (const struct ctables_axis *axis) { if (!axis) return NULL; else if (axis->op == CTAO_VAR) - return !axis->scale && axis->n_summaries ? axis : NULL; + return !axis->scale && axis->specs[CSV_CELL].n ? axis : NULL; else { for (size_t i = 0; i < 2; i++) { const struct ctables_axis *sum - = find_categorical_summary (axis->subs[i]); + = find_categorical_summary_spec (axis->subs[i]); if (sum) return sum; } @@ -912,7 +1127,7 @@ ctables_axis_parse_nest (struct ctables_axis_parse_ctx *ctx) return NULL; } - const struct ctables_axis *outer_sum = find_categorical_summary (lhs); + const struct ctables_axis *outer_sum = find_categorical_summary_spec (lhs); if (outer_sum) { msg_at (SE, nest->loc, @@ -984,7 +1199,7 @@ ctables_pairwise_destroy (struct ctables_pairwise *pairwise) } static void -ctables_table_uninit (struct ctables_table *t) +ctables_table_destroy (struct ctables_table *t) { if (!t) return; @@ -1001,6 +1216,7 @@ ctables_table_uninit (struct ctables_table *t) free (t->title); ctables_chisq_destroy (t->chisq); ctables_pairwise_destroy (t->pairwise); + free (t); } static void @@ -1014,16 +1230,16 @@ ctables_destroy (struct ctables *ct) free (ct->missing); free (ct->vlabels); for (size_t i = 0; i < ct->n_tables; i++) - ctables_table_uninit (&ct->tables[i]); + ctables_table_destroy (ct->tables[i]); free (ct->tables); free (ct); } -static struct ctables_cat_value -ccvt_range (double low, double high) +static struct ctables_category +cct_range (double low, double high) { - return (struct ctables_cat_value) { - .type = CCVT_RANGE, + return (struct ctables_category) { + .type = CCT_RANGE, .range = { low, high } }; } @@ -1052,31 +1268,30 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, } free (vars); + size_t allocated_cats = 0; if (lex_match (lexer, T_LBRACK)) { - size_t allocated_values = 0; do { - if (c->n_values >= allocated_values) - c->values = x2nrealloc (c->values, &allocated_values, - sizeof *c->values); + if (c->n_cats >= allocated_cats) + c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); - struct ctables_cat_value *v = &c->values[c->n_values]; + struct ctables_category *cat = &c->cats[c->n_cats]; if (lex_match_id (lexer, "OTHERNM")) - v->type = CCVT_OTHERNM; + cat->type = CCT_OTHERNM; else if (lex_match_id (lexer, "MISSING")) - v->type = CCVT_MISSING; + cat->type = CCT_MISSING; else if (lex_match_id (lexer, "SUBTOTAL")) - *v = (struct ctables_cat_value) - { .type = CCVT_SUBTOTAL, .subtotal_label = NULL }; + *cat = (struct ctables_category) + { .type = CCT_SUBTOTAL, .total_label = NULL }; else if (lex_match_id (lexer, "HSUBTOTAL")) - *v = (struct ctables_cat_value) - { .type = CCVT_HSUBTOTAL, .subtotal_label = NULL }; + *cat = (struct ctables_category) + { .type = CCT_HSUBTOTAL, .total_label = NULL }; else if (lex_match_id (lexer, "LO")) { if (!lex_force_match_id (lexer, "THRU") || lex_force_num (lexer)) return false; - *v = ccvt_range (-DBL_MAX, lex_number (lexer)); + *cat = cct_range (-DBL_MAX, lex_number (lexer)); lex_get (lexer); } else if (lex_is_number (lexer)) @@ -1085,28 +1300,28 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, lex_get (lexer); if (lex_match_id (lexer, "THRU")) { - v->type = CCVT_RANGE; - v->range[0] = number; + cat->type = CCT_RANGE; + cat->range[0] = number; if (lex_match_id (lexer, "HI")) - *v = ccvt_range (number, DBL_MAX); + *cat = cct_range (number, DBL_MAX); else { if (!lex_force_num (lexer)) return false; - *v = ccvt_range (number, lex_number (lexer)); + *cat = cct_range (number, lex_number (lexer)); lex_get (lexer); } } else - *v = (struct ctables_cat_value) { - .type = CCVT_NUMBER, + *cat = (struct ctables_category) { + .type = CCT_NUMBER, .number = number }; } else if (lex_is_string (lexer)) { - *v = (struct ctables_cat_value) { - .type = CCVT_STRING, + *cat = (struct ctables_category) { + .type = CCT_STRING, .string = ss_xstrdup (lex_tokss (lexer)), }; lex_get (lexer); @@ -1117,69 +1332,81 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, return false; } - if ((v->type == CCVT_SUBTOTAL || v->type == CCVT_HSUBTOTAL) - && lex_match (lexer, T_EQUALS)) + if (cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL) { - if (!lex_force_string (lexer)) - return false; + if (lex_match (lexer, T_EQUALS)) + { + if (!lex_force_string (lexer)) + return false; - v->subtotal_label = ss_xstrdup (lex_tokss (lexer)); - lex_get (lexer); + cat->total_label = ss_xstrdup (lex_tokss (lexer)); + lex_get (lexer); + } + else + cat->total_label = xstrdup (_("Subtotal")); } - c->n_values++; + c->n_cats++; lex_match (lexer, T_COMMA); } while (!lex_match (lexer, T_RBRACK)); } + struct ctables_category cat = { + .type = CCT_VALUE, + .include_missing = false, + .sort_ascending = true, + }; + bool show_totals = false; + char *total_label = NULL; + bool totals_before = false; while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) { - if (!c->n_values && lex_match_id (lexer, "ORDER")) + if (!c->n_cats && lex_match_id (lexer, "ORDER")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "A")) - c->sort_ascending = true; + cat.sort_ascending = true; else if (lex_match_id (lexer, "D")) - c->sort_ascending = false; + cat.sort_ascending = false; else { lex_error_expecting (lexer, "A", "D"); return false; } } - else if (!c->n_values && lex_match_id (lexer, "KEY")) + else if (!c->n_cats && lex_match_id (lexer, "KEY")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "VALUE")) - c->key = CTCS_VALUE; + cat.type = CCT_VALUE; else if (lex_match_id (lexer, "LABEL")) - c->key = CTCS_LABEL; + cat.type = CCT_LABEL; else { - c->key = CTCS_FUNCTION; - if (!parse_ctables_summary_function (lexer, &c->sort_func)) + cat.type = CCT_FUNCTION; + if (!parse_ctables_summary_function (lexer, &cat.sort_function)) return false; if (lex_match (lexer, T_LPAREN)) { - c->sort_func_var = parse_variable (lexer, dict); - if (!c->sort_func_var) + cat.sort_var = parse_variable (lexer, dict); + if (!cat.sort_var) return false; - if (c->sort_func == CTSF_PTILE) + if (cat.sort_function == CTSF_PTILE) { lex_match (lexer, T_COMMA); if (!lex_force_num_range_closed (lexer, "PTILE", 0, 100)) return false; - c->percentile = lex_number (lexer); + cat.percentile = lex_number (lexer); lex_get (lexer); } if (!lex_force_match (lexer, T_RPAREN)) return false; } - else if (ctables_function_availability (c->sort_func) + else if (ctables_function_availability (cat.sort_function) == CTFA_SCALE) { bool UNUSED b = lex_force_match (lexer, T_LPAREN); @@ -1187,13 +1414,13 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, } } } - else if (!c->n_values && lex_match_id (lexer, "MISSING")) + else if (!c->n_cats && lex_match_id (lexer, "MISSING")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "INCLUDE")) - c->include_missing = true; + cat.include_missing = true; else if (lex_match_id (lexer, "EXCLUDE")) - c->include_missing = false; + cat.include_missing = false; else { lex_error_expecting (lexer, "INCLUDE", "EXCLUDE"); @@ -1203,7 +1430,7 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, else if (lex_match_id (lexer, "TOTAL")) { lex_match (lexer, T_EQUALS); - if (!parse_bool (lexer, &c->show_totals)) + if (!parse_bool (lexer, &show_totals)) return false; } else if (lex_match_id (lexer, "LABEL")) @@ -1211,17 +1438,17 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, lex_match (lexer, T_EQUALS); if (!lex_force_string (lexer)) return false; - free (c->total_label); - c->total_label = ss_xstrdup (lex_tokss (lexer)); + free (total_label); + total_label = ss_xstrdup (lex_tokss (lexer)); lex_get (lexer); } else if (lex_match_id (lexer, "POSITION")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "BEFORE")) - c->totals_before = true; + totals_before = true; else if (lex_match_id (lexer, "AFTER")) - c->totals_before = false; + totals_before = false; else { lex_error_expecting (lexer, "BEFORE", "AFTER"); @@ -1243,7 +1470,7 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, } else { - if (!c->n_values) + if (!c->n_cats) lex_error_expecting (lexer, "ORDER", "KEY", "MISSING", "TOTAL", "LABEL", "POSITION", "EMPTY"); else @@ -1251,329 +1478,1713 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, return false; } } + + if (!c->n_cats) + { + if (c->n_cats >= allocated_cats) + c->cats = x2nrealloc (c->cats, &allocated_cats, + sizeof *c->cats); + c->cats[c->n_cats++] = cat; + } + + if (show_totals) + { + if (c->n_cats >= allocated_cats) + c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); + + struct ctables_category *totals; + if (totals_before) + { + insert_element (c->cats, c->n_cats, sizeof *c->cats, 0); + totals = &c->cats[0]; + } + else + totals = &c->cats[c->n_cats]; + c->n_cats++; + + *totals = (struct ctables_category) { + .type = CCT_TOTAL, + .total_label = total_label ? total_label : xstrdup (_("Total")), + }; + } + + struct ctables_category *subtotal = NULL; + for (size_t i = totals_before ? 0 : c->n_cats; + totals_before ? i < c->n_cats : i-- > 0; + totals_before ? i++ : 0) + { + struct ctables_category *cat = &c->cats[i]; + switch (cat->type) + { + case CCT_NUMBER: + case CCT_STRING: + case CCT_RANGE: + case CCT_MISSING: + case CCT_OTHERNM: + cat->subtotal = subtotal; + break; + + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + subtotal = cat; + break; + + case CCT_TOTAL: + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + break; + } + } + return true; } -struct var_array - { - struct variable **vars; - size_t n; - }; - static void -var_array_uninit (struct var_array *va) +ctables_nest_uninit (struct ctables_nest *nest) { - if (va) - free (va->vars); + if (nest) + free (nest->vars); } -struct var_array2 - { - struct var_array *vas; - size_t n; - }; - static void -var_array2_uninit (struct var_array2 *vaa) +ctables_stack_uninit (struct ctables_stack *stack) { - if (vaa) + if (stack) { - for (size_t i = 0; i < vaa->n; i++) - var_array_uninit (&vaa->vas[i]); - free (vaa->vas); + for (size_t i = 0; i < stack->n; i++) + ctables_nest_uninit (&stack->nests[i]); + free (stack->nests); } } -static struct var_array2 -nest_fts (struct var_array2 va0, struct var_array2 va1) +static struct ctables_stack +nest_fts (struct ctables_stack s0, struct ctables_stack s1) { - if (!va0.n) - return va1; - else if (!va1.n) - return va0; - - struct var_array2 vaa = { .vas = xnmalloc (va0.n, va1.n * sizeof *vaa.vas) }; - for (size_t i = 0; i < va0.n; i++) - for (size_t j = 0; j < va1.n; j++) + if (!s0.n) + return s1; + else if (!s1.n) + return s0; + + struct ctables_stack stack = { .nests = xnmalloc (s0.n, s1.n * sizeof *stack.nests) }; + for (size_t i = 0; i < s0.n; i++) + for (size_t j = 0; j < s1.n; j++) { - size_t allocate = va0.vas[i].n + va1.vas[j].n; + const struct ctables_nest *a = &s0.nests[i]; + const struct ctables_nest *b = &s1.nests[j]; + + size_t allocate = a->n + b->n; struct variable **vars = xnmalloc (allocate, sizeof *vars); + enum pivot_axis_type *axes = xnmalloc (allocate, sizeof *axes); size_t n = 0; - for (size_t k = 0; k < va0.vas[i].n; k++) - vars[n++] = va0.vas[i].vars[k]; - for (size_t k = 0; k < va1.vas[j].n; k++) - vars[n++] = va1.vas[j].vars[k]; + for (size_t k = 0; k < a->n; k++) + vars[n++] = a->vars[k]; + for (size_t k = 0; k < b->n; k++) + vars[n++] = b->vars[k]; assert (n == allocate); - vaa.vas[vaa.n++] = (struct var_array) { .vars = vars, n = n }; + const struct ctables_nest *summary_src; + if (!a->specs[CSV_CELL].var) + summary_src = b; + else if (!b->specs[CSV_CELL].var) + summary_src = a; + else + NOT_REACHED (); + + 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, + }; + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + ctables_summary_spec_set_clone (&new->specs[sv], &summary_src->specs[sv]); } - var_array2_uninit (&va0); - var_array2_uninit (&va1); - return vaa; + ctables_stack_uninit (&s0); + ctables_stack_uninit (&s1); + return stack; } -static struct var_array2 -stack_fts (struct var_array2 va0, struct var_array2 va1) +static struct ctables_stack +stack_fts (struct ctables_stack s0, struct ctables_stack s1) { - struct var_array2 vaa = { .vas = xnmalloc (va0.n + va1.n, sizeof *vaa.vas) }; - for (size_t i = 0; i < va0.n; i++) - vaa.vas[vaa.n++] = va0.vas[i]; - for (size_t i = 0; i < va1.n; i++) - vaa.vas[vaa.n++] = va1.vas[i]; - assert (vaa.n == va0.n + va1.n); - free (va0.vas); - free (va1.vas); - return vaa; + struct ctables_stack stack = { .nests = xnmalloc (s0.n + s1.n, sizeof *stack.nests) }; + for (size_t i = 0; i < s0.n; i++) + stack.nests[stack.n++] = s0.nests[i]; + for (size_t i = 0; i < s1.n; i++) + stack.nests[stack.n++] = s1.nests[i]; + assert (stack.n == s0.n + s1.n); + free (s0.nests); + free (s1.nests); + return stack; } -static struct var_array2 -enumerate_fts (const struct ctables_axis *a) +static struct ctables_stack +enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a) { if (!a) - return (struct var_array2) { .n = 0 }; + return (struct ctables_stack) { .n = 0 }; switch (a->op) { case CTAO_VAR: assert (!a->var.is_mrset); - struct variable **v = xmalloc (sizeof *v); - *v = a->var.var; - struct var_array *va = xmalloc (sizeof *va); - *va = (struct var_array) { .vars = v, .n = 1 }; - return (struct var_array2) { .vas = va, .n = 1 }; + + struct variable **vars = xmalloc (sizeof *vars); + *vars = a->var.var; + + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { + .vars = vars, + .n = 1, + .scale_idx = a->scale ? 0 : SIZE_MAX, + }; + 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: - return stack_fts (enumerate_fts (a->subs[0]), - enumerate_fts (a->subs[1])); + return stack_fts (enumerate_fts (axis_type, a->subs[0]), + enumerate_fts (axis_type, a->subs[1])); case CTAO_NEST: - return nest_fts (enumerate_fts (a->subs[0]), - enumerate_fts (a->subs[1])); + return nest_fts (enumerate_fts (axis_type, a->subs[0]), + enumerate_fts (axis_type, a->subs[1])); } NOT_REACHED (); } -struct ctables_freqtab +union ctables_summary { - struct var_array vars; - struct hmap data; /* Contains "struct freq"s. */ - struct freq **sorted; + /* COUNT, VALIDN, TOTALN. */ + struct + { + double valid; + double missing; + }; + + /* MINIMUM, MAXIMUM, RANGE. */ + struct + { + double min; + double max; + }; + + /* MEAN, SEMEAN, STDDEV, SUM, VARIANCE, *.SUM. */ + struct moments1 *moments; + + /* XXX percentiles, median, mode, multiple response */ }; -static int -compare_freq_3way (const void *a_, const void *b_, const void *vars_) +static void +ctables_summary_init (union ctables_summary *s, + const struct ctables_summary_spec *ss) { - const struct var_array *vars = vars_; - struct freq *const *a = a_; - struct freq *const *b = b_; - - for (size_t i = 0; i < vars->n; i++) + switch (ss->function) { - int cmp = value_compare_3way (&(*a)->values[i], &(*b)->values[i], - var_get_width (vars->vars[i])); - if (cmp) - return cmp; + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + s->missing = s->valid = 0; + break; + + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + s->min = s->max = SYSMIS; + break; + + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + s->moments = moments1_create (MOMENT_VARIANCE); + break; + + case CTSF_MEDIAN: + case CTSF_MISSING: + case CTSF_MODE: + case CTSF_PTILE: + NOT_REACHED (); + + case CTSF_RESPONSES: + case CTSF_ROWPCT_RESPONSES: + case CTSF_COLPCT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES: + case CTSF_ROWPCT_RESPONSES_COUNT: + case CTSF_COLPCT_RESPONSES_COUNT: + case CTSF_TABLEPCT_RESPONSES_COUNT: + case CTSF_SUBTABLEPCT_RESPONSES_COUNT: + case CTSF_LAYERPCT_RESPONSES_COUNT: + case CTSF_LAYERROWPCT_RESPONSES_COUNT: + case CTSF_LAYERCOLPCT_RESPONSES_COUNT: + case CTSF_ROWPCT_COUNT_RESPONSES: + case CTSF_COLPCT_COUNT_RESPONSES: + case CTSF_TABLEPCT_COUNT_RESPONSES: + case CTSF_SUBTABLEPCT_COUNT_RESPONSES: + case CTSF_LAYERPCT_COUNT_RESPONSES: + case CTSF_LAYERROWPCT_COUNT_RESPONSES: + case CTSF_LAYERCOLPCT_COUNT_RESPONSES: + NOT_REACHED (); } - - return 0; } -static bool -ctables_execute (struct dataset *ds, struct ctables *ct) +static void UNUSED +ctables_summary_uninit (union ctables_summary *s, + const struct ctables_summary_spec *ss) { - for (size_t i = 0; i < ct->n_tables; i++) + switch (ss->function) { - size_t allocated_fts = 0; + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + break; - struct ctables_table *t = &ct->tables[i]; - struct var_array2 vaa = enumerate_fts (t->axes[PIVOT_AXIS_ROW]); - vaa = nest_fts (vaa, enumerate_fts (t->axes[PIVOT_AXIS_COLUMN])); - vaa = nest_fts (vaa, enumerate_fts (t->axes[PIVOT_AXIS_LAYER])); - for (size_t i = 0; i < vaa.n; i++) - { - for (size_t j = 0; j < vaa.vas[i].n; j++) - { - if (j) - fputs (", ", stdout); - fputs (var_get_name (vaa.vas[i].vars[j]), stdout); - } - putchar ('\n'); - } + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + break; - for (size_t j = 0; j < vaa.n; j++) - { - struct ctables_freqtab *ft = xmalloc (sizeof *ft); - *ft = (struct ctables_freqtab) { - .vars = vaa.vas[j], - .data = HMAP_INITIALIZER (ft->data), - }; + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + moments1_destroy (s->moments); + break; - if (t->n_fts >= allocated_fts) - t->fts = x2nrealloc (t->fts, &allocated_fts, sizeof *t->fts); - t->fts[t->n_fts++] = ft; - } + case CTSF_MEDIAN: + case CTSF_MISSING: + case CTSF_MODE: + case CTSF_PTILE: + NOT_REACHED (); - free (vaa.vas); + case CTSF_RESPONSES: + case CTSF_ROWPCT_RESPONSES: + case CTSF_COLPCT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES: + case CTSF_ROWPCT_RESPONSES_COUNT: + case CTSF_COLPCT_RESPONSES_COUNT: + case CTSF_TABLEPCT_RESPONSES_COUNT: + case CTSF_SUBTABLEPCT_RESPONSES_COUNT: + case CTSF_LAYERPCT_RESPONSES_COUNT: + case CTSF_LAYERROWPCT_RESPONSES_COUNT: + case CTSF_LAYERCOLPCT_RESPONSES_COUNT: + case CTSF_ROWPCT_COUNT_RESPONSES: + case CTSF_COLPCT_COUNT_RESPONSES: + case CTSF_TABLEPCT_COUNT_RESPONSES: + case CTSF_SUBTABLEPCT_COUNT_RESPONSES: + case CTSF_LAYERPCT_COUNT_RESPONSES: + case CTSF_LAYERROWPCT_COUNT_RESPONSES: + case CTSF_LAYERCOLPCT_COUNT_RESPONSES: + NOT_REACHED (); } +} - struct casereader *input = casereader_create_filter_weight (proc_open (ds), - dataset_dict (ds), - NULL, NULL); - bool warn_on_invalid = true; - for (struct ccase *c = casereader_read (input); c; - case_unref (c), c = casereader_read (input)) +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) +{ + switch (ss->function) { - double weight = dict_get_case_weight (dataset_dict (ds), c, - &warn_on_invalid); + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + if (var_is_value_missing (var, value)) + s->missing += weight; + else + s->valid += weight; + break; - for (size_t i = 0; i < ct->n_tables; i++) + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + if (!var_is_value_missing (var, value)) { - struct ctables_table *t = &ct->tables[i]; - - for (size_t j = 0; j < t->n_fts; j++) - { - struct ctables_freqtab *ft = t->fts[j]; + assert (!var_is_alpha (var)); /* XXX? */ + if (s->min == SYSMIS || value->f < s->min) + s->min = value->f; + if (s->max == SYSMIS || value->f > s->max) + s->max = value->f; + } + break; - for (size_t k = 0; k < ft->vars.n; k++) - { - const struct variable *var = ft->vars.vars[k]; - switch (var_is_value_missing (var, case_data (c, var))) - { - case MV_SYSTEM: - goto next_ft; - - case MV_USER: - if (!t->categories[var_get_dict_index (var)] - || !t->categories[var_get_dict_index (var)]->include_missing) - goto next_ft; - break; - } - } - size_t hash = 0; - for (size_t k = 0; k < ft->vars.n; k++) - { - const struct variable *var = ft->vars.vars[k]; - hash = value_hash (case_data (c, var), var_get_width (var), hash); - } + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + if (!var_is_value_missing (var, value)) + moments1_add (s->moments, value->f, weight); + break; - struct freq *f; - HMAP_FOR_EACH_WITH_HASH (f, struct freq, node, hash, &ft->data) - { - for (size_t k = 0; k < ft->vars.n; k++) - { - const struct variable *var = ft->vars.vars[k]; - if (!value_equal (case_data (c, var), &f->values[k], - var_get_width (var))) - goto next_hash_node; - } + case CTSF_MEDIAN: + case CTSF_MISSING: + case CTSF_MODE: + case CTSF_PTILE: + NOT_REACHED (); - f->count += weight; - goto next_ft; + case CTSF_RESPONSES: + case CTSF_ROWPCT_RESPONSES: + case CTSF_COLPCT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES: + case CTSF_ROWPCT_RESPONSES_COUNT: + case CTSF_COLPCT_RESPONSES_COUNT: + case CTSF_TABLEPCT_RESPONSES_COUNT: + case CTSF_SUBTABLEPCT_RESPONSES_COUNT: + case CTSF_LAYERPCT_RESPONSES_COUNT: + case CTSF_LAYERROWPCT_RESPONSES_COUNT: + case CTSF_LAYERCOLPCT_RESPONSES_COUNT: + case CTSF_ROWPCT_COUNT_RESPONSES: + case CTSF_COLPCT_COUNT_RESPONSES: + case CTSF_TABLEPCT_COUNT_RESPONSES: + case CTSF_SUBTABLEPCT_COUNT_RESPONSES: + case CTSF_LAYERPCT_COUNT_RESPONSES: + case CTSF_LAYERROWPCT_COUNT_RESPONSES: + case CTSF_LAYERCOLPCT_COUNT_RESPONSES: + NOT_REACHED (); + } +} - next_hash_node: ; - } +static double +ctables_summary_value (const struct ctables_cell *cell, + union ctables_summary *s, + const struct ctables_summary_spec *ss) +{ + switch (ss->function) + { + case CTSF_COUNT: + 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_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; + + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + NOT_REACHED (); - f = xmalloc (table_entry_size (ft->vars.n)); - f->count = weight; - for (size_t k = 0; k < ft->vars.n; k++) - { - const struct variable *var = ft->vars.vars[k]; - value_clone (&f->values[k], case_data (c, var), - var_get_width (var)); - } - hmap_insert (&ft->data, &f->node, hash); + case CSTF_TOTALN: + case CTSF_ETOTALN: + return s->valid + s->missing; - next_ft: ; - } - } - } - casereader_destroy (input); + case CTSF_VALIDN: + case CTSF_EVALIDN: + return s->valid; - for (size_t i = 0; i < ct->n_tables; i++) - { - struct ctables_table *t = &ct->tables[i]; + case CTSF_MAXIMUM: + return s->max; - struct pivot_table *pt = pivot_table_create (N_("Custom Tables")); - struct pivot_dimension *d = pivot_dimension_create ( - pt, PIVOT_AXIS_ROW, N_("Rows")); - for (size_t j = 0; j < t->n_fts; j++) - { - struct ctables_freqtab *ft = t->fts[j]; - ft->sorted = xnmalloc (ft->data.count, sizeof *ft->sorted); - - struct freq *f; - size_t n = 0; - HMAP_FOR_EACH (f, struct freq, node, &ft->data) - ft->sorted[n++] = f; - assert (n == ft->data.count); - sort (ft->sorted, n, sizeof *ft->sorted, - compare_freq_3way, &ft->vars); - - struct pivot_category **groups = xnmalloc (ft->vars.n, - sizeof *groups); - for (size_t k = 0; k < n; k++) - { - struct freq *prev = k > 0 ? ft->sorted[k - 1] : NULL; - struct freq *f = ft->sorted[k]; - - size_t n_common = 0; - if (prev) - for (; n_common + 1 < ft->vars.n; n_common++) - if (!value_equal (&prev->values[n_common], - &f->values[n_common], - var_get_type (ft->vars.vars[n_common]))) - break; - - for (size_t m = n_common; m + 1 < ft->vars.n; m++) - { - struct pivot_category *parent = m > 0 ? groups[m - 1] : d->root; - if (true) - parent = pivot_category_create_group__ ( - parent, pivot_value_new_variable (ft->vars.vars[m])); - groups[m] = pivot_category_create_group__ ( - parent, - pivot_value_new_var_value (ft->vars.vars[m], &f->values[m])); - } + case CTSF_MINIMUM: + return s->min; - int leaf = pivot_category_create_leaf ( - ft->vars.n > 1 ? groups[ft->vars.n - 2] : d->root, - pivot_value_new_var_value (ft->vars.vars[ft->vars.n - 1], - &f->values[ft->vars.n - 1])); + case CTSF_RANGE: + return s->max != SYSMIS && s->min != SYSMIS ? s->max - s->min : SYSMIS; - pivot_table_put1 (pt, leaf, pivot_value_new_number (f->count)); + case CTSF_MEAN: + { + double mean; + moments1_calculate (s->moments, NULL, &mean, NULL, NULL, NULL); + return mean; + } + + case CTSF_SEMEAN: + { + double weight, variance; + moments1_calculate (s->moments, &weight, NULL, &variance, NULL, NULL); + return calc_semean (variance, weight); + } + + case CTSF_STDDEV: + { + double variance; + moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL); + return variance != SYSMIS ? sqrt (variance) : SYSMIS; + } + + case CTSF_SUM: + { + double weight, mean; + moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL); + return weight != SYSMIS && mean != SYSMIS ? weight * mean : SYSMIS; + } + + case CTSF_VARIANCE: + { + double variance; + moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL); + return variance; + } + + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + NOT_REACHED (); + + case CTSF_MEDIAN: + case CTSF_MISSING: + case CTSF_MODE: + case CTSF_PTILE: + NOT_REACHED (); + + case CTSF_RESPONSES: + case CTSF_ROWPCT_RESPONSES: + case CTSF_COLPCT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES: + case CTSF_ROWPCT_RESPONSES_COUNT: + case CTSF_COLPCT_RESPONSES_COUNT: + case CTSF_TABLEPCT_RESPONSES_COUNT: + case CTSF_SUBTABLEPCT_RESPONSES_COUNT: + case CTSF_LAYERPCT_RESPONSES_COUNT: + case CTSF_LAYERROWPCT_RESPONSES_COUNT: + case CTSF_LAYERCOLPCT_RESPONSES_COUNT: + case CTSF_ROWPCT_COUNT_RESPONSES: + case CTSF_COLPCT_COUNT_RESPONSES: + case CTSF_TABLEPCT_COUNT_RESPONSES: + case CTSF_SUBTABLEPCT_COUNT_RESPONSES: + case CTSF_LAYERPCT_COUNT_RESPONSES: + case CTSF_LAYERROWPCT_COUNT_RESPONSES: + case CTSF_LAYERCOLPCT_COUNT_RESPONSES: + NOT_REACHED (); + } + + NOT_REACHED (); +} + +struct ctables_cell_sort_aux + { + const struct ctables_table *t; + enum pivot_axis_type a; + }; + +static int +ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) +{ + const struct ctables_cell_sort_aux *aux = aux_; + struct ctables_cell *const *ap = a_; + struct ctables_cell *const *bp = b_; + const struct ctables_cell *a = *ap; + const struct ctables_cell *b = *bp; + + 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; + + const struct ctables_nest *nest = &aux->t->stacks[aux->a].nests[a_idx]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct variable *var = nest->vars[i]; + const struct ctables_cell_value *a_cv = &a->axes[aux->a].cvs[i]; + const struct ctables_cell_value *b_cv = &b->axes[aux->a].cvs[i]; + if (a_cv->category != b_cv->category) + return a_cv->category > b_cv->category ? 1 : -1; + + const union value *a_val = &a_cv->value; + const union value *b_val = &b_cv->value; + switch (a_cv->category->type) + { + case CCT_NUMBER: + case CCT_STRING: + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + case CCT_TOTAL: + /* Must be equal. */ + continue; + + case CCT_RANGE: + case CCT_MISSING: + case CCT_OTHERNM: + { + int cmp = value_compare_3way (a_val, b_val, var_get_width (var)); + if (cmp) + return cmp; + } + break; + + case CCT_VALUE: + { + int cmp = value_compare_3way (a_val, b_val, var_get_width (var)); + if (cmp) + return a_cv->category->sort_ascending ? cmp : -cmp; + } + break; + + case CCT_LABEL: + { + const char *a_label = var_lookup_value_label (var, a_val); + const char *b_label = var_lookup_value_label (var, b_val); + int cmp = (a_label + ? (b_label ? strcmp (a_label, b_label) : 1) + : (b_label ? -1 : value_compare_3way ( + a_val, b_val, var_get_width (var)))); + if (cmp) + return a_cv->category->sort_ascending ? cmp : -cmp; + } + break; + + case CCT_FUNCTION: + NOT_REACHED (); + } + } + return 0; +} + +/* Algorithm: + + For each row: + For each ctables_table: + For each combination of row vars: + For each combination of column vars: + For each combination of layer vars: + Add entry + Make a table of row values: + Sort entries by row values + Assign a 0-based index to each actual value + Construct a dimension + Make a table of column values + Make a table of layer values + For each entry: + Fill the table entry using the indexes from before. + */ + +static struct ctables_domain * +ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, + enum ctables_domain_type domain) +{ + size_t hash = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + 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++) + { + size_t v_idx = nest->domains[domain][i]; + hash = value_hash (&cell->axes[a].cvs[v_idx].value, + var_get_width (nest->vars[v_idx]), hash); + } + } + + struct ctables_domain *d; + HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &t->domains[domain]) + { + 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].nest_idx; + if (idx != df->axes[a].nest_idx) + goto not_equal; + + const struct ctables_nest *nest = &t->stacks[a].nests[idx]; + for (size_t i = 0; i < nest->n_domains[domain]; i++) + { + size_t v_idx = nest->domains[domain][i]; + if (!value_equal (&df->axes[a].cvs[v_idx].value, + &cell->axes[a].cvs[v_idx].value, + var_get_width (nest->vars[v_idx]))) + goto not_equal; } - free (groups); } - pivot_table_submit (pt); + return d; + + not_equal: ; } - for (size_t i = 0; i < ct->n_tables; i++) + d = xmalloc (sizeof *d); + *d = (struct ctables_domain) { .example = cell }; + hmap_insert (&t->domains[domain], &d->node, hash); + return d; +} + +static const struct ctables_category * +ctables_categories_match (const struct ctables_categories *c, + const union value *v, const struct variable *var) +{ + const struct ctables_category *othernm = NULL; + for (size_t i = c->n_cats; i-- > 0; ) + { + const struct ctables_category *cat = &c->cats[i]; + switch (cat->type) + { + case CCT_NUMBER: + if (cat->number == v->f) + return cat; + break; + + case CCT_STRING: + NOT_REACHED (); + + case CCT_RANGE: + if ((cat->range[0] == -DBL_MAX || v->f >= cat->range[0]) + && (cat->range[1] == DBL_MAX || v->f <= cat->range[1])) + return cat; + break; + + case CCT_MISSING: + if (var_is_value_missing (var, v)) + return cat; + break; + + case CCT_OTHERNM: + if (!othernm) + othernm = cat; + break; + + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + case CCT_TOTAL: + break; + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + return (cat->include_missing || !var_is_value_missing (var, v) ? cat + : NULL); + } + } + + return var_is_value_missing (var, v) ? NULL : othernm; +} + +static const struct ctables_category * +ctables_categories_total (const struct ctables_categories *c) +{ + const struct ctables_category *first = &c->cats[0]; + const struct ctables_category *last = &c->cats[c->n_cats - 1]; + return (first->type == CCT_TOTAL ? first + : last->type == CCT_TOTAL ? last + : NULL); +} + +static struct ctables_cell * +ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, + size_t ix[PIVOT_N_AXES], + const struct ctables_category *cats[PIVOT_N_AXES][10]) +{ + const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; + + size_t hash = 0; + 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]]; + hash = hash_int (ix[a], hash); + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + hash = hash_pointer (cats[a][i], hash); + if (cats[a][i]->type != CCT_TOTAL + && cats[a][i]->type != CCT_SUBTOTAL + && cats[a][i]->type != CCT_HSUBTOTAL) + hash = value_hash (case_data (c, nest->vars[i]), + var_get_width (nest->vars[i]), hash); + else + sv = CSV_TOTAL; + } + } + + struct ctables_cell *cell; + HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &t->cells) + { + 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].nest_idx != ix[a]) + goto not_equal; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx + && (cats[a][i] != cell->axes[a].cvs[i].category + || (cats[a][i]->type != CCT_TOTAL + && cats[a][i]->type != CCT_SUBTOTAL + && cats[a][i]->type != CCT_HSUBTOTAL + && !value_equal (case_data (c, nest->vars[i]), + &cell->axes[a].cvs[i].value, + var_get_width (nest->vars[i]))))) + goto not_equal; + } + + return cell; + + not_equal: ; + } + + cell = xmalloc (sizeof *cell); + cell->hide = false; + 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]]; + 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++) + { + if (i != nest->scale_idx) + { + const struct ctables_category *subtotal = cats[a][i]->subtotal; + if (subtotal && subtotal->type == CCT_HSUBTOTAL) + cell->hide = true; + } + + cell->axes[a].cvs[i].category = cats[a][i]; + value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]), + var_get_width (nest->vars[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); + return cell; +} + +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) +{ + 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 *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; +} + +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, + 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 variable *var = nest->vars[i]; + + const struct ctables_category *total = ctables_categories_total ( + t->categories[var_get_dict_index (var)]); + if (total) + { + 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); + 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 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, weight); + recurse_subtotals (t, c, ix, cats, weight, a, i + 1); + cats[a][i] = save; + } + } + start_nest = 0; + } +} + +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] = { + [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++) + { + 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; + + const struct variable *var = nest->vars[i]; + const union value *value = case_data (c, var); + + if (var_is_numeric (var) && value->f == SYSMIS) + return; + + cats[a][i] = ctables_categories_match ( + t->categories[var_get_dict_index (var)], value, var); + if (!cats[a][i]) + return; + } + } + + ctables_cell_add__ (t, c, ix, cats, weight); + + recurse_totals (t, c, ix, cats, weight, 0, 0); + recurse_subtotals (t, c, ix, cats, weight, 0, 0); +} + +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) +{ + 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 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 (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)); + + 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++) + { + 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].nest_idx]; + + bool new_subtable = !prev || prev->axes[a].nest_idx != cell->axes[a].nest_idx; + if (new_subtable) + { + n_levels = 0; + 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) + { + 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, + }; + } + } + + if (!summary_dimension && a == t->slabels_axis) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_SUMMARY, + .var_idx = SIZE_MAX, + }; + } + } + + 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; + 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 < 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++) + { + int leaf = pivot_category_create_leaf ( + parent, pivot_value_new_text (specs->specs[m].label)); + if (!m) + prev_leaf = leaf; + } + } + 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) + prev_leaf = 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); + } + + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) + { + if (cell->hide) + continue; + + 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[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 && !summary_dimension) + leaf += j; + dindexes[n_dindexes++] = leaf; + } + + double d = ctables_summary_value (cell, &cell->summaries[j], &specs->specs[j]); + struct pivot_value *value = pivot_value_new_number (d); + value->numeric.format = specs->specs[j].format; + pivot_table_put (pt, dindexes, n_dindexes, value); + } + } + + pivot_table_submit (pt); +} + +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; + + t->clabels_from_axis = a; + + 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; + } + 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; + } + + 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 (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; + } + 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; +} + +static bool +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++) + { + nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); + nest->n_domains[dt] = 0; + + for (size_t k = 0; k < nest->n; k++) + { + if (k == nest->scale_idx) + continue; + + switch (dt) + { + 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) + continue; + break; + + 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 }; + } + + 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_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] }; + } + + while (n_left > 0) { - struct ctables_table *t = &ct->tables[i]; + 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 < t->n_fts; j++) + for (size_t j = 0; j < n_left; ) { - struct ctables_freqtab *ft = t->fts[j]; - struct freq *f, *next; - HMAP_FOR_EACH_SAFE (f, next, struct freq, node, &ft->data) + if (merge_item_compare_3way (&items[j], &min) == 0) { - hmap_delete (&ft->data, &f->node); - for (size_t k = 0; k < ft->vars.n; k++) + struct merge_item *item = &items[j]; + item->set->specs[item->ofs].axis_idx = merged->n - 1; + if (++item->ofs >= item->set->n) { - const struct variable *var = ft->vars.vars[k]; - value_destroy (&f->values[k], var_get_width (var)); + items[j] = items[--n_left]; + continue; } - free (f); } - hmap_destroy (&ft->data); - free (ft->sorted); - var_array_uninit (&ft->vars); - free (ft); + 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 + + return (ctables_check_label_position (t, PIVOT_AXIS_ROW) + && ctables_check_label_position (t, PIVOT_AXIS_COLUMN)); +} + +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 *var = nest->vars[nest->n - 1]; + int width = var_get_width (var); + const union value *value = case_data (c, var); + + if (var_is_numeric (var) && value->f == SYSMIS) + continue; + + if (!ctables_categories_match (t->categories [var_get_dict_index (var)], + value, var)) + continue; + + unsigned int hash = value_hash (value, width, 0); + + 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 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->value, &b->value, *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); + + 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; + 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); + 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; + + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + + 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); + + 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); } - free (t->fts); } + casereader_destroy (input); + + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + if (t->clabels_example) + ctables_sort_clabels_values (t); + + ctables_table_output (ct, ct->tables[i]); + } return proc_commit (ds); } @@ -1582,8 +3193,9 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) { size_t n_vars = dict_get_n_vars (dataset_dict (ds)); enum ctables_vlabel *vlabels = xnmalloc (n_vars, sizeof *vlabels); + enum settings_value_show tvars = settings_get_show_variables (); for (size_t i = 0; i < n_vars; i++) - vlabels[i] = CTVL_DEFAULT; + vlabels[i] = (enum ctables_vlabel) tvars; struct ctables *ct = xmalloc (sizeof *ct); *ct = (struct ctables) { @@ -1592,6 +3204,7 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) .vlabels = vlabels, .hide_threshold = 5, }; + ct->look->omit_empty = false; if (!lex_force_match (lexer, T_SLASH)) goto error; @@ -1707,7 +3320,7 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) enum ctables_vlabel vlabel; if (lex_match_id (lexer, "DEFAULT")) - vlabel = CTVL_DEFAULT; + vlabel = (enum ctables_vlabel) settings_get_show_variables (); else if (lex_match_id (lexer, "NAME")) vlabel = CTVL_NAME; else if (lex_match_id (lexer, "LABEL")) @@ -1787,17 +3400,45 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) ct->tables = x2nrealloc (ct->tables, &allocated_tables, sizeof *ct->tables); - struct ctables_table *t = &ct->tables[ct->n_tables++]; + struct ctables_category *cat = xmalloc (sizeof *cat); + *cat = (struct ctables_category) { + .type = CCT_VALUE, + .include_missing = false, + .sort_ascending = true, + }; + + struct ctables_categories *c = xmalloc (sizeof *c); + size_t n_vars = dict_get_n_vars (dataset_dict (ds)); + *c = (struct ctables_categories) { + .n_refs = n_vars, + .cats = cat, + .n_cats = 1, + }; + + struct ctables_categories **categories = xnmalloc (n_vars, + sizeof *categories); + for (size_t i = 0; i < n_vars; i++) + categories[i] = c; + + struct ctables_table *t = xmalloc (sizeof *t); *t = (struct ctables_table) { - .slabels_position = PIVOT_AXIS_COLUMN, + .cells = HMAP_INITIALIZER (t->cells), + .slabels_axis = PIVOT_AXIS_COLUMN, .slabels_visible = true, - .row_labels = CTLP_NORMAL, - .col_labels = CTLP_NORMAL, - .categories = xcalloc (dict_get_n_vars (dataset_dict (ds)), - sizeof *t->categories), - .n_categories = dict_get_n_vars (dataset_dict (ds)), + .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, }; + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + hmap_init (&t->domains[dt]); + ct->tables[ct->n_tables++] = t; lex_match (lexer, T_EQUALS); if (!ctables_axis_parse (lexer, dataset_dict (ds), ct, t, PIVOT_AXIS_ROW)) @@ -1825,29 +3466,64 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) const struct ctables_axis *scales[PIVOT_N_AXES]; size_t n_scales = 0; - for (size_t i = 0; i < 3; i++) + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - scales[i] = find_scale (t->axes[i]); - if (scales[i]) + scales[a] = find_scale (t->axes[a]); + if (scales[a]) n_scales++; } if (n_scales > 1) { - msg (SE, _("Scale variables may appear only on one dimension.")); + msg (SE, _("Scale variables may appear only on one axis.")); if (scales[PIVOT_AXIS_ROW]) msg_at (SN, scales[PIVOT_AXIS_ROW]->loc, - _("This scale variable appears in the rows dimension.")); + _("This scale variable appears on the rows axis.")); if (scales[PIVOT_AXIS_COLUMN]) msg_at (SN, scales[PIVOT_AXIS_COLUMN]->loc, - _("This scale variable appears in the columns dimension.")); + _("This scale variable appears on the columns axis.")); if (scales[PIVOT_AXIS_LAYER]) msg_at (SN, scales[PIVOT_AXIS_LAYER]->loc, - _("This scale variable appears in the layer dimension.")); + _("This scale variable appears on the layer axis.")); goto error; } + const struct ctables_axis *summaries[PIVOT_N_AXES]; + size_t n_summaries = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + summaries[a] = (scales[a] + ? scales[a] + : find_categorical_summary_spec (t->axes[a])); + if (summaries[a]) + n_summaries++; + } + if (n_summaries > 1) + { + msg (SE, _("Summaries may appear only on one axis.")); + if (summaries[PIVOT_AXIS_ROW]) + msg_at (SN, summaries[PIVOT_AXIS_ROW]->loc, + _("This variable on the rows axis has a summary.")); + if (summaries[PIVOT_AXIS_COLUMN]) + msg_at (SN, summaries[PIVOT_AXIS_COLUMN]->loc, + _("This variable on the columns axis has a summary.")); + if (summaries[PIVOT_AXIS_LAYER]) + msg_at (SN, summaries[PIVOT_AXIS_LAYER]->loc, + _("This variable on the layers axis has a summary.")); + goto error; + } + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (n_summaries ? summaries[a] : t->axes[a]) + { + t->summary_axis = a; + break; + } + if (lex_token (lexer) == T_ENDCMD) - break; + { + if (!ctables_prepare_table (t)) + goto error; + break; + } if (!lex_force_match (lexer, T_SLASH)) break; @@ -1855,17 +3531,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"); @@ -1887,17 +3563,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"); @@ -1908,9 +3587,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"); @@ -2180,14 +3859,20 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) "SIGTEST", "COMPARETEST"); goto error; } + + if (!lex_match (lexer, T_SLASH)) + 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; } + if (!ctables_prepare_table (t)) + goto error; } while (lex_token (lexer) != T_ENDCMD);