From 042cd96c590125ddf6e5dff0961da2ff55ac9d5a Mon Sep 17 00:00:00 2001 From: Ben Pfaff Date: Mon, 3 Jan 2022 22:02:08 -0800 Subject: [PATCH] Unify categories as the "explicit" categories. --- src/language/stats/ctables.c | 455 ++++++++++++++++++++--------------- 1 file changed, 264 insertions(+), 191 deletions(-) diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index aee54a1f52..b3ddee623f 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -183,7 +183,12 @@ struct ctables_cell struct { size_t vaa_idx; - union value *values; + struct ctables_cell_value + { + const struct ctables_category *category; + union value value; + } + *cvs; int leaf; } axes[PIVOT_N_AXES]; @@ -343,76 +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_cat_value *ctables_categories_match ( +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 CCT_STRING: + free (cat->string); break; - case CCVT_STRING: - free (cv->string); + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + case CCT_TOTAL: + free (cat->total_label); break; - case CCVT_SUBTOTAL: - case CCVT_HSUBTOTAL: - free (cv->subtotal_label); + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + break; } } @@ -426,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); } @@ -1085,11 +1097,11 @@ ctables_destroy (struct ctables *ct) 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 } }; } @@ -1118,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)) @@ -1151,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); @@ -1183,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); @@ -1253,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"); @@ -1269,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")) @@ -1277,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"); @@ -1309,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 @@ -1317,6 +1336,36 @@ 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; } @@ -1907,49 +1956,56 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) if (i != va->scale_idx) { const struct variable *var = va->vars[i]; - const union value *val_a = &a->axes[aux->a].values[i]; - const union value *val_b = &b->axes[aux->a].values[i]; - int cmp = value_compare_3way (val_a, val_b, var_get_width (var)); - if (!cmp) - continue; - - const struct ctables_categories *cats = aux->t->categories[var_get_dict_index (var)]; - if (!cats) - return cmp; - else if (cats->n_values) + 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) { - const struct ctables_cat_value *a_cv = ctables_categories_match (cats, val_a, var); - const struct ctables_cat_value *b_cv = ctables_categories_match (cats, val_b, var); - assert (a_cv && b_cv); - return (a_cv == b_cv ? cmp - : a_cv > b_cv ? 1 - : -1); - } - else - { - switch (cats->key) - { - case CTCS_VALUE: - /* Nothing to do. */ - break; + case CCT_NUMBER: + case CCT_STRING: + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + case CCT_TOTAL: + /* Must be equal. */ + continue; - case CTCS_LABEL: - { - const char *a_label = var_lookup_value_label (var, val_a); - const char *b_label = var_lookup_value_label (var, val_b); - int label_cmp = (a_label - ? (b_label ? strcmp (a_label, b_label) : 1) - : (b_label ? -1 : 0)); - if (label_cmp) - cmp = label_cmp; - } - break; + 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 CTCS_FUNCTION: - NOT_REACHED (); - } + 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; - return cats->sort_ascending ? cmp : -cmp; + case CCT_FUNCTION: + NOT_REACHED (); } } return 0; @@ -1986,7 +2042,7 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *f, 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].values[v_idx], + hash = value_hash (&f->axes[a].cvs[v_idx].value, var_get_width (va->vars[v_idx]), hash); } } @@ -2005,8 +2061,8 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *f, 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].values[v_idx], - &f->axes[a].values[v_idx], + 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; } @@ -2022,43 +2078,50 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *f, return d; } -static const struct ctables_cat_value * -ctables_categories_match (const struct ctables_categories *cats, +static const struct ctables_category * +ctables_categories_match (const struct ctables_categories *c, const union value *v, const struct variable *var) { - const struct ctables_cat_value *othernm = NULL; - for (size_t i = cats->n_values; i-- > 0; ) + const struct ctables_category *othernm = NULL; + for (size_t i = c->n_cats; i-- > 0; ) { - const struct ctables_cat_value *cv = &cats->values[i]; - switch (cv->type) + const struct ctables_category *cat = &c->cats[i]; + switch (cat->type) { - case CCVT_NUMBER: - if (cv->number == v->f) - return cv; + case CCT_NUMBER: + if (cat->number == v->f) + return cat; break; - case CCVT_STRING: + case CCT_STRING: NOT_REACHED (); - case CCVT_RANGE: - if ((cv->range[0] == -DBL_MAX || v->f >= cv->range[0]) - && (cv->range[1] == DBL_MAX || v->f <= cv->range[1])) - return cv; + 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 CCVT_MISSING: + case CCT_MISSING: if (var_is_value_missing (var, v)) - return cv; + return cat; break; - case CCVT_OTHERNM: + case CCT_OTHERNM: if (!othernm) - othernm = cv; + othernm = cat; break; - case CCVT_SUBTOTAL: - case CCVT_HSUBTOTAL: + 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); } } @@ -2078,6 +2141,7 @@ ctables_cell_insert (struct ctables_table *t, }; const struct var_array *ss = &t->vaas[t->summary_axis].vas[ix[t->summary_axis]]; + const struct ctables_category *cats[PIVOT_N_AXES][10]; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { const struct var_array *va = &t->vaas[a].vas[ix[a]]; @@ -2089,26 +2153,13 @@ ctables_cell_insert (struct ctables_table *t, const struct variable *var = va->vars[i]; const union value *value = case_data (c, var); - enum mv_class missing = var_is_value_missing (var, value); - if (missing == MV_SYSTEM) + if (var_is_numeric (var) && value->f == SYSMIS) return; - const struct ctables_categories *cats = t->categories[var_get_dict_index (var)]; - if (!cats) - { - if (missing) - return; - } - else if (cats->n_values) - { - if (!ctables_categories_match (cats, value, var)) - return; - } - else - { - if (missing && !cats->include_missing) - return; - } + cats[a][i] = ctables_categories_match ( + t->categories[var_get_dict_index (var)], value, var); + if (!cats[a][i]) + return; } } @@ -2134,7 +2185,7 @@ ctables_cell_insert (struct ctables_table *t, 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].values[i], + &f->axes[a].cvs[i].value, var_get_width (va->vars[i]))) goto not_equal; } @@ -2149,12 +2200,15 @@ ctables_cell_insert (struct ctables_table *t, { const struct var_array *va = &t->vaas[a].vas[ix[a]]; f->axes[a].vaa_idx = ix[a]; - f->axes[a].values = (va->n - ? xnmalloc (va->n, sizeof *f->axes[a].values) - : NULL); + f->axes[a].cvs = (va->n + ? xnmalloc (va->n, sizeof *f->axes[a].cvs) + : NULL); for (size_t i = 0; i < va->n; i++) - value_clone (&f->axes[a].values[i], case_data (c, va->vars[i]), - var_get_width (va->vars[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++) @@ -2355,8 +2409,8 @@ ctables_execute (struct dataset *ds, struct ctables *ct) { for (; n_common < va->n; n_common++) if (n_common != va->scale_idx - && !value_equal (&prev->axes[a].values[n_common], - &f->axes[a].values[n_common], + && !value_equal (&prev->axes[a].cvs[n_common].value, + &f->axes[a].cvs[n_common].value, var_get_type (va->vars[n_common]))) break; } @@ -2387,7 +2441,7 @@ ctables_execute (struct dataset *ds, struct ctables *ct) struct pivot_value *label = (k != va->scale_idx ? pivot_value_new_var_value (va->vars[k], - &f->axes[a].values[k]) + &f->axes[a].cvs[k].value) : NULL); if (k == va->n - 1) { @@ -2672,6 +2726,26 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) ct->tables = x2nrealloc (ct->tables, &allocated_tables, sizeof *ct->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), @@ -2679,9 +2753,8 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) .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++) -- 2.30.2