src/language/stats/crosstabs.q

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2009 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 /* FIXME:
  18
  19    - Pearson's R (but not Spearman!) is off a little.
  20    - T values for Spearman's R and Pearson's R are wrong.
  21    - How to calculate significance of symmetric and directional measures?
  22    - Asymmetric ASEs and T values for lambda are wrong.
  23    - ASE of Goodman and Kruskal's tau is not calculated.
  24    - ASE of symmetric somers' d is wrong.
  25    - Approx. T of uncertainty coefficient is wrong.
  26
  27 */
  28
  29 #include <config.h>
  30
  31 #include <ctype.h>
  32 #include <gsl/gsl_cdf.h>
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35
  36 #include <data/case.h>
  37 #include <data/casegrouper.h>
  38 #include <data/casereader.h>
  39 #include <data/data-out.h>
  40 #include <data/dictionary.h>
  41 #include <data/format.h>
  42 #include <data/procedure.h>
  43 #include <data/value-labels.h>
  44 #include <data/variable.h>
  45 #include <language/command.h>
  46 #include <language/dictionary/split-file.h>
  47 #include <language/lexer/lexer.h>
  48 #include <language/lexer/variable-parser.h>
  49 #include <libpspp/array.h>
  50 #include <libpspp/assertion.h>
  51 #include <libpspp/compiler.h>
  52 #include <libpspp/hash.h>
  53 #include <libpspp/hmap.h>
  54 #include <libpspp/hmapx.h>
  55 #include <libpspp/message.h>
  56 #include <libpspp/misc.h>
  57 #include <libpspp/pool.h>
  58 #include <libpspp/str.h>
  59 #include <output/output.h>
  60 #include <output/table.h>
  61
  62 #include "minmax.h"
  63 #include "xalloc.h"
  64 #include "xsize.h"
  65
  66 #include "gettext.h"
  67 #define _(msgid) gettext (msgid)
  68 #define N_(msgid) msgid
  69
  70 /* (headers) */
  71
  72 /* (specification)
  73    crosstabs (crs_):
  74      *^tables=custom;
  75      +variables=custom;
  76      missing=miss:!table/include/report;
  77      +write[wr_]=none,cells,all;
  78      +format=fmt:!labels/nolabels/novallabs,
  79              val:!avalue/dvalue,
  80              indx:!noindex/index,
  81              tabl:!tables/notables,
  82              box:!box/nobox,
  83              pivot:!pivot/nopivot;
  84      +cells[cl_]=count,expected,row,column,total,residual,sresidual,
  85                  asresidual,all,none;
  86      +statistics[st_]=chisq,phi,cc,lambda,uc,none,btau,ctau,risk,gamma,d,
  87                       kappa,eta,corr,all.
  88 */
  89 /* (declarations) */
  90 /* (functions) */
  91
  92 /* Number of chi-square statistics. */
  93 #define N_CHISQ 5
  94
  95 /* Number of symmetric statistics. */
  96 #define N_SYMMETRIC 9
  97
  98 /* Number of directional statistics. */
  99 #define N_DIRECTIONAL 13
 100
 101 /* A single table entry for general mode. */
 102 struct table_entry
 103   {
 104     struct hmap_node node;      /* Entry in hash table. */
 105     double freq;                /* Frequency count. */
 106     union value values[1];      /* Values. */
 107   };
 108
 109 static size_t
 110 table_entry_size (size_t n_values)
 111 {
 112   return (offsetof (struct table_entry, values)
 113           + n_values * sizeof (union value));
 114 }
 115
 116 /* Indexes into the 'vars' member of struct pivot_table and
 117    struct crosstab member. */
 118 enum
 119   {
 120     ROW_VAR = 0,                /* Row variable. */
 121     COL_VAR = 1                 /* Column variable. */
 122     /* Higher indexes cause multiple tables to be output. */
 123   };
 124
 125 /* A crosstabulation of 2 or more variables. */
 126 struct pivot_table
 127   {
 128     struct fmt_spec weight_format; /* Format for weight variable. */
 129     double missing;             /* Weight of missing cases. */
 130
 131     /* Variables (2 or more). */
 132     int n_vars;
 133     const struct variable **vars;
 134
 135     /* Constants (0 or more). */
 136     int n_consts;
 137     const struct variable **const_vars;
 138     union value *const_values;
 139
 140     /* Data. */
 141     struct hmap data;
 142     struct table_entry **entries;
 143     size_t n_entries;
 144
 145     /* Column values, number of columns. */
 146     union value *cols;
 147     int n_cols;
 148
 149     /* Row values, number of rows. */
 150     union value *rows;
 151     int n_rows;
 152
 153     /* Number of statistically interesting columns/rows
 154        (columns/rows with data in them). */
 155     int ns_cols, ns_rows;
 156
 157     /* Matrix contents. */
 158     double *mat;                /* Matrix proper. */
 159     double *row_tot;            /* Row totals. */
 160     double *col_tot;            /* Column totals. */
 161     double total;               /* Grand total. */
 162   };
 163
 164 /* A crosstabulation of exactly 2 variables, conditional on zero
 165    or more other variables having given values. */
 166 struct crosstab
 167   {
 168     /* Case counts. */
 169     double missing;
 170
 171     /* Variables. */
 172     int n_vars;                 /* Number of variables (at least 2). */
 173     const struct variable **vars;
 174     union value *values;       /* Values of variables beyond 2. */
 175
 176     /* Data. */
 177     struct table_entry **entries;
 178     size_t n_entries;
 179
 180     /* Column values, number of columns. */
 181     union value *cols;
 182     int n_cols;
 183
 184     /* Row values, number of rows. */
 185     union value *rows;
 186     int n_rows;
 187
 188     /* Number of statistically interesting columns/rows
 189        (columns/rows with data in them). */
 190     int ns_cols, ns_rows;
 191
 192     /* Matrix contents. */
 193     double *mat;                /* Matrix proper. */
 194     double *row_tot;            /* Row totals. */
 195     double *col_tot;            /* Column totals. */
 196     double total;               /* Grand total. */
 197   };
 198
 199 /* Integer mode variable info. */
 200 struct var_range
 201   {
 202     int min;                    /* Minimum value. */
 203     int max;                    /* Maximum value + 1. */
 204     int count;                  /* max - min. */
 205   };
 206
 207 static inline struct var_range *
 208 get_var_range (const struct variable *v)
 209 {
 210   return var_get_aux (v);
 211 }
 212
 213 struct crosstabs_proc
 214   {
 215     enum { INTEGER, GENERAL } mode;
 216     enum mv_class exclude;
 217     bool pivot;
 218     bool bad_warn;
 219     struct fmt_spec weight_format;
 220
 221     /* Variables specifies on VARIABLES. */
 222     const struct variable **variables;
 223     size_t n_variables;
 224
 225     /* TABLES. */
 226     struct pivot_table *pivots;
 227     int n_pivots;
 228
 229     /* CELLS. */
 230     int n_cells;                /* Number of cells requested. */
 231     unsigned int cells;         /* Bit k is 1 if cell k is requested. */
 232     int a_cells[CRS_CL_count];  /* 0...n_cells-1 are the requested cells. */
 233
 234     /* STATISTICS. */
 235     unsigned int statistics;    /* Bit k is 1 if statistic k is requested. */
 236   };
 237
 238 static void
 239 init_proc (struct crosstabs_proc *proc, struct dataset *ds)
 240 {
 241   const struct variable *wv = dict_get_weight (dataset_dict (ds));
 242   proc->bad_warn = true;
 243   proc->variables = NULL;
 244   proc->n_variables = 0;
 245   proc->pivots = NULL;
 246   proc->n_pivots = 0;
 247   proc->weight_format = wv ? *var_get_print_format (wv) : F_8_0;
 248 }
 249
 250 static void
 251 free_proc (struct crosstabs_proc *proc)
 252 {
 253   struct pivot_table *pt;
 254
 255   free (proc->variables);
 256   for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
 257     {
 258       free (pt->vars);
 259       free (pt->const_vars);
 260       /* We must not call value_destroy on const_values because
 261          it is a wild pointer; it never pointed to anything owned
 262          by the pivot_table.
 263
 264          The rest of the data was allocated and destroyed at a
 265          lower level already. */
 266       free (pt);
 267     }
 268 }
 269
 270 static int internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds,
 271                                    struct crosstabs_proc *);
 272 static bool should_tabulate_case (const struct pivot_table *,
 273                                   const struct ccase *, enum mv_class exclude);
 274 static void tabulate_general_case (struct pivot_table *, const struct ccase *,
 275                                    double weight);
 276 static void tabulate_integer_case (struct pivot_table *, const struct ccase *,
 277                                    double weight);
 278 static void postcalc (struct crosstabs_proc *);
 279 static void submit (struct crosstabs_proc *, struct pivot_table *,
 280                     struct tab_table *);
 281
 282 /* Parse and execute CROSSTABS, then clean up. */
 283 int
 284 cmd_crosstabs (struct lexer *lexer, struct dataset *ds)
 285 {
 286   struct crosstabs_proc proc;
 287   int result;
 288
 289   init_proc (&proc, ds);
 290   result = internal_cmd_crosstabs (lexer, ds, &proc);
 291   free_proc (&proc);
 292
 293   return result;
 294 }
 295
 296 /* Parses and executes the CROSSTABS procedure. */
 297 static int
 298 internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds,
 299                         struct crosstabs_proc *proc)
 300 {
 301   struct casegrouper *grouper;
 302   struct casereader *input, *group;
 303   struct cmd_crosstabs cmd;
 304   struct pivot_table *pt;
 305   bool ok;
 306   int i;
 307
 308   if (!parse_crosstabs (lexer, ds, &cmd, proc))
 309     return CMD_FAILURE;
 310
 311   proc->mode = proc->n_variables ? INTEGER : GENERAL;
 312
 313   /* CELLS. */
 314   if (!cmd.sbc_cells)
 315     proc->cells = 1u << CRS_CL_COUNT;
 316   else if (cmd.a_cells[CRS_CL_ALL])
 317     proc->cells = UINT_MAX;
 318   else
 319     {
 320       proc->cells = 0;
 321       for (i = 0; i < CRS_CL_count; i++)
 322         if (cmd.a_cells[i])
 323           proc->cells |= 1u << i;
 324       if (proc->cells == 0)
 325         proc->cells = ((1u << CRS_CL_COUNT)
 326                        | (1u << CRS_CL_ROW)
 327                        | (1u << CRS_CL_COLUMN)
 328                        | (1u << CRS_CL_TOTAL));
 329     }
 330   proc->cells &= ((1u << CRS_CL_count) - 1);
 331   proc->cells &= ~((1u << CRS_CL_NONE) | (1u << CRS_CL_ALL));
 332   proc->n_cells = 0;
 333   for (i = 0; i < CRS_CL_count; i++)
 334     if (proc->cells & (1u << i))
 335       proc->a_cells[proc->n_cells++] = i;
 336
 337   /* STATISTICS. */
 338   if (cmd.a_statistics[CRS_ST_ALL])
 339     proc->statistics = UINT_MAX;
 340   else if (cmd.sbc_statistics)
 341     {
 342       int i;
 343
 344       proc->statistics = 0;
 345       for (i = 0; i < CRS_ST_count; i++)
 346         if (cmd.a_statistics[i])
 347           proc->statistics |= 1u << i;
 348       if (proc->statistics == 0)
 349         proc->statistics |= 1u << CRS_ST_CHISQ;
 350     }
 351   else
 352     proc->statistics = 0;
 353
 354   /* MISSING. */
 355   proc->exclude = (cmd.miss == CRS_TABLE ? MV_ANY
 356                    : cmd.miss == CRS_INCLUDE ? MV_SYSTEM
 357                    : MV_NEVER);
 358   if (proc->mode == GENERAL && proc->mode == MV_NEVER)
 359     {
 360       msg (SE, _("Missing mode REPORT not allowed in general mode.  "
 361                  "Assuming MISSING=TABLE."));
 362       proc->mode = MV_ANY;
 363     }
 364
 365   /* PIVOT. */
 366   proc->pivot = cmd.pivot == CRS_PIVOT;
 367
 368   input = casereader_create_filter_weight (proc_open (ds), dataset_dict (ds),
 369                                            NULL, NULL);
 370   grouper = casegrouper_create_splits (input, dataset_dict (ds));
 371   while (casegrouper_get_next_group (grouper, &group))
 372     {
 373       struct ccase *c;
 374
 375       /* Output SPLIT FILE variables. */
 376       c = casereader_peek (group, 0);
 377       if (c != NULL)
 378         {
 379           output_split_file_values (ds, c);
 380           case_unref (c);
 381         }
 382
 383       /* Tabulate. */
 384       for (; (c = casereader_read (group)) != NULL; case_unref (c))
 385         for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
 386           {
 387             double weight = dict_get_case_weight (dataset_dict (ds), c,
 388                                                   &proc->bad_warn);
 389             if (should_tabulate_case (pt, c, proc->exclude))
 390               {
 391                 if (proc->mode == GENERAL)
 392                   tabulate_general_case (pt, c, weight);
 393                 else
 394                   tabulate_integer_case (pt, c, weight);
 395               }
 396             else
 397               pt->missing += weight;
 398           }
 399       casereader_destroy (group);
 400
 401       /* Output. */
 402       postcalc (proc);
 403     }
 404   ok = casegrouper_destroy (grouper);
 405   ok = proc_commit (ds) && ok;
 406
 407   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
 408 }
 409
 410 /* Parses the TABLES subcommand. */
 411 static int
 412 crs_custom_tables (struct lexer *lexer, struct dataset *ds,
 413                    struct cmd_crosstabs *cmd UNUSED, void *proc_)
 414 {
 415   struct crosstabs_proc *proc = proc_;
 416   struct const_var_set *var_set;
 417   int n_by;
 418   const struct variable ***by = NULL;
 419   int *by_iter;
 420   size_t *by_nvar = NULL;
 421   size_t nx = 1;
 422   bool ok = false;
 423   int i;
 424
 425   /* Ensure that this is a TABLES subcommand. */
 426   if (!lex_match_id (lexer, "TABLES")
 427       && (lex_token (lexer) != T_ID ||
 428           dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)
 429       && lex_token (lexer) != T_ALL)
 430     return 2;
 431   lex_match (lexer, '=');
 432
 433   if (proc->variables != NULL)
 434     var_set = const_var_set_create_from_array (proc->variables,
 435                                                proc->n_variables);
 436   else
 437     var_set = const_var_set_create_from_dict (dataset_dict (ds));
 438   assert (var_set != NULL);
 439
 440   for (n_by = 0; ;)
 441     {
 442       by = xnrealloc (by, n_by + 1, sizeof *by);
 443       by_nvar = xnrealloc (by_nvar, n_by + 1, sizeof *by_nvar);
 444       if (!parse_const_var_set_vars (lexer, var_set, &by[n_by], &by_nvar[n_by],
 445                                      PV_NO_DUPLICATE | PV_NO_SCRATCH))
 446         goto done;
 447       if (xalloc_oversized (nx, by_nvar[n_by]))
 448         {
 449           msg (SE, _("Too many cross-tabulation variables or dimensions."));
 450           goto done;
 451         }
 452       nx *= by_nvar[n_by];
 453       n_by++;
 454
 455       if (!lex_match (lexer, T_BY))
 456         {
 457           if (n_by < 2)
 458             {
 459               lex_error (lexer, _("expecting BY"));
 460               goto done;
 461             }
 462           else
 463             break;
 464         }
 465     }
 466
 467   by_iter = xcalloc (n_by, sizeof *by_iter);
 468   proc->pivots = xnrealloc (proc->pivots,
 469                             proc->n_pivots + nx, sizeof *proc->pivots);
 470   for (i = 0; i < nx; i++)
 471     {
 472       struct pivot_table *pt = &proc->pivots[proc->n_pivots++];
 473       int j;
 474
 475       pt->weight_format = proc->weight_format;
 476       pt->missing = 0.;
 477       pt->n_vars = n_by;
 478       pt->vars = xmalloc (n_by * sizeof *pt->vars);
 479       pt->n_consts = 0;
 480       pt->const_vars = NULL;
 481       pt->const_values = NULL;
 482       hmap_init (&pt->data);
 483       pt->entries = NULL;
 484       pt->n_entries = 0;
 485
 486       for (j = 0; j < n_by; j++)
 487         pt->vars[j] = by[j][by_iter[j]];
 488
 489       for (j = n_by - 1; j >= 0; j--)
 490         {
 491           if (++by_iter[j] < by_nvar[j])
 492             break;
 493           by_iter[j] = 0;
 494         }
 495     }
 496   free (by_iter);
 497   ok = true;
 498
 499 done:
 500   /* All return paths lead here. */
 501   for (i = 0; i < n_by; i++)
 502     free (by[i]);
 503   free (by);
 504   free (by_nvar);
 505
 506   const_var_set_destroy (var_set);
 507
 508   return ok;
 509 }
 510
 511 /* Parses the VARIABLES subcommand. */
 512 static int
 513 crs_custom_variables (struct lexer *lexer, struct dataset *ds,
 514                       struct cmd_crosstabs *cmd UNUSED, void *proc_)
 515 {
 516   struct crosstabs_proc *proc = proc_;
 517   if (proc->n_pivots)
 518     {
 519       msg (SE, _("VARIABLES must be specified before TABLES."));
 520       return 0;
 521     }
 522
 523   lex_match (lexer, '=');
 524
 525   for (;;)
 526     {
 527       size_t orig_nv = proc->n_variables;
 528       size_t i;
 529
 530       long min, max;
 531
 532       if (!parse_variables_const (lexer, dataset_dict (ds),
 533                                   &proc->variables, &proc->n_variables,
 534                                   (PV_APPEND | PV_NUMERIC
 535                                    | PV_NO_DUPLICATE | PV_NO_SCRATCH)))
 536         return 0;
 537
 538       if (lex_token (lexer) != '(')
 539         {
 540           lex_error (lexer, "expecting `('");
 541           goto lossage;
 542         }
 543       lex_get (lexer);
 544
 545       if (!lex_force_int (lexer))
 546         goto lossage;
 547       min = lex_integer (lexer);
 548       lex_get (lexer);
 549
 550       lex_match (lexer, ',');
 551
 552       if (!lex_force_int (lexer))
 553         goto lossage;
 554       max = lex_integer (lexer);
 555       if (max < min)
 556         {
 557           msg (SE, _("Maximum value (%ld) less than minimum value (%ld)."),
 558                max, min);
 559           goto lossage;
 560         }
 561       lex_get (lexer);
 562
 563       if (lex_token (lexer) != ')')
 564         {
 565           lex_error (lexer, "expecting `)'");
 566           goto lossage;
 567         }
 568       lex_get (lexer);
 569
 570       for (i = orig_nv; i < proc->n_variables; i++)
 571         {
 572           struct var_range *vr = xmalloc (sizeof *vr);
 573           vr->min = min;
 574           vr->max = max + 1.;
 575           vr->count = max - min + 1;
 576           var_attach_aux (proc->variables[i], vr, var_dtor_free);
 577         }
 578
 579       if (lex_token (lexer) == '/')
 580         break;
 581     }
 582
 583   return 1;
 584
 585  lossage:
 586   free (proc->variables);
 587   proc->variables = NULL;
 588   proc->n_variables = 0;
 589   return 0;
 590 }
 591 \f
 592 /* Data file processing. */
 593
 594 static bool
 595 should_tabulate_case (const struct pivot_table *pt, const struct ccase *c,
 596                       enum mv_class exclude)
 597 {
 598   int j;
 599   for (j = 0; j < pt->n_vars; j++)
 600     {
 601       const struct variable *var = pt->vars[j];
 602       struct var_range *range = get_var_range (var);
 603
 604       if (var_is_value_missing (var, case_data (c, var), exclude))
 605         return false;
 606
 607       if (range != NULL)
 608         {
 609           double num = case_num (c, var);
 610           if (num < range->min || num > range->max)
 611             return false;
 612         }
 613     }
 614   return true;
 615 }
 616
 617 static void
 618 tabulate_integer_case (struct pivot_table *pt, const struct ccase *c,
 619                        double weight)
 620 {
 621   struct table_entry *te;
 622   size_t hash;
 623   int j;
 624
 625   hash = 0;
 626   for (j = 0; j < pt->n_vars; j++)
 627     {
 628       /* Throw away fractional parts of values. */
 629       hash = hash_int (case_num (c, pt->vars[j]), hash);
 630     }
 631
 632   HMAP_FOR_EACH_WITH_HASH (te, struct table_entry, node, hash, &pt->data)
 633     {
 634       for (j = 0; j < pt->n_vars; j++)
 635         if ((int) case_num (c, pt->vars[j]) != (int) te->values[j].f)
 636           goto no_match;
 637
 638       /* Found an existing entry. */
 639       te->freq += weight;
 640       return;
 641
 642     no_match: ;
 643     }
 644
 645   /* No existing entry.  Create a new one. */
 646   te = xmalloc (table_entry_size (pt->n_vars));
 647   te->freq = weight;
 648   for (j = 0; j < pt->n_vars; j++)
 649     te->values[j].f = (int) case_num (c, pt->vars[j]);
 650   hmap_insert (&pt->data, &te->node, hash);
 651 }
 652
 653 static void
 654 tabulate_general_case (struct pivot_table *pt, const struct ccase *c,
 655                        double weight)
 656 {
 657   struct table_entry *te;
 658   size_t hash;
 659   int j;
 660
 661   hash = 0;
 662   for (j = 0; j < pt->n_vars; j++)
 663     {
 664       const struct variable *var = pt->vars[j];
 665       hash = value_hash (case_data (c, var), var_get_width (var), hash);
 666     }
 667
 668   HMAP_FOR_EACH_WITH_HASH (te, struct table_entry, node, hash, &pt->data)
 669     {
 670       for (j = 0; j < pt->n_vars; j++)
 671         {
 672           const struct variable *var = pt->vars[j];
 673           if (!value_equal (case_data (c, var), &te->values[j],
 674                             var_get_width (var)))
 675             goto no_match;
 676         }
 677
 678       /* Found an existing entry. */
 679       te->freq += weight;
 680       return;
 681
 682     no_match: ;
 683     }
 684
 685   /* No existing entry.  Create a new one. */
 686   te = xmalloc (table_entry_size (pt->n_vars));
 687   te->freq = weight;
 688   for (j = 0; j < pt->n_vars; j++)
 689     {
 690       const struct variable *var = pt->vars[j];
 691       int width = var_get_width (var);
 692       value_init (&te->values[j], width);
 693       value_copy (&te->values[j], case_data (c, var), width);
 694     }
 695   hmap_insert (&pt->data, &te->node, hash);
 696 }
 697 \f
 698 /* Post-data reading calculations. */
 699
 700 static int compare_table_entry_vars_3way (const struct table_entry *a,
 701                                           const struct table_entry *b,
 702                                           const struct pivot_table *pt,
 703                                           int idx0, int idx1);
 704 static int compare_table_entry_3way (const void *ap_, const void *bp_,
 705                                      const void *pt_);
 706 static void enum_var_values (const struct pivot_table *, int var_idx,
 707                              union value **valuesp, int *n_values);
 708 static void output_pivot_table (struct crosstabs_proc *,
 709                                 struct pivot_table *);
 710 static void make_pivot_table_subset (struct pivot_table *pt,
 711                                      size_t row0, size_t row1,
 712                                      struct pivot_table *subset);
 713 static void make_summary_table (struct crosstabs_proc *);
 714 static bool find_crosstab (struct pivot_table *, size_t *row0p, size_t *row1p);
 715
 716 static void
 717 postcalc (struct crosstabs_proc *proc)
 718 {
 719   struct pivot_table *pt;
 720
 721   /* Convert hash tables into sorted arrays of entries. */
 722   for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
 723     {
 724       struct table_entry *e;
 725       size_t i;
 726
 727       pt->n_entries = hmap_count (&pt->data);
 728       pt->entries = xnmalloc (pt->n_entries, sizeof *pt->entries);
 729       i = 0;
 730       HMAP_FOR_EACH (e, struct table_entry, node, &pt->data)
 731         pt->entries[i++] = e;
 732       hmap_destroy (&pt->data);
 733
 734       sort (pt->entries, pt->n_entries, sizeof *pt->entries,
 735             compare_table_entry_3way, pt);
 736     }
 737
 738   make_summary_table (proc);
 739
 740   /* Output each pivot table. */
 741   for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
 742     {
 743       if (proc->pivot || pt->n_vars == 2)
 744         output_pivot_table (proc, pt);
 745       else
 746         {
 747           size_t row0 = 0, row1 = 0;
 748           while (find_crosstab (pt, &row0, &row1))
 749             {
 750               struct pivot_table subset;
 751               make_pivot_table_subset (pt, row0, row1, &subset);
 752               output_pivot_table (proc, &subset);
 753             }
 754         }
 755     }
 756
 757   /* Free output and prepare for next split file. */
 758   for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
 759     {
 760       size_t i;
 761
 762       pt->missing = 0.0;
 763
 764       /* Free only the members that were allocated in this
 765          function.  The other pointer members are either both
 766          allocated and destroyed at a lower level (in
 767          output_pivot_table), or both allocated and destroyed at
 768          a higher level (in crs_custom_tables and free_proc,
 769          respectively). */
 770       for (i = 0; i < pt->n_entries; i++)
 771         free (pt->entries[i]);
 772       free (pt->entries);
 773     }
 774 }
 775
 776 static void
 777 make_pivot_table_subset (struct pivot_table *pt, size_t row0, size_t row1,
 778                          struct pivot_table *subset)
 779 {
 780   *subset = *pt;
 781   if (pt->n_vars > 2)
 782     {
 783       assert (pt->n_consts == 0);
 784       subset->missing = pt->missing;
 785       subset->n_vars = 2;
 786       subset->vars = pt->vars;
 787       subset->n_consts = pt->n_vars - 2;
 788       subset->const_vars = pt->vars + 2;
 789       subset->const_values = &pt->entries[row0]->values[2];
 790     }
 791   subset->entries = &pt->entries[row0];
 792   subset->n_entries = row1 - row0;
 793 }
 794
 795 static int
 796 compare_table_entry_var_3way (const struct table_entry *a,
 797                               const struct table_entry *b,
 798                               const struct pivot_table *pt,
 799                               int idx)
 800 {
 801   return value_compare_3way (&a->values[idx], &b->values[idx],
 802                              var_get_width (pt->vars[idx]));
 803 }
 804
 805 static int
 806 compare_table_entry_vars_3way (const struct table_entry *a,
 807                                const struct table_entry *b,
 808                                const struct pivot_table *pt,
 809                                int idx0, int idx1)
 810 {
 811   int i;
 812
 813   for (i = idx1 - 1; i >= idx0; i--)
 814     {
 815       int cmp = compare_table_entry_var_3way (a, b, pt, i);
 816       if (cmp != 0)
 817         return cmp;
 818     }
 819   return 0;
 820 }
 821
 822 /* Compare the struct table_entry at *AP to the one at *BP and
 823    return a strcmp()-type result. */
 824 static int
 825 compare_table_entry_3way (const void *ap_, const void *bp_, const void *pt_)
 826 {
 827   const struct table_entry *const *ap = ap_;
 828   const struct table_entry *const *bp = bp_;
 829   const struct table_entry *a = *ap;
 830   const struct table_entry *b = *bp;
 831   const struct pivot_table *pt = pt_;
 832   int cmp;
 833
 834   cmp = compare_table_entry_vars_3way (a, b, pt, 2, pt->n_vars);
 835   if (cmp != 0)
 836     return cmp;
 837
 838   cmp = compare_table_entry_var_3way (a, b, pt, ROW_VAR);
 839   if (cmp != 0)
 840     return cmp;
 841
 842   return compare_table_entry_var_3way (a, b, pt, COL_VAR);
 843 }
 844
 845 static int
 846 find_first_difference (const struct pivot_table *pt, size_t row)
 847 {
 848   if (row == 0)
 849     return pt->n_vars - 1;
 850   else
 851     {
 852       const struct table_entry *a = pt->entries[row];
 853       const struct table_entry *b = pt->entries[row - 1];
 854       int col;
 855
 856       for (col = pt->n_vars - 1; col >= 0; col--)
 857         if (compare_table_entry_var_3way (a, b, pt, col))
 858           return col;
 859       NOT_REACHED ();
 860     }
 861 }
 862
 863 /* Output a table summarizing the cases processed. */
 864 static void
 865 make_summary_table (struct crosstabs_proc *proc)
 866 {
 867   struct tab_table *summary;
 868   struct pivot_table *pt;
 869   struct string name;
 870   int i;
 871
 872   summary = tab_create (7, 3 + proc->n_pivots, 1);
 873   tab_title (summary, _("Summary."));
 874   tab_headers (summary, 1, 0, 3, 0);
 875   tab_joint_text (summary, 1, 0, 6, 0, TAB_CENTER, _("Cases"));
 876   tab_joint_text (summary, 1, 1, 2, 1, TAB_CENTER, _("Valid"));
 877   tab_joint_text (summary, 3, 1, 4, 1, TAB_CENTER, _("Missing"));
 878   tab_joint_text (summary, 5, 1, 6, 1, TAB_CENTER, _("Total"));
 879   tab_hline (summary, TAL_1, 1, 6, 1);
 880   tab_hline (summary, TAL_1, 1, 6, 2);
 881   tab_vline (summary, TAL_1, 3, 1, 1);
 882   tab_vline (summary, TAL_1, 5, 1, 1);
 883   for (i = 0; i < 3; i++)
 884     {
 885       tab_text (summary, 1 + i * 2, 2, TAB_RIGHT, _("N"));
 886       tab_text (summary, 2 + i * 2, 2, TAB_RIGHT, _("Percent"));
 887     }
 888   tab_offset (summary, 0, 3);
 889
 890   ds_init_empty (&name);
 891   for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
 892     {
 893       double valid;
 894       double n[3];
 895       size_t i;
 896
 897       tab_hline (summary, TAL_1, 0, 6, 0);
 898
 899       ds_clear (&name);
 900       for (i = 0; i < pt->n_vars; i++)
 901         {
 902           if (i > 0)
 903             ds_put_cstr (&name, " * ");
 904           ds_put_cstr (&name, var_to_string (pt->vars[i]));
 905         }
 906       tab_text (summary, 0, 0, TAB_LEFT, ds_cstr (&name));
 907
 908       valid = 0.;
 909       for (i = 0; i < pt->n_entries; i++)
 910         valid += pt->entries[i]->freq;
 911
 912       n[0] = valid;
 913       n[1] = pt->missing;
 914       n[2] = n[0] + n[1];
 915       for (i = 0; i < 3; i++)
 916         {
 917           tab_double (summary, i * 2 + 1, 0, TAB_RIGHT, n[i],
 918                       &proc->weight_format);
 919           tab_text (summary, i * 2 + 2, 0, TAB_RIGHT | TAT_PRINTF, "%.1f%%",
 920                     n[i] / n[2] * 100.);
 921         }
 922
 923       tab_next_row (summary);
 924     }
 925   ds_destroy (&name);
 926
 927   submit (proc, NULL, summary);
 928 }
 929 \f
 930 /* Output. */
 931
 932 static struct tab_table *create_crosstab_table (struct crosstabs_proc *,
 933                                                 struct pivot_table *);
 934 static struct tab_table *create_chisq_table (struct pivot_table *);
 935 static struct tab_table *create_sym_table (struct pivot_table *);
 936 static struct tab_table *create_risk_table (struct pivot_table *);
 937 static struct tab_table *create_direct_table (struct pivot_table *);
 938 static void display_dimensions (struct crosstabs_proc *, struct pivot_table *,
 939                                 struct tab_table *, int first_difference);
 940 static void display_crosstabulation (struct crosstabs_proc *,
 941                                      struct pivot_table *,
 942                                      struct tab_table *);
 943 static void display_chisq (struct pivot_table *, struct tab_table *,
 944                            bool *showed_fisher);
 945 static void display_symmetric (struct crosstabs_proc *, struct pivot_table *,
 946                                struct tab_table *);
 947 static void display_risk (struct pivot_table *, struct tab_table *);
 948 static void display_directional (struct crosstabs_proc *, struct pivot_table *,
 949                                  struct tab_table *);
 950 static void crosstabs_dim (struct tab_table *, struct outp_driver *,
 951                            void *proc);
 952 static void table_value_missing (struct crosstabs_proc *proc,
 953                                  struct tab_table *table, int c, int r,
 954                                  unsigned char opt, const union value *v,
 955                                  const struct variable *var);
 956 static void delete_missing (struct pivot_table *);
 957 static void build_matrix (struct pivot_table *);
 958
 959 /* Output pivot table beginning at PB and continuing until PE,
 960    exclusive.  For efficiency, *MATP is a pointer to a matrix that can
 961    hold *MAXROWS entries. */
 962 static void
 963 output_pivot_table (struct crosstabs_proc *proc, struct pivot_table *pt)
 964 {
 965   struct tab_table *table = NULL; /* Crosstabulation table. */
 966   struct tab_table *chisq = NULL; /* Chi-square table. */
 967   bool showed_fisher = false;
 968   struct tab_table *sym = NULL;   /* Symmetric measures table. */
 969   struct tab_table *risk = NULL;  /* Risk estimate table. */
 970   struct tab_table *direct = NULL; /* Directional measures table. */
 971   size_t row0, row1;
 972
 973   enum_var_values (pt, COL_VAR, &pt->cols, &pt->n_cols);
 974
 975   if (proc->cells)
 976     table = create_crosstab_table (proc, pt);
 977   if (proc->statistics & (1u << CRS_ST_CHISQ))
 978     chisq = create_chisq_table (pt);
 979   if (proc->statistics & ((1u << CRS_ST_PHI) | (1u << CRS_ST_CC)
 980                           | (1u << CRS_ST_BTAU) | (1u << CRS_ST_CTAU)
 981                           | (1u << CRS_ST_GAMMA) | (1u << CRS_ST_CORR)
 982                           | (1u << CRS_ST_KAPPA)))
 983     sym = create_sym_table (pt);
 984   if (proc->statistics & (1u << CRS_ST_RISK))
 985     risk = create_risk_table (pt);
 986   if (proc->statistics & ((1u << CRS_ST_LAMBDA) | (1u << CRS_ST_UC)
 987                           | (1u << CRS_ST_D) | (1u << CRS_ST_ETA)))
 988     direct = create_direct_table (pt);
 989
 990   row0 = row1 = 0;
 991   while (find_crosstab (pt, &row0, &row1))
 992     {
 993       struct pivot_table x;
 994       int first_difference;
 995
 996       make_pivot_table_subset (pt, row0, row1, &x);
 997
 998       /* Find all the row variable values. */
 999       enum_var_values (&x, ROW_VAR, &x.rows, &x.n_rows);
1000
1001       if (size_overflow_p (xtimes (xtimes (x.n_rows, x.n_cols),
1002                                    sizeof (double))))
1003         xalloc_die ();
1004       x.row_tot = xmalloc (x.n_rows * sizeof *x.row_tot);
1005       x.col_tot = xmalloc (x.n_cols * sizeof *x.col_tot);
1006       x.mat = xmalloc (x.n_rows * x.n_cols * sizeof *x.mat);
1007
1008       /* Allocate table space for the matrix. */
1009       if (table
1010           && tab_row (table) + (x.n_rows + 1) * proc->n_cells > tab_nr (table))
1011         tab_realloc (table, -1,
1012                      MAX (tab_nr (table) + (x.n_rows + 1) * proc->n_cells,
1013                           tab_nr (table) * pt->n_entries / x.n_entries));
1014
1015       build_matrix (&x);
1016
1017       /* Find the first variable that differs from the last subtable. */
1018       first_difference = find_first_difference (pt, row0);
1019       if (table)
1020         {
1021           display_dimensions (proc, &x, table, first_difference);
1022           display_crosstabulation (proc, &x, table);
1023         }
1024
1025       if (proc->exclude == MV_NEVER)
1026         delete_missing (&x);
1027
1028       if (chisq)
1029         {
1030           display_dimensions (proc, &x, chisq, first_difference);
1031           display_chisq (pt, chisq, &showed_fisher);
1032         }
1033       if (sym)
1034         {
1035           display_dimensions (proc, &x, sym, first_difference);
1036           display_symmetric (proc, pt, sym);
1037         }
1038       if (risk)
1039         {
1040           display_dimensions (proc, &x, risk, first_difference);
1041           display_risk (pt, risk);
1042         }
1043       if (direct)
1044         {
1045           display_dimensions (proc, &x, direct, first_difference);
1046           display_directional (proc, pt, direct);
1047         }
1048
1049       /* Free the parts of x that are not owned by pt.  In
1050          particular we must not free x.cols, which is the same as
1051          pt->cols, which is freed at the end of this function. */
1052       free (x.rows);
1053
1054       free (x.mat);
1055       free (x.row_tot);
1056       free (x.col_tot);
1057     }
1058
1059   submit (proc, NULL, table);
1060
1061   if (chisq)
1062     {
1063       if (!showed_fisher)
1064         tab_resize (chisq, 4 + (pt->n_vars - 2), -1);
1065       submit (proc, pt, chisq);
1066     }
1067
1068   submit (proc, pt, sym);
1069   submit (proc, pt, risk);
1070   submit (proc, pt, direct);
1071
1072   free (pt->cols);
1073 }
1074
1075 static void
1076 build_matrix (struct pivot_table *x)
1077 {
1078   const int col_var_width = var_get_width (x->vars[COL_VAR]);
1079   const int row_var_width = var_get_width (x->vars[ROW_VAR]);
1080   int col, row;
1081   double *mp;
1082   struct table_entry **p;
1083
1084   mp = x->mat;
1085   col = row = 0;
1086   for (p = x->entries; p < &x->entries[x->n_entries]; p++)
1087     {
1088       const struct table_entry *te = *p;
1089
1090       while (!value_equal (&x->rows[row], &te->values[ROW_VAR], row_var_width))
1091         {
1092           for (; col < x->n_cols; col++)
1093             *mp++ = 0.0;
1094           col = 0;
1095           row++;
1096         }
1097
1098       while (!value_equal (&x->cols[col], &te->values[COL_VAR], col_var_width))
1099         {
1100           *mp++ = 0.0;
1101           col++;
1102         }
1103
1104       *mp++ = te->freq;
1105       if (++col >= x->n_cols)
1106         {
1107           col = 0;
1108           row++;
1109         }
1110     }
1111   while (mp < &x->mat[x->n_cols * x->n_rows])
1112     *mp++ = 0.0;
1113   assert (mp == &x->mat[x->n_cols * x->n_rows]);
1114
1115   /* Column totals, row totals, ns_rows. */
1116   mp = x->mat;
1117   for (col = 0; col < x->n_cols; col++)
1118     x->col_tot[col] = 0.0;
1119   for (row = 0; row < x->n_rows; row++)
1120     x->row_tot[row] = 0.0;
1121   x->ns_rows = 0;
1122   for (row = 0; row < x->n_rows; row++)
1123     {
1124       bool row_is_empty = true;
1125       for (col = 0; col < x->n_cols; col++)
1126         {
1127           if (*mp != 0.0)
1128             {
1129               row_is_empty = false;
1130               x->col_tot[col] += *mp;
1131               x->row_tot[row] += *mp;
1132             }
1133           mp++;
1134         }
1135       if (!row_is_empty)
1136         x->ns_rows++;
1137     }
1138   assert (mp == &x->mat[x->n_cols * x->n_rows]);
1139
1140   /* ns_cols. */
1141   x->ns_cols = 0;
1142   for (col = 0; col < x->n_cols; col++)
1143     for (row = 0; row < x->n_rows; row++)
1144       if (x->mat[col + row * x->n_cols] != 0.0)
1145         {
1146           x->ns_cols++;
1147           break;
1148         }
1149
1150   /* Grand total. */
1151   x->total = 0.0;
1152   for (col = 0; col < x->n_cols; col++)
1153     x->total += x->col_tot[col];
1154 }
1155
1156 static struct tab_table *
1157 create_crosstab_table (struct crosstabs_proc *proc, struct pivot_table *pt)
1158 {
1159   struct tuple
1160     {
1161       int value;
1162       const char *name;
1163     };
1164   static const struct tuple names[] =
1165     {
1166       {CRS_CL_COUNT, N_("count")},
1167       {CRS_CL_ROW, N_("row %")},
1168       {CRS_CL_COLUMN, N_("column %")},
1169       {CRS_CL_TOTAL, N_("total %")},
1170       {CRS_CL_EXPECTED, N_("expected")},
1171       {CRS_CL_RESIDUAL, N_("residual")},
1172       {CRS_CL_SRESIDUAL, N_("std. resid.")},
1173       {CRS_CL_ASRESIDUAL, N_("adj. resid.")},
1174     };
1175   const int n_names = sizeof names / sizeof *names;
1176   const struct tuple *t;
1177
1178   struct tab_table *table;
1179   struct string title;
1180   int i;
1181
1182   table = tab_create (pt->n_consts + 1 + pt->n_cols + 1,
1183                       (pt->n_entries / pt->n_cols) * 3 / 2 * proc->n_cells + 10,
1184                       true);
1185   tab_headers (table, pt->n_consts + 1, 0, 2, 0);
1186
1187   /* First header line. */
1188   tab_joint_text (table, pt->n_consts + 1, 0,
1189                   (pt->n_consts + 1) + (pt->n_cols - 1), 0,
1190                   TAB_CENTER | TAT_TITLE, var_get_name (pt->vars[COL_VAR]));
1191
1192   tab_hline (table, TAL_1, pt->n_consts + 1,
1193              pt->n_consts + 2 + pt->n_cols - 2, 1);
1194
1195   /* Second header line. */
1196   for (i = 2; i < pt->n_consts + 2; i++)
1197     tab_joint_text (table, pt->n_consts + 2 - i - 1, 0,
1198                     pt->n_consts + 2 - i - 1, 1,
1199                     TAB_RIGHT | TAT_TITLE, var_to_string (pt->vars[i]));
1200   tab_text (table, pt->n_consts + 2 - 2, 1, TAB_RIGHT | TAT_TITLE,
1201             var_get_name (pt->vars[ROW_VAR]));
1202   for (i = 0; i < pt->n_cols; i++)
1203     table_value_missing (proc, table, pt->n_consts + 2 + i - 1, 1, TAB_RIGHT,
1204                          &pt->cols[i], pt->vars[COL_VAR]);
1205   tab_text (table, pt->n_consts + 2 + pt->n_cols - 1, 1, TAB_CENTER, _("Total"));
1206
1207   tab_hline (table, TAL_1, 0, pt->n_consts + 2 + pt->n_cols - 1, 2);
1208   tab_vline (table, TAL_1, pt->n_consts + 2 + pt->n_cols - 1, 0, 1);
1209
1210   /* Title. */
1211   ds_init_empty (&title);
1212   for (i = 0; i < pt->n_consts + 2; i++)
1213     {
1214       if (i)
1215         ds_put_cstr (&title, " * ");
1216       ds_put_cstr (&title, var_get_name (pt->vars[i]));
1217     }
1218   for (i = 0; i < pt->n_consts; i++)
1219     {
1220       const struct variable *var = pt->const_vars[i];
1221       ds_put_format (&title, ", %s=", var_get_name (var));
1222       data_out (&pt->const_values[i], var_get_print_format (var),
1223                 ds_put_uninit (&title, var_get_width (var)));
1224       /* XXX remove any leading space in what was just inserted.  */
1225     }
1226
1227   ds_put_cstr (&title, " [");
1228   i = 0;
1229   for (t = names; t < &names[n_names]; t++)
1230     if (proc->cells & (1u << t->value))
1231       {
1232         if (i++)
1233           ds_put_cstr (&title, ", ");
1234         ds_put_cstr (&title, gettext (t->name));
1235       }
1236   ds_put_cstr (&title, "].");
1237
1238   tab_title (table, "%s", ds_cstr (&title));
1239   ds_destroy (&title);
1240
1241   tab_offset (table, 0, 2);
1242   return table;
1243 }
1244
1245 static struct tab_table *
1246 create_chisq_table (struct pivot_table *pt)
1247 {
1248   struct tab_table *chisq;
1249
1250   chisq = tab_create (6 + (pt->n_vars - 2),
1251                       pt->n_entries / pt->n_cols * 3 / 2 * N_CHISQ + 10,
1252                       1);
1253   tab_headers (chisq, 1 + (pt->n_vars - 2), 0, 1, 0);
1254
1255   tab_title (chisq, _("Chi-square tests."));
1256
1257   tab_offset (chisq, pt->n_vars - 2, 0);
1258   tab_text (chisq, 0, 0, TAB_LEFT | TAT_TITLE, _("Statistic"));
1259   tab_text (chisq, 1, 0, TAB_RIGHT | TAT_TITLE, _("Value"));
1260   tab_text (chisq, 2, 0, TAB_RIGHT | TAT_TITLE, _("df"));
1261   tab_text (chisq, 3, 0, TAB_RIGHT | TAT_TITLE,
1262             _("Asymp. Sig. (2-sided)"));
1263   tab_text (chisq, 4, 0, TAB_RIGHT | TAT_TITLE,
1264             _("Exact. Sig. (2-sided)"));
1265   tab_text (chisq, 5, 0, TAB_RIGHT | TAT_TITLE,
1266             _("Exact. Sig. (1-sided)"));
1267   chisq = 0;
1268   tab_offset (chisq, 0, 1);
1269
1270   return chisq;
1271 }
1272
1273 /* Symmetric measures. */
1274 static struct tab_table *
1275 create_sym_table (struct pivot_table *pt)
1276 {
1277   struct tab_table *sym;
1278
1279   sym = tab_create (6 + (pt->n_vars - 2),
1280                     pt->n_entries / pt->n_cols * 7 + 10, 1);
1281   tab_headers (sym, 2 + (pt->n_vars - 2), 0, 1, 0);
1282   tab_title (sym, _("Symmetric measures."));
1283
1284   tab_offset (sym, pt->n_vars - 2, 0);
1285   tab_text (sym, 0, 0, TAB_LEFT | TAT_TITLE, _("Category"));
1286   tab_text (sym, 1, 0, TAB_LEFT | TAT_TITLE, _("Statistic"));
1287   tab_text (sym, 2, 0, TAB_RIGHT | TAT_TITLE, _("Value"));
1288   tab_text (sym, 3, 0, TAB_RIGHT | TAT_TITLE, _("Asymp. Std. Error"));
1289   tab_text (sym, 4, 0, TAB_RIGHT | TAT_TITLE, _("Approx. T"));
1290   tab_text (sym, 5, 0, TAB_RIGHT | TAT_TITLE, _("Approx. Sig."));
1291   tab_offset (sym, 0, 1);
1292
1293   return sym;
1294 }
1295
1296 /* Risk estimate. */
1297 static struct tab_table *
1298 create_risk_table (struct pivot_table *pt)
1299 {
1300   struct tab_table *risk;
1301
1302   risk = tab_create (4 + (pt->n_vars - 2), pt->n_entries / pt->n_cols * 4 + 10,
1303                      1);
1304   tab_headers (risk, 1 + pt->n_vars - 2, 0, 2, 0);
1305   tab_title (risk, _("Risk estimate."));
1306
1307   tab_offset (risk, pt->n_vars - 2, 0);
1308   tab_joint_text (risk, 2, 0, 3, 0, TAB_CENTER | TAT_TITLE | TAT_PRINTF,
1309                   _("95%% Confidence Interval"));
1310   tab_text (risk, 0, 1, TAB_LEFT | TAT_TITLE, _("Statistic"));
1311   tab_text (risk, 1, 1, TAB_RIGHT | TAT_TITLE, _("Value"));
1312   tab_text (risk, 2, 1, TAB_RIGHT | TAT_TITLE, _("Lower"));
1313   tab_text (risk, 3, 1, TAB_RIGHT | TAT_TITLE, _("Upper"));
1314   tab_hline (risk, TAL_1, 2, 3, 1);
1315   tab_vline (risk, TAL_1, 2, 0, 1);
1316   tab_offset (risk, 0, 2);
1317
1318   return risk;
1319 }
1320
1321 /* Directional measures. */
1322 static struct tab_table *
1323 create_direct_table (struct pivot_table *pt)
1324 {
1325   struct tab_table *direct;
1326
1327   direct = tab_create (7 + (pt->n_vars - 2),
1328                        pt->n_entries / pt->n_cols * 7 + 10, 1);
1329   tab_headers (direct, 3 + (pt->n_vars - 2), 0, 1, 0);
1330   tab_title (direct, _("Directional measures."));
1331
1332   tab_offset (direct, pt->n_vars - 2, 0);
1333   tab_text (direct, 0, 0, TAB_LEFT | TAT_TITLE, _("Category"));
1334   tab_text (direct, 1, 0, TAB_LEFT | TAT_TITLE, _("Statistic"));
1335   tab_text (direct, 2, 0, TAB_LEFT | TAT_TITLE, _("Type"));
1336   tab_text (direct, 3, 0, TAB_RIGHT | TAT_TITLE, _("Value"));
1337   tab_text (direct, 4, 0, TAB_RIGHT | TAT_TITLE, _("Asymp. Std. Error"));
1338   tab_text (direct, 5, 0, TAB_RIGHT | TAT_TITLE, _("Approx. T"));
1339   tab_text (direct, 6, 0, TAB_RIGHT | TAT_TITLE, _("Approx. Sig."));
1340   tab_offset (direct, 0, 1);
1341
1342   return direct;
1343 }
1344
1345
1346 /* Delete missing rows and columns for statistical analysis when
1347    /MISSING=REPORT. */
1348 static void
1349 delete_missing (struct pivot_table *pt)
1350 {
1351   int r, c;
1352
1353   for (r = 0; r < pt->n_rows; r++)
1354     if (var_is_num_missing (pt->vars[ROW_VAR], pt->rows[r].f, MV_USER))
1355       {
1356         for (c = 0; c < pt->n_cols; c++)
1357           pt->mat[c + r * pt->n_cols] = 0.;
1358         pt->ns_rows--;
1359       }
1360
1361
1362   for (c = 0; c < pt->n_cols; c++)
1363     if (var_is_num_missing (pt->vars[COL_VAR], pt->cols[c].f, MV_USER))
1364       {
1365         for (r = 0; r < pt->n_rows; r++)
1366           pt->mat[c + r * pt->n_cols] = 0.;
1367         pt->ns_cols--;
1368       }
1369 }
1370
1371 /* Prepare table T for submission, and submit it. */
1372 static void
1373 submit (struct crosstabs_proc *proc, struct pivot_table *pt,
1374         struct tab_table *t)
1375 {
1376   int i;
1377
1378   if (t == NULL)
1379     return;
1380
1381   tab_resize (t, -1, 0);
1382   if (tab_nr (t) == tab_t (t))
1383     {
1384       tab_destroy (t);
1385       return;
1386     }
1387   tab_offset (t, 0, 0);
1388   if (pt != NULL)
1389     for (i = 2; i < pt->n_vars; i++)
1390       tab_text (t, pt->n_vars - i - 1, 0, TAB_RIGHT | TAT_TITLE,
1391                 var_to_string (pt->vars[i]));
1392   tab_box (t, TAL_2, TAL_2, -1, -1, 0, 0, tab_nc (t) - 1, tab_nr (t) - 1);
1393   tab_box (t, -1, -1, -1, TAL_1, tab_l (t), tab_t (t) - 1, tab_nc (t) - 1,
1394            tab_nr (t) - 1);
1395   tab_box (t, -1, -1, -1, TAL_GAP, 0, tab_t (t), tab_l (t) - 1,
1396            tab_nr (t) - 1);
1397   tab_vline (t, TAL_2, tab_l (t), 0, tab_nr (t) - 1);
1398   tab_dim (t, crosstabs_dim, proc);
1399   tab_submit (t);
1400 }
1401
1402 /* Sets the widths of all the columns and heights of all the rows in
1403    table T for driver D. */
1404 static void
1405 crosstabs_dim (struct tab_table *t, struct outp_driver *d, void *proc_)
1406 {
1407   struct crosstabs_proc *proc = proc_;
1408   int i;
1409
1410   /* Width of a numerical column. */
1411   int c = outp_string_width (d, "0.000000", OUTP_PROPORTIONAL);
1412   if (proc->exclude == MV_NEVER)
1413     c += outp_string_width (d, "M", OUTP_PROPORTIONAL);
1414
1415   /* Set width for header columns. */
1416   if (t->l != 0)
1417     {
1418       size_t i;
1419       int w;
1420
1421       w = d->width - c * (t->nc - t->l);
1422       for (i = 0; i <= t->nc; i++)
1423         w -= t->wrv[i];
1424       w /= t->l;
1425
1426       if (w < d->prop_em_width * 8)
1427         w = d->prop_em_width * 8;
1428
1429       if (w > d->prop_em_width * 15)
1430         w = d->prop_em_width * 15;
1431
1432       for (i = 0; i < t->l; i++)
1433         t->w[i] = w;
1434     }
1435
1436   for (i = t->l; i < t->nc; i++)
1437     t->w[i] = c;
1438
1439   for (i = 0; i < t->nr; i++)
1440     t->h[i] = tab_natural_height (t, d, i);
1441 }
1442
1443 static bool
1444 find_crosstab (struct pivot_table *pt, size_t *row0p, size_t *row1p)
1445 {
1446   size_t row0 = *row1p;
1447   size_t row1;
1448
1449   if (row0 >= pt->n_entries)
1450     return false;
1451
1452   for (row1 = row0 + 1; row1 < pt->n_entries; row1++)
1453     {
1454       struct table_entry *a = pt->entries[row0];
1455       struct table_entry *b = pt->entries[row1];
1456       if (compare_table_entry_vars_3way (a, b, pt, 2, pt->n_vars) != 0)
1457         break;
1458     }
1459   *row0p = row0;
1460   *row1p = row1;
1461   return true;
1462 }
1463
1464 /* Compares `union value's A_ and B_ and returns a strcmp()-like
1465    result.  WIDTH_ points to an int which is either 0 for a
1466    numeric value or a string width for a string value. */
1467 static int
1468 compare_value_3way (const void *a_, const void *b_, const void *width_)
1469 {
1470   const union value *a = a_;
1471   const union value *b = b_;
1472   const int *width = width_;
1473
1474   return value_compare_3way (a, b, *width);
1475 }
1476
1477 /* Given an array of ENTRY_CNT table_entry structures starting at
1478    ENTRIES, creates a sorted list of the values that the variable
1479    with index VAR_IDX takes on.  The values are returned as a
1480    malloc()'d array stored in *VALUES, with the number of values
1481    stored in *VALUE_CNT.
1482    */
1483 static void
1484 enum_var_values (const struct pivot_table *pt, int var_idx,
1485                  union value **valuesp, int *n_values)
1486 {
1487   const struct variable *var = pt->vars[var_idx];
1488   struct var_range *range = get_var_range (var);
1489   union value *values;
1490   size_t i;
1491
1492   if (range)
1493     {
1494       values = *valuesp = xnmalloc (range->count, sizeof *values);
1495       *n_values = range->count;
1496       for (i = 0; i < range->count; i++)
1497         values[i].f = range->min + i;
1498     }
1499   else
1500     {
1501       int width = var_get_width (var);
1502       struct hmapx_node *node;
1503       const union value *iter;
1504       struct hmapx set;
1505
1506       hmapx_init (&set);
1507       for (i = 0; i < pt->n_entries; i++)
1508         {
1509           const struct table_entry *te = pt->entries[i];
1510           const union value *value = &te->values[var_idx];
1511           size_t hash = value_hash (value, width, 0);
1512
1513           HMAPX_FOR_EACH_WITH_HASH (iter, node, hash, &set)
1514             if (value_equal (iter, value, width))
1515               goto next_entry;
1516
1517           hmapx_insert (&set, (union value *) value, hash);
1518
1519         next_entry: ;
1520         }
1521
1522       *n_values = hmapx_count (&set);
1523       values = *valuesp = xnmalloc (*n_values, sizeof *values);
1524       i = 0;
1525       HMAPX_FOR_EACH (iter, node, &set)
1526         values[i++] = *iter;
1527       hmapx_destroy (&set);
1528
1529       sort (values, *n_values, sizeof *values, compare_value_3way, &width);
1530     }
1531 }
1532
1533 /* Sets cell (C,R) in TABLE, with options OPT, to have a value taken
1534    from V, displayed with print format spec from variable VAR.  When
1535    in REPORT missing-value mode, missing values have an M appended. */
1536 static void
1537 table_value_missing (struct crosstabs_proc *proc,
1538                      struct tab_table *table, int c, int r, unsigned char opt,
1539                      const union value *v, const struct variable *var)
1540 {
1541   struct substring s;
1542   const struct fmt_spec *print = var_get_print_format (var);
1543
1544   const char *label = var_lookup_value_label (var, v);
1545   if (label)
1546     {
1547       tab_text (table, c, r, TAB_LEFT, label);
1548       return;
1549     }
1550
1551   s.string = tab_alloc (table, print->w);
1552   data_out (v, print, s.string);
1553   s.length = print->w;
1554   if (proc->exclude == MV_NEVER && var_is_num_missing (var, v->f, MV_USER))
1555     s.string[s.length++] = 'M';
1556   while (s.length && *s.string == ' ')
1557     {
1558       s.length--;
1559       s.string++;
1560     }
1561   tab_raw (table, c, r, opt, &s);
1562 }
1563
1564 /* Draws a line across TABLE at the current row to indicate the most
1565    major dimension variable with index FIRST_DIFFERENCE out of N_VARS
1566    that changed, and puts the values that changed into the table.  TB
1567    and PT must be the corresponding table_entry and crosstab,
1568    respectively. */
1569 static void
1570 display_dimensions (struct crosstabs_proc *proc, struct pivot_table *pt,
1571                     struct tab_table *table, int first_difference)
1572 {
1573   tab_hline (table, TAL_1, pt->n_vars - first_difference - 1, tab_nc (table) - 1, 0);
1574
1575   for (; first_difference >= 2; first_difference--)
1576     table_value_missing (proc, table, pt->n_vars - first_difference - 1, 0,
1577                          TAB_RIGHT, &pt->entries[0]->values[first_difference],
1578                          pt->vars[first_difference]);
1579 }
1580
1581 /* Put VALUE into cell (C,R) of TABLE, suffixed with character
1582    SUFFIX if nonzero.  If MARK_MISSING is true the entry is
1583    additionally suffixed with a letter `M'. */
1584 static void
1585 format_cell_entry (struct tab_table *table, int c, int r, double value,
1586                    char suffix, bool mark_missing)
1587 {
1588   const struct fmt_spec f = {FMT_F, 10, 1};
1589   union value v;
1590   struct substring s;
1591
1592   s.length = 10;
1593   s.string = tab_alloc (table, 16);
1594   v.f = value;
1595   data_out (&v, &f, s.string);
1596   while (*s.string == ' ')
1597     {
1598       s.length--;
1599       s.string++;
1600     }
1601   if (suffix != 0)
1602     s.string[s.length++] = suffix;
1603   if (mark_missing)
1604     s.string[s.length++] = 'M';
1605
1606   tab_raw (table, c, r, TAB_RIGHT, &s);
1607 }
1608
1609 /* Displays the crosstabulation table. */
1610 static void
1611 display_crosstabulation (struct crosstabs_proc *proc, struct pivot_table *pt,
1612                          struct tab_table *table)
1613 {
1614   int last_row;
1615   int r, c, i;
1616   double *mp;
1617
1618   for (r = 0; r < pt->n_rows; r++)
1619     table_value_missing (proc, table, pt->n_vars - 2, r * proc->n_cells,
1620                          TAB_RIGHT, &pt->rows[r], pt->vars[ROW_VAR]);
1621
1622   tab_text (table, pt->n_vars - 2, pt->n_rows * proc->n_cells,
1623             TAB_LEFT, _("Total"));
1624
1625   /* Put in the actual cells. */
1626   mp = pt->mat;
1627   tab_offset (table, pt->n_vars - 1, -1);
1628   for (r = 0; r < pt->n_rows; r++)
1629     {
1630       if (proc->n_cells > 1)
1631         tab_hline (table, TAL_1, -1, pt->n_cols, 0);
1632       for (c = 0; c < pt->n_cols; c++)
1633         {
1634           bool mark_missing = false;
1635           double expected_value = pt->row_tot[r] * pt->col_tot[c] / pt->total;
1636           if (proc->exclude == MV_NEVER
1637               && (var_is_num_missing (pt->vars[COL_VAR], pt->cols[c].f, MV_USER)
1638                   || var_is_num_missing (pt->vars[ROW_VAR], pt->rows[r].f,
1639                                          MV_USER)))
1640             mark_missing = true;
1641           for (i = 0; i < proc->n_cells; i++)
1642             {
1643               double v;
1644               int suffix = 0;
1645
1646               switch (proc->a_cells[i])
1647                 {
1648                 case CRS_CL_COUNT:
1649                   v = *mp;
1650                   break;
1651                 case CRS_CL_ROW:
1652                   v = *mp / pt->row_tot[r] * 100.;
1653                   suffix = '%';
1654                   break;
1655                 case CRS_CL_COLUMN:
1656                   v = *mp / pt->col_tot[c] * 100.;
1657                   suffix = '%';
1658                   break;
1659                 case CRS_CL_TOTAL:
1660                   v = *mp / pt->total * 100.;
1661                   suffix = '%';
1662                   break;
1663                 case CRS_CL_EXPECTED:
1664                   v = expected_value;
1665                   break;
1666                 case CRS_CL_RESIDUAL:
1667                   v = *mp - expected_value;
1668                   break;
1669                 case CRS_CL_SRESIDUAL:
1670                   v = (*mp - expected_value) / sqrt (expected_value);
1671                   break;
1672                 case CRS_CL_ASRESIDUAL:
1673                   v = ((*mp - expected_value)
1674                        / sqrt (expected_value
1675                                * (1. - pt->row_tot[r] / pt->total)
1676                                * (1. - pt->col_tot[c] / pt->total)));
1677                   break;
1678                 default:
1679                   NOT_REACHED ();
1680                 }
1681               format_cell_entry (table, c, i, v, suffix, mark_missing);
1682             }
1683
1684           mp++;
1685         }
1686
1687       tab_offset (table, -1, tab_row (table) + proc->n_cells);
1688     }
1689
1690   /* Row totals. */
1691   tab_offset (table, -1, tab_row (table) - proc->n_cells * pt->n_rows);
1692   for (r = 0; r < pt->n_rows; r++)
1693     {
1694       bool mark_missing = false;
1695
1696       if (proc->exclude == MV_NEVER
1697           && var_is_num_missing (pt->vars[ROW_VAR], pt->rows[r].f, MV_USER))
1698         mark_missing = true;
1699
1700       for (i = 0; i < proc->n_cells; i++)
1701         {
1702           char suffix = 0;
1703           double v;
1704
1705           switch (proc->a_cells[i])
1706             {
1707             case CRS_CL_COUNT:
1708               v = pt->row_tot[r];
1709               break;
1710             case CRS_CL_ROW:
1711               v = 100.0;
1712               suffix = '%';
1713               break;
1714             case CRS_CL_COLUMN:
1715               v = pt->row_tot[r] / pt->total * 100.;
1716               suffix = '%';
1717               break;
1718             case CRS_CL_TOTAL:
1719               v = pt->row_tot[r] / pt->total * 100.;
1720               suffix = '%';
1721               break;
1722             case CRS_CL_EXPECTED:
1723             case CRS_CL_RESIDUAL:
1724             case CRS_CL_SRESIDUAL:
1725             case CRS_CL_ASRESIDUAL:
1726               v = 0.;
1727               break;
1728             default:
1729               NOT_REACHED ();
1730             }
1731
1732           format_cell_entry (table, pt->n_cols, 0, v, suffix, mark_missing);
1733           tab_next_row (table);
1734         }
1735     }
1736
1737   /* Column totals, grand total. */
1738   last_row = 0;
1739   if (proc->n_cells > 1)
1740     tab_hline (table, TAL_1, -1, pt->n_cols, 0);
1741   for (c = 0; c <= pt->n_cols; c++)
1742     {
1743       double ct = c < pt->n_cols ? pt->col_tot[c] : pt->total;
1744       bool mark_missing = false;
1745       int i;
1746
1747       if (proc->exclude == MV_NEVER && c < pt->n_cols
1748           && var_is_num_missing (pt->vars[COL_VAR], pt->cols[c].f, MV_USER))
1749         mark_missing = true;
1750
1751       for (i = 0; i < proc->n_cells; i++)
1752         {
1753           char suffix = 0;
1754           double v;
1755
1756           switch (proc->a_cells[i])
1757             {
1758             case CRS_CL_COUNT:
1759               v = ct;
1760               break;
1761             case CRS_CL_ROW:
1762               v = ct / pt->total * 100.;
1763               suffix = '%';
1764               break;
1765             case CRS_CL_COLUMN:
1766               v = 100.;
1767               suffix = '%';
1768               break;
1769             case CRS_CL_TOTAL:
1770               v = ct / pt->total * 100.;
1771               suffix = '%';
1772               break;
1773             case CRS_CL_EXPECTED:
1774             case CRS_CL_RESIDUAL:
1775             case CRS_CL_SRESIDUAL:
1776             case CRS_CL_ASRESIDUAL:
1777               continue;
1778             default:
1779               NOT_REACHED ();
1780             }
1781
1782           format_cell_entry (table, c, i, v, suffix, mark_missing);
1783         }
1784       last_row = i;
1785     }
1786
1787   tab_offset (table, -1, tab_row (table) + last_row);
1788   tab_offset (table, 0, -1);
1789 }
1790
1791 static void calc_r (struct pivot_table *,
1792                     double *PT, double *Y, double *, double *, double *);
1793 static void calc_chisq (struct pivot_table *,
1794                         double[N_CHISQ], int[N_CHISQ], double *, double *);
1795
1796 /* Display chi-square statistics. */
1797 static void
1798 display_chisq (struct pivot_table *pt, struct tab_table *chisq,
1799                bool *showed_fisher)
1800 {
1801   static const char *chisq_stats[N_CHISQ] =
1802     {
1803       N_("Pearson Chi-Square"),
1804       N_("Likelihood Ratio"),
1805       N_("Fisher's Exact Test"),
1806       N_("Continuity Correction"),
1807       N_("Linear-by-Linear Association"),
1808     };
1809   double chisq_v[N_CHISQ];
1810   double fisher1, fisher2;
1811   int df[N_CHISQ];
1812   int s = 0;
1813
1814   int i;
1815
1816   calc_chisq (pt, chisq_v, df, &fisher1, &fisher2);
1817
1818   tab_offset (chisq, pt->n_vars - 2, -1);
1819
1820   for (i = 0; i < N_CHISQ; i++)
1821     {
1822       if ((i != 2 && chisq_v[i] == SYSMIS)
1823           || (i == 2 && fisher1 == SYSMIS))
1824         continue;
1825       s = 1;
1826
1827       tab_text (chisq, 0, 0, TAB_LEFT, gettext (chisq_stats[i]));
1828       if (i != 2)
1829         {
1830           tab_double (chisq, 1, 0, TAB_RIGHT, chisq_v[i], NULL);
1831           tab_double (chisq, 2, 0, TAB_RIGHT, df[i], &pt->weight_format);
1832           tab_double (chisq, 3, 0, TAB_RIGHT,
1833                      gsl_cdf_chisq_Q (chisq_v[i], df[i]), NULL);
1834         }
1835       else
1836         {
1837           *showed_fisher = true;
1838           tab_double (chisq, 4, 0, TAB_RIGHT, fisher2, NULL);
1839           tab_double (chisq, 5, 0, TAB_RIGHT, fisher1, NULL);
1840         }
1841       tab_next_row (chisq);
1842     }
1843
1844   tab_text (chisq, 0, 0, TAB_LEFT, _("N of Valid Cases"));
1845   tab_double (chisq, 1, 0, TAB_RIGHT, pt->total, &pt->weight_format);
1846   tab_next_row (chisq);
1847
1848   tab_offset (chisq, 0, -1);
1849 }
1850
1851 static int calc_symmetric (struct crosstabs_proc *, struct pivot_table *,
1852                            double[N_SYMMETRIC], double[N_SYMMETRIC],
1853                            double[N_SYMMETRIC],
1854                            double[3], double[3], double[3]);
1855
1856 /* Display symmetric measures. */
1857 static void
1858 display_symmetric (struct crosstabs_proc *proc, struct pivot_table *pt,
1859                    struct tab_table *sym)
1860 {
1861   static const char *categories[] =
1862     {
1863       N_("Nominal by Nominal"),
1864       N_("Ordinal by Ordinal"),
1865       N_("Interval by Interval"),
1866       N_("Measure of Agreement"),
1867     };
1868
1869   static const char *stats[N_SYMMETRIC] =
1870     {
1871       N_("Phi"),
1872       N_("Cramer's V"),
1873       N_("Contingency Coefficient"),
1874       N_("Kendall's tau-b"),
1875       N_("Kendall's tau-c"),
1876       N_("Gamma"),
1877       N_("Spearman Correlation"),
1878       N_("Pearson's R"),
1879       N_("Kappa"),
1880     };
1881
1882   static const int stats_categories[N_SYMMETRIC] =
1883     {
1884       0, 0, 0, 1, 1, 1, 1, 2, 3,
1885     };
1886
1887   int last_cat = -1;
1888   double sym_v[N_SYMMETRIC], sym_ase[N_SYMMETRIC], sym_t[N_SYMMETRIC];
1889   double somers_d_v[3], somers_d_ase[3], somers_d_t[3];
1890   int i;
1891
1892   if (!calc_symmetric (proc, pt, sym_v, sym_ase, sym_t,
1893                        somers_d_v, somers_d_ase, somers_d_t))
1894     return;
1895
1896   tab_offset (sym, pt->n_vars - 2, -1);
1897
1898   for (i = 0; i < N_SYMMETRIC; i++)
1899     {
1900       if (sym_v[i] == SYSMIS)
1901         continue;
1902
1903       if (stats_categories[i] != last_cat)
1904         {
1905           last_cat = stats_categories[i];
1906           tab_text (sym, 0, 0, TAB_LEFT, gettext (categories[last_cat]));
1907         }
1908
1909       tab_text (sym, 1, 0, TAB_LEFT, gettext (stats[i]));
1910       tab_double (sym, 2, 0, TAB_RIGHT, sym_v[i], NULL);
1911       if (sym_ase[i] != SYSMIS)
1912         tab_double (sym, 3, 0, TAB_RIGHT, sym_ase[i], NULL);
1913       if (sym_t[i] != SYSMIS)
1914         tab_double (sym, 4, 0, TAB_RIGHT, sym_t[i], NULL);
1915       /*tab_double (sym, 5, 0, TAB_RIGHT, normal_sig (sym_v[i]), NULL);*/
1916       tab_next_row (sym);
1917     }
1918
1919   tab_text (sym, 0, 0, TAB_LEFT, _("N of Valid Cases"));
1920   tab_double (sym, 2, 0, TAB_RIGHT, pt->total, &pt->weight_format);
1921   tab_next_row (sym);
1922
1923   tab_offset (sym, 0, -1);
1924 }
1925
1926 static int calc_risk (struct pivot_table *,
1927                       double[], double[], double[], union value *);
1928
1929 /* Display risk estimate. */
1930 static void
1931 display_risk (struct pivot_table *pt, struct tab_table *risk)
1932 {
1933   char buf[256];
1934   double risk_v[3], lower[3], upper[3];
1935   union value c[2];
1936   int i;
1937
1938   if (!calc_risk (pt, risk_v, upper, lower, c))
1939     return;
1940
1941   tab_offset (risk, pt->n_vars - 2, -1);
1942
1943   for (i = 0; i < 3; i++)
1944     {
1945       const struct variable *cv = pt->vars[COL_VAR];
1946       const struct variable *rv = pt->vars[ROW_VAR];
1947       int cvw = var_get_width (cv);
1948       int rvw = var_get_width (rv);
1949
1950       if (risk_v[i] == SYSMIS)
1951         continue;
1952
1953       switch (i)
1954         {
1955         case 0:
1956           if (var_is_numeric (cv))
1957             sprintf (buf, _("Odds Ratio for %s (%g / %g)"),
1958                      var_get_name (cv), c[0].f, c[1].f);
1959           else
1960             sprintf (buf, _("Odds Ratio for %s (%.*s / %.*s)"),
1961                      var_get_name (cv),
1962                      cvw, value_str (&c[0], cvw),
1963                      cvw, value_str (&c[1], cvw));
1964           break;
1965         case 1:
1966         case 2:
1967           if (var_is_numeric (rv))
1968             sprintf (buf, _("For cohort %s = %g"),
1969                      var_get_name (rv), pt->rows[i - 1].f);
1970           else
1971             sprintf (buf, _("For cohort %s = %.*s"),
1972                      var_get_name (rv),
1973                      rvw, value_str (&pt->rows[i - 1], rvw));
1974           break;
1975         }
1976
1977       tab_text (risk, 0, 0, TAB_LEFT, buf);
1978       tab_double (risk, 1, 0, TAB_RIGHT, risk_v[i], NULL);
1979       tab_double (risk, 2, 0, TAB_RIGHT, lower[i], NULL);
1980       tab_double (risk, 3, 0, TAB_RIGHT, upper[i], NULL);
1981       tab_next_row (risk);
1982     }
1983
1984   tab_text (risk, 0, 0, TAB_LEFT, _("N of Valid Cases"));
1985   tab_double (risk, 1, 0, TAB_RIGHT, pt->total, &pt->weight_format);
1986   tab_next_row (risk);
1987
1988   tab_offset (risk, 0, -1);
1989 }
1990
1991 static int calc_directional (struct crosstabs_proc *, struct pivot_table *,
1992                              double[N_DIRECTIONAL], double[N_DIRECTIONAL],
1993                              double[N_DIRECTIONAL]);
1994
1995 /* Display directional measures. */
1996 static void
1997 display_directional (struct crosstabs_proc *proc, struct pivot_table *pt,
1998                      struct tab_table *direct)
1999 {
2000   static const char *categories[] =
2001     {
2002       N_("Nominal by Nominal"),
2003       N_("Ordinal by Ordinal"),
2004       N_("Nominal by Interval"),
2005     };
2006
2007   static const char *stats[] =
2008     {
2009       N_("Lambda"),
2010       N_("Goodman and Kruskal tau"),
2011       N_("Uncertainty Coefficient"),
2012       N_("Somers' d"),
2013       N_("Eta"),
2014     };
2015
2016   static const char *types[] =
2017     {
2018       N_("Symmetric"),
2019       N_("%s Dependent"),
2020       N_("%s Dependent"),
2021     };
2022
2023   static const int stats_categories[N_DIRECTIONAL] =
2024     {
2025       0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2,
2026     };
2027
2028   static const int stats_stats[N_DIRECTIONAL] =
2029     {
2030       0, 0, 0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4,
2031     };
2032
2033   static const int stats_types[N_DIRECTIONAL] =
2034     {
2035       0, 1, 2, 1, 2, 0, 1, 2, 0, 1, 2, 1, 2,
2036     };
2037
2038   static const int *stats_lookup[] =
2039     {
2040       stats_categories,
2041       stats_stats,
2042       stats_types,
2043     };
2044
2045   static const char **stats_names[] =
2046     {
2047       categories,
2048       stats,
2049       types,
2050     };
2051
2052   int last[3] =
2053     {
2054       -1, -1, -1,
2055     };
2056
2057   double direct_v[N_DIRECTIONAL];
2058   double direct_ase[N_DIRECTIONAL];
2059   double direct_t[N_DIRECTIONAL];
2060
2061   int i;
2062
2063   if (!calc_directional (proc, pt, direct_v, direct_ase, direct_t))
2064     return;
2065
2066   tab_offset (direct, pt->n_vars - 2, -1);
2067
2068   for (i = 0; i < N_DIRECTIONAL; i++)
2069     {
2070       if (direct_v[i] == SYSMIS)
2071         continue;
2072
2073       {
2074         int j;
2075
2076         for (j = 0; j < 3; j++)
2077           if (last[j] != stats_lookup[j][i])
2078             {
2079               if (j < 2)
2080                 tab_hline (direct, TAL_1, j, 6, 0);
2081
2082               for (; j < 3; j++)
2083                 {
2084                   const char *string;
2085                   int k = last[j] = stats_lookup[j][i];
2086
2087                   if (k == 0)
2088                     string = NULL;
2089                   else if (k == 1)
2090                     string = var_get_name (pt->vars[0]);
2091                   else
2092                     string = var_get_name (pt->vars[1]);
2093
2094                   tab_text (direct, j, 0, TAB_LEFT | TAT_PRINTF,
2095                             gettext (stats_names[j][k]), string);
2096                 }
2097             }
2098       }
2099
2100       tab_double (direct, 3, 0, TAB_RIGHT, direct_v[i], NULL);
2101       if (direct_ase[i] != SYSMIS)
2102         tab_double (direct, 4, 0, TAB_RIGHT, direct_ase[i], NULL);
2103       if (direct_t[i] != SYSMIS)
2104         tab_double (direct, 5, 0, TAB_RIGHT, direct_t[i], NULL);
2105       /*tab_double (direct, 6, 0, TAB_RIGHT, normal_sig (direct_v[i]), NULL);*/
2106       tab_next_row (direct);
2107     }
2108
2109   tab_offset (direct, 0, -1);
2110 }
2111 \f
2112 /* Statistical calculations. */
2113
2114 /* Returns the value of the gamma (factorial) function for an integer
2115    argument PT. */
2116 static double
2117 gamma_int (double pt)
2118 {
2119   double r = 1;
2120   int i;
2121
2122   for (i = 2; i < pt; i++)
2123     r *= i;
2124   return r;
2125 }
2126
2127 /* Calculate P_r as specified in _SPSS Statistical Algorithms_,
2128    Appendix 5. */
2129 static inline double
2130 Pr (int a, int b, int c, int d)
2131 {
2132   return (gamma_int (a + b + 1.) / gamma_int (a + 1.)
2133           * gamma_int (c + d + 1.) / gamma_int (b + 1.)
2134           * gamma_int (a + c + 1.) / gamma_int (c + 1.)
2135           * gamma_int (b + d + 1.) / gamma_int (d + 1.)
2136           / gamma_int (a + b + c + d + 1.));
2137 }
2138
2139 /* Swap the contents of A and B. */
2140 static inline void
2141 swap (int *a, int *b)
2142 {
2143   int t = *a;
2144   *a = *b;
2145   *b = t;
2146 }
2147
2148 /* Calculate significance for Fisher's exact test as specified in
2149    _SPSS Statistical Algorithms_, Appendix 5. */
2150 static void
2151 calc_fisher (int a, int b, int c, int d, double *fisher1, double *fisher2)
2152 {
2153   int pt;
2154
2155   if (MIN (c, d) < MIN (a, b))
2156     swap (&a, &c), swap (&b, &d);
2157   if (MIN (b, d) < MIN (a, c))
2158     swap (&a, &b), swap (&c, &d);
2159   if (b * c < a * d)
2160     {
2161       if (b < c)
2162         swap (&a, &b), swap (&c, &d);
2163       else
2164         swap (&a, &c), swap (&b, &d);
2165     }
2166
2167   *fisher1 = 0.;
2168   for (pt = 0; pt <= a; pt++)
2169     *fisher1 += Pr (a - pt, b + pt, c + pt, d - pt);
2170
2171   *fisher2 = *fisher1;
2172   for (pt = 1; pt <= b; pt++)
2173     *fisher2 += Pr (a + pt, b - pt, c - pt, d + pt);
2174 }
2175
2176 /* Calculates chi-squares into CHISQ.  MAT is a matrix with N_COLS
2177    columns with values COLS and N_ROWS rows with values ROWS.  Values
2178    in the matrix sum to pt->total. */
2179 static void
2180 calc_chisq (struct pivot_table *pt,
2181             double chisq[N_CHISQ], int df[N_CHISQ],
2182             double *fisher1, double *fisher2)
2183 {
2184   int r, c;
2185
2186   chisq[0] = chisq[1] = 0.;
2187   chisq[2] = chisq[3] = chisq[4] = SYSMIS;
2188   *fisher1 = *fisher2 = SYSMIS;
2189
2190   df[0] = df[1] = (pt->ns_cols - 1) * (pt->ns_rows - 1);
2191
2192   if (pt->ns_rows <= 1 || pt->ns_cols <= 1)
2193     {
2194       chisq[0] = chisq[1] = SYSMIS;
2195       return;
2196     }
2197
2198   for (r = 0; r < pt->n_rows; r++)
2199     for (c = 0; c < pt->n_cols; c++)
2200       {
2201         const double expected = pt->row_tot[r] * pt->col_tot[c] / pt->total;
2202         const double freq = pt->mat[pt->n_cols * r + c];
2203         const double residual = freq - expected;
2204
2205         chisq[0] += residual * residual / expected;
2206         if (freq)
2207           chisq[1] += freq * log (expected / freq);
2208       }
2209
2210   if (chisq[0] == 0.)
2211     chisq[0] = SYSMIS;
2212
2213   if (chisq[1] != 0.)
2214     chisq[1] *= -2.;
2215   else
2216     chisq[1] = SYSMIS;
2217
2218   /* Calculate Yates and Fisher exact test. */
2219   if (pt->ns_cols == 2 && pt->ns_rows == 2)
2220     {
2221       double f11, f12, f21, f22;
2222
2223       {
2224         int nz_cols[2];
2225         int i, j;
2226
2227         for (i = j = 0; i < pt->n_cols; i++)
2228           if (pt->col_tot[i] != 0.)
2229             {
2230               nz_cols[j++] = i;
2231               if (j == 2)
2232                 break;
2233             }
2234
2235         assert (j == 2);
2236
2237         f11 = pt->mat[nz_cols[0]];
2238         f12 = pt->mat[nz_cols[1]];
2239         f21 = pt->mat[nz_cols[0] + pt->n_cols];
2240         f22 = pt->mat[nz_cols[1] + pt->n_cols];
2241       }
2242
2243       /* Yates. */
2244       {
2245         const double pt_ = fabs (f11 * f22 - f12 * f21) - 0.5 * pt->total;
2246
2247         if (pt_ > 0.)
2248           chisq[3] = (pt->total * pow2 (pt_)
2249                       / (f11 + f12) / (f21 + f22)
2250                       / (f11 + f21) / (f12 + f22));
2251         else
2252           chisq[3] = 0.;
2253
2254         df[3] = 1.;
2255       }
2256
2257       /* Fisher. */
2258       if (f11 < 5. || f12 < 5. || f21 < 5. || f22 < 5.)
2259         calc_fisher (f11 + .5, f12 + .5, f21 + .5, f22 + .5, fisher1, fisher2);
2260     }
2261
2262   /* Calculate Mantel-Haenszel. */
2263   if (var_is_numeric (pt->vars[ROW_VAR]) && var_is_numeric (pt->vars[COL_VAR]))
2264     {
2265       double r, ase_0, ase_1;
2266       calc_r (pt, (double *) pt->rows, (double *) pt->cols, &r, &ase_0, &ase_1);
2267
2268       chisq[4] = (pt->total - 1.) * r * r;
2269       df[4] = 1;
2270     }
2271 }
2272
2273 /* Calculate the value of Pearson's r.  r is stored into R, ase_1 into
2274    ASE_1, and ase_0 into ASE_0.  The row and column values must be
2275    passed in PT and Y. */
2276 static void
2277 calc_r (struct pivot_table *pt,
2278         double *PT, double *Y, double *r, double *ase_0, double *ase_1)
2279 {
2280   double SX, SY, S, T;
2281   double Xbar, Ybar;
2282   double sum_XYf, sum_X2Y2f;
2283   double sum_Xr, sum_X2r;
2284   double sum_Yc, sum_Y2c;
2285   int i, j;
2286
2287   for (sum_X2Y2f = sum_XYf = 0., i = 0; i < pt->n_rows; i++)
2288     for (j = 0; j < pt->n_cols; j++)
2289       {
2290         double fij = pt->mat[j + i * pt->n_cols];
2291         double product = PT[i] * Y[j];
2292         double temp = fij * product;
2293         sum_XYf += temp;
2294         sum_X2Y2f += temp * product;
2295       }
2296
2297   for (sum_Xr = sum_X2r = 0., i = 0; i < pt->n_rows; i++)
2298     {
2299       sum_Xr += PT[i] * pt->row_tot[i];
2300       sum_X2r += pow2 (PT[i]) * pt->row_tot[i];
2301     }
2302   Xbar = sum_Xr / pt->total;
2303
2304   for (sum_Yc = sum_Y2c = 0., i = 0; i < pt->n_cols; i++)
2305     {
2306       sum_Yc += Y[i] * pt->col_tot[i];
2307       sum_Y2c += Y[i] * Y[i] * pt->col_tot[i];
2308     }
2309   Ybar = sum_Yc / pt->total;
2310
2311   S = sum_XYf - sum_Xr * sum_Yc / pt->total;
2312   SX = sum_X2r - pow2 (sum_Xr) / pt->total;
2313   SY = sum_Y2c - pow2 (sum_Yc) / pt->total;
2314   T = sqrt (SX * SY);
2315   *r = S / T;
2316   *ase_0 = sqrt ((sum_X2Y2f - pow2 (sum_XYf) / pt->total) / (sum_X2r * sum_Y2c));
2317
2318   {
2319     double s, c, y, t;
2320
2321     for (s = c = 0., i = 0; i < pt->n_rows; i++)
2322       for (j = 0; j < pt->n_cols; j++)
2323         {
2324           double Xresid, Yresid;
2325           double temp;
2326
2327           Xresid = PT[i] - Xbar;
2328           Yresid = Y[j] - Ybar;
2329           temp = (T * Xresid * Yresid
2330                   - ((S / (2. * T))
2331                      * (Xresid * Xresid * SY + Yresid * Yresid * SX)));
2332           y = pt->mat[j + i * pt->n_cols] * temp * temp - c;
2333           t = s + y;
2334           c = (t - s) - y;
2335           s = t;
2336         }
2337     *ase_1 = sqrt (s) / (T * T);
2338   }
2339 }
2340
2341 /* Calculate symmetric statistics and their asymptotic standard
2342    errors.  Returns 0 if none could be calculated. */
2343 static int
2344 calc_symmetric (struct crosstabs_proc *proc, struct pivot_table *pt,
2345                 double v[N_SYMMETRIC], double ase[N_SYMMETRIC],
2346                 double t[N_SYMMETRIC],
2347                 double somers_d_v[3], double somers_d_ase[3],
2348                 double somers_d_t[3])
2349 {
2350   int q, i;
2351
2352   q = MIN (pt->ns_rows, pt->ns_cols);
2353   if (q <= 1)
2354     return 0;
2355
2356   for (i = 0; i < N_SYMMETRIC; i++)
2357     v[i] = ase[i] = t[i] = SYSMIS;
2358
2359   /* Phi, Cramer's V, contingency coefficient. */
2360   if (proc->statistics & ((1u << CRS_ST_PHI) | (1u << CRS_ST_CC)))
2361     {
2362       double Xp = 0.;   /* Pearson chi-square. */
2363       int r, c;
2364
2365       for (r = 0; r < pt->n_rows; r++)
2366         for (c = 0; c < pt->n_cols; c++)
2367           {
2368             const double expected = pt->row_tot[r] * pt->col_tot[c] / pt->total;
2369             const double freq = pt->mat[pt->n_cols * r + c];
2370             const double residual = freq - expected;
2371
2372             Xp += residual * residual / expected;
2373           }
2374
2375       if (proc->statistics & (1u << CRS_ST_PHI))
2376         {
2377           v[0] = sqrt (Xp / pt->total);
2378           v[1] = sqrt (Xp / (pt->total * (q - 1)));
2379         }
2380       if (proc->statistics & (1u << CRS_ST_CC))
2381         v[2] = sqrt (Xp / (Xp + pt->total));
2382     }
2383
2384   if (proc->statistics & ((1u << CRS_ST_BTAU) | (1u << CRS_ST_CTAU)
2385                           | (1u << CRS_ST_GAMMA) | (1u << CRS_ST_D)))
2386     {
2387       double *cum;
2388       double Dr, Dc;
2389       double P, Q;
2390       double btau_cum, ctau_cum, gamma_cum, d_yx_cum, d_xy_cum;
2391       double btau_var;
2392       int r, c;
2393
2394       Dr = Dc = pow2 (pt->total);
2395       for (r = 0; r < pt->n_rows; r++)
2396         Dr -= pow2 (pt->row_tot[r]);
2397       for (c = 0; c < pt->n_cols; c++)
2398         Dc -= pow2 (pt->col_tot[c]);
2399
2400       cum = xnmalloc (pt->n_cols * pt->n_rows, sizeof *cum);
2401       for (c = 0; c < pt->n_cols; c++)
2402         {
2403           double ct = 0.;
2404
2405           for (r = 0; r < pt->n_rows; r++)
2406             cum[c + r * pt->n_cols] = ct += pt->mat[c + r * pt->n_cols];
2407         }
2408
2409       /* P and Q. */
2410       {
2411         int i, j;
2412         double Cij, Dij;
2413
2414         P = Q = 0.;
2415         for (i = 0; i < pt->n_rows; i++)
2416           {
2417             Cij = Dij = 0.;
2418
2419             for (j = 1; j < pt->n_cols; j++)
2420               Cij += pt->col_tot[j] - cum[j + i * pt->n_cols];
2421
2422             if (i > 0)
2423               for (j = 1; j < pt->n_cols; j++)
2424                 Dij += cum[j + (i - 1) * pt->n_cols];
2425
2426             for (j = 0;;)
2427               {
2428                 double fij = pt->mat[j + i * pt->n_cols];
2429                 P += fij * Cij;
2430                 Q += fij * Dij;
2431
2432                 if (++j == pt->n_cols)
2433                   break;
2434                 assert (j < pt->n_cols);
2435
2436                 Cij -= pt->col_tot[j] - cum[j + i * pt->n_cols];
2437                 Dij += pt->col_tot[j - 1] - cum[j - 1 + i * pt->n_cols];
2438
2439                 if (i > 0)
2440                   {
2441                     Cij += cum[j - 1 + (i - 1) * pt->n_cols];
2442                     Dij -= cum[j + (i - 1) * pt->n_cols];
2443                   }
2444               }
2445           }
2446       }
2447
2448       if (proc->statistics & (1u << CRS_ST_BTAU))
2449         v[3] = (P - Q) / sqrt (Dr * Dc);
2450       if (proc->statistics & (1u << CRS_ST_CTAU))
2451         v[4] = (q * (P - Q)) / (pow2 (pt->total) * (q - 1));
2452       if (proc->statistics & (1u << CRS_ST_GAMMA))
2453         v[5] = (P - Q) / (P + Q);
2454
2455       /* ASE for tau-b, tau-c, gamma.  Calculations could be
2456          eliminated here, at expense of memory.  */
2457       {
2458         int i, j;
2459         double Cij, Dij;
2460
2461         btau_cum = ctau_cum = gamma_cum = d_yx_cum = d_xy_cum = 0.;
2462         for (i = 0; i < pt->n_rows; i++)
2463           {
2464             Cij = Dij = 0.;
2465
2466             for (j = 1; j < pt->n_cols; j++)
2467               Cij += pt->col_tot[j] - cum[j + i * pt->n_cols];
2468
2469             if (i > 0)
2470               for (j = 1; j < pt->n_cols; j++)
2471                 Dij += cum[j + (i - 1) * pt->n_cols];
2472
2473             for (j = 0;;)
2474               {
2475                 double fij = pt->mat[j + i * pt->n_cols];
2476
2477                 if (proc->statistics & (1u << CRS_ST_BTAU))
2478                   {
2479                     const double temp = (2. * sqrt (Dr * Dc) * (Cij - Dij)
2480                                          + v[3] * (pt->row_tot[i] * Dc
2481                                                    + pt->col_tot[j] * Dr));
2482                     btau_cum += fij * temp * temp;
2483                   }
2484
2485                 {
2486                   const double temp = Cij - Dij;
2487                   ctau_cum += fij * temp * temp;
2488                 }
2489
2490                 if (proc->statistics & (1u << CRS_ST_GAMMA))
2491                   {
2492                     const double temp = Q * Cij - P * Dij;
2493                     gamma_cum += fij * temp * temp;
2494                   }
2495
2496                 if (proc->statistics & (1u << CRS_ST_D))
2497                   {
2498                     d_yx_cum += fij * pow2 (Dr * (Cij - Dij)
2499                                             - (P - Q) * (pt->total - pt->row_tot[i]));
2500                     d_xy_cum += fij * pow2 (Dc * (Dij - Cij)
2501                                             - (Q - P) * (pt->total - pt->col_tot[j]));
2502                   }
2503
2504                 if (++j == pt->n_cols)
2505                   break;
2506                 assert (j < pt->n_cols);
2507
2508                 Cij -= pt->col_tot[j] - cum[j + i * pt->n_cols];
2509                 Dij += pt->col_tot[j - 1] - cum[j - 1 + i * pt->n_cols];
2510
2511                 if (i > 0)
2512                   {
2513                     Cij += cum[j - 1 + (i - 1) * pt->n_cols];
2514                     Dij -= cum[j + (i - 1) * pt->n_cols];
2515                   }
2516               }
2517           }
2518       }
2519
2520       btau_var = ((btau_cum
2521                    - (pt->total * pow2 (pt->total * (P - Q) / sqrt (Dr * Dc) * (Dr + Dc))))
2522                   / pow2 (Dr * Dc));
2523       if (proc->statistics & (1u << CRS_ST_BTAU))
2524         {
2525           ase[3] = sqrt (btau_var);
2526           t[3] = v[3] / (2 * sqrt ((ctau_cum - (P - Q) * (P - Q) / pt->total)
2527                                    / (Dr * Dc)));
2528         }
2529       if (proc->statistics & (1u << CRS_ST_CTAU))
2530         {
2531           ase[4] = ((2 * q / ((q - 1) * pow2 (pt->total)))
2532                     * sqrt (ctau_cum - (P - Q) * (P - Q) / pt->total));
2533           t[4] = v[4] / ase[4];
2534         }
2535       if (proc->statistics & (1u << CRS_ST_GAMMA))
2536         {
2537           ase[5] = ((4. / ((P + Q) * (P + Q))) * sqrt (gamma_cum));
2538           t[5] = v[5] / (2. / (P + Q)
2539                          * sqrt (ctau_cum - (P - Q) * (P - Q) / pt->total));
2540         }
2541       if (proc->statistics & (1u << CRS_ST_D))
2542         {
2543           somers_d_v[0] = (P - Q) / (.5 * (Dc + Dr));
2544           somers_d_ase[0] = 2. * btau_var / (Dr + Dc) * sqrt (Dr * Dc);
2545           somers_d_t[0] = (somers_d_v[0]
2546                            / (4 / (Dc + Dr)
2547                               * sqrt (ctau_cum - pow2 (P - Q) / pt->total)));
2548           somers_d_v[1] = (P - Q) / Dc;
2549           somers_d_ase[1] = 2. / pow2 (Dc) * sqrt (d_xy_cum);
2550           somers_d_t[1] = (somers_d_v[1]
2551                            / (2. / Dc
2552                               * sqrt (ctau_cum - pow2 (P - Q) / pt->total)));
2553           somers_d_v[2] = (P - Q) / Dr;
2554           somers_d_ase[2] = 2. / pow2 (Dr) * sqrt (d_yx_cum);
2555           somers_d_t[2] = (somers_d_v[2]
2556                            / (2. / Dr
2557                               * sqrt (ctau_cum - pow2 (P - Q) / pt->total)));
2558         }
2559
2560       free (cum);
2561     }
2562
2563   /* Spearman correlation, Pearson's r. */
2564   if (proc->statistics & (1u << CRS_ST_CORR))
2565     {
2566       double *R = xmalloc (sizeof *R * pt->n_rows);
2567       double *C = xmalloc (sizeof *C * pt->n_cols);
2568
2569       {
2570         double y, t, c = 0., s = 0.;
2571         int i = 0;
2572
2573         for (;;)
2574           {
2575             R[i] = s + (pt->row_tot[i] + 1.) / 2.;
2576             y = pt->row_tot[i] - c;
2577             t = s + y;
2578             c = (t - s) - y;
2579             s = t;
2580             if (++i == pt->n_rows)
2581               break;
2582             assert (i < pt->n_rows);
2583           }
2584       }
2585
2586       {
2587         double y, t, c = 0., s = 0.;
2588         int j = 0;
2589
2590         for (;;)
2591           {
2592             C[j] = s + (pt->col_tot[j] + 1.) / 2;
2593             y = pt->col_tot[j] - c;
2594             t = s + y;
2595             c = (t - s) - y;
2596             s = t;
2597             if (++j == pt->n_cols)
2598               break;
2599             assert (j < pt->n_cols);
2600           }
2601       }
2602
2603       calc_r (pt, R, C, &v[6], &t[6], &ase[6]);
2604       t[6] = v[6] / t[6];
2605
2606       free (R);
2607       free (C);
2608
2609       calc_r (pt, (double *) pt->rows, (double *) pt->cols, &v[7], &t[7], &ase[7]);
2610       t[7] = v[7] / t[7];
2611     }
2612
2613   /* Cohen's kappa. */
2614   if (proc->statistics & (1u << CRS_ST_KAPPA) && pt->ns_rows == pt->ns_cols)
2615     {
2616       double sum_fii, sum_rici, sum_fiiri_ci, sum_fijri_ci2, sum_riciri_ci;
2617       int i, j;
2618
2619       for (sum_fii = sum_rici = sum_fiiri_ci = sum_riciri_ci = 0., i = j = 0;
2620            i < pt->ns_rows; i++, j++)
2621         {
2622           double prod, sum;
2623
2624           while (pt->col_tot[j] == 0.)
2625             j++;
2626
2627           prod = pt->row_tot[i] * pt->col_tot[j];
2628           sum = pt->row_tot[i] + pt->col_tot[j];
2629
2630           sum_fii += pt->mat[j + i * pt->n_cols];
2631           sum_rici += prod;
2632           sum_fiiri_ci += pt->mat[j + i * pt->n_cols] * sum;
2633           sum_riciri_ci += prod * sum;
2634         }
2635       for (sum_fijri_ci2 = 0., i = 0; i < pt->ns_rows; i++)
2636         for (j = 0; j < pt->ns_cols; j++)
2637           {
2638             double sum = pt->row_tot[i] + pt->col_tot[j];
2639             sum_fijri_ci2 += pt->mat[j + i * pt->n_cols] * sum * sum;
2640           }
2641
2642       v[8] = (pt->total * sum_fii - sum_rici) / (pow2 (pt->total) - sum_rici);
2643
2644       ase[8] = sqrt ((pow2 (pt->total) * sum_rici
2645                       + sum_rici * sum_rici
2646                       - pt->total * sum_riciri_ci)
2647                      / (pt->total * (pow2 (pt->total) - sum_rici) * (pow2 (pt->total) - sum_rici)));
2648 #if 0
2649       t[8] = v[8] / sqrt (pt->total * (((sum_fii * (pt->total - sum_fii))
2650                                 / pow2 (pow2 (pt->total) - sum_rici))
2651                                + ((2. * (pt->total - sum_fii)
2652                                    * (2. * sum_fii * sum_rici
2653                                       - pt->total * sum_fiiri_ci))
2654                                   / cube (pow2 (pt->total) - sum_rici))
2655                                + (pow2 (pt->total - sum_fii)
2656                                   * (pt->total * sum_fijri_ci2 - 4.
2657                                      * sum_rici * sum_rici)
2658                                   / pow4 (pow2 (pt->total) - sum_rici))));
2659 #else
2660       t[8] = v[8] / ase[8];
2661 #endif
2662     }
2663
2664   return 1;
2665 }
2666
2667 /* Calculate risk estimate. */
2668 static int
2669 calc_risk (struct pivot_table *pt,
2670            double *value, double *upper, double *lower, union value *c)
2671 {
2672   double f11, f12, f21, f22;
2673   double v;
2674
2675   {
2676     int i;
2677
2678     for (i = 0; i < 3; i++)
2679       value[i] = upper[i] = lower[i] = SYSMIS;
2680   }
2681
2682   if (pt->ns_rows != 2 || pt->ns_cols != 2)
2683     return 0;
2684
2685   {
2686     int nz_cols[2];
2687     int i, j;
2688
2689     for (i = j = 0; i < pt->n_cols; i++)
2690       if (pt->col_tot[i] != 0.)
2691         {
2692           nz_cols[j++] = i;
2693           if (j == 2)
2694             break;
2695         }
2696
2697     assert (j == 2);
2698
2699     f11 = pt->mat[nz_cols[0]];
2700     f12 = pt->mat[nz_cols[1]];
2701     f21 = pt->mat[nz_cols[0] + pt->n_cols];
2702     f22 = pt->mat[nz_cols[1] + pt->n_cols];
2703
2704     c[0] = pt->cols[nz_cols[0]];
2705     c[1] = pt->cols[nz_cols[1]];
2706   }
2707
2708   value[0] = (f11 * f22) / (f12 * f21);
2709   v = sqrt (1. / f11 + 1. / f12 + 1. / f21 + 1. / f22);
2710   lower[0] = value[0] * exp (-1.960 * v);
2711   upper[0] = value[0] * exp (1.960 * v);
2712
2713   value[1] = (f11 * (f21 + f22)) / (f21 * (f11 + f12));
2714   v = sqrt ((f12 / (f11 * (f11 + f12)))
2715             + (f22 / (f21 * (f21 + f22))));
2716   lower[1] = value[1] * exp (-1.960 * v);
2717   upper[1] = value[1] * exp (1.960 * v);
2718
2719   value[2] = (f12 * (f21 + f22)) / (f22 * (f11 + f12));
2720   v = sqrt ((f11 / (f12 * (f11 + f12)))
2721             + (f21 / (f22 * (f21 + f22))));
2722   lower[2] = value[2] * exp (-1.960 * v);
2723   upper[2] = value[2] * exp (1.960 * v);
2724
2725   return 1;
2726 }
2727
2728 /* Calculate directional measures. */
2729 static int
2730 calc_directional (struct crosstabs_proc *proc, struct pivot_table *pt,
2731                   double v[N_DIRECTIONAL], double ase[N_DIRECTIONAL],
2732                   double t[N_DIRECTIONAL])
2733 {
2734   {
2735     int i;
2736
2737     for (i = 0; i < N_DIRECTIONAL; i++)
2738       v[i] = ase[i] = t[i] = SYSMIS;
2739   }
2740
2741   /* Lambda. */
2742   if (proc->statistics & (1u << CRS_ST_LAMBDA))
2743     {
2744       double *fim = xnmalloc (pt->n_rows, sizeof *fim);
2745       int *fim_index = xnmalloc (pt->n_rows, sizeof *fim_index);
2746       double *fmj = xnmalloc (pt->n_cols, sizeof *fmj);
2747       int *fmj_index = xnmalloc (pt->n_cols, sizeof *fmj_index);
2748       double sum_fim, sum_fmj;
2749       double rm, cm;
2750       int rm_index, cm_index;
2751       int i, j;
2752
2753       /* Find maximum for each row and their sum. */
2754       for (sum_fim = 0., i = 0; i < pt->n_rows; i++)
2755         {
2756           double max = pt->mat[i * pt->n_cols];
2757           int index = 0;
2758
2759           for (j = 1; j < pt->n_cols; j++)
2760             if (pt->mat[j + i * pt->n_cols] > max)
2761               {
2762                 max = pt->mat[j + i * pt->n_cols];
2763                 index = j;
2764               }
2765
2766           sum_fim += fim[i] = max;
2767           fim_index[i] = index;
2768         }
2769
2770       /* Find maximum for each column. */
2771       for (sum_fmj = 0., j = 0; j < pt->n_cols; j++)
2772         {
2773           double max = pt->mat[j];
2774           int index = 0;
2775
2776           for (i = 1; i < pt->n_rows; i++)
2777             if (pt->mat[j + i * pt->n_cols] > max)
2778               {
2779                 max = pt->mat[j + i * pt->n_cols];
2780                 index = i;
2781               }
2782
2783           sum_fmj += fmj[j] = max;
2784           fmj_index[j] = index;
2785         }
2786
2787       /* Find maximum row total. */
2788       rm = pt->row_tot[0];
2789       rm_index = 0;
2790       for (i = 1; i < pt->n_rows; i++)
2791         if (pt->row_tot[i] > rm)
2792           {
2793             rm = pt->row_tot[i];
2794             rm_index = i;
2795           }
2796
2797       /* Find maximum column total. */
2798       cm = pt->col_tot[0];
2799       cm_index = 0;
2800       for (j = 1; j < pt->n_cols; j++)
2801         if (pt->col_tot[j] > cm)
2802           {
2803             cm = pt->col_tot[j];
2804             cm_index = j;
2805           }
2806
2807       v[0] = (sum_fim + sum_fmj - cm - rm) / (2. * pt->total - rm - cm);
2808       v[1] = (sum_fmj - rm) / (pt->total - rm);
2809       v[2] = (sum_fim - cm) / (pt->total - cm);
2810
2811       /* ASE1 for Y given PT. */
2812       {
2813         double accum;
2814
2815         for (accum = 0., i = 0; i < pt->n_rows; i++)
2816           for (j = 0; j < pt->n_cols; j++)
2817             {
2818               const int deltaj = j == cm_index;
2819               accum += (pt->mat[j + i * pt->n_cols]
2820                         * pow2 ((j == fim_index[i])
2821                                - deltaj
2822                                + v[0] * deltaj));
2823             }
2824
2825         ase[2] = sqrt (accum - pt->total * v[0]) / (pt->total - cm);
2826       }
2827
2828       /* ASE0 for Y given PT. */
2829       {
2830         double accum;
2831
2832         for (accum = 0., i = 0; i < pt->n_rows; i++)
2833           if (cm_index != fim_index[i])
2834             accum += (pt->mat[i * pt->n_cols + fim_index[i]]
2835                       + pt->mat[i * pt->n_cols + cm_index]);
2836         t[2] = v[2] / (sqrt (accum - pow2 (sum_fim - cm) / pt->total) / (pt->total - cm));
2837       }
2838
2839       /* ASE1 for PT given Y. */
2840       {
2841         double accum;
2842
2843         for (accum = 0., i = 0; i < pt->n_rows; i++)
2844           for (j = 0; j < pt->n_cols; j++)
2845             {
2846               const int deltaj = i == rm_index;
2847               accum += (pt->mat[j + i * pt->n_cols]
2848                         * pow2 ((i == fmj_index[j])
2849                                - deltaj
2850                                + v[0] * deltaj));
2851             }
2852
2853         ase[1] = sqrt (accum - pt->total * v[0]) / (pt->total - rm);
2854       }
2855
2856       /* ASE0 for PT given Y. */
2857       {
2858         double accum;
2859
2860         for (accum = 0., j = 0; j < pt->n_cols; j++)
2861           if (rm_index != fmj_index[j])
2862             accum += (pt->mat[j + pt->n_cols * fmj_index[j]]
2863                       + pt->mat[j + pt->n_cols * rm_index]);
2864         t[1] = v[1] / (sqrt (accum - pow2 (sum_fmj - rm) / pt->total) / (pt->total - rm));
2865       }
2866
2867       /* Symmetric ASE0 and ASE1. */
2868       {
2869         double accum0;
2870         double accum1;
2871
2872         for (accum0 = accum1 = 0., i = 0; i < pt->n_rows; i++)
2873           for (j = 0; j < pt->n_cols; j++)
2874             {
2875               int temp0 = (fmj_index[j] == i) + (fim_index[i] == j);
2876               int temp1 = (i == rm_index) + (j == cm_index);
2877               accum0 += pt->mat[j + i * pt->n_cols] * pow2 (temp0 - temp1);
2878               accum1 += (pt->mat[j + i * pt->n_cols]
2879                          * pow2 (temp0 + (v[0] - 1.) * temp1));
2880             }
2881         ase[0] = sqrt (accum1 - 4. * pt->total * v[0] * v[0]) / (2. * pt->total - rm - cm);
2882         t[0] = v[0] / (sqrt (accum0 - pow2 ((sum_fim + sum_fmj - cm - rm) / pt->total))
2883                        / (2. * pt->total - rm - cm));
2884       }
2885
2886       free (fim);
2887       free (fim_index);
2888       free (fmj);
2889       free (fmj_index);
2890
2891       {
2892         double sum_fij2_ri, sum_fij2_ci;
2893         double sum_ri2, sum_cj2;
2894
2895         for (sum_fij2_ri = sum_fij2_ci = 0., i = 0; i < pt->n_rows; i++)
2896           for (j = 0; j < pt->n_cols; j++)
2897             {
2898               double temp = pow2 (pt->mat[j + i * pt->n_cols]);
2899               sum_fij2_ri += temp / pt->row_tot[i];
2900               sum_fij2_ci += temp / pt->col_tot[j];
2901             }
2902
2903         for (sum_ri2 = 0., i = 0; i < pt->n_rows; i++)
2904           sum_ri2 += pow2 (pt->row_tot[i]);
2905
2906         for (sum_cj2 = 0., j = 0; j < pt->n_cols; j++)
2907           sum_cj2 += pow2 (pt->col_tot[j]);
2908
2909         v[3] = (pt->total * sum_fij2_ci - sum_ri2) / (pow2 (pt->total) - sum_ri2);
2910         v[4] = (pt->total * sum_fij2_ri - sum_cj2) / (pow2 (pt->total) - sum_cj2);
2911       }
2912     }
2913
2914   if (proc->statistics & (1u << CRS_ST_UC))
2915     {
2916       double UX, UY, UXY, P;
2917       double ase1_yx, ase1_xy, ase1_sym;
2918       int i, j;
2919
2920       for (UX = 0., i = 0; i < pt->n_rows; i++)
2921         if (pt->row_tot[i] > 0.)
2922           UX -= pt->row_tot[i] / pt->total * log (pt->row_tot[i] / pt->total);
2923
2924       for (UY = 0., j = 0; j < pt->n_cols; j++)
2925         if (pt->col_tot[j] > 0.)
2926           UY -= pt->col_tot[j] / pt->total * log (pt->col_tot[j] / pt->total);
2927
2928       for (UXY = P = 0., i = 0; i < pt->n_rows; i++)
2929         for (j = 0; j < pt->n_cols; j++)
2930           {
2931             double entry = pt->mat[j + i * pt->n_cols];
2932
2933             if (entry <= 0.)
2934               continue;
2935
2936             P += entry * pow2 (log (pt->col_tot[j] * pt->row_tot[i] / (pt->total * entry)));
2937             UXY -= entry / pt->total * log (entry / pt->total);
2938           }
2939
2940       for (ase1_yx = ase1_xy = ase1_sym = 0., i = 0; i < pt->n_rows; i++)
2941         for (j = 0; j < pt->n_cols; j++)
2942           {
2943             double entry = pt->mat[j + i * pt->n_cols];
2944
2945             if (entry <= 0.)
2946               continue;
2947
2948             ase1_yx += entry * pow2 (UY * log (entry / pt->row_tot[i])
2949                                     + (UX - UXY) * log (pt->col_tot[j] / pt->total));
2950             ase1_xy += entry * pow2 (UX * log (entry / pt->col_tot[j])
2951                                     + (UY - UXY) * log (pt->row_tot[i] / pt->total));
2952             ase1_sym += entry * pow2 ((UXY
2953                                       * log (pt->row_tot[i] * pt->col_tot[j] / pow2 (pt->total)))
2954                                      - (UX + UY) * log (entry / pt->total));
2955           }
2956
2957       v[5] = 2. * ((UX + UY - UXY) / (UX + UY));
2958       ase[5] = (2. / (pt->total * pow2 (UX + UY))) * sqrt (ase1_sym);
2959       t[5] = v[5] / ((2. / (pt->total * (UX + UY)))
2960                      * sqrt (P - pow2 (UX + UY - UXY) / pt->total));
2961
2962       v[6] = (UX + UY - UXY) / UX;
2963       ase[6] = sqrt (ase1_xy) / (pt->total * UX * UX);
2964       t[6] = v[6] / (sqrt (P - pt->total * pow2 (UX + UY - UXY)) / (pt->total * UX));
2965
2966       v[7] = (UX + UY - UXY) / UY;
2967       ase[7] = sqrt (ase1_yx) / (pt->total * UY * UY);
2968       t[7] = v[7] / (sqrt (P - pt->total * pow2 (UX + UY - UXY)) / (pt->total * UY));
2969     }
2970
2971   /* Somers' D. */
2972   if (proc->statistics & (1u << CRS_ST_D))
2973     {
2974       double v_dummy[N_SYMMETRIC];
2975       double ase_dummy[N_SYMMETRIC];
2976       double t_dummy[N_SYMMETRIC];
2977       double somers_d_v[3];
2978       double somers_d_ase[3];
2979       double somers_d_t[3];
2980
2981       if (calc_symmetric (proc, pt, v_dummy, ase_dummy, t_dummy,
2982                           somers_d_v, somers_d_ase, somers_d_t))
2983         {
2984           int i;
2985           for (i = 0; i < 3; i++)
2986             {
2987               v[8 + i] = somers_d_v[i];
2988               ase[8 + i] = somers_d_ase[i];
2989               t[8 + i] = somers_d_t[i];
2990             }
2991         }
2992     }
2993
2994   /* Eta. */
2995   if (proc->statistics & (1u << CRS_ST_ETA))
2996     {
2997       {
2998         double sum_Xr, sum_X2r;
2999         double SX, SXW;
3000         int i, j;
3001
3002         for (sum_Xr = sum_X2r = 0., i = 0; i < pt->n_rows; i++)
3003           {
3004             sum_Xr += pt->rows[i].f * pt->row_tot[i];
3005             sum_X2r += pow2 (pt->rows[i].f) * pt->row_tot[i];
3006           }
3007         SX = sum_X2r - pow2 (sum_Xr) / pt->total;
3008
3009         for (SXW = 0., j = 0; j < pt->n_cols; j++)
3010           {
3011             double cum;
3012
3013             for (cum = 0., i = 0; i < pt->n_rows; i++)
3014               {
3015                 SXW += pow2 (pt->rows[i].f) * pt->mat[j + i * pt->n_cols];
3016                 cum += pt->rows[i].f * pt->mat[j + i * pt->n_cols];
3017               }
3018
3019             SXW -= cum * cum / pt->col_tot[j];
3020           }
3021         v[11] = sqrt (1. - SXW / SX);
3022       }
3023
3024       {
3025         double sum_Yc, sum_Y2c;
3026         double SY, SYW;
3027         int i, j;
3028
3029         for (sum_Yc = sum_Y2c = 0., i = 0; i < pt->n_cols; i++)
3030           {
3031             sum_Yc += pt->cols[i].f * pt->col_tot[i];
3032             sum_Y2c += pow2 (pt->cols[i].f) * pt->col_tot[i];
3033           }
3034         SY = sum_Y2c - sum_Yc * sum_Yc / pt->total;
3035
3036         for (SYW = 0., i = 0; i < pt->n_rows; i++)
3037           {
3038             double cum;
3039
3040             for (cum = 0., j = 0; j < pt->n_cols; j++)
3041               {
3042                 SYW += pow2 (pt->cols[j].f) * pt->mat[j + i * pt->n_cols];
3043                 cum += pt->cols[j].f * pt->mat[j + i * pt->n_cols];
3044               }
3045
3046             SYW -= cum * cum / pt->row_tot[i];
3047           }
3048         v[12] = sqrt (1. - SYW / SY);
3049       }
3050     }
3051
3052   return 1;
3053 }
3054
3055 /*
3056    Local Variables:
3057    mode: c
3058    End:
3059 */