X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=07de68d919361ecb73cd7c8b269b1698b21295f7;hb=00d4d0efe75746bd43f792541c53c65ed178d40d;hp=53b99519dcadb8bdfb853e44edb0158c30b95df4;hpb=f35912a15bd3e7b3b344f54b264f6fc5fde89907;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 53b99519dc..07de68d919 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -144,6 +144,53 @@ 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_freq *example; + + double valid; + double missing; + }; + +struct ctables_freq + { + /* In struct ctables's 'ft' 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; + union value *values; + int leaf; + } + axes[PIVOT_N_AXES]; + + union ctables_summary *summaries; + }; + struct ctables { struct pivot_table_look *look; @@ -227,6 +274,8 @@ 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; @@ -245,6 +294,7 @@ struct ctables_table struct var_array2 vaas[PIVOT_N_AXES]; enum pivot_axis_type summary_axis; struct hmap ft; + struct hmap domains[N_CTDTS]; enum pivot_axis_type slabels_position; bool slabels_visible; @@ -264,7 +314,6 @@ struct ctables_table struct ctables_chisq *chisq; struct ctables_pairwise *pairwise; - }; struct ctables_var @@ -1687,7 +1736,8 @@ ctables_summary_add (union ctables_summary *s, } static double -ctables_summary_value (union ctables_summary *s, +ctables_summary_value (const struct ctables_freq *f, + union ctables_summary *s, const struct ctables_summary_spec *ss) { switch (ss->function) @@ -1696,13 +1746,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: @@ -1814,43 +1878,6 @@ ctables_summary_value (union ctables_summary *s, NOT_REACHED (); } -struct ctables_freq - { - struct hmap_node node; /* Element in hash table. */ - - struct - { - size_t vaa_idx; - union value *values; - int leaf; - } - axes[PIVOT_N_AXES]; - - union ctables_summary *summaries; - }; - -#if 0 -static struct ctables_freq * -ctables_freq_create (struct ctables_freqtab *ft) -{ - 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; -} - -static void -ctables_freq_add (struct ctables_freqtab *ft, struct ctables_freq *f, - const struct variable *var, const union value *value, - double weight) -{ - for (size_t i = 0; i < ft->n_summaries; i++) - ctables_summary_add (&f->summaries[i], &ft->summaries[i], - var, value, weight); -} -#endif - struct ctables_freq_sort_aux { const struct ctables_table *t; @@ -1902,6 +1929,98 @@ ctables_freq_compare_3way (const void *a_, const void *b_, const void *aux_) Fill the table entry using the indexes from before. */ +static struct ctables_domain * +ctables_domain_insert (struct ctables_table *t, struct ctables_freq *f, + 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]; + 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].values[v_idx], + 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_freq *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].values[v_idx], + &f->axes[a].values[v_idx], + 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; +} + +static const struct ctables_cat_value * +ctables_categories_match (const struct ctables_categories *cats, + 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_cat_value *cv = &cats->values[i]; + switch (cv->type) + { + case CCVT_NUMBER: + if (cv->number == v->f) + return cv; + break; + + case CCVT_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; + break; + + case CCVT_MISSING: + if (var_is_value_missing (var, v)) + return cv; + break; + + case CCVT_OTHERNM: + if (!othernm) + othernm = cv; + break; + + case CCVT_SUBTOTAL: + case CCVT_HSUBTOTAL: + break; + } + } + + return var_is_value_missing (var, v) ? NULL : othernm; +} + static void ctables_freqtab_insert (struct ctables_table *t, const struct ccase *c, @@ -1915,6 +2034,23 @@ ctables_freqtab_insert (struct ctables_table *t, }; const struct var_array *ss = &t->vaas[t->summary_axis].vas[ix[t->summary_axis]]; + 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++) + { + if (i == va->scale_idx) + continue; + + const struct ctables_categories *cats = t->categories[var_get_dict_index (va->vars[i])]; + if (!cats || !cats->n_values) + continue; + + if (!ctables_categories_match (cats, case_data (c, va->vars[i]), va->vars[i])) + return; + } + } + size_t hash = 0; for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) { @@ -1962,12 +2098,16 @@ ctables_freqtab_insert (struct ctables_table *t, 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->ft, &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 @@ -1978,7 +2118,62 @@ ctables_execute (struct dataset *ds, struct ctables *ct) struct ctables_table *t = ct->tables[i]; 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->vaas[a] = enumerate_fts (a, t->axes[a]); + + 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); @@ -2191,7 +2386,7 @@ ctables_execute (struct dataset *ds, struct ctables *ct) dindexes[n_dindexes++] = leaf; } - double d = ctables_summary_value (&f->summaries[j], &ss->summaries[j]); + 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); @@ -2458,6 +2653,8 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) .n_categories = dict_get_n_vars (dataset_dict (ds)), .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);