X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=b3ddee623f2bf4209ff3e2143723bb551e054042;hb=042cd96c590125ddf6e5dff0961da2ff55ac9d5a;hp=8cf79c01230d3c87165e24e475d1f98c5de3e29c;hpb=daf83021bebf527fa36e5f7a4accd71e09315e26;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 8cf79c0123..b3ddee623f 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -28,6 +28,7 @@ #include "language/lexer/variable-parser.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" @@ -143,6 +144,58 @@ 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; + }; + +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 contains this cell. */ + struct ctables_domain *domains[N_CTDTS]; + + struct + { + size_t vaa_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; @@ -163,7 +216,7 @@ struct ctables struct variable *base_weight; /* WEIGHT. */ int hide_threshold; /* HIDESMALLCOUNTS. */ - struct ctables_table *tables; + struct ctables_table **tables; size_t n_tables; }; @@ -221,9 +274,32 @@ enum ctables_label_position CTLP_LAYER, }; +struct var_array + { + 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 *summaries; + size_t n_summaries; + struct variable *summary_var; + }; + +struct var_array2 + { + struct var_array *vas; + size_t n; + }; + struct ctables_table { struct ctables_axis *axes[PIVOT_N_AXES]; + struct var_array2 vaas[PIVOT_N_AXES]; + enum pivot_axis_type summary_axis; + struct hmap cells; + struct hmap domains[N_CTDTS]; enum pivot_axis_type slabels_position; bool slabels_visible; @@ -243,9 +319,6 @@ struct ctables_table struct ctables_chisq *chisq; struct ctables_pairwise *pairwise; - - struct ctables_freqtab **fts; - size_t n_fts; }; struct ctables_var @@ -275,72 +348,84 @@ 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; 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 const struct ctables_category *ctables_categories_match ( + const struct ctables_categories *, const union value *, + const struct variable *); + 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 CCVT_STRING: - free (cv->string); + case CCT_STRING: + free (cat->string); break; - case CCVT_SUBTOTAL: - case CCVT_HSUBTOTAL: - free (cv->subtotal_label); + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + case CCT_TOTAL: + free (cat->total_label); + break; + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + break; } } @@ -354,10 +439,9 @@ 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); } @@ -602,6 +686,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) { @@ -778,17 +877,8 @@ 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; @@ -971,7 +1061,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; @@ -988,6 +1078,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 @@ -1001,16 +1092,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 } }; } @@ -1039,31 +1130,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)) @@ -1072,28 +1162,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); @@ -1104,69 +1194,77 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, return false; } - if ((v->type == CCVT_SUBTOTAL || v->type == CCVT_HSUBTOTAL) + if ((cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL) && lex_match (lexer, T_EQUALS)) { if (!lex_force_string (lexer)) return false; - v->subtotal_label = ss_xstrdup (lex_tokss (lexer)); + cat->total_label = ss_xstrdup (lex_tokss (lexer)); lex_get (lexer); } - 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); @@ -1174,13 +1272,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"); @@ -1190,7 +1288,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")) @@ -1198,17 +1296,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"); @@ -1230,7 +1328,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 @@ -1238,33 +1336,46 @@ 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")), + }; + } + return true; } -struct var_array - { - const struct ctables_axis *summary; - struct variable **vars; - enum pivot_axis_type *axes; - size_t n; - }; - static void var_array_uninit (struct var_array *va) { if (va) - { - free (va->vars); - free (va->axes); - } + free (va->vars); } -struct var_array2 - { - struct var_array *vas; - size_t n; - }; - static void var_array2_uninit (struct var_array2 *vaa) { @@ -1296,25 +1407,27 @@ nest_fts (struct var_array2 va0, struct var_array2 va1) enum pivot_axis_type *axes = xnmalloc (allocate, sizeof *axes); size_t n = 0; for (size_t k = 0; k < a->n; k++) - { - vars[n] = a->vars[k]; - axes[n] = a->axes[k]; - n++; - } + vars[n++] = a->vars[k]; for (size_t k = 0; k < b->n; k++) - { - vars[n] = b->vars[k]; - axes[n] = b->axes[k]; - n++; - } + vars[n++] = b->vars[k]; assert (n == allocate); - assert (!(a->summary && b->summary)); + const struct var_array *summary_src; + if (!a->summary_var) + summary_src = b; + else if (!b->summary_var) + summary_src = a; + else + NOT_REACHED (); vaa.vas[vaa.n++] = (struct var_array) { - .summary = a->summary ? a->summary : b->summary, .vars = vars, - .axes = axes, - .n = n + .scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx + : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx + : SIZE_MAX), + .n = n, + .summaries = summary_src->summaries, + .n_summaries = summary_src->n_summaries, + .summary_var = summary_src->summary_var, }; } var_array2_uninit (&va0); @@ -1346,18 +1459,22 @@ enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a) { case CTAO_VAR: assert (!a->var.is_mrset); + + struct variable **vars = xmalloc (sizeof *vars); + *vars = a->var.var; + struct var_array *va = xmalloc (sizeof *va); - if (a->scale) - *va = (struct var_array) { .n = 0 }; - else + *va = (struct var_array) { + .vars = vars, + .n = 1, + .scale_idx = a->scale ? 0 : SIZE_MAX, + }; + if (a->n_summaries || a->scale) { - struct variable **vars = xmalloc (sizeof *vars); - *vars = a->var.var; - enum pivot_axis_type *axes = xmalloc (sizeof *axes); - *axes = axis_type; - *va = (struct var_array) { .vars = vars, .axes = axes, .n = 1 }; + va->summaries = a->summaries; + va->n_summaries = a->n_summaries; + va->summary_var = a->var.var; } - va->summary = a->scale || a->n_summaries ? a : NULL; return (struct var_array2) { .vas = va, .n = 1 }; case CTAO_STACK: @@ -1483,7 +1600,7 @@ ctables_summary_init (union ctables_summary *s, } } -static void +static void UNUSED ctables_summary_uninit (union ctables_summary *s, const struct ctables_summary_spec *ss) { @@ -1671,9 +1788,9 @@ ctables_summary_add (union ctables_summary *s, } } - -static double UNUSED -ctables_summary_value (union ctables_summary *s, +static double +ctables_summary_value (const struct ctables_cell *f, + union ctables_summary *s, const struct ctables_summary_spec *ss) { switch (ss->function) @@ -1682,13 +1799,27 @@ ctables_summary_value (union ctables_summary *s, case CTSF_ECOUNT: return s->valid; + case CTSF_SUBTABLEPCT_COUNT: + return f->domains[CTDT_SUBTABLE]->valid ? s->valid / f->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS; + case CTSF_ROWPCT_COUNT: + return f->domains[CTDT_ROW]->valid ? s->valid / f->domains[CTDT_ROW]->valid * 100 : SYSMIS; + case CTSF_COLPCT_COUNT: + return f->domains[CTDT_COL]->valid ? s->valid / f->domains[CTDT_COL]->valid * 100 : SYSMIS; + case CTSF_TABLEPCT_COUNT: - case CTSF_SUBTABLEPCT_COUNT: + return f->domains[CTDT_TABLE]->valid ? s->valid / f->domains[CTDT_TABLE]->valid * 100 : SYSMIS; + case CTSF_LAYERPCT_COUNT: + return f->domains[CTDT_LAYER]->valid ? s->valid / f->domains[CTDT_LAYER]->valid * 100 : SYSMIS; + case CTSF_LAYERROWPCT_COUNT: + return f->domains[CTDT_LAYERROW]->valid ? s->valid / f->domains[CTDT_LAYERROW]->valid * 100 : SYSMIS; + case CTSF_LAYERCOLPCT_COUNT: + return f->domains[CTDT_LAYERCOL]->valid ? s->valid / f->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS; + case CTSF_ROWPCT_VALIDN: case CTSF_COLPCT_VALIDN: case CTSF_TABLEPCT_VALIDN: @@ -1800,68 +1931,298 @@ ctables_summary_value (union ctables_summary *s, NOT_REACHED (); } -struct ctables_freq - { - struct hmap_node node; /* Element in hash table. */ - union ctables_summary *summaries; - union value values[]; /* The value. */ - }; - -struct ctables_freqtab +struct ctables_cell_sort_aux { - struct var_array vars; - struct hmap data; /* Contains "struct ctables_freq"s. */ - const struct ctables_summary_spec *summaries; - size_t n_summaries; - const struct variable *summary_var; + const struct ctables_table *t; + enum pivot_axis_type a; }; -static struct ctables_freq * -ctables_freq_create (struct ctables_freqtab *ft) +static int +ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) { - struct ctables_freq *f = xmalloc (sizeof *f + ft->vars.n * sizeof *f->values); - f->summaries = xmalloc (ft->n_summaries * sizeof *f->summaries); - for (size_t i = 0; i < ft->n_summaries; i++) - ctables_summary_init (&f->summaries[i], &ft->summaries[i]); - return f; + 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].vaa_idx; + size_t b_idx = b->axes[aux->a].vaa_idx; + if (a_idx != b_idx) + return a_idx < b_idx ? -1 : 1; + + const struct var_array *va = &aux->t->vaas[aux->a].vas[a_idx]; + for (size_t i = 0; i < va->n; i++) + if (i != va->scale_idx) + { + const struct variable *var = va->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; } -static void -ctables_freq_add (struct ctables_freqtab *ft, struct ctables_freq *f, - const struct variable *var, const union value *value, - double weight) +/* 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 *f, + enum ctables_domain_type domain) { - for (size_t i = 0; i < ft->n_summaries; i++) - ctables_summary_add (&f->summaries[i], &ft->summaries[i], - var, value, weight); + size_t hash = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + size_t idx = f->axes[a].vaa_idx; + const struct var_array *va = &t->vaas[a].vas[idx]; + hash = hash_int (idx, hash); + for (size_t i = 0; i < va->n_domains[domain]; i++) + { + size_t v_idx = va->domains[domain][i]; + hash = value_hash (&f->axes[a].cvs[v_idx].value, + var_get_width (va->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 = f->axes[a].vaa_idx; + if (idx != df->axes[a].vaa_idx) + goto not_equal; + + const struct var_array *va = &t->vaas[a].vas[idx]; + for (size_t i = 0; i < va->n_domains[domain]; i++) + { + size_t v_idx = va->domains[domain][i]; + if (!value_equal (&df->axes[a].cvs[v_idx].value, + &f->axes[a].cvs[v_idx].value, + var_get_width (va->vars[v_idx]))) + goto not_equal; + } + } + return d; + + not_equal: ; + } + + d = xmalloc (sizeof *d); + *d = (struct ctables_domain) { .example = f }; + hmap_insert (&t->domains[domain], &d->node, hash); + return d; } -struct ctables_axis_render - { - size_t ofs; - struct variable **vars; - size_t n_vars; +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; - struct ctables_freq **freqs; - size_t n_freqs; - }; + case CCT_STRING: + NOT_REACHED (); -static int -ctables_freq_compare_3way (const void *a_, const void *b_, const void *ar_) + 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 void +ctables_cell_insert (struct ctables_table *t, + const struct ccase *c, + size_t ir, size_t ic, size_t il, + double weight) { - const struct ctables_axis_render *ar = ar_; - struct ctables_freq *const *a = a_; - struct ctables_freq *const *b = b_; + size_t ix[PIVOT_N_AXES] = { + [PIVOT_AXIS_ROW] = ir, + [PIVOT_AXIS_COLUMN] = ic, + [PIVOT_AXIS_LAYER] = il, + }; + const struct var_array *ss = &t->vaas[t->summary_axis].vas[ix[t->summary_axis]]; - for (size_t i = 0; i < ar->n_vars; i++) + const struct ctables_category *cats[PIVOT_N_AXES][10]; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - int cmp = value_compare_3way (&(*a)->values[i + ar->ofs], - &(*b)->values[i + ar->ofs], - var_get_width (ar->vars[i])); - if (cmp) - return cmp; + const struct var_array *va = &t->vaas[a].vas[ix[a]]; + for (size_t i = 0; i < va->n; i++) + { + if (i == va->scale_idx) + continue; + + const struct variable *var = va->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; + } } - return 0; + + size_t hash = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct var_array *va = &t->vaas[a].vas[ix[a]]; + hash = hash_int (ix[a], hash); + for (size_t i = 0; i < va->n; i++) + if (i != va->scale_idx) + hash = value_hash (case_data (c, va->vars[i]), + var_get_width (va->vars[i]), hash); + } + + struct ctables_cell *f; + HMAP_FOR_EACH_WITH_HASH (f, struct ctables_cell, node, hash, &t->cells) + { + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct var_array *va = &t->vaas[a].vas[ix[a]]; + if (f->axes[a].vaa_idx != ix[a]) + goto not_equal; + for (size_t i = 0; i < va->n; i++) + if (i != va->scale_idx + && !value_equal (case_data (c, va->vars[i]), + &f->axes[a].cvs[i].value, + var_get_width (va->vars[i]))) + goto not_equal; + } + + goto summarize; + + not_equal: ; + } + + f = xmalloc (sizeof *f); + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct var_array *va = &t->vaas[a].vas[ix[a]]; + f->axes[a].vaa_idx = ix[a]; + f->axes[a].cvs = (va->n + ? xnmalloc (va->n, sizeof *f->axes[a].cvs) + : NULL); + for (size_t i = 0; i < va->n; i++) + { + f->axes[a].cvs[i].category = cats[a][i]; + value_clone (&f->axes[a].cvs[i].value, case_data (c, va->vars[i]), + var_get_width (va->vars[i])); + } + } + f->summaries = xmalloc (ss->n_summaries * sizeof *f->summaries); + for (size_t i = 0; i < ss->n_summaries; i++) + ctables_summary_init (&f->summaries[i], &ss->summaries[i]); + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + f->domains[dt] = ctables_domain_insert (t, f, dt); + hmap_insert (&t->cells, &f->node, hash); + +summarize: + for (size_t i = 0; i < ss->n_summaries; i++) + ctables_summary_add (&f->summaries[i], &ss->summaries[i], ss->summary_var, + case_data (c, ss->summary_var), weight); + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + f->domains[dt]->valid += weight; } static bool @@ -1869,158 +2230,135 @@ ctables_execute (struct dataset *ds, struct ctables *ct) { for (size_t i = 0; i < ct->n_tables; i++) { - size_t allocated_fts = 0; - - struct ctables_table *t = &ct->tables[i]; - struct var_array2 vaa = { .n = 0 }; + struct ctables_table *t = ct->tables[i]; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - vaa = nest_fts (vaa, enumerate_fts (a, t->axes[a])); - for (size_t i = 0; i < vaa.n; i++) - { - for (size_t j = 0; j < vaa.vas[i].n; j++) - { - if (j) - fputs (", ", stdout); - printf ("%s (%c)", var_get_name (vaa.vas[i].vars[j]), - vaa.vas[i].axes[j] == PIVOT_AXIS_ROW ? 'r' - : vaa.vas[i].axes[j] == PIVOT_AXIS_COLUMN ? 'c' - : vaa.vas[i].axes[j] == PIVOT_AXIS_LAYER ? 'l' - : '?'); - } - putchar ('\n'); - } + if (t->axes[a]) + { + t->vaas[a] = enumerate_fts (a, t->axes[a]); - for (size_t j = 0; j < vaa.n; j++) + for (size_t j = 0; j < t->vaas[a].n; j++) + { + struct var_array *va = &t->vaas[a].vas[j]; + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + va->domains[dt] = xmalloc (va->n * sizeof *va->domains[dt]); + va->n_domains[dt] = 0; + + for (size_t k = 0; k < va->n; k++) + { + if (k == va->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 == va->n - 1 + || (va->scale_idx == va->n - 1 + && k == va->n - 2)) + continue; + } + break; + + case CTDT_LAYERROW: + if (a == PIVOT_AXIS_COLUMN) + continue; + break; + + case CTDT_LAYERCOL: + if (a == PIVOT_AXIS_ROW) + continue; + break; + } + + va->domains[dt][va->n_domains[dt]++] = k; + } + } + } + } + else + { + struct var_array *va = xmalloc (sizeof *va); + *va = (struct var_array) { .n = 0 }; + t->vaas[a] = (struct var_array2) { .vas = va, .n = 1 }; + } + + for (size_t i = 0; i < t->vaas[t->summary_axis].n; i++) { - const struct var_array *va = &vaa.vas[j]; - const struct ctables_summary_spec *summaries; - size_t n_summaries; - const struct variable *summary_var; - if (!va->summary) + struct var_array *va = &t->vaas[t->summary_axis].vas[i]; + if (!va->n_summaries) { - static const struct ctables_summary_spec count = { - .function = CTSF_COUNT, - .label = (char *) N_("Count"), - .format = { .type = FMT_F, .w = 40 }, + va->summaries = xmalloc (sizeof *va->summaries); + va->n_summaries = 1; + + enum ctables_summary_function function + = va->summary_var ? CTSF_MEAN : CTSF_COUNT; + struct ctables_var var = { .is_mrset = false, .var = va->summary_var }; + + *va->summaries = (struct ctables_summary_spec) { + .function = function, + .format = ctables_summary_default_format (function, &var), + .label = ctables_summary_default_label (function, 0), }; - summaries = &count; - n_summaries = 1; - summary_var = va->vars[0]; + if (!va->summary_var) + va->summary_var = va->vars[0]; } - else if (va->summary->n_summaries) - { - summaries = va->summary->summaries; - n_summaries = va->summary->n_summaries; - summary_var = va->summary->var.var; - } - else - { - static const struct ctables_summary_spec mean = { - .function = CTSF_MEAN, - .label = (char *) N_("Mean"), - .format = { .type = FMT_F, .w = 40, .d = 2}, /* XXX */ - }; - summaries = &mean; - n_summaries = 1; - summary_var = va->summary->var.var; - }; - - struct ctables_freqtab *ft = xmalloc (sizeof *ft); - *ft = (struct ctables_freqtab) { - .vars = *va, - .summaries = summaries, - .n_summaries = n_summaries, - .summary_var = summary_var, - .data = HMAP_INITIALIZER (ft->data), - }; - - if (t->n_fts >= allocated_fts) - t->fts = x2nrealloc (t->fts, &allocated_fts, sizeof *t->fts); - t->fts[t->n_fts++] = ft; } - - free (vaa.vas); } 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 j = 0; j < t->n_fts; j++) - { - struct ctables_freqtab *ft = t->fts[j]; - - 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); - } + struct ctables_table *t = ct->tables[i]; - struct ctables_freq *f; - HMAP_FOR_EACH_WITH_HASH (f, struct ctables_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; - } - goto found; - - next_hash_node: ; - } - - f = ctables_freq_create (ft); - 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); - - found: - ctables_freq_add (ft, f, ft->summary_var, - case_data (c, ft->summary_var), weight); - - next_ft: ; - } + for (size_t ir = 0; ir < t->vaas[PIVOT_AXIS_ROW].n; ir++) + for (size_t ic = 0; ic < t->vaas[PIVOT_AXIS_COLUMN].n; ic++) + for (size_t il = 0; il < t->vaas[PIVOT_AXIS_LAYER].n; il++) + ctables_cell_insert (t, c, ir, ic, il, weight); } } casereader_destroy (input); for (size_t i = 0; i < ct->n_tables; i++) { - struct ctables_table *t = &ct->tables[i]; + 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"))), + NULL); + 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)); - struct pivot_table *pt = pivot_table_create (N_("Custom Tables")); 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++) @@ -2030,140 +2368,147 @@ ctables_execute (struct dataset *ds, struct ctables *ct) [PIVOT_AXIS_COLUMN] = N_("Columns"), [PIVOT_AXIS_LAYER] = N_("Layers"), }; - d[a] = (t->axes[a] || a == t->slabels_position + d[a] = (t->axes[a] || a == t->summary_axis ? pivot_dimension_create (pt, a, names[a]) : NULL); - } - for (size_t j = 0; j < t->n_fts; j++) - { - struct ctables_freqtab *ft = t->fts[j]; + if (!d[a]) + continue; - struct ctables_axis_render axis_renders[PIVOT_N_AXES]; + assert (t->axes[a]); - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - { - size_t ofs = 0; - struct variable **vars = NULL; - size_t n = 0; - for (size_t k = 0; k < ft->vars.n; k++) - if (ft->vars.axes[k] == a) - { - ofs = k; - vars = &ft->vars.vars[k]; - for (n = 1; k + n < ft->vars.n; n++) - if (ft->vars.axes[k + n] != a) - break; - break; - } + struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); - struct ctables_axis_render *ar = &axis_renders[a]; - *ar = (struct ctables_axis_render) { - .ofs = ofs, - .vars = vars, - .n_vars = n - }; - printf ("axis %s: %zu variables\n", pivot_axis_type_to_string (a), n); - if (!n) - continue; - - ar->freqs = xnmalloc (ft->data.count, sizeof *ar->freqs); - - struct ctables_freq *f; - size_t n_freqs = 0; - HMAP_FOR_EACH (f, struct ctables_freq, node, &ft->data) - ar->freqs[n_freqs++] = f; - assert (n_freqs == ft->data.count); - ar->n_freqs = sort_unique (ar->freqs, n_freqs, sizeof *ar->freqs, - ctables_freq_compare_3way, ar); - } + struct ctables_cell *f; + size_t n = 0; + HMAP_FOR_EACH (f, struct ctables_cell, node, &t->cells) + sorted[n++] = f; + 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); - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + size_t max_depth = 0; + for (size_t j = 0; j < t->vaas[a].n; j++) + if (t->vaas[a].vas[j].n > max_depth) + max_depth = t->vaas[a].vas[j].n; + + 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_axis_render *ar = &axis_renders[a]; - if (!ar->n_vars && a != t->slabels_position) - continue; + struct ctables_cell *f = sorted[j]; + const struct var_array *va = &t->vaas[a].vas[f->axes[a].vaa_idx]; - struct pivot_category **groups = xnmalloc (ar->n_vars, - sizeof *groups); - for (size_t k = 0; k < ar->n_freqs; k++) + size_t n_common = 0; + bool new_subtable = false; + if (j > 0) { - struct ctables_freq *prev = k > 0 ? ar->freqs[k - 1] : NULL; - struct ctables_freq *f = ar->freqs[k]; - - size_t n_common = 0; - if (prev) - for (; n_common + 1 < ar->n_vars; n_common++) - if (!value_equal (&prev->values[ar->ofs + n_common], - &f->values[ar->ofs + n_common], - var_get_type (ar->vars[n_common]))) - break; - - for (size_t m = n_common; m < ar->n_vars; m++) + struct ctables_cell *prev = sorted[j - 1]; + if (prev->axes[a].vaa_idx == f->axes[a].vaa_idx) { - struct pivot_category *parent = m > 0 ? groups[m - 1] : d[a]->root; - const struct variable *var = ar->vars[m]; - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (var)]; - - if (vlabel != CTVL_NONE) - parent = pivot_category_create_group__ ( - parent, pivot_value_new_variable (ar->vars[m])); + for (; n_common < va->n; n_common++) + if (n_common != va->scale_idx + && !value_equal (&prev->axes[a].cvs[n_common].value, + &f->axes[a].cvs[n_common].value, + var_get_type (va->vars[n_common]))) + break; + } + else + new_subtable = true; + } + else + new_subtable = true; - if (m + 1 < ar->n_vars) - parent = pivot_category_create_group__ ( - parent, - pivot_value_new_var_value (ar->vars[m], &f->values[m])); - groups[m] = parent; + if (new_subtable) + { + enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[0])]; + top = d[a]->root; + if (vlabel != CTVL_NONE) + top = pivot_category_create_group__ ( + top, pivot_value_new_variable (va->vars[0])); + } + if (n_common == va->n) + { + f->axes[a].leaf = prev_leaf; + continue; + } - if (m == ar->n_vars - 1) + for (size_t k = n_common; k < va->n; k++) + { + struct pivot_category *parent = k > 0 ? groups[k - 1] : top; + + struct pivot_value *label + = (k != va->scale_idx + ? pivot_value_new_var_value (va->vars[k], + &f->axes[a].cvs[k].value) + : NULL); + if (k == va->n - 1) + { + if (a == t->summary_axis) { - pivot_category_create_leaf ( - parent, - pivot_value_new_var_value (ar->vars[ar->n_vars - 1], - &f->values[ar->ofs + ar->n_vars - 1])); -#if 0 - for (size_t p = 0; p < ft->n_summaries; p++) + if (label) + parent = pivot_category_create_group__ (parent, label); + for (size_t m = 0; m < va->n_summaries; m++) { - if (a == t->slabels_position) - pivot_category_create_leaf ( - c, pivot_value_new_text (ft->summaries[p].label)); - //pivot_table_put1 (pt, leaf, pivot_value_new_number (value)); + int leaf = pivot_category_create_leaf ( + parent, pivot_value_new_text (va->summaries[m].label)); + if (m == 0) + prev_leaf = leaf; } -#endif } + else + { + /* This assertion is true as long as the summary axis + is the axis where the summaries are displayed. */ + assert (label); + + prev_leaf = pivot_category_create_leaf (parent, label); + } + break; } + + if (label) + parent = pivot_category_create_group__ (parent, label); + + enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[k + 1])]; + if (vlabel != CTVL_NONE) + parent = pivot_category_create_group__ ( + parent, pivot_value_new_variable (va->vars[k + 1])); + groups[k] = parent; } - free (groups); + + f->axes[a].leaf = prev_leaf; } + free (sorted); + free (groups); } - pivot_table_submit (pt); - } - - for (size_t i = 0; i < ct->n_tables; i++) - { - struct ctables_table *t = &ct->tables[i]; - - for (size_t j = 0; j < t->n_fts; j++) + struct ctables_cell *f; + HMAP_FOR_EACH (f, struct ctables_cell, node, &t->cells) { - struct ctables_freqtab *ft = t->fts[j]; - struct ctables_freq *f, *next; - HMAP_FOR_EACH_SAFE (f, next, struct ctables_freq, node, &ft->data) + const struct var_array *ss = &t->vaas[t->summary_axis].vas[f->axes[t->summary_axis].vaa_idx]; + for (size_t j = 0; j < ss->n_summaries; j++) { - hmap_delete (&ft->data, &f->node); - for (size_t k = 0; k < ft->n_summaries; k++) - ctables_summary_uninit (&f->summaries[k], &ft->summaries[k]); - free (f->summaries); - for (size_t k = 0; k < ft->vars.n; k++) - { - const struct variable *var = ft->vars.vars[k]; - value_destroy (&f->values[k], var_get_width (var)); - } - free (f); + 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 = f->axes[a].leaf; + if (a == t->summary_axis) + leaf += j; + dindexes[n_dindexes++] = leaf; + } + + double d = ctables_summary_value (f, &f->summaries[j], &ss->summaries[j]); + struct pivot_value *value = pivot_value_new_number (d); + value->numeric.format = ss->summaries[j].format; + pivot_table_put (pt, dindexes, n_dindexes, value); } - hmap_destroy (&ft->data); - var_array_uninit (&ft->vars); - free (ft); } - free (t->fts); + + pivot_table_submit (pt); } return proc_commit (ds); @@ -2381,17 +2726,40 @@ 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) { + .cells = HMAP_INITIALIZER (t->cells), .slabels_position = 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)), + .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)) @@ -2419,26 +2787,57 @@ 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;