X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=ca2cfd9b66d2b7e3d05141948019627ccee8adc5;hb=5cc8d996ceb67400912b46199ae658cdfbfea180;hp=9c5b8ee6149d85e6aa5558cdb498466dcd06639e;hpb=b0a400eb4ab34438115c4be640a43c9b0b3bf7ad;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 9c5b8ee614..ca2cfd9b66 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -177,12 +177,15 @@ struct ctables_cell axes (except the scalar variable, if any). */ struct hmap_node node; - /* The domains that contains this cell. */ + /* The domains that contain this cell. */ struct ctables_domain *domains[N_CTDTS]; + bool hide; + bool total; + struct { - size_t vaa_idx; + size_t stack_idx; struct ctables_cell_value { const struct ctables_category *category; @@ -274,7 +277,19 @@ enum ctables_label_position CTLP_LAYER, }; -struct var_array +struct ctables_summary_spec_set + { + struct ctables_summary_spec *summaries; + size_t n; + size_t allocated; + + struct variable *var; + }; + +static void ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *); + +/* A nested sequence of variables, e.g. a > b > c. */ +struct ctables_nest { struct variable **vars; size_t n; @@ -282,21 +297,21 @@ struct var_array 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 ctables_summary_spec_set cell_sss; + struct ctables_summary_spec_set total_sss; }; -struct var_array2 +/* A stack of nestings, e.g. nest1 + nest2 + ... + nestN. */ +struct ctables_stack { - struct var_array *vas; + struct ctables_nest *nests; size_t n; }; struct ctables_table { struct ctables_axis *axes[PIVOT_N_AXES]; - struct var_array2 vaas[PIVOT_N_AXES]; + struct ctables_stack stacks[PIVOT_N_AXES]; enum pivot_axis_type summary_axis; struct hmap cells; struct hmap domains[N_CTDTS]; @@ -373,6 +388,8 @@ struct ctables_category } type; + struct ctables_category *subtotal; + union { double number; /* CCT_NUMBER. */ @@ -483,9 +500,8 @@ struct ctables_axis { struct ctables_var var; bool scale; - struct ctables_summary_spec *summaries; - size_t n_summaries; - size_t allocated_summaries; + struct ctables_summary_spec_set cell_sss; + struct ctables_summary_spec_set total_sss; }; /* Nonterminals. */ @@ -526,6 +542,14 @@ ctables_summary_spec_uninit (struct ctables_summary_spec *s) free (s->label); } +static void +ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *set) +{ + for (size_t i = 0; i < set->n; i++) + ctables_summary_spec_uninit (&set->summaries[i]); + free (set->summaries); +} + static bool parse_col_width (struct lexer *lexer, const char *name, double *width) { @@ -619,9 +643,8 @@ ctables_axis_destroy (struct ctables_axis *axis) switch (axis->op) { case CTAO_VAR: - for (size_t i = 0; i < axis->n_summaries; i++) - ctables_summary_spec_uninit (&axis->summaries[i]); - free (axis->summaries); + ctables_summary_spec_set_uninit (&axis->cell_sss); + ctables_summary_spec_set_uninit (&axis->total_sss); break; case CTAO_STACK: @@ -712,15 +735,10 @@ static bool add_summary_spec (struct ctables_axis *axis, enum ctables_summary_function function, double percentile, const char *label, const struct fmt_spec *format, - const struct msg_location *loc) + const struct msg_location *loc, bool totals) { if (axis->op == CTAO_VAR) { - if (axis->n_summaries >= axis->allocated_summaries) - axis->summaries = x2nrealloc (axis->summaries, - &axis->allocated_summaries, - sizeof *axis->summaries); - const char *function_name = ctables_summary_function_name (function); const char *var_name = ctables_var_name (&axis->var); switch (ctables_function_availability (function)) @@ -752,7 +770,13 @@ add_summary_spec (struct ctables_axis *axis, break; } - struct ctables_summary_spec *dst = &axis->summaries[axis->n_summaries++]; + struct ctables_summary_spec_set *set = (totals ? &axis->total_sss + : &axis->cell_sss); + if (set->n >= set->allocated) + set->summaries = x2nrealloc (set->summaries, &set->allocated, + sizeof *set->summaries); + + struct ctables_summary_spec *dst = &set->summaries[set->n++]; *dst = (struct ctables_summary_spec) { .function = function, .percentile = percentile, @@ -766,7 +790,7 @@ add_summary_spec (struct ctables_axis *axis, { for (size_t i = 0; i < 2; i++) if (!add_summary_spec (axis->subs[i], function, percentile, label, - format, loc)) + format, loc, totals)) return false; return true; } @@ -847,7 +871,8 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) if (!sub || !lex_match (ctx->lexer, T_LBRACK)) return sub; - do + bool totals = false; + for (;;) { int start_ofs = lex_ofs (ctx->lexer); @@ -895,15 +920,29 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) struct msg_location *loc = lex_ofs_location (ctx->lexer, start_ofs, lex_ofs (ctx->lexer) - 1); - add_summary_spec (sub, function, percentile, label, formatp, loc); + add_summary_spec (sub, function, percentile, label, formatp, loc, + totals); free (label); msg_location_destroy (loc); - lex_match (ctx->lexer, T_COMMA); + if (lex_match (ctx->lexer, T_COMMA)) + { + if (!totals && lex_match_id (ctx->lexer, "TOTALS")) + { + if (!lex_force_match (ctx->lexer, T_LBRACK)) + goto error; + totals = true; + } + } + else if (lex_force_match (ctx->lexer, T_RBRACK)) + { + if (totals && !lex_force_match (ctx->lexer, T_RBRACK)) + goto error; + return sub; + } + else + goto error; } - while (!lex_match (ctx->lexer, T_RBRACK)); - - return sub; error: ctables_axis_destroy (sub); @@ -943,7 +982,7 @@ find_categorical_summary_spec (const struct ctables_axis *axis) if (!axis) return NULL; else if (axis->op == CTAO_VAR) - return !axis->scale && axis->n_summaries ? axis : NULL; + return !axis->scale && axis->cell_sss.n ? axis : NULL; else { for (size_t i = 0; i < 2; i++) @@ -1190,14 +1229,18 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, return false; } - if ((cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL) - && lex_match (lexer, T_EQUALS)) + if (cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL) { - if (!lex_force_string (lexer)) - return false; + if (lex_match (lexer, T_EQUALS)) + { + if (!lex_force_string (lexer)) + return false; - cat->total_label = ss_xstrdup (lex_tokss (lexer)); - lex_get (lexer); + cat->total_label = ss_xstrdup (lex_tokss (lexer)); + lex_get (lexer); + } + else + cat->total_label = xstrdup (_("Subtotal")); } c->n_cats++; @@ -1362,41 +1405,70 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, }; } + struct ctables_category *subtotal = NULL; + for (size_t i = totals_before ? 0 : c->n_cats; + totals_before ? i < c->n_cats : i-- > 0; + totals_before ? i++ : 0) + { + struct ctables_category *cat = &c->cats[i]; + switch (cat->type) + { + case CCT_NUMBER: + case CCT_STRING: + case CCT_RANGE: + case CCT_MISSING: + case CCT_OTHERNM: + cat->subtotal = subtotal; + break; + + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + subtotal = cat; + break; + + case CCT_TOTAL: + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + break; + } + } + return true; } static void -var_array_uninit (struct var_array *va) +ctables_nest_uninit (struct ctables_nest *nest) { - if (va) - free (va->vars); + if (nest) + free (nest->vars); } static void -var_array2_uninit (struct var_array2 *vaa) +ctables_stack_uninit (struct ctables_stack *stack) { - if (vaa) + if (stack) { - for (size_t i = 0; i < vaa->n; i++) - var_array_uninit (&vaa->vas[i]); - free (vaa->vas); + for (size_t i = 0; i < stack->n; i++) + ctables_nest_uninit (&stack->nests[i]); + free (stack->nests); } } -static struct var_array2 -nest_fts (struct var_array2 va0, struct var_array2 va1) +static struct ctables_stack +nest_fts (struct ctables_stack s0, struct ctables_stack s1) { - if (!va0.n) - return va1; - else if (!va1.n) - return va0; - - struct var_array2 vaa = { .vas = xnmalloc (va0.n, va1.n * sizeof *vaa.vas) }; - for (size_t i = 0; i < va0.n; i++) - for (size_t j = 0; j < va1.n; j++) + if (!s0.n) + return s1; + else if (!s1.n) + return s0; + + struct ctables_stack stack = { .nests = xnmalloc (s0.n, s1.n * sizeof *stack.nests) }; + for (size_t i = 0; i < s0.n; i++) + for (size_t j = 0; j < s1.n; j++) { - const struct var_array *a = &va0.vas[i]; - const struct var_array *b = &va1.vas[j]; + const struct ctables_nest *a = &s0.nests[i]; + const struct ctables_nest *b = &s1.nests[j]; size_t allocate = a->n + b->n; struct variable **vars = xnmalloc (allocate, sizeof *vars); @@ -1408,48 +1480,47 @@ nest_fts (struct var_array2 va0, struct var_array2 va1) vars[n++] = b->vars[k]; assert (n == allocate); - const struct var_array *summary_src; - if (!a->summary_var) + const struct ctables_nest *summary_src; + if (!a->cell_sss.var) summary_src = b; - else if (!b->summary_var) + else if (!b->cell_sss.var) summary_src = a; else NOT_REACHED (); - vaa.vas[vaa.n++] = (struct var_array) { + stack.nests[stack.n++] = (struct ctables_nest) { .vars = vars, .scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx : SIZE_MAX), .n = n, - .summaries = summary_src->summaries, - .n_summaries = summary_src->n_summaries, - .summary_var = summary_src->summary_var, + .cell_sss = summary_src->cell_sss, + .total_sss = summary_src->total_sss, }; } - var_array2_uninit (&va0); - var_array2_uninit (&va1); - return vaa; + ctables_stack_uninit (&s0); + ctables_stack_uninit (&s1); + return stack; } -static struct var_array2 -stack_fts (struct var_array2 va0, struct var_array2 va1) +static struct ctables_stack +stack_fts (struct ctables_stack s0, struct ctables_stack s1) { - struct var_array2 vaa = { .vas = xnmalloc (va0.n + va1.n, sizeof *vaa.vas) }; - for (size_t i = 0; i < va0.n; i++) - vaa.vas[vaa.n++] = va0.vas[i]; - for (size_t i = 0; i < va1.n; i++) - vaa.vas[vaa.n++] = va1.vas[i]; - assert (vaa.n == va0.n + va1.n); - free (va0.vas); - free (va1.vas); - return vaa; + struct ctables_stack stack = { .nests = xnmalloc (s0.n + s1.n, sizeof *stack.nests) }; + for (size_t i = 0; i < s0.n; i++) + stack.nests[stack.n++] = s0.nests[i]; + for (size_t i = 0; i < s1.n; i++) + stack.nests[stack.n++] = s1.nests[i]; + assert (stack.n == s0.n + s1.n); + free (s0.nests); + free (s1.nests); + return stack; } -static struct var_array2 +static struct ctables_stack enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a) { if (!a) - return (struct var_array2) { .n = 0 }; + return (struct ctables_stack) { .n = 0 }; switch (a->op) { @@ -1459,19 +1530,20 @@ enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a) struct variable **vars = xmalloc (sizeof *vars); *vars = a->var.var; - struct var_array *va = xmalloc (sizeof *va); - *va = (struct var_array) { + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { .vars = vars, .n = 1, .scale_idx = a->scale ? 0 : SIZE_MAX, }; - if (a->n_summaries || a->scale) + if (a->cell_sss.n || a->scale) { - va->summaries = a->summaries; - va->n_summaries = a->n_summaries; - va->summary_var = a->var.var; + nest->cell_sss = a->cell_sss; + nest->total_sss = a->total_sss; + nest->cell_sss.var = a->var.var; + nest->total_sss.var = a->var.var; } - return (struct var_array2) { .vas = va, .n = 1 }; + return (struct ctables_stack) { .nests = nest, .n = 1 }; case CTAO_STACK: return stack_fts (enumerate_fts (axis_type, a->subs[0]), @@ -1785,7 +1857,7 @@ ctables_summary_add (union ctables_summary *s, } static double -ctables_summary_value (const struct ctables_cell *f, +ctables_summary_value (const struct ctables_cell *cell, union ctables_summary *s, const struct ctables_summary_spec *ss) { @@ -1796,25 +1868,25 @@ ctables_summary_value (const struct ctables_cell *f, return s->valid; case CTSF_SUBTABLEPCT_COUNT: - return f->domains[CTDT_SUBTABLE]->valid ? s->valid / f->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS; + return cell->domains[CTDT_SUBTABLE]->valid ? s->valid / cell->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; + return cell->domains[CTDT_ROW]->valid ? s->valid / cell->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; + return cell->domains[CTDT_COL]->valid ? s->valid / cell->domains[CTDT_COL]->valid * 100 : SYSMIS; case CTSF_TABLEPCT_COUNT: - return f->domains[CTDT_TABLE]->valid ? s->valid / f->domains[CTDT_TABLE]->valid * 100 : SYSMIS; + return cell->domains[CTDT_TABLE]->valid ? s->valid / cell->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; + return cell->domains[CTDT_LAYER]->valid ? s->valid / cell->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; + return cell->domains[CTDT_LAYERROW]->valid ? s->valid / cell->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; + return cell->domains[CTDT_LAYERCOL]->valid ? s->valid / cell->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS; case CTSF_ROWPCT_VALIDN: case CTSF_COLPCT_VALIDN: @@ -1942,16 +2014,16 @@ 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].vaa_idx; - size_t b_idx = b->axes[aux->a].vaa_idx; + size_t a_idx = a->axes[aux->a].stack_idx; + size_t b_idx = b->axes[aux->a].stack_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 ctables_nest *nest = &aux->t->stacks[aux->a].nests[a_idx]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) { - const struct variable *var = va->vars[i]; + const struct variable *var = nest->vars[i]; const struct ctables_cell_value *a_cv = &a->axes[aux->a].cvs[i]; const struct ctables_cell_value *b_cv = &b->axes[aux->a].cvs[i]; if (a_cv->category != b_cv->category) @@ -2026,20 +2098,20 @@ 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 *f, +ctables_domain_insert (struct ctables_table *t, struct ctables_cell *cell, enum ctables_domain_type domain) { size_t hash = 0; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - size_t idx = f->axes[a].vaa_idx; - const struct var_array *va = &t->vaas[a].vas[idx]; + size_t idx = cell->axes[a].stack_idx; + const struct ctables_nest *nest = &t->stacks[a].nests[idx]; hash = hash_int (idx, hash); - for (size_t i = 0; i < va->n_domains[domain]; i++) + for (size_t i = 0; i < nest->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); + size_t v_idx = nest->domains[domain][i]; + hash = value_hash (&cell->axes[a].cvs[v_idx].value, + var_get_width (nest->vars[v_idx]), hash); } } @@ -2049,17 +2121,17 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *f, 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) + size_t idx = cell->axes[a].stack_idx; + if (idx != df->axes[a].stack_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++) + const struct ctables_nest *nest = &t->stacks[a].nests[idx]; + for (size_t i = 0; i < nest->n_domains[domain]; i++) { - size_t v_idx = va->domains[domain][i]; + size_t v_idx = nest->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]))) + &cell->axes[a].cvs[v_idx].value, + var_get_width (nest->vars[v_idx]))) goto not_equal; } } @@ -2069,7 +2141,7 @@ ctables_domain_insert (struct ctables_table *t, struct ctables_cell *f, } d = xmalloc (sizeof *d); - *d = (struct ctables_domain) { .example = f }; + *d = (struct ctables_domain) { .example = cell }; hmap_insert (&t->domains[domain], &d->node, hash); return d; } @@ -2127,8 +2199,11 @@ ctables_categories_match (const struct ctables_categories *c, static const struct ctables_category * ctables_categories_total (const struct ctables_categories *c) { - const struct ctables_category *total = &c->cats[c->n_cats - 1]; - return total->type == CCT_TOTAL ? total : NULL; + const struct ctables_category *first = &c->cats[0]; + const struct ctables_category *last = &c->cats[c->n_cats - 1]; + return (first->type == CCT_TOTAL ? first + : last->type == CCT_TOTAL ? last + : NULL); } static void @@ -2137,38 +2212,45 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, const struct ctables_category *cats[PIVOT_N_AXES][10], double weight) { - const struct var_array *ss = &t->vaas[t->summary_axis].vas[ix[t->summary_axis]]; + const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]]; size_t hash = 0; + bool total = false; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - const struct var_array *va = &t->vaas[a].vas[ix[a]]; + const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; hash = hash_int (ix[a], hash); - for (size_t i = 0; i < va->n; i++) - if (i != va->scale_idx) + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) { hash = hash_pointer (cats[a][i], hash); - if (cats[a][i]->type != CCT_TOTAL) - hash = value_hash (case_data (c, va->vars[i]), - var_get_width (va->vars[i]), hash); + if (cats[a][i]->type != CCT_TOTAL + && cats[a][i]->type != CCT_SUBTOTAL + && cats[a][i]->type != CCT_HSUBTOTAL) + hash = value_hash (case_data (c, nest->vars[i]), + var_get_width (nest->vars[i]), hash); + else + total = true; } } - struct ctables_cell *f; - HMAP_FOR_EACH_WITH_HASH (f, struct ctables_cell, node, hash, &t->cells) + struct ctables_cell *cell; + HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &t->cells) { for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { - const struct var_array *va = &t->vaas[a].vas[ix[a]]; - if (f->axes[a].vaa_idx != ix[a]) + const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + if (cell->axes[a].stack_idx != ix[a]) goto not_equal; - for (size_t i = 0; i < va->n; i++) - if (i != va->scale_idx - && (cats[a][i] != f->axes[a].cvs[i].category + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx + && (cats[a][i] != cell->axes[a].cvs[i].category || (cats[a][i]->type != CCT_TOTAL - && !value_equal (case_data (c, va->vars[i]), - &f->axes[a].cvs[i].value, - var_get_width (va->vars[i]))))) + && cats[a][i]->type != CCT_SUBTOTAL + && cats[a][i]->type != CCT_HSUBTOTAL + && !value_equal (case_data (c, nest->vars[i]), + &cell->axes[a].cvs[i].value, + var_get_width (nest->vars[i]))))) goto not_equal; } @@ -2177,34 +2259,50 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c, not_equal: ; } - f = xmalloc (sizeof *f); + cell = xmalloc (sizeof *cell); + cell->hide = false; + cell->total = total; 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) + const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + cell->axes[a].stack_idx = ix[a]; + cell->axes[a].cvs = (nest->n + ? xnmalloc (nest->n, sizeof *cell->axes[a].cvs) : NULL); - for (size_t i = 0; i < va->n; i++) + for (size_t i = 0; i < nest->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])); + if (i != nest->scale_idx) + { + const struct ctables_category *subtotal = cats[a][i]->subtotal; + if (subtotal && subtotal->type == CCT_HSUBTOTAL) + cell->hide = true; + } + + cell->axes[a].cvs[i].category = cats[a][i]; + value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]), + var_get_width (nest->vars[i])); } } - 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); + { + const struct ctables_summary_spec_set *sss + = (cell->total ? &ss->total_sss : &ss->cell_sss); + cell->summaries = xmalloc (sss->n * sizeof *cell->summaries); + for (size_t i = 0; i < sss->n; i++) + ctables_summary_init (&cell->summaries[i], &sss->summaries[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); + +summarize: ; + const struct ctables_summary_spec_set *sss + = (cell->total ? &ss->total_sss : &ss->cell_sss); + for (size_t i = 0; i < sss->n; i++) + ctables_summary_add (&cell->summaries[i], &sss->summaries[i], sss->var, + case_data (c, sss->var), weight); for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) - f->domains[dt]->valid += weight; + cell->domains[dt]->valid += weight; } static void @@ -2212,17 +2310,17 @@ recurse_totals (struct ctables_table *t, const struct ccase *c, size_t ix[PIVOT_N_AXES], const struct ctables_category *cats[PIVOT_N_AXES][10], double weight, - enum pivot_axis_type start_a, size_t start_va) + enum pivot_axis_type start_axis, size_t start_nest) { - for (enum pivot_axis_type a = start_a; a < PIVOT_N_AXES; a++) + for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) { - const struct var_array *va = &t->vaas[a].vas[ix[a]]; - for (size_t i = start_va; i < va->n; i++) + const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + for (size_t i = start_nest; i < nest->n; i++) { - if (i == va->scale_idx) + if (i == nest->scale_idx) continue; - const struct variable *var = va->vars[i]; + const struct variable *var = nest->vars[i]; const struct ctables_category *total = ctables_categories_total ( t->categories[var_get_dict_index (var)]); @@ -2235,7 +2333,7 @@ recurse_totals (struct ctables_table *t, const struct ccase *c, cats[a][i] = save; } } - start_va = 0; + start_nest = 0; } } @@ -2254,13 +2352,13 @@ ctables_cell_insert (struct ctables_table *t, 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]]; - for (size_t i = 0; i < va->n; i++) + const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + for (size_t i = 0; i < nest->n; i++) { - if (i == va->scale_idx) + if (i == nest->scale_idx) continue; - const struct variable *var = va->vars[i]; + const struct variable *var = nest->vars[i]; const union value *value = case_data (c, var); if (var_is_numeric (var) && value->f == SYSMIS) @@ -2276,6 +2374,24 @@ ctables_cell_insert (struct ctables_table *t, ctables_cell_insert__ (t, c, ix, cats, weight); recurse_totals (t, c, ix, cats, weight, 0, 0); + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + for (size_t i = 0; i < nest->n; i++) + { + if (i == nest->scale_idx) + continue; + + const struct ctables_category *save = cats[a][i]; + if (save->subtotal) + { + cats[a][i] = save->subtotal; + ctables_cell_insert__ (t, c, ix, cats, weight); + cats[a][i] = save; + } + } + } } static bool @@ -2287,19 +2403,19 @@ ctables_execute (struct dataset *ds, struct ctables *ct) for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) if (t->axes[a]) { - t->vaas[a] = enumerate_fts (a, t->axes[a]); + t->stacks[a] = enumerate_fts (a, t->axes[a]); - for (size_t j = 0; j < t->vaas[a].n; j++) + for (size_t j = 0; j < t->stacks[a].n; j++) { - struct var_array *va = &t->vaas[a].vas[j]; + struct ctables_nest *nest = &t->stacks[a].nests[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; + nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); + nest->n_domains[dt] = 0; - for (size_t k = 0; k < va->n; k++) + for (size_t k = 0; k < nest->n; k++) { - if (k == va->scale_idx) + if (k == nest->scale_idx) continue; switch (dt) @@ -2319,9 +2435,9 @@ ctables_execute (struct dataset *ds, struct ctables *ct) : 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)) + if (k == nest->n - 1 + || (nest->scale_idx == nest->n - 1 + && k == nest->n - 2)) continue; } break; @@ -2337,38 +2453,43 @@ ctables_execute (struct dataset *ds, struct ctables *ct) break; } - va->domains[dt][va->n_domains[dt]++] = k; + nest->domains[dt][nest->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 }; + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { .n = 0 }; + t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 }; } - for (size_t i = 0; i < t->vaas[t->summary_axis].n; i++) + for (size_t i = 0; i < t->stacks[t->summary_axis].n; i++) { - struct var_array *va = &t->vaas[t->summary_axis].vas[i]; - if (!va->n_summaries) + struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[i]; + if (!nest->cell_sss.n) { - va->summaries = xmalloc (sizeof *va->summaries); - va->n_summaries = 1; + struct ctables_summary_spec_set *sss = &nest->cell_sss; + sss->summaries = xmalloc (sizeof *sss->summaries); + sss->n = 1; enum ctables_summary_function function - = va->summary_var ? CTSF_MEAN : CTSF_COUNT; - struct ctables_var var = { .is_mrset = false, .var = va->summary_var }; + = sss->var ? CTSF_MEAN : CTSF_COUNT; + struct ctables_var var = { .is_mrset = false, .var = sss->var }; - *va->summaries = (struct ctables_summary_spec) { + *sss->summaries = (struct ctables_summary_spec) { .function = function, .format = ctables_summary_default_format (function, &var), .label = ctables_summary_default_label (function, 0), }; - if (!va->summary_var) - va->summary_var = va->vars[0]; + if (!sss->var) + sss->var = nest->vars[0]; + + nest->total_sss = nest->cell_sss; } + else if (!nest->total_sss.n) + nest->total_sss = nest->cell_sss; } } @@ -2388,9 +2509,9 @@ ctables_execute (struct dataset *ds, struct ctables *ct) { struct ctables_table *t = ct->tables[i]; - 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++) + 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); } } @@ -2431,42 +2552,43 @@ ctables_execute (struct dataset *ds, struct ctables *ct) struct ctables_cell **sorted = xnmalloc (t->cells.count, sizeof *sorted); - struct ctables_cell *f; + struct ctables_cell *cell; size_t n = 0; - HMAP_FOR_EACH (f, struct ctables_cell, node, &t->cells) - sorted[n++] = f; - assert (n == t->cells.count); + HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) + if (!cell->hide) + sorted[n++] = cell; + assert (n <= t->cells.count); struct ctables_cell_sort_aux aux = { .t = t, .a = a }; sort (sorted, n, sizeof *sorted, ctables_cell_compare_3way, &aux); size_t max_depth = 0; - for (size_t j = 0; j < t->vaas[a].n; j++) - if (t->vaas[a].vas[j].n > max_depth) - max_depth = t->vaas[a].vas[j].n; + 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; struct pivot_category **groups = xnmalloc (max_depth, sizeof *groups); struct pivot_category *top = NULL; int prev_leaf = 0; for (size_t j = 0; j < n; j++) { - struct ctables_cell *f = sorted[j]; - const struct var_array *va = &t->vaas[a].vas[f->axes[a].vaa_idx]; + struct ctables_cell *cell = sorted[j]; + const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx]; size_t n_common = 0; bool new_subtable = false; if (j > 0) { struct ctables_cell *prev = sorted[j - 1]; - if (prev->axes[a].vaa_idx == f->axes[a].vaa_idx) + if (prev->axes[a].stack_idx == cell->axes[a].stack_idx) { - for (; n_common < va->n; n_common++) - if (n_common != va->scale_idx + for (; n_common < nest->n; n_common++) + if (n_common != nest->scale_idx && (prev->axes[a].cvs[n_common].category - != f->axes[a].cvs[n_common].category + != cell->axes[a].cvs[n_common].category || !value_equal (&prev->axes[a].cvs[n_common].value, - &f->axes[a].cvs[n_common].value, - var_get_type (va->vars[n_common])))) + &cell->axes[a].cvs[n_common].value, + var_get_type (nest->vars[n_common])))) break; } else @@ -2477,39 +2599,43 @@ ctables_execute (struct dataset *ds, struct ctables *ct) if (new_subtable) { - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[0])]; + enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[0])]; top = d[a]->root; if (vlabel != CTVL_NONE) top = pivot_category_create_group__ ( - top, pivot_value_new_variable (va->vars[0])); + top, pivot_value_new_variable (nest->vars[0])); } - if (n_common == va->n) + if (n_common == nest->n) { - f->axes[a].leaf = prev_leaf; + cell->axes[a].leaf = prev_leaf; continue; } - for (size_t k = n_common; k < va->n; k++) + for (size_t k = n_common; k < nest->n; k++) { struct pivot_category *parent = k > 0 ? groups[k - 1] : top; struct pivot_value *label - = (k == va->scale_idx ? NULL - : f->axes[a].cvs[k].category->type == CCT_TOTAL - ? pivot_value_new_user_text (f->axes[a].cvs[k].category->total_label, + = (k == nest->scale_idx ? NULL + : (cell->axes[a].cvs[k].category->type == CCT_TOTAL + || cell->axes[a].cvs[k].category->type == CCT_SUBTOTAL + || cell->axes[a].cvs[k].category->type == CCT_HSUBTOTAL) + ? pivot_value_new_user_text (cell->axes[a].cvs[k].category->total_label, SIZE_MAX) - : pivot_value_new_var_value (va->vars[k], - &f->axes[a].cvs[k].value)); - if (k == va->n - 1) + : pivot_value_new_var_value (nest->vars[k], + &cell->axes[a].cvs[k].value)); + if (k == nest->n - 1) { if (a == t->summary_axis) { if (label) parent = pivot_category_create_group__ (parent, label); - for (size_t m = 0; m < va->n_summaries; m++) + const struct ctables_summary_spec_set *sss + = cell->total ? &nest->total_sss : &nest->cell_sss; + for (size_t m = 0; m < sss->n; m++) { int leaf = pivot_category_create_leaf ( - parent, pivot_value_new_text (va->summaries[m].label)); + parent, pivot_value_new_text (sss->summaries[m].label)); if (m == 0) prev_leaf = leaf; } @@ -2528,23 +2654,27 @@ ctables_execute (struct dataset *ds, struct ctables *ct) if (label) parent = pivot_category_create_group__ (parent, label); - enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[k + 1])]; + enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k + 1])]; if (vlabel != CTVL_NONE) parent = pivot_category_create_group__ ( - parent, pivot_value_new_variable (va->vars[k + 1])); + parent, pivot_value_new_variable (nest->vars[k + 1])); groups[k] = parent; } - f->axes[a].leaf = prev_leaf; + cell->axes[a].leaf = prev_leaf; } free (sorted); free (groups); } - struct ctables_cell *f; - HMAP_FOR_EACH (f, struct ctables_cell, node, &t->cells) + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells) { - 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++) + if (cell->hide) + continue; + + const struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].stack_idx]; + const struct ctables_summary_spec_set *sss = cell->total ? &nest->total_sss : &nest->cell_sss; + for (size_t j = 0; j < sss->n; j++) { size_t dindexes[3]; size_t n_dindexes = 0; @@ -2552,15 +2682,15 @@ ctables_execute (struct dataset *ds, struct ctables *ct) for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) if (d[a]) { - int leaf = f->axes[a].leaf; + int leaf = cell->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]); + double d = ctables_summary_value (cell, &cell->summaries[j], &sss->summaries[j]); struct pivot_value *value = pivot_value_new_number (d); - value->numeric.format = ss->summaries[j].format; + value->numeric.format = sss->summaries[j].format; pivot_table_put (pt, dindexes, n_dindexes, value); } } @@ -3230,6 +3360,9 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) "SIGTEST", "COMPARETEST"); goto error; } + + if (!lex_match (lexer, T_SLASH)) + break; } if (t->row_labels != CTLP_NORMAL && t->col_labels != CTLP_NORMAL)