CROSSTABS: Drop buggy ASE for asymmetric lambda; fix T for symmetric lambda.
[pspp] / src / language / stats / crosstabs.q
index be096bc4056d0c155242b53e1c153494dd4786fb..21947ee45785426476716947b4581cc65ec3fac6 100644 (file)
@@ -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, 2014 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
 
 /* 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.
+   - How to calculate ASE for asymmetric lambda?
    - ASE of Goodman and Kruskal's tau is not calculated.
    - ASE of symmetric somers' d is wrong.
    - Approx. T of uncertainty coefficient is wrong.
 #include <config.h>
 
 #include <ctype.h>
+#include <float.h>
 #include <gsl/gsl_cdf.h>
 #include <stdlib.h>
 #include <stdio.h>
 
-#include <data/case.h>
-#include <data/casegrouper.h>
-#include <data/casereader.h>
-#include <data/data-out.h>
-#include <data/dictionary.h>
-#include <data/format.h>
-#include <data/procedure.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 "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 +73,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 +122,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 +162,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 +181,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;
@@ -202,6 +198,9 @@ struct crosstabs_proc
     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 *,
@@ -216,6 +215,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;
@@ -229,6 +229,7 @@ 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;
@@ -290,11 +291,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;
+      msg (SE, _("Missing mode %s not allowed in general mode.  "
+                "Assuming %s."), "REPORT", "MISSING=TABLE");
+      proc.exclude = MV_ANY;
     }
 
   /* PIVOT. */
@@ -347,6 +348,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);
@@ -381,10 +388,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,6 +435,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;
@@ -469,11 +477,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 (;;)
     {
@@ -488,7 +496,7 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds,
                                    | PV_NO_DUPLICATE | PV_NO_SCRATCH)))
        return 0;
 
-      if (!lex_force_match (lexer, '('))
+      if (!lex_force_match (lexer, T_LPAREN))
          goto lossage;
 
       if (!lex_force_int (lexer))
@@ -496,7 +504,7 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds,
       min = lex_integer (lexer);
       lex_get (lexer);
 
-      lex_match (lexer, ',');
+      lex_match (lexer, T_COMMA);
 
       if (!lex_force_int (lexer))
        goto lossage;
@@ -509,19 +517,23 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds,
        }
       lex_get (lexer);
 
-      if (!lex_force_match (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;
     }
 
@@ -536,6 +548,22 @@ crs_custom_variables (struct lexer *lexer, struct dataset *ds,
 \f
 /* 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)
@@ -544,7 +572,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;
@@ -708,12 +736,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);
@@ -824,6 +865,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"));
@@ -868,8 +910,7 @@ make_summary_table (struct crosstabs_proc *proc)
       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.);
         }
@@ -885,10 +926,10 @@ make_summary_table (struct crosstabs_proc *proc)
 
 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 *,
@@ -908,9 +949,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)
 {
@@ -924,20 +963,39 @@ output_pivot_table (struct crosstabs_proc *proc, struct pivot_table *pt)
 
   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))
@@ -1138,11 +1196,12 @@ create_crosstab_table (struct crosstabs_proc *proc, struct pivot_table *pt)
   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, 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);
@@ -1153,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]);
@@ -1168,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, " [");
@@ -1208,13 +1262,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."));
 
@@ -1235,12 +1290,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."));
 
@@ -1258,13 +1316,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,
@@ -1282,7 +1341,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;
 
@@ -1290,6 +1349,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"));
@@ -1407,13 +1467,15 @@ compare_value_3way_inv (const void *a_, const void *b_, const void *width_)
    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, 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;
 
@@ -1481,7 +1543,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);
     }
 }
 
@@ -1509,14 +1571,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)
@@ -1740,7 +1801,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++)
     {
@@ -1751,22 +1812,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);
@@ -1817,7 +1878,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++)
     {
@@ -1831,17 +1892,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);
@@ -1862,7 +1923,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++)
     {
@@ -1879,34 +1940,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);
@@ -1987,7 +2048,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++)
     {
@@ -2011,9 +2072,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);
@@ -2021,12 +2082,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, normal_sig (direct_v[i]), NULL, RC_PVALUE);*/
       tab_next_row (direct);
     }
 
@@ -2035,16 +2096,17 @@ display_directional (struct crosstabs_proc *proc, struct pivot_table *pt,
 \f
 /* 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;
 }
 
@@ -2053,11 +2115,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. */
@@ -2075,6 +2137,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);
@@ -2088,13 +2151,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
@@ -2179,8 +2250,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. */
@@ -2194,12 +2264,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;
@@ -2237,7 +2307,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;
@@ -2258,7 +2328,7 @@ calc_r (struct pivot_table *pt,
          c = (t - s) - y;
          s = t;
        }
-    *ase_1 = sqrt (s) / (T * T);
+    *error = sqrt (s) / (T * T);
   }
 }
 
@@ -2525,13 +2595,11 @@ 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. */
@@ -2732,22 +2800,8 @@ calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt,
       v[1] = (sum_fmj - rm) / (pt->total - rm);
       v[2] = (sum_fim - cm) / (pt->total - cm);
 
-      /* ASE1 for Y given PT. */
-      {
-       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);
-      }
+      /* XXX We don't have a working formula for ASE1. */
+      ase[2] = SYSMIS;
 
       /* ASE0 for Y given PT. */
       {
@@ -2760,22 +2814,8 @@ calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt,
        t[2] = v[2] / (sqrt (accum - pow2 (sum_fim - cm) / pt->total) / (pt->total - cm));
       }
 
-      /* ASE1 for PT given Y. */
-      {
-       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);
-      }
+      /* XXX We don't have a working formula for ASE1. */
+      ase[1] = SYSMIS;
 
       /* ASE0 for PT given Y. */
       {
@@ -2803,7 +2843,7 @@ 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));
       }