X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=0ce4a333e922d998effd86f9ade28b7c50822e86;hb=6583a419b0ddfddd2f6cef8fcc3d1c74262e533a;hp=7a1cb3b2ca08bc7149a0315e28c673dfe5e0a2d2;hpb=4c4ec0fcc6224a46fcc522978da581bc07f3ad47;p=pspp diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c index 7a1cb3b2ca..0ce4a333e9 100644 --- a/src/language/stats/ctables.c +++ b/src/language/stats/ctables.c @@ -22,6 +22,7 @@ #include "data/dataset.h" #include "data/dictionary.h" #include "data/mrset.h" +#include "data/value-labels.h" #include "language/command.h" #include "language/lexer/format-parser.h" #include "language/lexer/lexer.h" @@ -284,6 +285,19 @@ enum ctables_label_position CTLP_LAYER, }; +static const char * +ctables_label_position_to_string (enum ctables_label_position p) +{ + switch (p) + { + case CTLP_NORMAL: return "NORMAL"; + case CTLP_OPPOSITE: return "OPPOSITE"; + case CTLP_LAYER: return "LAYER"; + } + + NOT_REACHED (); +} + struct ctables_summary_spec_set { struct ctables_summary_spec *specs; @@ -451,6 +465,46 @@ ctables_category_uninit (struct ctables_category *cat) } } +static bool +ctables_category_equal (const struct ctables_category *a, + const struct ctables_category *b) +{ + if (a->type != b->type) + return false; + + switch (a->type) + { + case CCT_NUMBER: + return a->number == b->number; + + case CCT_STRING: + return strcmp (a->string, b->string); + + case CCT_RANGE: + return a->range[0] == b->range[0] && a->range[1] == b->range[1]; + + case CCT_MISSING: + case CCT_OTHERNM: + return true; + + case CCT_SUBTOTAL: + case CCT_HSUBTOTAL: + case CCT_TOTAL: + return !strcmp (a->total_label, b->total_label); + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + return (a->include_missing == b->include_missing + && a->sort_ascending == b->sort_ascending + && a->sort_function == b->sort_function + && a->sort_var == b->sort_var + && a->percentile == b->percentile); + } + + NOT_REACHED (); +} + static void ctables_categories_unref (struct ctables_categories *c) { @@ -467,6 +521,20 @@ ctables_categories_unref (struct ctables_categories *c) free (c); } +static bool +ctables_categories_equal (const struct ctables_categories *a, + const struct ctables_categories *b) +{ + if (a->n_cats != b->n_cats || a->show_empty != b->show_empty) + return false; + + for (size_t i = 0; i < a->n_cats; i++) + if (!ctables_category_equal (&a->cats[i], &b->cats[i])) + return false; + + return true; +} + /* Chi-square test (SIGTEST). */ struct ctables_chisq { @@ -2779,165 +2847,165 @@ ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t } -static bool -ctables_execute (struct dataset *ds, struct ctables *ct) +static void +ctables_prepare_table (struct ctables_table *t) { - for (size_t i = 0; i < ct->n_tables; i++) - { - struct ctables_table *t = ct->tables[i]; - for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) - if (t->axes[a]) - { - t->stacks[a] = enumerate_fts (a, t->axes[a]); + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (t->axes[a]) + { + t->stacks[a] = enumerate_fts (a, t->axes[a]); - for (size_t j = 0; j < t->stacks[a].n; j++) + for (size_t j = 0; j < t->stacks[a].n; j++) + { + struct ctables_nest *nest = &t->stacks[a].nests[j]; + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) { - struct ctables_nest *nest = &t->stacks[a].nests[j]; - for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); + nest->n_domains[dt] = 0; + + for (size_t k = 0; k < nest->n; k++) { - nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); - nest->n_domains[dt] = 0; + if (k == nest->scale_idx) + continue; - for (size_t k = 0; k < nest->n; k++) + switch (dt) { - if (k == nest->scale_idx) - continue; + case CTDT_TABLE: + continue; - switch (dt) + 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) { - case CTDT_TABLE: - continue; - - case CTDT_LAYER: - if (a != PIVOT_AXIS_LAYER) + if (k == nest->n - 1 + || (nest->scale_idx == nest->n - 1 + && k == nest->n - 2)) 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 == nest->n - 1 - || (nest->scale_idx == nest->n - 1 - && k == nest->n - 2)) - continue; - } - break; - - case CTDT_LAYERROW: - if (a == PIVOT_AXIS_COLUMN) - continue; - break; - - case CTDT_LAYERCOL: - if (a == PIVOT_AXIS_ROW) - continue; - break; } + break; + + case CTDT_LAYERROW: + if (a == PIVOT_AXIS_COLUMN) + continue; + break; - nest->domains[dt][nest->n_domains[dt]++] = k; + case CTDT_LAYERCOL: + if (a == PIVOT_AXIS_ROW) + continue; + break; } + + nest->domains[dt][nest->n_domains[dt]++] = k; } } } - else - { - struct ctables_nest *nest = xmalloc (sizeof *nest); - *nest = (struct ctables_nest) { .n = 0 }; - t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 }; - } + } + else + { + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { .n = 0 }; + t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 }; + } - struct ctables_stack *stack = &t->stacks[t->summary_axis]; - for (size_t i = 0; i < stack->n; i++) + struct ctables_stack *stack = &t->stacks[t->summary_axis]; + for (size_t i = 0; i < stack->n; i++) + { + struct ctables_nest *nest = &stack->nests[i]; + if (!nest->specs[CSV_CELL].n) { - struct ctables_nest *nest = &stack->nests[i]; - if (!nest->specs[CSV_CELL].n) - { - struct ctables_summary_spec_set *specs = &nest->specs[CSV_CELL]; - specs->specs = xmalloc (sizeof *specs->specs); - specs->n = 1; - - enum ctables_summary_function function - = specs->var ? CTSF_MEAN : CTSF_COUNT; - struct ctables_var var = { .is_mrset = false, .var = specs->var }; - - *specs->specs = (struct ctables_summary_spec) { - .function = function, - .format = ctables_summary_default_format (function, &var), - .label = ctables_summary_default_label (function, 0), - }; - if (!specs->var) - specs->var = nest->vars[0]; + struct ctables_summary_spec_set *specs = &nest->specs[CSV_CELL]; + specs->specs = xmalloc (sizeof *specs->specs); + specs->n = 1; + + enum ctables_summary_function function + = specs->var ? CTSF_MEAN : CTSF_COUNT; + struct ctables_var var = { .is_mrset = false, .var = specs->var }; + + *specs->specs = (struct ctables_summary_spec) { + .function = function, + .format = ctables_summary_default_format (function, &var), + .label = ctables_summary_default_label (function, 0), + }; + if (!specs->var) + specs->var = nest->vars[0]; - ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], - &nest->specs[CSV_CELL]); - } - else if (!nest->specs[CSV_TOTAL].n) - ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], - &nest->specs[CSV_CELL]); + ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], + &nest->specs[CSV_CELL]); } + else if (!nest->specs[CSV_TOTAL].n) + ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], + &nest->specs[CSV_CELL]); + } - struct ctables_summary_spec_set *merged = &t->summary_specs; - struct merge_item *items = xnmalloc (2 * stack->n, sizeof *items); - size_t n_left = 0; - for (size_t j = 0; j < stack->n; j++) - { - const struct ctables_nest *nest = &stack->nests[j]; - if (nest->n) - for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) - items[n_left++] = (struct merge_item) { .set = &nest->specs[sv] }; - } + struct ctables_summary_spec_set *merged = &t->summary_specs; + struct merge_item *items = xnmalloc (2 * stack->n, sizeof *items); + size_t n_left = 0; + for (size_t j = 0; j < stack->n; j++) + { + const struct ctables_nest *nest = &stack->nests[j]; + if (nest->n) + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + items[n_left++] = (struct merge_item) { .set = &nest->specs[sv] }; + } - while (n_left > 0) - { - struct merge_item min = items[0]; - for (size_t j = 1; j < n_left; j++) - if (merge_item_compare_3way (&items[j], &min) < 0) - min = items[j]; + while (n_left > 0) + { + struct merge_item min = items[0]; + for (size_t j = 1; j < n_left; j++) + if (merge_item_compare_3way (&items[j], &min) < 0) + min = items[j]; - if (merged->n >= merged->allocated) - merged->specs = x2nrealloc (merged->specs, &merged->allocated, - sizeof *merged->specs); - merged->specs[merged->n++] = min.set->specs[min.ofs]; + if (merged->n >= merged->allocated) + merged->specs = x2nrealloc (merged->specs, &merged->allocated, + sizeof *merged->specs); + merged->specs[merged->n++] = min.set->specs[min.ofs]; - for (size_t j = 0; j < n_left; ) + for (size_t j = 0; j < n_left; ) + { + if (merge_item_compare_3way (&items[j], &min) == 0) { - if (merge_item_compare_3way (&items[j], &min) == 0) + struct merge_item *item = &items[j]; + item->set->specs[item->ofs].axis_idx = merged->n - 1; + if (++item->ofs >= item->set->n) { - struct merge_item *item = &items[j]; - item->set->specs[item->ofs].axis_idx = merged->n - 1; - if (++item->ofs >= item->set->n) - { - items[j] = items[--n_left]; - continue; - } + items[j] = items[--n_left]; + continue; } - j++; } + j++; } + } #if 0 - for (size_t j = 0; j < merged->n; j++) - printf ("%s\n", ctables_summary_function_name (merged->specs[j].function)); + for (size_t j = 0; j < merged->n; j++) + printf ("%s\n", ctables_summary_function_name (merged->specs[j].function)); - for (size_t j = 0; j < stack->n; j++) + for (size_t j = 0; j < stack->n; j++) + { + const struct ctables_nest *nest = &stack->nests[j]; + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) { - const struct ctables_nest *nest = &stack->nests[j]; - for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) - { - const struct ctables_summary_spec_set *specs = &nest->specs[sv]; - for (size_t k = 0; k < specs->n; k++) - printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function), - specs->specs[k].axis_idx); - printf ("\n"); - } + const struct ctables_summary_spec_set *specs = &nest->specs[sv]; + for (size_t k = 0; k < specs->n; k++) + printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function), + specs->specs[k].axis_idx); + printf ("\n"); } -#endif } +#endif +} +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); @@ -2973,6 +3041,73 @@ ctables_execute (struct dataset *ds, struct ctables *ct) return proc_commit (ds); } +static bool +ctables_check_label_position (struct ctables_table *t, + enum pivot_axis_type axis, + enum ctables_label_position label_pos, + const char *subcommand_name) +{ + if (label_pos == CTLP_NORMAL) + return true; + + const struct ctables_stack *stack = &t->stacks[axis]; + if (!stack->n) + return true; + + const struct ctables_nest *n0 = &stack->nests[0]; + const struct variable *v0 = n0->vars[n0->n - 1]; + struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)]; + + for (size_t i = 0; i < c0->n_cats; i++) + if (c0->cats[i].type == CCT_FUNCTION) + { + msg (SE, _("%s=%s is not allowed with sorting based " + "on a summary function."), + subcommand_name, ctables_label_position_to_string (label_pos)); + return false; + } + + for (size_t i = 1; i < stack->n; i++) + { + const struct ctables_nest *ni = &stack->nests[i]; + const struct variable *vi = ni->vars[ni->n - 1]; + struct ctables_categories *ci = t->categories[var_get_dict_index (vi)]; + + if (var_get_width (v0) != var_get_width (vi)) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same width, but %s has " + "width %d and %s has width %d."), + subcommand_name, ctables_label_position_to_string (label_pos), + var_get_name (v0), var_get_width (v0), + var_get_name (vi), var_get_width (vi)); + return false; + } + if (!val_labs_equal (var_get_value_labels (v0), + var_get_value_labels (vi))) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same value labels, but %s " + "and %s have different value labels."), + subcommand_name, ctables_label_position_to_string (label_pos), + var_get_name (v0), var_get_name (vi)); + return false; + } + if (!ctables_categories_equal (c0, ci)) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same category " + "specifications, but %s and %s have different " + "category specifications."), + subcommand_name, ctables_label_position_to_string (label_pos), + var_get_name (v0), var_get_name (vi)); + return false; + } + } + + return true; +} + int cmd_ctables (struct lexer *lexer, struct dataset *ds) { @@ -3643,6 +3778,12 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds) goto error; } + ctables_prepare_table (t); + + ctables_check_label_position (t, PIVOT_AXIS_ROW, t->row_labels, + "ROWLABELS"); + ctables_check_label_position (t, PIVOT_AXIS_COLUMN, t->col_labels, + "COLLABELS"); } while (lex_token (lexer) != T_ENDCMD);