X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=4ee180f518141bf373dcfdc460e7cab6a9e0126f;hb=a43a4b9abb1aa793c32b23bc7bbf41da9c657bff;hp=2edd40d5d39d78cfc46a86e1dd6bdfad9df0b0ff;hpb=e84a26c32c9acf582772d1b4fd5e237fc0865dc3;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 2edd40d5d3..4ee180f518 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -173,8 +173,10 @@ struct ctables_domain const struct ctables_cell *example; - double valid; - double missing; + double d_valid; /* Dictionary weight. */ + double d_missing; + double e_valid; /* Effective weight */ + double e_missing; }; enum ctables_summary_variant @@ -199,7 +201,6 @@ struct ctables_cell struct { - size_t nest_idx; struct ctables_cell_value { const struct ctables_category *category; @@ -230,7 +231,7 @@ struct ctables bool mrsets_count_duplicates; /* MRSETS. */ bool smissing_listwise; /* SMISSING. */ - struct variable *base_weight; /* WEIGHT. */ + struct variable *e_weight; /* WEIGHT. */ int hide_threshold; /* HIDESMALLCOUNTS. */ struct ctables_table **tables; @@ -323,14 +324,22 @@ struct ctables_value int leaf; }; +struct ctables_section + { + struct ctables_table *table; + struct ctables_nest *nests[PIVOT_N_AXES]; + struct hmap cells; /* Contains "struct ctable_cell"s. */ + struct hmap domains[N_CTDTS]; /* Contains "struct ctable_domain"s. */ + }; + struct ctables_table { struct ctables_axis *axes[PIVOT_N_AXES]; struct ctables_stack stacks[PIVOT_N_AXES]; + struct ctables_section *sections; + size_t n_sections; 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; @@ -1892,11 +1901,19 @@ static void ctables_summary_add (union ctables_summary *s, const struct ctables_summary_spec *ss, const struct variable *var, const union value *value, - double weight) + double d_weight, double e_weight) { switch (ss->function) { case CTSF_COUNT: + case CSTF_TOTALN: + case CTSF_VALIDN: + if (var_is_value_missing (var, value)) + s->missing += d_weight; + else + s->valid += d_weight; + break; + case CTSF_ECOUNT: case CTSF_ROWPCT_COUNT: case CTSF_COLPCT_COUNT: @@ -1920,14 +1937,12 @@ ctables_summary_add (union ctables_summary *s, case CTSF_LAYERROWPCT_TOTALN: case CTSF_LAYERCOLPCT_TOTALN: case CTSF_MISSING: - case CSTF_TOTALN: case CTSF_ETOTALN: - case CTSF_VALIDN: case CTSF_EVALIDN: if (var_is_value_missing (var, value)) - s->missing += weight; + s->missing += e_weight; else - s->valid += weight; + s->valid += e_weight; break; case CTSF_MAXIMUM: @@ -1956,7 +1971,7 @@ ctables_summary_add (union ctables_summary *s, case CTSF_LAYERROWPCT_SUM: case CTSF_LAYERCOLPCT_SUM: if (!var_is_value_missing (var, value)) - moments1_add (s->moments, value->f, weight); + moments1_add (s->moments, value->f, e_weight); break; case CTSF_MEDIAN: @@ -1964,11 +1979,11 @@ ctables_summary_add (union ctables_summary *s, case CTSF_PTILE: if (var_is_value_missing (var, value)) { - s->ovalid += weight; + s->ovalid += e_weight; struct ccase *c = case_create (casewriter_get_proto (s->writer)); *case_num_rw_idx (c, 0) = value->f; - *case_num_rw_idx (c, 1) = weight; + *case_num_rw_idx (c, 1) = e_weight; casewriter_write (s->writer, c); } break; @@ -1999,6 +2014,99 @@ ctables_summary_add (union ctables_summary *s, } } +static enum ctables_domain_type +ctables_function_domain (enum ctables_summary_function function) +{ + switch (function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_MEDIAN: + case CTSF_PTILE: + case CTSF_MODE: + case CTSF_RESPONSES: + NOT_REACHED (); + + case CTSF_COLPCT_COUNT: + case CTSF_COLPCT_COUNT_RESPONSES: + case CTSF_COLPCT_RESPONSES: + case CTSF_COLPCT_RESPONSES_COUNT: + case CTSF_COLPCT_SUM: + case CTSF_COLPCT_TOTALN: + case CTSF_COLPCT_VALIDN: + return CTDT_COL; + + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES: + case CTSF_LAYERCOLPCT_RESPONSES_COUNT: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_LAYERCOLPCT_VALIDN: + return CTDT_LAYERCOL; + + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERPCT_COUNT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES: + case CTSF_LAYERPCT_RESPONSES_COUNT: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERPCT_VALIDN: + return CTDT_LAYER; + + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES: + case CTSF_LAYERROWPCT_RESPONSES_COUNT: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERROWPCT_VALIDN: + return CTDT_LAYERROW; + + case CTSF_ROWPCT_COUNT: + case CTSF_ROWPCT_COUNT_RESPONSES: + case CTSF_ROWPCT_RESPONSES: + case CTSF_ROWPCT_RESPONSES_COUNT: + case CTSF_ROWPCT_SUM: + case CTSF_ROWPCT_TOTALN: + case CTSF_ROWPCT_VALIDN: + return CTDT_ROW; + + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES: + case CTSF_SUBTABLEPCT_RESPONSES_COUNT: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_VALIDN: + return CTDT_SUBTABLE; + + case CTSF_TABLEPCT_COUNT: + case CTSF_TABLEPCT_COUNT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES: + case CTSF_TABLEPCT_RESPONSES_COUNT: + case CTSF_TABLEPCT_SUM: + case CTSF_TABLEPCT_TOTALN: + case CTSF_TABLEPCT_VALIDN: + return CTDT_TABLE; + } + + NOT_REACHED (); +} + static double ctables_summary_value (const struct ctables_cell *cell, union ctables_summary *s, @@ -2010,26 +2118,19 @@ ctables_summary_value (const struct ctables_cell *cell, case CTSF_ECOUNT: return s->valid; - case CTSF_SUBTABLEPCT_COUNT: - return cell->domains[CTDT_SUBTABLE]->valid ? s->valid / cell->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS; - case CTSF_ROWPCT_COUNT: - return cell->domains[CTDT_ROW]->valid ? s->valid / cell->domains[CTDT_ROW]->valid * 100 : SYSMIS; - case CTSF_COLPCT_COUNT: - return cell->domains[CTDT_COL]->valid ? s->valid / cell->domains[CTDT_COL]->valid * 100 : SYSMIS; - case CTSF_TABLEPCT_COUNT: - return cell->domains[CTDT_TABLE]->valid ? s->valid / cell->domains[CTDT_TABLE]->valid * 100 : SYSMIS; - + case CTSF_SUBTABLEPCT_COUNT: case CTSF_LAYERPCT_COUNT: - return cell->domains[CTDT_LAYER]->valid ? s->valid / cell->domains[CTDT_LAYER]->valid * 100 : SYSMIS; - case CTSF_LAYERROWPCT_COUNT: - return cell->domains[CTDT_LAYERROW]->valid ? s->valid / cell->domains[CTDT_LAYERROW]->valid * 100 : SYSMIS; - case CTSF_LAYERCOLPCT_COUNT: - return cell->domains[CTDT_LAYERCOL]->valid ? s->valid / cell->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS; + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_valid + ? s->valid / cell->domains[d]->e_valid * 100 + : SYSMIS); + } case CTSF_ROWPCT_VALIDN: case CTSF_COLPCT_VALIDN: @@ -2171,7 +2272,7 @@ ctables_summary_value (const struct ctables_cell *cell, struct ctables_cell_sort_aux { - const struct ctables_table *t; + const struct ctables_nest *nest; enum pivot_axis_type a; }; @@ -2184,12 +2285,7 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) const struct ctables_cell *a = *ap; const struct ctables_cell *b = *bp; - size_t a_idx = a->axes[aux->a].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]; + const struct ctables_nest *nest = aux->nest; for (size_t i = 0; i < nest->n; i++) if (i != nest->scale_idx) { @@ -2268,15 +2364,13 @@ ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) */ static struct ctables_domain * -ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, +ctables_domain_insert (struct ctables_section *s, 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); + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n_domains[domain]; i++) { size_t v_idx = nest->domains[domain][i]; @@ -2286,16 +2380,12 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, } struct ctables_domain *d; - HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &t->domains[domain]) + HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &s->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]; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n_domains[domain]; i++) { size_t v_idx = nest->domains[domain][i]; @@ -2312,7 +2402,7 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, d = xmalloc (sizeof *d); *d = (struct ctables_domain) { .example = cell }; - hmap_insert (&t->domains[domain], &d->node, hash); + hmap_insert (&s->domains[domain], &d->node, hash); return d; } @@ -2377,18 +2467,16 @@ ctables_categories_total (const struct ctables_categories *c) } static struct ctables_cell * -ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, - size_t ix[PIVOT_N_AXES], +ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10]) { - const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; + const struct ctables_nest *ss = s->nests[s->table->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); + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n; i++) if (i != nest->scale_idx) { @@ -2404,13 +2492,11 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, } struct ctables_cell *cell; - HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &t->cells) + HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &s->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; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n; i++) if (i != nest->scale_idx && (cats[a][i] != cell->axes[a].cvs[i].category @@ -2434,8 +2520,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, cell->contributes_to_domains = true; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; - cell->axes[a].nest_idx = ix[a]; + const struct ctables_nest *nest = s->nests[a]; cell->axes[a].cvs = (nest->n ? xnmalloc (nest->n, sizeof *cell->axes[a].cvs) : NULL); @@ -2464,39 +2549,42 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, 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); + cell->domains[dt] = ctables_domain_insert (s, cell, dt); + hmap_insert (&s->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], +ctables_cell_add__ (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10], - double weight) + double d_weight, double e_weight) { - struct ctables_cell *cell = ctables_cell_insert__ (t, c, ix, cats); - const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; + struct ctables_cell *cell = ctables_cell_insert__ (s, c, cats); + const struct ctables_nest *ss = s->nests[s->table->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); + case_data (c, specs->var), d_weight, e_weight); if (cell->contributes_to_domains) - for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) - cell->domains[dt]->valid += weight; + { + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + cell->domains[dt]->d_valid += d_weight; + cell->domains[dt]->e_valid += e_weight; + } + } } static void -recurse_totals (struct ctables_table *t, const struct ccase *c, - size_t ix[PIVOT_N_AXES], +recurse_totals (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10], - double weight, + double d_weight, double e_weight, enum pivot_axis_type start_axis, size_t start_nest) { for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = start_nest; i < nest->n; i++) { if (i == nest->scale_idx) @@ -2505,13 +2593,13 @@ recurse_totals (struct ctables_table *t, const struct ccase *c, const struct variable *var = nest->vars[i]; const struct ctables_category *total = ctables_categories_total ( - t->categories[var_get_dict_index (var)]); + s->table->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); + ctables_cell_add__ (s, c, cats, d_weight, e_weight); + recurse_totals (s, c, cats, d_weight, e_weight, a, i + 1); cats[a][i] = save; } } @@ -2520,15 +2608,14 @@ recurse_totals (struct ctables_table *t, const struct ccase *c, } static void -recurse_subtotals (struct ctables_table *t, const struct ccase *c, - size_t ix[PIVOT_N_AXES], +recurse_subtotals (struct ctables_section *s, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10], - double weight, + double d_weight, double e_weight, enum pivot_axis_type start_axis, size_t start_nest) { for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = start_nest; i < nest->n; i++) { if (i == nest->scale_idx) @@ -2538,8 +2625,8 @@ recurse_subtotals (struct ctables_table *t, const struct ccase *c, 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); + ctables_cell_add__ (s, c, cats, d_weight, e_weight); + recurse_subtotals (s, c, cats, d_weight, e_weight, a, i + 1); cats[a][i] = save; } } @@ -2548,21 +2635,14 @@ recurse_subtotals (struct ctables_table *t, const struct ccase *c, } static void -ctables_cell_insert (struct ctables_table *t, +ctables_cell_insert (struct ctables_section *s, const struct ccase *c, - size_t ir, size_t ic, size_t il, - double weight) + double d_weight, double e_weight) { - size_t ix[PIVOT_N_AXES] = { - [PIVOT_AXIS_ROW] = ir, - [PIVOT_AXIS_COLUMN] = ic, - [PIVOT_AXIS_LAYER] = il, - }; - const struct ctables_category *cats[PIVOT_N_AXES][10]; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + const struct ctables_nest *nest = s->nests[a]; for (size_t i = 0; i < nest->n; i++) { if (i == nest->scale_idx) @@ -2575,16 +2655,16 @@ ctables_cell_insert (struct ctables_table *t, return; cats[a][i] = ctables_categories_match ( - t->categories[var_get_dict_index (var)], value, var); + s->table->categories[var_get_dict_index (var)], value, var); if (!cats[a][i]) return; } } - ctables_cell_add__ (t, c, ix, cats, weight); + ctables_cell_add__ (s, c, cats, d_weight, e_weight); - recurse_totals (t, c, ix, cats, weight, 0, 0); - recurse_subtotals (t, c, ix, cats, weight, 0, 0); + recurse_totals (s, c, cats, d_weight, e_weight, 0, 0); + recurse_subtotals (s, c, cats, d_weight, e_weight, 0, 0); } struct merge_item @@ -2635,6 +2715,30 @@ ctables_value_find (struct ctables_table *t, value_hash (value, width, 0)); } +static void +ctables_table_add_section (struct ctables_table *t, enum pivot_axis_type a, + size_t ix[PIVOT_N_AXES]) +{ + if (a < PIVOT_N_AXES) + { + size_t limit = MAX (t->stacks[a].n, 1); + for (ix[a] = 0; ix[a] < limit; ix[a]++) + ctables_table_add_section (t, a + 1, ix); + } + else + { + struct ctables_section *s = &t->sections[t->n_sections++]; + *s = (struct ctables_section) { + .table = t, + .cells = HMAP_INITIALIZER (s->cells), + }; + for (a = 0; a < PIVOT_N_AXES; a++) + s->nests[a] = t->stacks[a].n ? &t->stacks[a].nests[ix[a]] : NULL; + for (size_t i = 0; i < N_CTDTS; i++) + hmap_init (&s->domains[i]); + } +} + static void ctables_table_output (struct ctables *ct, struct ctables_table *t) { @@ -2702,205 +2806,228 @@ ctables_table_output (struct ctables *ct, struct ctables_table *t) assert (t->axes[a]); - struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); - size_t n_sorted = 0; + for (size_t i = 0; i < t->stacks[a].n; i++) + { + struct ctables_nest *nest = &t->stacks[a].nests[i]; + struct ctables_section **sections = xnmalloc (t->n_sections, + sizeof *sections); + size_t n_sections = 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 + size_t n_total_cells = 0; + size_t max_depth = 0; + for (size_t j = 0; j < t->n_sections; j++) + if (t->sections[j].nests[a] == nest) + { + struct ctables_section *s = &t->sections[j]; + sections[n_sections++] = s; + n_total_cells += s->cells.count; + + size_t depth = s->nests[a]->n; + max_depth = MAX (depth, max_depth); + } + + struct ctables_cell **sorted = xnmalloc (n_total_cells, + sizeof *sorted); + size_t n_sorted = 0; + + for (size_t j = 0; j < n_sections; j++) { - CTL_VAR, /* Variable label for nest->vars[var_idx]. */ - CTL_CATEGORY, /* Category for nest->vars[var_idx]. */ - CTL_SUMMARY, /* Summary functions. */ - } - type; + struct ctables_section *s = sections[j]; - size_t var_idx; - }; - struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels); - size_t n_levels = 0; + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells) + if (!cell->hide) + sorted[n_sorted++] = cell; + assert (n_sorted <= n_total_cells); + } - 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]; + struct ctables_cell_sort_aux aux = { .nest = nest, .a = a }; + sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux); - bool new_subtable = !prev || prev->axes[a].nest_idx != cell->axes[a].nest_idx; - if (new_subtable) + struct ctables_level { - n_levels = 0; - for (size_t k = 0; k < nest->n; k++) + enum ctables_level_type { - 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, - }; - } + CTL_VAR, /* Variable label for nest->vars[var_idx]. */ + CTL_CATEGORY, /* Category for nest->vars[var_idx]. */ + CTL_SUMMARY, /* Summary functions. */ + } + type; - 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, - }; - } + size_t var_idx; + }; + struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels); + size_t 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 (!summary_dimension && a == t->slabels_axis) + if (nest->scale_idx != k + && (k != nest->n - 1 || t->label_axis[a] == a)) { levels[n_levels++] = (struct ctables_level) { - .type = CTL_SUMMARY, - .var_idx = SIZE_MAX, + .type = CTL_CATEGORY, + .var_idx = k, }; } } - size_t n_common = 0; - if (!new_subtable) + if (!summary_dimension && a == t->slabels_axis) { - 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; - } - } + levels[n_levels++] = (struct ctables_level) { + .type = CTL_SUMMARY, + .var_idx = SIZE_MAX, + }; } - for (size_t k = n_common; k < n_levels; k++) + /* 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 pivot_category **groups = xnmalloc (1 + 2 * max_depth, sizeof *groups); + int prev_leaf = 0; + for (size_t j = 0; j < n_sorted; j++) { - const struct ctables_level *level = &levels[k]; - struct pivot_category *parent = k ? groups[k - 1] : d[a]->root; - if (level->type == CTL_SUMMARY) + struct ctables_cell *cell = sorted[j]; + struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL; + + size_t n_common = 0; + if (j > 0) { - const struct ctables_summary_spec_set *specs = &t->summary_specs; - for (size_t m = 0; m < specs->n; m++) + for (; n_common < n_levels; n_common++) { - int leaf = pivot_category_create_leaf ( - parent, pivot_value_new_text (specs->specs[m].label)); - if (!m) - prev_leaf = leaf; + 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; + } } } - else + + for (size_t k = n_common; k < n_levels; k++) { - 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_level *level = &levels[k]; + struct pivot_category *parent = k ? groups[k - 1] : d[a]->root; + if (level->type == CTL_SUMMARY) { - const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx]; - label = ctables_category_create_label (cv->category, - var, &cv->value); + assert (k == n_levels - 1); + + 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 - NOT_REACHED (); + { + 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); + 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; + cell->axes[a].leaf = prev_leaf; + } + free (sorted); + free (groups); } - free (sorted); - free (groups); } - struct ctables_cell *cell; - HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) + for (size_t i = 0; i < t->n_sections; i++) { - if (cell->hide) - continue; + struct ctables_section *s = &t->sections[i]; - 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++) + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells) { - size_t dindexes[5]; - size_t n_dindexes = 0; - - if (summary_dimension) - dindexes[n_dindexes++] = specs->specs[j].axis_idx; + if (cell->hide) + continue; - if (categories_dimension) + const struct ctables_nest *specs_nest = s->nests[t->summary_axis]; + const struct ctables_summary_spec_set *specs = &specs_nest->specs[cell->sv]; + for (size_t j = 0; j < specs->n; j++) { - 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; - } + size_t dindexes[5]; + size_t n_dindexes = 0; - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - if (d[a]) - { - int leaf = cell->axes[a].leaf; - if (a == t->summary_axis && !summary_dimension) - leaf += j; - dindexes[n_dindexes++] = leaf; - } + if (summary_dimension) + dindexes[n_dindexes++] = specs->specs[j].axis_idx; + + if (categories_dimension) + { + const struct ctables_nest *clabels_nest = s->nests[t->clabels_from_axis]; + 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); + 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); + } } } @@ -3220,26 +3347,36 @@ ctables_sort_clabels_values (struct ctables_table *t) 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); + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + t->sections = xnmalloc (MAX (1, t->stacks[PIVOT_AXIS_ROW].n) * + MAX (1, t->stacks[PIVOT_AXIS_COLUMN].n) * + MAX (1, t->stacks[PIVOT_AXIS_LAYER].n), + sizeof *t->sections); + size_t ix[PIVOT_N_AXES]; + ctables_table_add_section (t, 0, ix); + } + + struct casereader *input = proc_open (ds); bool warn_on_invalid = true; - double total_weight = 0; for (struct ccase *c = casereader_read (input); c; case_unref (c), c = casereader_read (input)) { - double weight = dict_get_case_weight (dataset_dict (ds), c, - &warn_on_invalid); - total_weight += weight; + double d_weight = dict_get_case_weight (dataset_dict (ds), c, + &warn_on_invalid); + double e_weight = (ct->e_weight + ? var_force_valid_weight (ct->e_weight, + case_num (c, ct->e_weight), + &warn_on_invalid) + : d_weight); for (size_t i = 0; i < ct->n_tables; i++) { 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 (size_t j = 0; j < t->n_sections; j++) + ctables_cell_insert (&t->sections[j], c, d_weight, e_weight); for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) if (t->label_axis[a] != a) @@ -3439,8 +3576,8 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) if (!lex_force_match_id (lexer, "VARIABLE")) goto error; lex_match (lexer, T_EQUALS); - ct->base_weight = parse_variable (lexer, dataset_dict (ds)); - if (!ct->base_weight) + ct->e_weight = parse_variable (lexer, dataset_dict (ds)); + if (!ct->e_weight) goto error; } else if (lex_match_id (lexer, "HIDESMALLCOUNTS")) @@ -3494,7 +3631,6 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) struct ctables_table *t = xmalloc (sizeof *t); *t = (struct ctables_table) { - .cells = HMAP_INITIALIZER (t->cells), .slabels_axis = PIVOT_AXIS_COLUMN, .slabels_visible = true, .clabels_values_map = HMAP_INITIALIZER (t->clabels_values_map), @@ -3508,8 +3644,6 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) .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);