X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fcrosstabs.q;h=08a182a456a4836d61d1fa9d2f847921f8ae97d3;hb=f790dbda9d498eef9c9c0a49078adbeecf768d56;hp=5695ed6478b64490095ea0c8abde83873fb38030;hpb=8b71948cd57dbd2787cb4c50525b957e9be8a62b;p=pspp diff --git a/src/language/stats/crosstabs.q b/src/language/stats/crosstabs.q index 5695ed6478..08a182a456 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, 2012, 2013, 2014, 2016 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 @@ -16,52 +16,52 @@ /* FIXME: - - Pearson's R (but not Spearman!) is off a little. - - T values for Spearman's R and Pearson's R are wrong. - - How to calculate significance of symmetric and directional measures? - - Asymmetric ASEs and T values for lambda are wrong. - - ASE of Goodman and Kruskal's tau is not calculated. - - ASE of symmetric somers' d is wrong. - - Approx. T of uncertainty coefficient is wrong. + - How to calculate significance of some symmetric and directional measures? + - How to calculate ASE for symmetric Somers ' d? + - How to calculate ASE for Goodman and Kruskal's tau? + - How to calculate approx. T of symmetric uncertainty coefficient? */ #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 -#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/stats/freq.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 "output/chart-item.h" +#include "output/charts/barchart.h" + +#include "gl/minmax.h" +#include "gl/xalloc.h" +#include "gl/xsize.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -74,13 +74,15 @@ *^tables=custom; +variables=custom; missing=miss:!table/include/report; + count=roundwhat:asis/case/!cell, + roundhow:!round/truncate; +write[wr_]=none,cells,all; - +format=fmt:!labels/nolabels/novallabs, - val:!avalue/dvalue, + +format=val:!avalue/dvalue, indx:!noindex/index, tabl:!tables/notables, box:!box/nobox, pivot:!pivot/nopivot; + +barchart=; +cells[cl_]=count,expected,row,column,total,residual,sresidual, asresidual,all,none; +statistics[st_]=chisq,phi,cc,lambda,uc,none,btau,ctau,risk,gamma,d, @@ -98,20 +100,6 @@ /* Number of directional statistics. */ #define N_DIRECTIONAL 13 -/* A single table entry for general mode. */ -struct table_entry - { - struct hmap_node node; /* Entry in hash table. */ - double freq; /* Frequency count. */ - union value values[1]; /* Values. */ - }; - -static size_t -table_entry_size (size_t n_values) -{ - return (offsetof (struct table_entry, values) - + n_values * sizeof (union value)); -} /* Indexes into the 'vars' member of struct pivot_table and struct crosstab member. */ @@ -125,6 +113,7 @@ enum /* A crosstabulation of 2 or more variables. */ struct pivot_table { + struct crosstabs_proc *proc; struct fmt_spec weight_format; /* Format for weight variable. */ double missing; /* Weight of missing cases. */ @@ -139,7 +128,7 @@ struct pivot_table /* Data. */ struct hmap data; - struct table_entry **entries; + struct freq **entries; size_t n_entries; /* Column values, number of columns. */ @@ -164,29 +153,27 @@ struct pivot_table /* Integer mode variable info. */ struct var_range { + struct hmap_node hmap_node; /* In struct crosstabs_proc var_ranges map. */ + const struct variable *var; /* The variable. */ int min; /* Minimum value. */ int max; /* Maximum value + 1. */ int count; /* max - min. */ }; -static inline struct var_range * -get_var_range (const struct variable *v) -{ - return var_get_aux (v); -} - struct crosstabs_proc { const struct dictionary *dict; enum { INTEGER, GENERAL } mode; enum mv_class exclude; bool pivot; + bool barchart; bool bad_warn; struct fmt_spec weight_format; /* Variables specifies on VARIABLES. */ const struct variable **variables; size_t n_variables; + struct hmap var_ranges; /* TABLES. */ struct pivot_table *pivots; @@ -197,51 +184,20 @@ struct crosstabs_proc unsigned int cells; /* Bit k is 1 if cell k is requested. */ int a_cells[CRS_CL_count]; /* 0...n_cells-1 are the requested cells. */ + /* Rounding of cells. */ + bool round_case_weights; /* Round case weights? */ + bool round_cells; /* If !round_case_weights, round cells? */ + bool round_down; /* Round down? (otherwise to nearest) */ + /* STATISTICS. */ unsigned int statistics; /* Bit k is 1 if statistic k is requested. */ - }; -/* Auxiliary data structure for tab_dim. */ -struct crosstabs_dim_aux - { - enum mv_class exclude; + bool descending; /* True if descending sort order is requested. */ }; -static void -init_proc (struct crosstabs_proc *proc, struct dataset *ds) -{ - const struct variable *wv = dict_get_weight (dataset_dict (ds)); - proc->dict = 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; -} +const struct var_range *get_var_range (const struct crosstabs_proc *, + const struct variable *); -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 (proc->pivots); -} - -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 *, @@ -249,94 +205,108 @@ 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. */ -int -cmd_crosstabs (struct lexer *lexer, struct dataset *ds) +static double +round_weight (const struct crosstabs_proc *proc, double weight) { - struct crosstabs_proc proc; - int result; - - init_proc (&proc, ds); - result = internal_cmd_crosstabs (lexer, ds, &proc); - free_proc (&proc); - - return result; + return proc->round_down ? floor (weight) : floor (weight + 0.5); } /* Parses and executes the CROSSTABS procedure. */ -static int -internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds, - struct crosstabs_proc *proc) +int +cmd_crosstabs (struct lexer *lexer, struct dataset *ds) { + const struct variable *wv = dict_get_weight (dataset_dict (ds)); + struct var_range *range, *next_range; + 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; + hmap_init (&proc.var_ranges); + 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.barchart = cmd.sbc_barchart > 0; + + proc.descending = cmd.val == CRS_DVALUE; - proc->mode = proc->n_variables ? INTEGER : GENERAL; + proc.round_case_weights = cmd.sbc_count && cmd.roundwhat == CRS_CASE; + proc.round_cells = cmd.sbc_count && cmd.roundwhat == CRS_CELL; + proc.round_down = cmd.roundhow == CRS_TRUNCATE; /* 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.exclude == MV_NEVER) { - msg (SE, _("Missing mode REPORT not allowed in general mode. " - "Assuming MISSING=TABLE.")); - proc->mode = MV_ANY; + msg (SE, _("Missing mode %s not allowed in general mode. " + "Assuming %s."), "REPORT", "MISSING=TABLE"); + proc.exclude = 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); @@ -353,15 +323,25 @@ 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 (cmd.roundwhat == CRS_CASE) { - if (proc->mode == GENERAL) + weight = round_weight (&proc, weight); + if (weight == 0.) + continue; + } + if (should_tabulate_case (pt, c, proc.exclude)) + { + if (proc.mode == GENERAL) tabulate_general_case (pt, c, weight); else tabulate_integer_case (pt, c, weight); @@ -372,12 +352,35 @@ 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); + HMAP_FOR_EACH_SAFE (range, next_range, struct var_range, hmap_node, + &proc.var_ranges) + { + hmap_delete (&proc.var_ranges, &range->hmap_node); + free (range); + } + 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. */ @@ -398,10 +401,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, @@ -428,10 +431,7 @@ crs_custom_tables (struct lexer *lexer, struct dataset *ds, if (!lex_match (lexer, T_BY)) { if (n_by < 2) - { - lex_error (lexer, _("expecting BY")); - goto done; - } + goto done; else break; } @@ -445,6 +445,7 @@ crs_custom_tables (struct lexer *lexer, struct dataset *ds, struct pivot_table *pt = &proc->pivots[proc->n_pivots++]; int j; + pt->proc = proc; pt->weight_format = proc->weight_format; pt->missing = 0.; pt->n_vars = n_by; @@ -452,9 +453,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]]; @@ -489,11 +487,11 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds, struct crosstabs_proc *proc = proc_; if (proc->n_pivots) { - msg (SE, _("VARIABLES must be specified before TABLES.")); + msg (SE, _("%s must be specified before %s."), "VARIABLES", "TABLES"); return 0; } - lex_match (lexer, '='); + lex_match (lexer, T_EQUALS); for (;;) { @@ -508,19 +506,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; @@ -533,23 +527,23 @@ 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++) { + const struct variable *var = proc->variables[i]; struct var_range *vr = xmalloc (sizeof *vr); + + vr->var = var; vr->min = min; - vr->max = max + 1.; + vr->max = max; vr->count = max - min + 1; - var_attach_aux (proc->variables[i], vr, var_dtor_free); + hmap_insert (&proc->var_ranges, &vr->hmap_node, + hash_pointer (var, 0)); } - if (lex_token (lexer) == '/') + if (lex_token (lexer) == T_SLASH) break; } @@ -564,6 +558,22 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds, /* Data file processing. */ +const struct var_range * +get_var_range (const struct crosstabs_proc *proc, const struct variable *var) +{ + if (!hmap_is_empty (&proc->var_ranges)) + { + const struct var_range *range; + + HMAP_FOR_EACH_IN_BUCKET (range, struct var_range, hmap_node, + hash_pointer (var, 0), &proc->var_ranges) + if (range->var == var) + return range; + } + + return NULL; +} + static bool should_tabulate_case (const struct pivot_table *pt, const struct ccase *c, enum mv_class exclude) @@ -572,7 +582,7 @@ should_tabulate_case (const struct pivot_table *pt, const struct ccase *c, for (j = 0; j < pt->n_vars; j++) { const struct variable *var = pt->vars[j]; - struct var_range *range = get_var_range (var); + const struct var_range *range = get_var_range (pt->proc, var); if (var_is_value_missing (var, case_data (c, var), exclude)) return false; @@ -580,7 +590,7 @@ should_tabulate_case (const struct pivot_table *pt, const struct ccase *c, if (range != NULL) { double num = case_num (c, var); - if (num < range->min || num > range->max) + if (num < range->min || num >= range->max + 1.) return false; } } @@ -591,7 +601,7 @@ static void tabulate_integer_case (struct pivot_table *pt, const struct ccase *c, double weight) { - struct table_entry *te; + struct freq *te; size_t hash; int j; @@ -602,14 +612,14 @@ tabulate_integer_case (struct pivot_table *pt, const struct ccase *c, hash = hash_int (case_num (c, pt->vars[j]), hash); } - HMAP_FOR_EACH_WITH_HASH (te, struct table_entry, node, hash, &pt->data) + HMAP_FOR_EACH_WITH_HASH (te, struct freq, node, hash, &pt->data) { for (j = 0; j < pt->n_vars; j++) if ((int) case_num (c, pt->vars[j]) != (int) te->values[j].f) goto no_match; /* Found an existing entry. */ - te->freq += weight; + te->count += weight; return; no_match: ; @@ -617,7 +627,7 @@ tabulate_integer_case (struct pivot_table *pt, const struct ccase *c, /* No existing entry. Create a new one. */ te = xmalloc (table_entry_size (pt->n_vars)); - te->freq = weight; + te->count = weight; for (j = 0; j < pt->n_vars; j++) te->values[j].f = (int) case_num (c, pt->vars[j]); hmap_insert (&pt->data, &te->node, hash); @@ -627,7 +637,7 @@ static void tabulate_general_case (struct pivot_table *pt, const struct ccase *c, double weight) { - struct table_entry *te; + struct freq *te; size_t hash; int j; @@ -638,7 +648,7 @@ tabulate_general_case (struct pivot_table *pt, const struct ccase *c, hash = value_hash (case_data (c, var), var_get_width (var), hash); } - HMAP_FOR_EACH_WITH_HASH (te, struct table_entry, node, hash, &pt->data) + HMAP_FOR_EACH_WITH_HASH (te, struct freq, node, hash, &pt->data) { for (j = 0; j < pt->n_vars; j++) { @@ -649,7 +659,7 @@ tabulate_general_case (struct pivot_table *pt, const struct ccase *c, } /* Found an existing entry. */ - te->freq += weight; + te->count += weight; return; no_match: ; @@ -657,27 +667,28 @@ tabulate_general_case (struct pivot_table *pt, const struct ccase *c, /* No existing entry. Create a new one. */ te = xmalloc (table_entry_size (pt->n_vars)); - te->freq = weight; + te->count = weight; 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); } /* Post-data reading calculations. */ -static int compare_table_entry_vars_3way (const struct table_entry *a, - const struct table_entry *b, +static int compare_table_entry_vars_3way (const struct freq *a, + const struct freq *b, const struct pivot_table *pt, 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, @@ -689,29 +700,51 @@ static bool find_crosstab (struct pivot_table *, size_t *row0p, size_t *row1p); static void postcalc (struct crosstabs_proc *proc) { - struct pivot_table *pt; + + /* Round hash table entries, if requested + + If this causes any of the cell counts to fall to zero, delete those + cells. */ + if (proc->round_cells) + for (struct pivot_table *pt = proc->pivots; + pt < &proc->pivots[proc->n_pivots]; pt++) + { + struct freq *e, *next; + HMAP_FOR_EACH_SAFE (e, next, struct freq, node, &pt->data) + { + e->count = round_weight (proc, e->count); + if (e->count == 0.0) + { + hmap_delete (&pt->data, &e->node); + free (e); + } + } + } /* Convert hash tables into sorted arrays of entries. */ - for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++) + for (struct pivot_table *pt = proc->pivots; + pt < &proc->pivots[proc->n_pivots]; pt++) { - struct table_entry *e; - size_t i; + struct freq *e; pt->n_entries = hmap_count (&pt->data); pt->entries = xnmalloc (pt->n_entries, sizeof *pt->entries); - i = 0; - HMAP_FOR_EACH (e, struct table_entry, node, &pt->data) + size_t i = 0; + HMAP_FOR_EACH (e, struct freq, node, &pt->data) pt->entries[i++] = e; 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); /* Output each pivot table. */ - for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++) + for (struct pivot_table *pt = proc->pivots; + pt < &proc->pivots[proc->n_pivots]; pt++) { if (proc->pivot || pt->n_vars == 2) output_pivot_table (proc, pt); @@ -725,22 +758,37 @@ postcalc (struct crosstabs_proc *proc) output_pivot_table (proc, &subset); } } + if (proc->barchart) + chart_item_submit + (barchart_create (pt->vars, pt->n_vars, _("Count"), false, pt->entries, pt->n_entries)); } /* Free output and prepare for next split file. */ - for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++) + for (struct pivot_table *pt = proc->pivots; + pt < &proc->pivots[proc->n_pivots]; pt++) { - size_t i; - pt->missing = 0.0; - /* Free only the members that were allocated in this - function. The other pointer members are either both - allocated and destroyed at a lower level (in - output_pivot_table), or both allocated and destroyed at - a higher level (in crs_custom_tables and free_proc, + /* Free the members that were allocated in this function(and the values + owned by the entries. + + The other pointer members are either both allocated and destroyed at a + lower level (in output_pivot_table), or both allocated and destroyed + at a higher level (in crs_custom_tables and free_proc, respectively). */ - for (i = 0; i < pt->n_entries; i++) + for (size_t i = 0; i < pt->n_vars; i++) + { + int width = var_get_width (pt->vars[i]); + if (value_needs_init (width)) + { + size_t j; + + for (j = 0; j < pt->n_entries; j++) + value_destroy (&pt->entries[j]->values[i], width); + } + } + + for (size_t i = 0; i < pt->n_entries; i++) free (pt->entries[i]); free (pt->entries); } @@ -766,8 +814,8 @@ make_pivot_table_subset (struct pivot_table *pt, size_t row0, size_t row1, } static int -compare_table_entry_var_3way (const struct table_entry *a, - const struct table_entry *b, +compare_table_entry_var_3way (const struct freq *a, + const struct freq *b, const struct pivot_table *pt, int idx) { @@ -776,8 +824,8 @@ compare_table_entry_var_3way (const struct table_entry *a, } static int -compare_table_entry_vars_3way (const struct table_entry *a, - const struct table_entry *b, +compare_table_entry_vars_3way (const struct freq *a, + const struct freq *b, const struct pivot_table *pt, int idx0, int idx1) { @@ -792,15 +840,15 @@ compare_table_entry_vars_3way (const struct table_entry *a, return 0; } -/* Compare the struct table_entry at *AP to the one at *BP and +/* Compare the struct freq at *AP to the one at *BP and return a strcmp()-type result. */ static int compare_table_entry_3way (const void *ap_, const void *bp_, const void *pt_) { - const struct table_entry *const *ap = ap_; - const struct table_entry *const *bp = bp_; - const struct table_entry *a = *ap; - const struct table_entry *b = *bp; + const struct freq *const *ap = ap_; + const struct freq *const *bp = bp_; + const struct freq *a = *ap; + const struct freq *b = *bp; const struct pivot_table *pt = pt_; int cmp; @@ -815,6 +863,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) { @@ -822,8 +877,8 @@ find_first_difference (const struct pivot_table *pt, size_t row) return pt->n_vars - 1; else { - const struct table_entry *a = pt->entries[row]; - const struct table_entry *b = pt->entries[row - 1]; + const struct freq *a = pt->entries[row]; + const struct freq *b = pt->entries[row - 1]; int col; for (col = pt->n_vars - 1; col >= 0; col--) @@ -843,6 +898,7 @@ make_summary_table (struct crosstabs_proc *proc) int i; summary = tab_create (7, 3 + proc->n_pivots); + tab_set_format (summary, RC_WEIGHT, &proc->weight_format); tab_title (summary, _("Summary.")); tab_headers (summary, 1, 0, 3, 0); tab_joint_text (summary, 1, 0, 6, 0, TAB_CENTER, _("Cases")); @@ -880,15 +936,14 @@ make_summary_table (struct crosstabs_proc *proc) valid = 0.; for (i = 0; i < pt->n_entries; i++) - valid += pt->entries[i]->freq; + valid += pt->entries[i]->count; n[0] = valid; n[1] = pt->missing; n[2] = n[0] + n[1]; for (i = 0; i < 3; i++) { - tab_double (summary, i * 2 + 1, 0, TAB_RIGHT, n[i], - &proc->weight_format); + tab_double (summary, i * 2 + 1, 0, TAB_RIGHT, n[i], NULL, RC_WEIGHT); tab_text_format (summary, i * 2 + 2, 0, TAB_RIGHT, "%.1f%%", n[i] / n[2] * 100.); } @@ -897,17 +952,17 @@ make_summary_table (struct crosstabs_proc *proc) } ds_destroy (&name); - submit (proc, NULL, summary); + submit (NULL, summary); } /* Output. */ static struct tab_table *create_crosstab_table (struct crosstabs_proc *, struct pivot_table *); -static struct tab_table *create_chisq_table (struct pivot_table *); -static struct tab_table *create_sym_table (struct pivot_table *); -static struct tab_table *create_risk_table (struct pivot_table *); -static struct tab_table *create_direct_table (struct pivot_table *); +static struct tab_table *create_chisq_table (struct crosstabs_proc *proc, struct pivot_table *); +static struct tab_table *create_sym_table (struct crosstabs_proc *proc, struct pivot_table *); +static struct tab_table *create_risk_table (struct crosstabs_proc *proc, struct pivot_table *); +static struct tab_table *create_direct_table (struct crosstabs_proc *proc, struct pivot_table *); static void display_dimensions (struct crosstabs_proc *, struct pivot_table *, struct tab_table *, int first_difference); static void display_crosstabulation (struct crosstabs_proc *, @@ -920,8 +975,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_rendering *, void *aux); -static void crosstabs_dim_free (void *aux); static void table_value_missing (struct crosstabs_proc *proc, struct tab_table *table, int c, int r, unsigned char opt, const union value *v, @@ -929,9 +982,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) { @@ -943,22 +994,41 @@ 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_to_string (pt->vars[0])); + for (i = 1; i < pt->n_vars; i++) + ds_put_format (&vars, " * %s", var_to_string (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); + free (pt->cols); + return; + } if (proc->cells) table = create_crosstab_table (proc, pt); if (proc->statistics & (1u << CRS_ST_CHISQ)) - chisq = create_chisq_table (pt); + chisq = create_chisq_table (proc, pt); if (proc->statistics & ((1u << CRS_ST_PHI) | (1u << CRS_ST_CC) | (1u << CRS_ST_BTAU) | (1u << CRS_ST_CTAU) | (1u << CRS_ST_GAMMA) | (1u << CRS_ST_CORR) | (1u << CRS_ST_KAPPA))) - sym = create_sym_table (pt); + sym = create_sym_table (proc, pt); if (proc->statistics & (1u << CRS_ST_RISK)) - risk = create_risk_table (pt); + risk = create_risk_table (proc, pt); if (proc->statistics & ((1u << CRS_ST_LAMBDA) | (1u << CRS_ST_UC) | (1u << CRS_ST_D) | (1u << CRS_ST_ETA))) - direct = create_direct_table (pt); + direct = create_direct_table (proc, pt); row0 = row1 = 0; while (find_crosstab (pt, &row0, &row1)) @@ -969,7 +1039,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)))) @@ -1029,18 +1099,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); } @@ -1052,13 +1122,13 @@ build_matrix (struct pivot_table *x) const int row_var_width = var_get_width (x->vars[ROW_VAR]); int col, row; double *mp; - struct table_entry **p; + struct freq **p; mp = x->mat; col = row = 0; for (p = x->entries; p < &x->entries[x->n_entries]; p++) { - const struct table_entry *te = *p; + const struct freq *te = *p; while (!value_equal (&x->rows[row], &te->values[ROW_VAR], row_var_width)) { @@ -1074,7 +1144,7 @@ build_matrix (struct pivot_table *x) col++; } - *mp++ = te->freq; + *mp++ = te->count; if (++col >= x->n_cols) { col = 0; @@ -1150,59 +1220,60 @@ 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); - 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); + tab_set_format (table, RC_WEIGHT, &proc->weight_format); /* 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_to_string (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_to_string (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_to_string (x.vars[i])); } for (i = 0; i < pt->n_consts; i++) { const struct variable *var = pt->const_vars[i]; - size_t ofs; - char *s = NULL; + char *s; - ds_put_format (&title, ", %s=", var_get_name (var)); + ds_put_format (&title, ", %s=", var_to_string (var)); - /* Insert the formatted value of the variable, then trim - leading spaces in what was just inserted. */ - ofs = ds_length (&title); - s = data_out (&pt->const_values[i], dict_get_encoding (proc->dict), var_get_print_format (var)); - ds_put_cstr (&title, s); + /* 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_remove (&title, ofs, ss_cspan (ds_substr (&title, ofs, SIZE_MAX), - ss_cstr (" "))); } ds_put_cstr (&title, " ["); @@ -1224,13 +1295,14 @@ create_crosstab_table (struct crosstabs_proc *proc, struct pivot_table *pt) } static struct tab_table * -create_chisq_table (struct pivot_table *pt) +create_chisq_table (struct crosstabs_proc *proc, 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); tab_headers (chisq, 1 + (pt->n_vars - 2), 0, 1, 0); + tab_set_format (chisq, RC_WEIGHT, &proc->weight_format); tab_title (chisq, _("Chi-square tests.")); @@ -1239,11 +1311,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; @@ -1251,12 +1323,15 @@ create_chisq_table (struct pivot_table *pt) /* Symmetric measures. */ static struct tab_table * -create_sym_table (struct pivot_table *pt) +create_sym_table (struct crosstabs_proc *proc, struct pivot_table *pt) { struct tab_table *sym; sym = tab_create (6 + (pt->n_vars - 2), pt->n_entries / pt->n_cols * 7 + 10); + + tab_set_format (sym, RC_WEIGHT, &proc->weight_format); + tab_headers (sym, 2 + (pt->n_vars - 2), 0, 1, 0); tab_title (sym, _("Symmetric measures.")); @@ -1274,13 +1349,14 @@ create_sym_table (struct pivot_table *pt) /* Risk estimate. */ static struct tab_table * -create_risk_table (struct pivot_table *pt) +create_risk_table (struct crosstabs_proc *proc, struct pivot_table *pt) { struct tab_table *risk; 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_set_format (risk, RC_WEIGHT, &proc->weight_format); tab_offset (risk, pt->n_vars - 2, 0); tab_joint_text_format (risk, 2, 0, 3, 0, TAB_CENTER | TAT_TITLE, @@ -1298,7 +1374,7 @@ create_risk_table (struct pivot_table *pt) /* Directional measures. */ static struct tab_table * -create_direct_table (struct pivot_table *pt) +create_direct_table (struct crosstabs_proc *proc, struct pivot_table *pt) { struct tab_table *direct; @@ -1306,6 +1382,7 @@ create_direct_table (struct pivot_table *pt) pt->n_entries / pt->n_cols * 7 + 10); tab_headers (direct, 3 + (pt->n_vars - 2), 0, 1, 0); tab_title (direct, _("Directional measures.")); + tab_set_format (direct, RC_WEIGHT, &proc->weight_format); tab_offset (direct, pt->n_vars - 2, 0); tab_text (direct, 0, 0, TAB_LEFT | TAT_TITLE, _("Category")); @@ -1348,10 +1425,8 @@ 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) { - struct crosstabs_dim_aux *aux; int i; if (t == NULL) @@ -1360,7 +1435,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); @@ -1375,63 +1450,9 @@ submit (struct crosstabs_proc *proc, struct pivot_table *pt, tab_nr (t) - 1); tab_vline (t, TAL_2, tab_l (t), 0, tab_nr (t) - 1); - aux = xmalloc (sizeof *aux); - aux->exclude = proc->exclude; - tab_dim (t, crosstabs_dim, crosstabs_dim_free, aux); - 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_rendering *r, void *aux_) -{ - const struct tab_table *t = r->table; - struct outp_driver *d = r->driver; - struct crosstabs_dim_aux *aux = aux_; - int i; - - /* Width of a numerical column. */ - int c = outp_string_width (d, "0.000000", OUTP_PROPORTIONAL); - if (aux->exclude == MV_NEVER) - c += outp_string_width (d, "M", OUTP_PROPORTIONAL); - - /* Set width for header columns. */ - if (tab_l (t) != 0) - { - size_t i; - int w; - - w = d->width - c * (tab_nc (t) - tab_l (t)); - for (i = 0; i <= tab_nc (t); i++) - w -= r->wrv[i]; - w /= tab_l (t); - - 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 < tab_l (t); i++) - r->w[i] = w; - } - - for (i = tab_l (t); i < tab_nc (t); i++) - r->w[i] = c; - - for (i = 0; i < tab_nr (t); i++) - r->h[i] = tab_natural_height (r, i); -} - -static void -crosstabs_dim_free (void *aux_) -{ - struct crosstabs_dim_aux *aux = aux_; - free (aux); -} - static bool find_crosstab (struct pivot_table *pt, size_t *row0p, size_t *row1p) { @@ -1443,8 +1464,8 @@ find_crosstab (struct pivot_table *pt, size_t *row0p, size_t *row1p) for (row1 = row0 + 1; row1 < pt->n_entries; row1++) { - struct table_entry *a = pt->entries[row0]; - struct table_entry *b = pt->entries[row1]; + struct freq *a = pt->entries[row0]; + struct freq *b = pt->entries[row1]; if (compare_table_entry_vars_3way (a, b, pt, 2, pt->n_vars) != 0) break; } @@ -1466,18 +1487,28 @@ 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 malloc()'d array stored in *VALUES, with the number of values stored in *VALUE_CNT. - */ + + The caller must eventually free *VALUES, but each pointer in *VALUES points + to existing data not owned by *VALUES itself. */ 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); + const struct var_range *range = get_var_range (pt->proc, var); union value *values; size_t i; @@ -1498,7 +1529,7 @@ enum_var_values (const struct pivot_table *pt, int var_idx, hmapx_init (&set); for (i = 0; i < pt->n_entries; i++) { - const struct table_entry *te = pt->entries[i]; + const struct freq *te = pt->entries[i]; const union value *value = &te->values[var_idx]; size_t hash = value_hash (value, width, 0); @@ -1518,7 +1549,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); } } @@ -1543,7 +1576,7 @@ table_value_missing (struct crosstabs_proc *proc, free (s); } else - tab_value (table, c, r, opt, v, proc->dict, print); + tab_value (table, c, r, opt, v, var, print); } } @@ -1556,10 +1589,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]); } @@ -1571,14 +1604,13 @@ static void format_cell_entry (struct tab_table *table, int c, int r, double value, char suffix, bool mark_missing, const struct dictionary *dict) { - const struct fmt_spec f = {FMT_F, 10, 1}; union value v; char suffixes[3]; int suffix_len; char *s; v.f = value; - s = data_out (&v, dict_get_encoding (dict), &f); + s = data_out (&v, dict_get_encoding (dict), settings_get_format ()); suffix_len = 0; if (suffix != 0) @@ -1589,6 +1621,8 @@ format_cell_entry (struct tab_table *table, int c, int r, double value, tab_text_format (table, c, r, TAB_RIGHT, "%s%s", s + strspn (s, " "), suffixes); + + free (s); } /* Displays the crosstabulation table. */ @@ -1601,15 +1635,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) @@ -1799,7 +1834,7 @@ display_chisq (struct pivot_table *pt, struct tab_table *chisq, calc_chisq (pt, chisq_v, df, &fisher1, &fisher2); - tab_offset (chisq, pt->n_vars - 2, -1); + tab_offset (chisq, pt->n_consts + pt->n_vars - 2, -1); for (i = 0; i < N_CHISQ; i++) { @@ -1810,22 +1845,22 @@ display_chisq (struct pivot_table *pt, struct tab_table *chisq, tab_text (chisq, 0, 0, TAB_LEFT, gettext (chisq_stats[i])); if (i != 2) { - tab_double (chisq, 1, 0, TAB_RIGHT, chisq_v[i], NULL); - tab_double (chisq, 2, 0, TAB_RIGHT, df[i], &pt->weight_format); + tab_double (chisq, 1, 0, TAB_RIGHT, chisq_v[i], NULL, RC_OTHER); + tab_double (chisq, 2, 0, TAB_RIGHT, df[i], NULL, RC_WEIGHT); tab_double (chisq, 3, 0, TAB_RIGHT, - gsl_cdf_chisq_Q (chisq_v[i], df[i]), NULL); + gsl_cdf_chisq_Q (chisq_v[i], df[i]), NULL, RC_PVALUE); } else { *showed_fisher = true; - tab_double (chisq, 4, 0, TAB_RIGHT, fisher2, NULL); - tab_double (chisq, 5, 0, TAB_RIGHT, fisher1, NULL); + tab_double (chisq, 4, 0, TAB_RIGHT, fisher2, NULL, RC_PVALUE); + tab_double (chisq, 5, 0, TAB_RIGHT, fisher1, NULL, RC_PVALUE); } tab_next_row (chisq); } tab_text (chisq, 0, 0, TAB_LEFT, _("N of Valid Cases")); - tab_double (chisq, 1, 0, TAB_RIGHT, pt->total, &pt->weight_format); + tab_double (chisq, 1, 0, TAB_RIGHT, pt->total, NULL, RC_WEIGHT); tab_next_row (chisq); tab_offset (chisq, 0, -1); @@ -1876,7 +1911,7 @@ display_symmetric (struct crosstabs_proc *proc, struct pivot_table *pt, somers_d_v, somers_d_ase, somers_d_t)) return; - tab_offset (sym, pt->n_vars - 2, -1); + tab_offset (sym, pt->n_consts + pt->n_vars - 2, -1); for (i = 0; i < N_SYMMETRIC; i++) { @@ -1890,17 +1925,17 @@ display_symmetric (struct crosstabs_proc *proc, struct pivot_table *pt, } tab_text (sym, 1, 0, TAB_LEFT, gettext (stats[i])); - tab_double (sym, 2, 0, TAB_RIGHT, sym_v[i], NULL); + tab_double (sym, 2, 0, TAB_RIGHT, sym_v[i], NULL, RC_OTHER); if (sym_ase[i] != SYSMIS) - tab_double (sym, 3, 0, TAB_RIGHT, sym_ase[i], NULL); + tab_double (sym, 3, 0, TAB_RIGHT, sym_ase[i], NULL, RC_OTHER); if (sym_t[i] != SYSMIS) - tab_double (sym, 4, 0, TAB_RIGHT, sym_t[i], NULL); - /*tab_double (sym, 5, 0, TAB_RIGHT, normal_sig (sym_v[i]), NULL);*/ + tab_double (sym, 4, 0, TAB_RIGHT, sym_t[i], NULL, RC_OTHER); + /*tab_double (sym, 5, 0, TAB_RIGHT, normal_sig (sym_v[i]), NULL, RC_PVALUE);*/ tab_next_row (sym); } tab_text (sym, 0, 0, TAB_LEFT, _("N of Valid Cases")); - tab_double (sym, 2, 0, TAB_RIGHT, pt->total, &pt->weight_format); + tab_double (sym, 2, 0, TAB_RIGHT, pt->total, NULL, RC_WEIGHT); tab_next_row (sym); tab_offset (sym, 0, -1); @@ -1921,7 +1956,7 @@ display_risk (struct pivot_table *pt, struct tab_table *risk) if (!calc_risk (pt, risk_v, upper, lower, c)) return; - tab_offset (risk, pt->n_vars - 2, -1); + tab_offset (risk, pt->n_consts + pt->n_vars - 2, -1); for (i = 0; i < 3; i++) { @@ -1938,34 +1973,34 @@ display_risk (struct pivot_table *pt, struct tab_table *risk) case 0: if (var_is_numeric (cv)) sprintf (buf, _("Odds Ratio for %s (%g / %g)"), - var_get_name (cv), c[0].f, c[1].f); + var_to_string (cv), c[0].f, c[1].f); else sprintf (buf, _("Odds Ratio for %s (%.*s / %.*s)"), - var_get_name (cv), + var_to_string (cv), cvw, value_str (&c[0], cvw), cvw, value_str (&c[1], cvw)); break; case 1: case 2: if (var_is_numeric (rv)) - sprintf (buf, _("For cohort %s = %g"), - var_get_name (rv), pt->rows[i - 1].f); + sprintf (buf, _("For cohort %s = %.*g"), + var_to_string (rv), DBL_DIG + 1, pt->rows[i - 1].f); else sprintf (buf, _("For cohort %s = %.*s"), - var_get_name (rv), + var_to_string (rv), rvw, value_str (&pt->rows[i - 1], rvw)); break; } tab_text (risk, 0, 0, TAB_LEFT, buf); - tab_double (risk, 1, 0, TAB_RIGHT, risk_v[i], NULL); - tab_double (risk, 2, 0, TAB_RIGHT, lower[i], NULL); - tab_double (risk, 3, 0, TAB_RIGHT, upper[i], NULL); + tab_double (risk, 1, 0, TAB_RIGHT, risk_v[i], NULL, RC_OTHER); + tab_double (risk, 2, 0, TAB_RIGHT, lower[i], NULL, RC_OTHER); + tab_double (risk, 3, 0, TAB_RIGHT, upper[i], NULL, RC_OTHER); tab_next_row (risk); } tab_text (risk, 0, 0, TAB_LEFT, _("N of Valid Cases")); - tab_double (risk, 1, 0, TAB_RIGHT, pt->total, &pt->weight_format); + tab_double (risk, 1, 0, TAB_RIGHT, pt->total, NULL, RC_WEIGHT); tab_next_row (risk); tab_offset (risk, 0, -1); @@ -1973,7 +2008,7 @@ display_risk (struct pivot_table *pt, struct tab_table *risk) static int calc_directional (struct crosstabs_proc *, struct pivot_table *, double[N_DIRECTIONAL], double[N_DIRECTIONAL], - double[N_DIRECTIONAL]); + double[N_DIRECTIONAL], double[N_DIRECTIONAL]); /* Display directional measures. */ static void @@ -2040,13 +2075,14 @@ display_directional (struct crosstabs_proc *proc, struct pivot_table *pt, double direct_v[N_DIRECTIONAL]; double direct_ase[N_DIRECTIONAL]; double direct_t[N_DIRECTIONAL]; + double sig[N_DIRECTIONAL]; int i; - if (!calc_directional (proc, pt, direct_v, direct_ase, direct_t)) + if (!calc_directional (proc, pt, direct_v, direct_ase, direct_t, sig)) return; - tab_offset (direct, pt->n_vars - 2, -1); + tab_offset (direct, pt->n_consts + pt->n_vars - 2, -1); for (i = 0; i < N_DIRECTIONAL; i++) { @@ -2070,9 +2106,9 @@ display_directional (struct crosstabs_proc *proc, struct pivot_table *pt, if (k == 0) string = NULL; else if (k == 1) - string = var_get_name (pt->vars[0]); + string = var_to_string (pt->vars[0]); else - string = var_get_name (pt->vars[1]); + string = var_to_string (pt->vars[1]); tab_text_format (direct, j, 0, TAB_LEFT, gettext (stats_names[j][k]), string); @@ -2080,12 +2116,12 @@ display_directional (struct crosstabs_proc *proc, struct pivot_table *pt, } } - tab_double (direct, 3, 0, TAB_RIGHT, direct_v[i], NULL); + tab_double (direct, 3, 0, TAB_RIGHT, direct_v[i], NULL, RC_OTHER); if (direct_ase[i] != SYSMIS) - tab_double (direct, 4, 0, TAB_RIGHT, direct_ase[i], NULL); + tab_double (direct, 4, 0, TAB_RIGHT, direct_ase[i], NULL, RC_OTHER); if (direct_t[i] != SYSMIS) - tab_double (direct, 5, 0, TAB_RIGHT, direct_t[i], NULL); - /*tab_double (direct, 6, 0, TAB_RIGHT, normal_sig (direct_v[i]), NULL);*/ + tab_double (direct, 5, 0, TAB_RIGHT, direct_t[i], NULL, RC_OTHER); + tab_double (direct, 6, 0, TAB_RIGHT, sig[i], NULL, RC_PVALUE); tab_next_row (direct); } @@ -2094,16 +2130,17 @@ display_directional (struct crosstabs_proc *proc, struct pivot_table *pt, /* Statistical calculations. */ -/* Returns the value of the gamma (factorial) function for an integer +/* Returns the value of the logarithm of gamma (factorial) function for an integer argument PT. */ static double -gamma_int (double pt) +log_gamma_int (double pt) { - double r = 1; + double r = 0; int i; for (i = 2; i < pt; i++) - r *= i; + r += log(i); + return r; } @@ -2112,11 +2149,11 @@ gamma_int (double pt) static inline double Pr (int a, int b, int c, int d) { - return (gamma_int (a + b + 1.) / gamma_int (a + 1.) - * gamma_int (c + d + 1.) / gamma_int (b + 1.) - * gamma_int (a + c + 1.) / gamma_int (c + 1.) - * gamma_int (b + d + 1.) / gamma_int (d + 1.) - / gamma_int (a + b + c + d + 1.)); + return exp (log_gamma_int (a + b + 1.) - log_gamma_int (a + 1.) + + log_gamma_int (c + d + 1.) - log_gamma_int (b + 1.) + + log_gamma_int (a + c + 1.) - log_gamma_int (c + 1.) + + log_gamma_int (b + d + 1.) - log_gamma_int (d + 1.) + - log_gamma_int (a + b + c + d + 1.)); } /* Swap the contents of A and B. */ @@ -2134,6 +2171,7 @@ static void calc_fisher (int a, int b, int c, int d, double *fisher1, double *fisher2) { int pt; + double pn1; if (MIN (c, d) < MIN (a, b)) swap (&a, &c), swap (&b, &d); @@ -2147,13 +2185,21 @@ calc_fisher (int a, int b, int c, int d, double *fisher1, double *fisher2) swap (&a, &c), swap (&b, &d); } - *fisher1 = 0.; - for (pt = 0; pt <= a; pt++) - *fisher1 += Pr (a - pt, b + pt, c + pt, d - pt); + pn1 = Pr (a, b, c, d); + *fisher1 = pn1; + for (pt = 1; pt <= a; pt++) + { + *fisher1 += Pr (a - pt, b + pt, c + pt, d - pt); + } *fisher2 = *fisher1; + for (pt = 1; pt <= b; pt++) - *fisher2 += Pr (a + pt, b - pt, c - pt, d + pt); + { + double p = Pr (a + pt, b - pt, c - pt, d + pt); + if (p < pn1) + *fisher2 += p; + } } /* Calculates chi-squares into CHISQ. MAT is a matrix with N_COLS @@ -2238,8 +2284,7 @@ calc_chisq (struct pivot_table *pt, } /* Fisher. */ - if (f11 < 5. || f12 < 5. || f21 < 5. || f22 < 5.) - calc_fisher (f11 + .5, f12 + .5, f21 + .5, f22 + .5, fisher1, fisher2); + calc_fisher (f11 + .5, f12 + .5, f21 + .5, f22 + .5, fisher1, fisher2); } /* Calculate Mantel-Haenszel. */ @@ -2253,12 +2298,12 @@ calc_chisq (struct pivot_table *pt, } } -/* Calculate the value of Pearson's r. r is stored into R, ase_1 into - ASE_1, and ase_0 into ASE_0. The row and column values must be +/* Calculate the value of Pearson's r. r is stored into R, its T value into + T, and standard error into ERROR. The row and column values must be passed in PT and Y. */ static void calc_r (struct pivot_table *pt, - double *PT, double *Y, double *r, double *ase_0, double *ase_1) + double *PT, double *Y, double *r, double *t, double *error) { double SX, SY, S, T; double Xbar, Ybar; @@ -2296,7 +2341,7 @@ calc_r (struct pivot_table *pt, SY = sum_Y2c - pow2 (sum_Yc) / pt->total; T = sqrt (SX * SY); *r = S / T; - *ase_0 = sqrt ((sum_X2Y2f - pow2 (sum_XYf) / pt->total) / (sum_X2r * sum_Y2c)); + *t = *r / sqrt (1 - pow2 (*r)) * sqrt (pt->total - 2); { double s, c, y, t; @@ -2317,7 +2362,7 @@ calc_r (struct pivot_table *pt, c = (t - s) - y; s = t; } - *ase_1 = sqrt (s) / (T * T); + *error = sqrt (s) / (T * T); } } @@ -2524,7 +2569,7 @@ calc_symmetric (struct crosstabs_proc *proc, struct pivot_table *pt, if (proc->statistics & (1u << CRS_ST_D)) { somers_d_v[0] = (P - Q) / (.5 * (Dc + Dr)); - somers_d_ase[0] = 2. * btau_var / (Dr + Dc) * sqrt (Dr * Dc); + somers_d_ase[0] = SYSMIS; somers_d_t[0] = (somers_d_v[0] / (4 / (Dc + Dr) * sqrt (ctau_cum - pow2 (P - Q) / pt->total))); @@ -2584,18 +2629,17 @@ calc_symmetric (struct crosstabs_proc *proc, struct pivot_table *pt, } calc_r (pt, R, C, &v[6], &t[6], &ase[6]); - t[6] = v[6] / t[6]; free (R); free (C); calc_r (pt, (double *) pt->rows, (double *) pt->cols, &v[7], &t[7], &ase[7]); - t[7] = v[7] / t[7]; } /* Cohen's kappa. */ if (proc->statistics & (1u << CRS_ST_KAPPA) && pt->ns_rows == pt->ns_cols) { + double ase_under_h0; double sum_fii, sum_rici, sum_fiiri_ci, sum_fijri_ci2, sum_riciri_ci; int i, j; @@ -2624,24 +2668,23 @@ calc_symmetric (struct crosstabs_proc *proc, struct pivot_table *pt, v[8] = (pt->total * sum_fii - sum_rici) / (pow2 (pt->total) - sum_rici); - ase[8] = sqrt ((pow2 (pt->total) * sum_rici - + sum_rici * sum_rici - - pt->total * sum_riciri_ci) - / (pt->total * (pow2 (pt->total) - sum_rici) * (pow2 (pt->total) - sum_rici))); -#if 0 - t[8] = v[8] / sqrt (pt->total * (((sum_fii * (pt->total - sum_fii)) + ase_under_h0 = sqrt ((pow2 (pt->total) * sum_rici + + sum_rici * sum_rici + - pt->total * sum_riciri_ci) + / (pt->total * (pow2 (pt->total) - sum_rici) * (pow2 (pt->total) - sum_rici))); + + ase[8] = sqrt (pt->total * (((sum_fii * (pt->total - sum_fii)) / pow2 (pow2 (pt->total) - sum_rici)) + ((2. * (pt->total - sum_fii) * (2. * sum_fii * sum_rici - pt->total * sum_fiiri_ci)) - / cube (pow2 (pt->total) - sum_rici)) + / pow3 (pow2 (pt->total) - sum_rici)) + (pow2 (pt->total - sum_fii) * (pt->total * sum_fijri_ci2 - 4. * sum_rici * sum_rici) / pow4 (pow2 (pt->total) - sum_rici)))); -#else - t[8] = v[8] / ase[8]; -#endif + + t[8] = v[8] / ase_under_h0; } return 1; @@ -2712,13 +2755,13 @@ calc_risk (struct pivot_table *pt, static int calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt, double v[N_DIRECTIONAL], double ase[N_DIRECTIONAL], - double t[N_DIRECTIONAL]) + double t[N_DIRECTIONAL], double sig[N_DIRECTIONAL]) { { int i; for (i = 0; i < N_DIRECTIONAL; i++) - v[i] = ase[i] = t[i] = SYSMIS; + v[i] = ase[i] = t[i] = sig[i] = SYSMIS; } /* Lambda. */ @@ -2793,19 +2836,14 @@ calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt, /* ASE1 for Y given PT. */ { - double accum; + double accum; - for (accum = 0., i = 0; i < pt->n_rows; i++) - for (j = 0; j < pt->n_cols; j++) - { - const int deltaj = j == cm_index; - accum += (pt->mat[j + i * pt->n_cols] - * pow2 ((j == fim_index[i]) - - deltaj - + v[0] * deltaj)); - } - - ase[2] = sqrt (accum - pt->total * v[0]) / (pt->total - cm); + accum = 0.; + for (i = 0; i < pt->n_rows; i++) + if (cm_index == fim_index[i]) + accum += fim[i]; + ase[2] = sqrt ((pt->total - sum_fim) * (sum_fim + cm - 2. * accum) + / pow3 (pt->total - cm)); } /* ASE0 for Y given PT. */ @@ -2821,19 +2859,14 @@ calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt, /* ASE1 for PT given Y. */ { - double accum; + double accum; - for (accum = 0., i = 0; i < pt->n_rows; i++) - for (j = 0; j < pt->n_cols; j++) - { - const int deltaj = i == rm_index; - accum += (pt->mat[j + i * pt->n_cols] - * pow2 ((i == fmj_index[j]) - - deltaj - + v[0] * deltaj)); - } - - ase[1] = sqrt (accum - pt->total * v[0]) / (pt->total - rm); + accum = 0.; + for (j = 0; j < pt->n_cols; j++) + if (rm_index == fmj_index[j]) + accum += fmj[j]; + ase[1] = sqrt ((pt->total - sum_fmj) * (sum_fmj + rm - 2. * accum) + / pow3 (pt->total - rm)); } /* ASE0 for PT given Y. */ @@ -2862,15 +2895,19 @@ calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt, * pow2 (temp0 + (v[0] - 1.) * temp1)); } ase[0] = sqrt (accum1 - 4. * pt->total * v[0] * v[0]) / (2. * pt->total - rm - cm); - t[0] = v[0] / (sqrt (accum0 - pow2 ((sum_fim + sum_fmj - cm - rm) / pt->total)) + t[0] = v[0] / (sqrt (accum0 - pow2 (sum_fim + sum_fmj - cm - rm) / pt->total) / (2. * pt->total - rm - cm)); } + for (i = 0; i < 3; i++) + sig[i] = 2 * gsl_cdf_ugaussian_Q (t[i]); + free (fim); free (fim_index); free (fmj); free (fmj_index); + /* Tau. */ { double sum_fij2_ri, sum_fij2_ci; double sum_ri2, sum_cj2; @@ -2939,8 +2976,7 @@ calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt, v[5] = 2. * ((UX + UY - UXY) / (UX + UY)); ase[5] = (2. / (pt->total * pow2 (UX + UY))) * sqrt (ase1_sym); - t[5] = v[5] / ((2. / (pt->total * (UX + UY))) - * sqrt (P - pow2 (UX + UY - UXY) / pt->total)); + t[5] = SYSMIS; v[6] = (UX + UY - UXY) / UX; ase[6] = sqrt (ase1_xy) / (pt->total * UX * UX); @@ -2970,6 +3006,7 @@ calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt, v[8 + i] = somers_d_v[i]; ase[8 + i] = somers_d_ase[i]; t[8 + i] = somers_d_t[i]; + sig[8 + i] = 2 * gsl_cdf_ugaussian_Q (fabs (somers_d_t[i])); } } }