X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fcrosstabs.q;h=91015f57c75ba877e5c5f2d6b1e9ec4cfc58a39e;hb=2be9bee9da6a2ce27715e58128569594319abfa2;hp=c18c3a960ec3c223c31292c642df72a102d0f4e4;hpb=a8c26042d5bae75837ec3776238d4f6495e64ef9;p=pspp-builds.git diff --git a/src/language/stats/crosstabs.q b/src/language/stats/crosstabs.q index c18c3a96..91015f57 100644 --- a/src/language/stats/crosstabs.q +++ b/src/language/stats/crosstabs.q @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2006, 2009 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -33,35 +33,34 @@ #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "minmax.h" -#include "xalloc.h" -#include "xsize.h" +#include "data/case.h" +#include "data/casegrouper.h" +#include "data/casereader.h" +#include "data/data-out.h" +#include "data/dataset.h" +#include "data/dictionary.h" +#include "data/format.h" +#include "data/value-labels.h" +#include "data/variable.h" +#include "language/command.h" +#include "language/dictionary/split-file.h" +#include "language/lexer/lexer.h" +#include "language/lexer/variable-parser.h" +#include "libpspp/array.h" +#include "libpspp/assertion.h" +#include "libpspp/compiler.h" +#include "libpspp/hash-functions.h" +#include "libpspp/hmap.h" +#include "libpspp/hmapx.h" +#include "libpspp/message.h" +#include "libpspp/misc.h" +#include "libpspp/pool.h" +#include "libpspp/str.h" +#include "output/tab.h" + +#include "gl/minmax.h" +#include "gl/xalloc.h" +#include "gl/xsize.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -161,41 +160,6 @@ struct pivot_table double total; /* Grand total. */ }; -/* A crosstabulation of exactly 2 variables, conditional on zero - or more other variables having given values. */ -struct crosstab - { - /* Case counts. */ - double missing; - - /* Variables. */ - int n_vars; /* Number of variables (at least 2). */ - const struct variable **vars; - union value *values; /* Values of variables beyond 2. */ - - /* Data. */ - struct table_entry **entries; - size_t n_entries; - - /* Column values, number of columns. */ - union value *cols; - int n_cols; - - /* Row values, number of rows. */ - union value *rows; - int n_rows; - - /* Number of statistically interesting columns/rows - (columns/rows with data in them). */ - int ns_cols, ns_rows; - - /* Matrix contents. */ - double *mat; /* Matrix proper. */ - double *row_tot; /* Row totals. */ - double *col_tot; /* Column totals. */ - double total; /* Grand total. */ - }; - /* Integer mode variable info. */ struct var_range { @@ -212,6 +176,7 @@ get_var_range (const struct variable *v) struct crosstabs_proc { + const struct dictionary *dict; enum { INTEGER, GENERAL } mode; enum mv_class exclude; bool pivot; @@ -233,42 +198,10 @@ struct crosstabs_proc /* STATISTICS. */ unsigned int statistics; /* Bit k is 1 if statistic k is requested. */ - }; - -static void -init_proc (struct crosstabs_proc *proc, struct dataset *ds) -{ - const struct variable *wv = dict_get_weight (dataset_dict (ds)); - proc->bad_warn = true; - proc->variables = NULL; - proc->n_variables = 0; - proc->pivots = NULL; - proc->n_pivots = 0; - proc->weight_format = wv ? *var_get_print_format (wv) : F_8_0; -} - -static void -free_proc (struct crosstabs_proc *proc) -{ - struct pivot_table *pt; - - free (proc->variables); - for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++) - { - free (pt->vars); - free (pt->const_vars); - /* We must not call value_destroy on const_values because - it is a wild pointer; it never pointed to anything owned - by the pivot_table. - The rest of the data was allocated and destroyed at a - lower level already. */ - free (pt); - } -} + bool descending; /* True if descending sort order is requested. */ + }; -static int internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds, - struct crosstabs_proc *); static bool should_tabulate_case (const struct pivot_table *, const struct ccase *, enum mv_class exclude); static void tabulate_general_case (struct pivot_table *, const struct ccase *, @@ -276,94 +209,96 @@ static void tabulate_general_case (struct pivot_table *, const struct ccase *, static void tabulate_integer_case (struct pivot_table *, const struct ccase *, double weight); static void postcalc (struct crosstabs_proc *); -static void submit (struct crosstabs_proc *, struct pivot_table *, - struct tab_table *); +static void submit (struct pivot_table *, struct tab_table *); -/* Parse and execute CROSSTABS, then clean up. */ +/* Parses and executes the CROSSTABS procedure. */ int cmd_crosstabs (struct lexer *lexer, struct dataset *ds) { + const struct variable *wv = dict_get_weight (dataset_dict (ds)); struct crosstabs_proc proc; - int result; - - init_proc (&proc, ds); - result = internal_cmd_crosstabs (lexer, ds, &proc); - free_proc (&proc); - - return result; -} - -/* Parses and executes the CROSSTABS procedure. */ -static int -internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds, - struct crosstabs_proc *proc) -{ struct casegrouper *grouper; struct casereader *input, *group; struct cmd_crosstabs cmd; struct pivot_table *pt; + int result; bool ok; int i; - if (!parse_crosstabs (lexer, ds, &cmd, proc)) - return CMD_FAILURE; + proc.dict = dataset_dict (ds); + proc.bad_warn = true; + proc.variables = NULL; + proc.n_variables = 0; + proc.pivots = NULL; + proc.n_pivots = 0; + proc.descending = false; + proc.weight_format = wv ? *var_get_print_format (wv) : F_8_0; + + if (!parse_crosstabs (lexer, ds, &cmd, &proc)) + { + result = CMD_FAILURE; + goto exit; + } - proc->mode = proc->n_variables ? INTEGER : GENERAL; + proc.mode = proc.n_variables ? INTEGER : GENERAL; + + + proc.descending = cmd.val == CRS_DVALUE; /* CELLS. */ if (!cmd.sbc_cells) - proc->cells = 1u << CRS_CL_COUNT; + proc.cells = 1u << CRS_CL_COUNT; else if (cmd.a_cells[CRS_CL_ALL]) - proc->cells = UINT_MAX; + proc.cells = UINT_MAX; else { - proc->cells = 0; + proc.cells = 0; for (i = 0; i < CRS_CL_count; i++) if (cmd.a_cells[i]) - proc->cells |= 1u << i; - if (proc->cells == 0) - proc->cells = ((1u << CRS_CL_COUNT) + proc.cells |= 1u << i; + if (proc.cells == 0) + proc.cells = ((1u << CRS_CL_COUNT) | (1u << CRS_CL_ROW) | (1u << CRS_CL_COLUMN) | (1u << CRS_CL_TOTAL)); } - proc->cells &= ((1u << CRS_CL_count) - 1); - proc->cells &= ~((1u << CRS_CL_NONE) | (1u << CRS_CL_ALL)); - proc->n_cells = 0; + proc.cells &= ((1u << CRS_CL_count) - 1); + proc.cells &= ~((1u << CRS_CL_NONE) | (1u << CRS_CL_ALL)); + proc.n_cells = 0; for (i = 0; i < CRS_CL_count; i++) - if (proc->cells & (1u << i)) - proc->a_cells[proc->n_cells++] = i; + if (proc.cells & (1u << i)) + proc.a_cells[proc.n_cells++] = i; /* STATISTICS. */ if (cmd.a_statistics[CRS_ST_ALL]) - proc->statistics = UINT_MAX; + proc.statistics = UINT_MAX; else if (cmd.sbc_statistics) { int i; - proc->statistics = 0; + proc.statistics = 0; for (i = 0; i < CRS_ST_count; i++) if (cmd.a_statistics[i]) - proc->statistics |= 1u << i; - if (proc->statistics == 0) - proc->statistics |= 1u << CRS_ST_CHISQ; + proc.statistics |= 1u << i; + if (proc.statistics == 0) + proc.statistics |= 1u << CRS_ST_CHISQ; } else - proc->statistics = 0; + proc.statistics = 0; /* MISSING. */ - proc->exclude = (cmd.miss == CRS_TABLE ? MV_ANY + proc.exclude = (cmd.miss == CRS_TABLE ? MV_ANY : cmd.miss == CRS_INCLUDE ? MV_SYSTEM : MV_NEVER); - if (proc->mode == GENERAL && proc->mode == MV_NEVER) + if (proc.mode == GENERAL && proc.mode == MV_NEVER) { msg (SE, _("Missing mode REPORT not allowed in general mode. " "Assuming MISSING=TABLE.")); - proc->mode = MV_ANY; + proc.mode = MV_ANY; } /* PIVOT. */ - proc->pivot = cmd.pivot == CRS_PIVOT; + proc.pivot = cmd.pivot == CRS_PIVOT; input = casereader_create_filter_weight (proc_open (ds), dataset_dict (ds), NULL, NULL); @@ -380,15 +315,19 @@ internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds, case_unref (c); } + /* Initialize hash tables. */ + for (pt = &proc.pivots[0]; pt < &proc.pivots[proc.n_pivots]; pt++) + hmap_init (&pt->data); + /* Tabulate. */ for (; (c = casereader_read (group)) != NULL; case_unref (c)) - for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++) + for (pt = &proc.pivots[0]; pt < &proc.pivots[proc.n_pivots]; pt++) { double weight = dict_get_case_weight (dataset_dict (ds), c, - &proc->bad_warn); - if (should_tabulate_case (pt, c, proc->exclude)) + &proc.bad_warn); + if (should_tabulate_case (pt, c, proc.exclude)) { - if (proc->mode == GENERAL) + if (proc.mode == GENERAL) tabulate_general_case (pt, c, weight); else tabulate_integer_case (pt, c, weight); @@ -399,12 +338,29 @@ internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds, casereader_destroy (group); /* Output. */ - postcalc (proc); + postcalc (&proc); } ok = casegrouper_destroy (grouper); ok = proc_commit (ds) && ok; - return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE; + result = ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE; + +exit: + free (proc.variables); + for (pt = &proc.pivots[0]; pt < &proc.pivots[proc.n_pivots]; pt++) + { + free (pt->vars); + free (pt->const_vars); + /* We must not call value_destroy on const_values because + it is a wild pointer; it never pointed to anything owned + by the pivot_table. + + The rest of the data was allocated and destroyed at a + lower level already. */ + } + free (proc.pivots); + + return result; } /* Parses the TABLES subcommand. */ @@ -425,10 +381,10 @@ crs_custom_tables (struct lexer *lexer, struct dataset *ds, /* Ensure that this is a TABLES subcommand. */ if (!lex_match_id (lexer, "TABLES") && (lex_token (lexer) != T_ID || - dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL) + dict_lookup_var (dataset_dict (ds), lex_tokcstr (lexer)) == NULL) && lex_token (lexer) != T_ALL) return 2; - lex_match (lexer, '='); + lex_match (lexer, T_EQUALS); if (proc->variables != NULL) var_set = const_var_set_create_from_array (proc->variables, @@ -456,7 +412,7 @@ crs_custom_tables (struct lexer *lexer, struct dataset *ds, { if (n_by < 2) { - lex_error (lexer, _("expecting BY")); + lex_force_match (lexer, T_BY); goto done; } else @@ -479,9 +435,6 @@ crs_custom_tables (struct lexer *lexer, struct dataset *ds, pt->n_consts = 0; pt->const_vars = NULL; pt->const_values = NULL; - hmap_init (&pt->data); - pt->entries = NULL; - pt->n_entries = 0; for (j = 0; j < n_by; j++) pt->vars[j] = by[j][by_iter[j]]; @@ -520,7 +473,7 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds, return 0; } - lex_match (lexer, '='); + lex_match (lexer, T_EQUALS); for (;;) { @@ -535,19 +488,15 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds, | PV_NO_DUPLICATE | PV_NO_SCRATCH))) return 0; - if (lex_token (lexer) != '(') - { - lex_error (lexer, "expecting `('"); + if (!lex_force_match (lexer, T_LPAREN)) goto lossage; - } - lex_get (lexer); if (!lex_force_int (lexer)) goto lossage; min = lex_integer (lexer); lex_get (lexer); - lex_match (lexer, ','); + lex_match (lexer, T_COMMA); if (!lex_force_int (lexer)) goto lossage; @@ -560,12 +509,8 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds, } lex_get (lexer); - if (lex_token (lexer) != ')') - { - lex_error (lexer, "expecting `)'"); - goto lossage; - } - lex_get (lexer); + if (!lex_force_match (lexer, T_RPAREN)) + goto lossage; for (i = orig_nv; i < proc->n_variables; i++) { @@ -576,7 +521,7 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds, var_attach_aux (proc->variables[i], vr, var_dtor_free); } - if (lex_token (lexer) == '/') + if (lex_token (lexer) == T_SLASH) break; } @@ -688,9 +633,7 @@ tabulate_general_case (struct pivot_table *pt, const struct ccase *c, for (j = 0; j < pt->n_vars; j++) { const struct variable *var = pt->vars[j]; - int width = var_get_width (var); - value_init (&te->values[j], width); - value_copy (&te->values[j], case_data (c, var), width); + value_clone (&te->values[j], case_data (c, var), var_get_width (var)); } hmap_insert (&pt->data, &te->node, hash); } @@ -703,8 +646,11 @@ static int compare_table_entry_vars_3way (const struct table_entry *a, int idx0, int idx1); static int compare_table_entry_3way (const void *ap_, const void *bp_, const void *pt_); +static int compare_table_entry_3way_inv (const void *ap_, const void *bp_, + const void *pt_); + static void enum_var_values (const struct pivot_table *, int var_idx, - union value **valuesp, int *n_values); + union value **valuesp, int *n_values, bool descending); static void output_pivot_table (struct crosstabs_proc *, struct pivot_table *); static void make_pivot_table_subset (struct pivot_table *pt, @@ -732,7 +678,8 @@ postcalc (struct crosstabs_proc *proc) hmap_destroy (&pt->data); sort (pt->entries, pt->n_entries, sizeof *pt->entries, - compare_table_entry_3way, pt); + proc->descending ? compare_table_entry_3way_inv : compare_table_entry_3way, + pt); } make_summary_table (proc); @@ -842,6 +789,13 @@ compare_table_entry_3way (const void *ap_, const void *bp_, const void *pt_) return compare_table_entry_var_3way (a, b, pt, COL_VAR); } +/* Inverted version of compare_table_entry_3way */ +static int +compare_table_entry_3way_inv (const void *ap_, const void *bp_, const void *pt_) +{ + return -compare_table_entry_3way (ap_, bp_, pt_); +} + static int find_first_difference (const struct pivot_table *pt, size_t row) { @@ -869,7 +823,7 @@ make_summary_table (struct crosstabs_proc *proc) struct string name; int i; - summary = tab_create (7, 3 + proc->n_pivots, 1); + summary = tab_create (7, 3 + proc->n_pivots); tab_title (summary, _("Summary.")); tab_headers (summary, 1, 0, 3, 0); tab_joint_text (summary, 1, 0, 6, 0, TAB_CENTER, _("Cases")); @@ -916,15 +870,15 @@ make_summary_table (struct crosstabs_proc *proc) { tab_double (summary, i * 2 + 1, 0, TAB_RIGHT, n[i], &proc->weight_format); - tab_text (summary, i * 2 + 2, 0, TAB_RIGHT | TAT_PRINTF, "%.1f%%", - n[i] / n[2] * 100.); + tab_text_format (summary, i * 2 + 2, 0, TAB_RIGHT, "%.1f%%", + n[i] / n[2] * 100.); } tab_next_row (summary); } ds_destroy (&name); - submit (proc, NULL, summary); + submit (NULL, summary); } /* Output. */ @@ -947,8 +901,6 @@ static void display_symmetric (struct crosstabs_proc *, struct pivot_table *, static void display_risk (struct pivot_table *, struct tab_table *); static void display_directional (struct crosstabs_proc *, struct pivot_table *, struct tab_table *); -static void crosstabs_dim (struct tab_table *, struct outp_driver *, - void *proc); static void table_value_missing (struct crosstabs_proc *proc, struct tab_table *table, int c, int r, unsigned char opt, const union value *v, @@ -956,9 +908,7 @@ static void table_value_missing (struct crosstabs_proc *proc, static void delete_missing (struct pivot_table *); static void build_matrix (struct pivot_table *); -/* Output pivot table beginning at PB and continuing until PE, - exclusive. For efficiency, *MATP is a pointer to a matrix that can - hold *MAXROWS entries. */ +/* Output pivot table PT in the context of PROC. */ static void output_pivot_table (struct crosstabs_proc *proc, struct pivot_table *pt) { @@ -970,7 +920,25 @@ output_pivot_table (struct crosstabs_proc *proc, struct pivot_table *pt) struct tab_table *direct = NULL; /* Directional measures table. */ size_t row0, row1; - enum_var_values (pt, COL_VAR, &pt->cols, &pt->n_cols); + enum_var_values (pt, COL_VAR, &pt->cols, &pt->n_cols, proc->descending); + + if (pt->n_cols == 0) + { + struct string vars; + int i; + + ds_init_cstr (&vars, var_get_name (pt->vars[0])); + for (i = 1; i < pt->n_vars; i++) + ds_put_format (&vars, " * %s", var_get_name (pt->vars[i])); + + /* TRANSLATORS: The %s here describes a crosstabulation. It takes the + form "var1 * var2 * var3 * ...". */ + msg (SW, _("Crosstabulation %s contained no non-missing cases."), + ds_cstr (&vars)); + + ds_destroy (&vars); + return; + } if (proc->cells) table = create_crosstab_table (proc, pt); @@ -996,7 +964,7 @@ output_pivot_table (struct crosstabs_proc *proc, struct pivot_table *pt) make_pivot_table_subset (pt, row0, row1, &x); /* Find all the row variable values. */ - enum_var_values (&x, ROW_VAR, &x.rows, &x.n_rows); + enum_var_values (&x, ROW_VAR, &x.rows, &x.n_rows, proc->descending); if (size_overflow_p (xtimes (xtimes (x.n_rows, x.n_cols), sizeof (double)))) @@ -1028,22 +996,22 @@ output_pivot_table (struct crosstabs_proc *proc, struct pivot_table *pt) if (chisq) { display_dimensions (proc, &x, chisq, first_difference); - display_chisq (pt, chisq, &showed_fisher); + display_chisq (&x, chisq, &showed_fisher); } if (sym) { display_dimensions (proc, &x, sym, first_difference); - display_symmetric (proc, pt, sym); + display_symmetric (proc, &x, sym); } if (risk) { display_dimensions (proc, &x, risk, first_difference); - display_risk (pt, risk); + display_risk (&x, risk); } if (direct) { display_dimensions (proc, &x, direct, first_difference); - display_directional (proc, pt, direct); + display_directional (proc, &x, direct); } /* Free the parts of x that are not owned by pt. In @@ -1056,18 +1024,18 @@ output_pivot_table (struct crosstabs_proc *proc, struct pivot_table *pt) free (x.col_tot); } - submit (proc, NULL, table); + submit (NULL, table); if (chisq) { if (!showed_fisher) tab_resize (chisq, 4 + (pt->n_vars - 2), -1); - submit (proc, pt, chisq); + submit (pt, chisq); } - submit (proc, pt, sym); - submit (proc, pt, risk); - submit (proc, pt, direct); + submit (pt, sym); + submit (pt, risk); + submit (pt, direct); free (pt->cols); } @@ -1177,58 +1145,59 @@ create_crosstab_table (struct crosstabs_proc *proc, struct pivot_table *pt) struct tab_table *table; struct string title; + struct pivot_table x; + int i; - table = tab_create (pt->n_consts + 1 + pt->n_cols + 1, - (pt->n_entries / pt->n_cols) * 3 / 2 * proc->n_cells + 10, - true); - tab_headers (table, pt->n_consts + 1, 0, 2, 0); + make_pivot_table_subset (pt, 0, 0, &x); + + table = tab_create (x.n_consts + 1 + x.n_cols + 1, + (x.n_entries / x.n_cols) * 3 / 2 * proc->n_cells + 10); + tab_headers (table, x.n_consts + 1, 0, 2, 0); /* First header line. */ - tab_joint_text (table, pt->n_consts + 1, 0, - (pt->n_consts + 1) + (pt->n_cols - 1), 0, - TAB_CENTER | TAT_TITLE, var_get_name (pt->vars[COL_VAR])); + tab_joint_text (table, x.n_consts + 1, 0, + (x.n_consts + 1) + (x.n_cols - 1), 0, + TAB_CENTER | TAT_TITLE, var_get_name (x.vars[COL_VAR])); - tab_hline (table, TAL_1, pt->n_consts + 1, - pt->n_consts + 2 + pt->n_cols - 2, 1); + tab_hline (table, TAL_1, x.n_consts + 1, + x.n_consts + 2 + x.n_cols - 2, 1); /* Second header line. */ - for (i = 2; i < pt->n_consts + 2; i++) - tab_joint_text (table, pt->n_consts + 2 - i - 1, 0, - pt->n_consts + 2 - i - 1, 1, - TAB_RIGHT | TAT_TITLE, var_to_string (pt->vars[i])); - tab_text (table, pt->n_consts + 2 - 2, 1, TAB_RIGHT | TAT_TITLE, - var_get_name (pt->vars[ROW_VAR])); - for (i = 0; i < pt->n_cols; i++) - table_value_missing (proc, table, pt->n_consts + 2 + i - 1, 1, TAB_RIGHT, - &pt->cols[i], pt->vars[COL_VAR]); - tab_text (table, pt->n_consts + 2 + pt->n_cols - 1, 1, TAB_CENTER, _("Total")); - - tab_hline (table, TAL_1, 0, pt->n_consts + 2 + pt->n_cols - 1, 2); - tab_vline (table, TAL_1, pt->n_consts + 2 + pt->n_cols - 1, 0, 1); + for (i = 2; i < x.n_consts + 2; i++) + tab_joint_text (table, x.n_consts + 2 - i - 1, 0, + x.n_consts + 2 - i - 1, 1, + TAB_RIGHT | TAT_TITLE, var_to_string (x.vars[i])); + tab_text (table, x.n_consts + 2 - 2, 1, TAB_RIGHT | TAT_TITLE, + var_get_name (x.vars[ROW_VAR])); + for (i = 0; i < x.n_cols; i++) + table_value_missing (proc, table, x.n_consts + 2 + i - 1, 1, TAB_RIGHT, + &x.cols[i], x.vars[COL_VAR]); + tab_text (table, x.n_consts + 2 + x.n_cols - 1, 1, TAB_CENTER, _("Total")); + + tab_hline (table, TAL_1, 0, x.n_consts + 2 + x.n_cols - 1, 2); + tab_vline (table, TAL_1, x.n_consts + 2 + x.n_cols - 1, 0, 1); /* Title. */ ds_init_empty (&title); - for (i = 0; i < pt->n_consts + 2; i++) + for (i = 0; i < x.n_consts + 2; i++) { if (i) ds_put_cstr (&title, " * "); - ds_put_cstr (&title, var_get_name (pt->vars[i])); + ds_put_cstr (&title, var_get_name (x.vars[i])); } for (i = 0; i < pt->n_consts; i++) { const struct variable *var = pt->const_vars[i]; - size_t ofs; + char *s; ds_put_format (&title, ", %s=", var_get_name (var)); - /* Insert the formatted value of the variable, then trim - leading spaces in what was just inserted. */ - ofs = ds_length (&title); - data_out (&pt->const_values[i], var_get_print_format (var), - ds_put_uninit (&title, var_get_width (var))); - ds_remove (&title, ofs, ss_cspan (ds_substr (&title, ofs, SIZE_MAX), - ss_cstr (" "))); + /* Insert the formatted value of VAR without any leading spaces. */ + s = data_out (&pt->const_values[i], var_get_encoding (var), + var_get_print_format (var)); + ds_put_cstr (&title, s + strspn (s, " ")); + free (s); } ds_put_cstr (&title, " ["); @@ -1255,8 +1224,7 @@ create_chisq_table (struct pivot_table *pt) struct tab_table *chisq; chisq = tab_create (6 + (pt->n_vars - 2), - pt->n_entries / pt->n_cols * 3 / 2 * N_CHISQ + 10, - 1); + pt->n_entries / pt->n_cols * 3 / 2 * N_CHISQ + 10); tab_headers (chisq, 1 + (pt->n_vars - 2), 0, 1, 0); tab_title (chisq, _("Chi-square tests.")); @@ -1266,11 +1234,11 @@ create_chisq_table (struct pivot_table *pt) tab_text (chisq, 1, 0, TAB_RIGHT | TAT_TITLE, _("Value")); tab_text (chisq, 2, 0, TAB_RIGHT | TAT_TITLE, _("df")); tab_text (chisq, 3, 0, TAB_RIGHT | TAT_TITLE, - _("Asymp. Sig. (2-sided)")); - tab_text (chisq, 4, 0, TAB_RIGHT | TAT_TITLE, - _("Exact. Sig. (2-sided)")); - tab_text (chisq, 5, 0, TAB_RIGHT | TAT_TITLE, - _("Exact. Sig. (1-sided)")); + _("Asymp. Sig. (2-tailed)")); + tab_text_format (chisq, 4, 0, TAB_RIGHT | TAT_TITLE, + _("Exact Sig. (%d-tailed)"), 2); + tab_text_format (chisq, 5, 0, TAB_RIGHT | TAT_TITLE, + _("Exact Sig. (%d-tailed)"), 1); tab_offset (chisq, 0, 1); return chisq; @@ -1283,7 +1251,7 @@ create_sym_table (struct pivot_table *pt) struct tab_table *sym; sym = tab_create (6 + (pt->n_vars - 2), - pt->n_entries / pt->n_cols * 7 + 10, 1); + pt->n_entries / pt->n_cols * 7 + 10); tab_headers (sym, 2 + (pt->n_vars - 2), 0, 1, 0); tab_title (sym, _("Symmetric measures.")); @@ -1305,14 +1273,13 @@ create_risk_table (struct pivot_table *pt) { struct tab_table *risk; - risk = tab_create (4 + (pt->n_vars - 2), pt->n_entries / pt->n_cols * 4 + 10, - 1); + risk = tab_create (4 + (pt->n_vars - 2), pt->n_entries / pt->n_cols * 4 + 10); tab_headers (risk, 1 + pt->n_vars - 2, 0, 2, 0); tab_title (risk, _("Risk estimate.")); tab_offset (risk, pt->n_vars - 2, 0); - tab_joint_text (risk, 2, 0, 3, 0, TAB_CENTER | TAT_TITLE | TAT_PRINTF, - _("95%% Confidence Interval")); + tab_joint_text_format (risk, 2, 0, 3, 0, TAB_CENTER | TAT_TITLE, + _("95%% Confidence Interval")); tab_text (risk, 0, 1, TAB_LEFT | TAT_TITLE, _("Statistic")); tab_text (risk, 1, 1, TAB_RIGHT | TAT_TITLE, _("Value")); tab_text (risk, 2, 1, TAB_RIGHT | TAT_TITLE, _("Lower")); @@ -1331,7 +1298,7 @@ create_direct_table (struct pivot_table *pt) struct tab_table *direct; direct = tab_create (7 + (pt->n_vars - 2), - pt->n_entries / pt->n_cols * 7 + 10, 1); + pt->n_entries / pt->n_cols * 7 + 10); tab_headers (direct, 3 + (pt->n_vars - 2), 0, 1, 0); tab_title (direct, _("Directional measures.")); @@ -1376,8 +1343,7 @@ delete_missing (struct pivot_table *pt) /* Prepare table T for submission, and submit it. */ static void -submit (struct crosstabs_proc *proc, struct pivot_table *pt, - struct tab_table *t) +submit (struct pivot_table *pt, struct tab_table *t) { int i; @@ -1387,7 +1353,7 @@ submit (struct crosstabs_proc *proc, struct pivot_table *pt, tab_resize (t, -1, 0); if (tab_nr (t) == tab_t (t)) { - tab_destroy (t); + table_unref (&t->table); return; } tab_offset (t, 0, 0); @@ -1401,49 +1367,8 @@ submit (struct crosstabs_proc *proc, struct pivot_table *pt, tab_box (t, -1, -1, -1, TAL_GAP, 0, tab_t (t), tab_l (t) - 1, tab_nr (t) - 1); tab_vline (t, TAL_2, tab_l (t), 0, tab_nr (t) - 1); - tab_dim (t, crosstabs_dim, proc); - tab_submit (t); -} - -/* Sets the widths of all the columns and heights of all the rows in - table T for driver D. */ -static void -crosstabs_dim (struct tab_table *t, struct outp_driver *d, void *proc_) -{ - struct crosstabs_proc *proc = proc_; - int i; - - /* Width of a numerical column. */ - int c = outp_string_width (d, "0.000000", OUTP_PROPORTIONAL); - if (proc->exclude == MV_NEVER) - c += outp_string_width (d, "M", OUTP_PROPORTIONAL); - - /* Set width for header columns. */ - if (t->l != 0) - { - size_t i; - int w; - - w = d->width - c * (t->nc - t->l); - for (i = 0; i <= t->nc; i++) - w -= t->wrv[i]; - w /= t->l; - - if (w < d->prop_em_width * 8) - w = d->prop_em_width * 8; - - if (w > d->prop_em_width * 15) - w = d->prop_em_width * 15; - for (i = 0; i < t->l; i++) - t->w[i] = w; - } - - for (i = t->l; i < t->nc; i++) - t->w[i] = c; - - for (i = 0; i < t->nr; i++) - t->h[i] = tab_natural_height (t, d, i); + tab_submit (t); } static bool @@ -1480,6 +1405,14 @@ compare_value_3way (const void *a_, const void *b_, const void *width_) return value_compare_3way (a, b, *width); } +/* Inverted version of the above */ +static int +compare_value_3way_inv (const void *a_, const void *b_, const void *width_) +{ + return -compare_value_3way (a_, b_, width_); +} + + /* Given an array of ENTRY_CNT table_entry structures starting at ENTRIES, creates a sorted list of the values that the variable with index VAR_IDX takes on. The values are returned as a @@ -1488,7 +1421,7 @@ compare_value_3way (const void *a_, const void *b_, const void *width_) */ static void enum_var_values (const struct pivot_table *pt, int var_idx, - union value **valuesp, int *n_values) + union value **valuesp, int *n_values, bool descending) { const struct variable *var = pt->vars[var_idx]; struct var_range *range = get_var_range (var); @@ -1532,7 +1465,9 @@ enum_var_values (const struct pivot_table *pt, int var_idx, values[i++] = *iter; hmapx_destroy (&set); - sort (values, *n_values, sizeof *values, compare_value_3way, &width); + sort (values, *n_values, sizeof *values, + descending ? compare_value_3way_inv : compare_value_3way, + &width); } } @@ -1544,27 +1479,21 @@ table_value_missing (struct crosstabs_proc *proc, struct tab_table *table, int c, int r, unsigned char opt, const union value *v, const struct variable *var) { - struct substring s; - const struct fmt_spec *print = var_get_print_format (var); - const char *label = var_lookup_value_label (var, v); - if (label) - { - tab_text (table, c, r, TAB_LEFT, label); - return; - } - - s.string = tab_alloc (table, print->w); - data_out (v, print, s.string); - s.length = print->w; - if (proc->exclude == MV_NEVER && var_is_num_missing (var, v->f, MV_USER)) - s.string[s.length++] = 'M'; - while (s.length && *s.string == ' ') + if (label != NULL) + tab_text (table, c, r, TAB_LEFT, label); + else { - s.length--; - s.string++; + const struct fmt_spec *print = var_get_print_format (var); + if (proc->exclude == MV_NEVER && var_is_value_missing (var, v, MV_USER)) + { + char *s = data_out (v, dict_get_encoding (proc->dict), print); + tab_text_format (table, c, r, opt, "%sM", s + strspn (s, " ")); + free (s); + } + else + tab_value (table, c, r, opt, v, proc->dict, print); } - tab_raw (table, c, r, opt, &s); } /* Draws a line across TABLE at the current row to indicate the most @@ -1576,10 +1505,10 @@ static void display_dimensions (struct crosstabs_proc *proc, struct pivot_table *pt, struct tab_table *table, int first_difference) { - tab_hline (table, TAL_1, pt->n_vars - first_difference - 1, tab_nc (table) - 1, 0); + tab_hline (table, TAL_1, pt->n_consts + pt->n_vars - first_difference - 1, tab_nc (table) - 1, 0); for (; first_difference >= 2; first_difference--) - table_value_missing (proc, table, pt->n_vars - first_difference - 1, 0, + table_value_missing (proc, table, pt->n_consts + pt->n_vars - first_difference - 1, 0, TAB_RIGHT, &pt->entries[0]->values[first_difference], pt->vars[first_difference]); } @@ -1589,27 +1518,28 @@ display_dimensions (struct crosstabs_proc *proc, struct pivot_table *pt, additionally suffixed with a letter `M'. */ static void format_cell_entry (struct tab_table *table, int c, int r, double value, - char suffix, bool mark_missing) + char suffix, bool mark_missing, const struct dictionary *dict) { const struct fmt_spec f = {FMT_F, 10, 1}; union value v; - struct substring s; + char suffixes[3]; + int suffix_len; + char *s; - s.length = 10; - s.string = tab_alloc (table, 16); v.f = value; - data_out (&v, &f, s.string); - while (*s.string == ' ') - { - s.length--; - s.string++; - } + s = data_out (&v, dict_get_encoding (dict), &f); + + suffix_len = 0; if (suffix != 0) - s.string[s.length++] = suffix; + suffixes[suffix_len++] = suffix; if (mark_missing) - s.string[s.length++] = 'M'; + suffixes[suffix_len++] = 'M'; + suffixes[suffix_len] = '\0'; + + tab_text_format (table, c, r, TAB_RIGHT, "%s%s", + s + strspn (s, " "), suffixes); - tab_raw (table, c, r, TAB_RIGHT, &s); + free (s); } /* Displays the crosstabulation table. */ @@ -1622,15 +1552,16 @@ display_crosstabulation (struct crosstabs_proc *proc, struct pivot_table *pt, double *mp; for (r = 0; r < pt->n_rows; r++) - table_value_missing (proc, table, pt->n_vars - 2, r * proc->n_cells, - TAB_RIGHT, &pt->rows[r], pt->vars[ROW_VAR]); + table_value_missing (proc, table, pt->n_consts + pt->n_vars - 2, + r * proc->n_cells, TAB_RIGHT, &pt->rows[r], + pt->vars[ROW_VAR]); tab_text (table, pt->n_vars - 2, pt->n_rows * proc->n_cells, TAB_LEFT, _("Total")); /* Put in the actual cells. */ mp = pt->mat; - tab_offset (table, pt->n_vars - 1, -1); + tab_offset (table, pt->n_consts + pt->n_vars - 1, -1); for (r = 0; r < pt->n_rows; r++) { if (proc->n_cells > 1) @@ -1684,7 +1615,7 @@ display_crosstabulation (struct crosstabs_proc *proc, struct pivot_table *pt, default: NOT_REACHED (); } - format_cell_entry (table, c, i, v, suffix, mark_missing); + format_cell_entry (table, c, i, v, suffix, mark_missing, proc->dict); } mp++; @@ -1735,7 +1666,7 @@ display_crosstabulation (struct crosstabs_proc *proc, struct pivot_table *pt, NOT_REACHED (); } - format_cell_entry (table, pt->n_cols, 0, v, suffix, mark_missing); + format_cell_entry (table, pt->n_cols, 0, v, suffix, mark_missing, proc->dict); tab_next_row (table); } } @@ -1785,7 +1716,7 @@ display_crosstabulation (struct crosstabs_proc *proc, struct pivot_table *pt, NOT_REACHED (); } - format_cell_entry (table, c, i, v, suffix, mark_missing); + format_cell_entry (table, c, i, v, suffix, mark_missing, proc->dict); } last_row = i; } @@ -2095,8 +2026,8 @@ display_directional (struct crosstabs_proc *proc, struct pivot_table *pt, else string = var_get_name (pt->vars[1]); - tab_text (direct, j, 0, TAB_LEFT | TAT_PRINTF, - gettext (stats_names[j][k]), string); + tab_text_format (direct, j, 0, TAB_LEFT, + gettext (stats_names[j][k]), string); } } }