X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fcrosstabs.q;h=6adae77b030a674e81035da71ea6dd245652f828;hb=f219320996e359b41708a94059e5f27a45926bf6;hp=f75e249e8fdd3bba0363a9a26240aedd30ad16e3;hpb=ca5f6bb9df6d4019d777b52da0419d917d4dfc52;p=pspp diff --git a/src/language/stats/crosstabs.q b/src/language/stats/crosstabs.q index f75e249e8f..6adae77b03 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, 2010 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012, 2013 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,34 +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 "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) @@ -74,8 +74,7 @@ +variables=custom; missing=miss:!table/include/report; +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, @@ -124,6 +123,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. */ @@ -163,17 +163,13 @@ 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; @@ -186,6 +182,7 @@ struct crosstabs_proc /* Variables specifies on VARIABLES. */ const struct variable **variables; size_t n_variables; + struct hmap var_ranges; /* TABLES. */ struct pivot_table *pivots; @@ -198,8 +195,13 @@ struct crosstabs_proc /* STATISTICS. */ unsigned int statistics; /* Bit k is 1 if statistic k is requested. */ + + bool descending; /* True if descending sort order is requested. */ }; +const struct var_range *get_var_range (const struct crosstabs_proc *, + const struct variable *); + 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 *, @@ -214,6 +216,7 @@ 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; @@ -227,8 +230,10 @@ cmd_crosstabs (struct lexer *lexer, struct dataset *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)) @@ -239,6 +244,9 @@ cmd_crosstabs (struct lexer *lexer, struct dataset *ds) proc.mode = proc.n_variables ? INTEGER : GENERAL; + + proc.descending = cmd.val == CRS_DVALUE; + /* CELLS. */ if (!cmd.sbc_cells) proc.cells = 1u << CRS_CL_COUNT; @@ -284,11 +292,11 @@ cmd_crosstabs (struct lexer *lexer, struct dataset *ds) 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; + proc.exclude = MV_ANY; } /* PIVOT. */ @@ -341,6 +349,12 @@ cmd_crosstabs (struct lexer *lexer, struct dataset *ds) 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); @@ -375,10 +389,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, @@ -406,7 +420,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 @@ -422,6 +436,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; @@ -467,7 +482,7 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds, return 0; } - lex_match (lexer, '='); + lex_match (lexer, T_EQUALS); for (;;) { @@ -482,19 +497,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; @@ -507,23 +518,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->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; } @@ -538,6 +549,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) @@ -546,7 +573,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; @@ -648,8 +675,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, @@ -677,7 +707,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); @@ -706,12 +737,25 @@ postcalc (struct crosstabs_proc *proc) 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_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 (i = 0; i < pt->n_entries; i++) free (pt->entries[i]); free (pt->entries); @@ -787,6 +831,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) { @@ -899,9 +950,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) { @@ -913,7 +962,26 @@ 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); @@ -939,7 +1007,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)))) @@ -1133,7 +1201,7 @@ create_crosstab_table (struct crosstabs_proc *proc, struct pivot_table *pt) /* First header line. */ 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_CENTER | TAT_TITLE, var_to_string (x.vars[COL_VAR])); tab_hline (table, TAL_1, x.n_consts + 1, x.n_consts + 2 + x.n_cols - 2, 1); @@ -1144,7 +1212,7 @@ create_crosstab_table (struct crosstabs_proc *proc, struct pivot_table *pt) 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])); + 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]); @@ -1159,25 +1227,20 @@ create_crosstab_table (struct crosstabs_proc *proc, struct pivot_table *pt) { if (i) ds_put_cstr (&title, " * "); - ds_put_cstr (&title, var_get_name (x.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); + /* 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); + 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, " ["); @@ -1215,10 +1278,10 @@ create_chisq_table (struct pivot_table *pt) tab_text (chisq, 2, 0, TAB_RIGHT | TAT_TITLE, _("df")); tab_text (chisq, 3, 0, TAB_RIGHT | TAT_TITLE, _("Asymp. Sig. (2-tailed)")); - tab_text (chisq, 4, 0, TAB_RIGHT | TAT_TITLE, - _("Exact Sig. (2-tailed)")); - tab_text (chisq, 5, 0, TAB_RIGHT | TAT_TITLE, - _("Exact Sig. (1-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; @@ -1385,18 +1448,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; @@ -1437,7 +1510,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); } } @@ -1462,7 +1537,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); } } @@ -1490,14 +1565,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) @@ -1721,7 +1795,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++) { @@ -1798,7 +1872,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++) { @@ -1843,7 +1917,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++) { @@ -1860,10 +1934,10 @@ 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; @@ -1871,10 +1945,10 @@ display_risk (struct pivot_table *pt, struct tab_table *risk) case 2: if (var_is_numeric (rv)) sprintf (buf, _("For cohort %s = %g"), - var_get_name (rv), pt->rows[i - 1].f); + var_to_string (rv), 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; } @@ -1968,7 +2042,7 @@ display_directional (struct crosstabs_proc *proc, struct pivot_table *pt, if (!calc_directional (proc, pt, direct_v, direct_ase, direct_t)) 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++) { @@ -1992,9 +2066,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); @@ -2016,16 +2090,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; } @@ -2034,11 +2109,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. */ @@ -2056,6 +2131,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); @@ -2069,13 +2145,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 @@ -2160,8 +2244,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. */