pintos-os.org Git - pspp/blob - src/language/stats/logistic.c

   1 /* pspp - a program for statistical analysis.
   2    Copyright (C) 2012 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
  18 /*
  19    References:
  20    1. "Coding Logistic Regression with Newton-Raphson", James McCaffrey
  21    http://msdn.microsoft.com/en-us/magazine/jj618304.aspx
  22
  23    2. "SPSS Statistical Algorithms" Chapter LOGISTIC REGRESSION Algorithms
  24
  25
  26    The Newton Raphson method finds successive approximations to $\bf b$ where
  27    approximation ${\bf b}_t$ is (hopefully) better than the previous ${\bf b}_{t-1}$.
  28
  29    $ {\bf b}_t = {\bf b}_{t -1} + ({\bf X}^T{\bf W}_{t-1}{\bf X})^{-1}{\bf X}^T({\bf y} - {\bf \pi}_{t-1})$
  30    where:
  31
  32    $\bf X$ is the $n \times p$ design matrix, $n$ being the number of cases,
  33    $p$ the number of parameters, \par
  34    $\bf W$ is the diagonal matrix whose diagonal elements are
  35    $\hat{\pi}_0(1 - \hat{\pi}_0), \, \hat{\pi}_1(1 - \hat{\pi}_2)\dots \hat{\pi}_{n-1}(1 - \hat{\pi}_{n-1})$
  36    \par
  37
  38 */
  39
  40 #include <config.h>
  41
  42 #include <gsl/gsl_blas.h>
  43
  44 #include <gsl/gsl_linalg.h>
  45 #include <gsl/gsl_cdf.h>
  46 #include <gsl/gsl_matrix.h>
  47 #include <gsl/gsl_vector.h>
  48 #include <math.h>
  49
  50 #include "data/case.h"
  51 #include "data/casegrouper.h"
  52 #include "data/casereader.h"
  53 #include "data/dataset.h"
  54 #include "data/dictionary.h"
  55 #include "data/format.h"
  56 #include "data/value.h"
  57 #include "language/command.h"
  58 #include "language/dictionary/split-file.h"
  59 #include "language/lexer/lexer.h"
  60 #include "language/lexer/value-parser.h"
  61 #include "language/lexer/variable-parser.h"
  62 #include "libpspp/assertion.h"
  63 #include "libpspp/ll.h"
  64 #include "libpspp/message.h"
  65 #include "libpspp/misc.h"
  66 #include "math/categoricals.h"
  67 #include "math/interaction.h"
  68 #include "libpspp/hmap.h"
  69 #include "libpspp/hash-functions.h"
  70
  71 #include "output/tab.h"
  72
  73 #include "gettext.h"
  74 #define _(msgid) gettext (msgid)
  75
  76
  77
  78
  79 #define   PRINT_EACH_STEP  0x01
  80 #define   PRINT_SUMMARY    0x02
  81 #define   PRINT_CORR       0x04
  82 #define   PRINT_ITER       0x08
  83 #define   PRINT_GOODFIT    0x10
  84 #define   PRINT_CI         0x20
  85
  86
  87 #define PRINT_DEFAULT (PRINT_SUMMARY | PRINT_EACH_STEP)
  88
  89 /*
  90   The constant parameters of the procedure.
  91   That is, those which are set by the user.
  92 */
  93 struct lr_spec
  94 {
  95   /* The dependent variable */
  96   const struct variable *dep_var;
  97
  98   /* The predictor variables (excluding categorical ones) */
  99   const struct variable **predictor_vars;
 100   size_t n_predictor_vars;
 101
 102   /* The categorical predictors */
 103   struct interaction **cat_predictors;
 104   size_t n_cat_predictors;
 105
 106
 107   /* The union of the categorical and non-categorical variables */
 108   const struct variable **indep_vars;
 109   size_t n_indep_vars;
 110
 111
 112   /* Which classes of missing vars are to be excluded */
 113   enum mv_class exclude;
 114
 115   /* The weight variable */
 116   const struct variable *wv;
 117
 118   /* The dictionary of the dataset */
 119   const struct dictionary *dict;
 120
 121   /* True iff the constant (intercept) is to be included in the model */
 122   bool constant;
 123
 124   /* Ths maximum number of iterations */
 125   int max_iter;
 126
 127   /* Other iteration limiting conditions */
 128   double bcon;
 129   double min_epsilon;
 130   double lcon;
 131
 132   /* The confidence interval (in percent) */
 133   int confidence;
 134
 135   /* What results should be presented */
 136   unsigned int print;
 137
 138   /* Inverse logit of the cut point */
 139   double ilogit_cut_point;
 140 };
 141
 142
 143 /* The results and intermediate result of the procedure.
 144    These are mutated as the procedure runs. Used for
 145    temporary variables etc.
 146 */
 147 struct lr_result
 148 {
 149   /* Used to indicate if a pass should flag a warning when
 150      invalid (ie negative or missing) weight values are encountered */
 151   bool warn_bad_weight;
 152
 153   /* The two values of the dependent variable. */
 154   union value y0;
 155   union value y1;
 156
 157
 158   /* The sum of caseweights */
 159   double cc;
 160
 161   /* The number of missing and nonmissing cases */
 162   casenumber n_missing;
 163   casenumber n_nonmissing;
 164
 165
 166   gsl_matrix *hessian;
 167
 168   /* The categoricals and their payload. Null if  the analysis has no
 169    categorical predictors */
 170   struct categoricals *cats;
 171   struct payload cp;
 172
 173
 174   /* The estimates of the predictor coefficients */
 175   gsl_vector *beta_hat;
 176
 177   /* The predicted classifications:
 178      True Negative, True Positive, False Negative, False Positive */
 179   double tn, tp, fn, fp;
 180 };
 181
 182
 183 /*
 184   Convert INPUT into a dichotomous scalar, according to how the dependent variable's
 185   values are mapped.
 186   For simple cases, this is a 1:1 mapping
 187   The return value is always either 0 or 1
 188 */
 189 static double
 190 map_dependent_var (const struct lr_spec *cmd, const struct lr_result *res, const union value *input)
 191 {
 192   const int width = var_get_width (cmd->dep_var);
 193   if (value_equal (input, &res->y0, width))
 194     return 0;
 195
 196   if (value_equal (input, &res->y1, width))
 197     return 1;
 198
 199   /* This should never happen.  If it does,  then y0 and/or y1 have probably not been set */
 200   NOT_REACHED ();
 201
 202   return SYSMIS;
 203 }
 204
 205 static void output_classification_table (const struct lr_spec *cmd, const struct lr_result *res);
 206
 207 static void output_categories (const struct lr_spec *cmd, const struct lr_result *res);
 208
 209 static void output_depvarmap (const struct lr_spec *cmd, const struct lr_result *);
 210
 211 static void output_variables (const struct lr_spec *cmd,
 212                               const struct lr_result *);
 213
 214 static void output_model_summary (const struct lr_result *,
 215                                   double initial_likelihood, double likelihood);
 216
 217 static void case_processing_summary (const struct lr_result *);
 218
 219
 220 /* Return the value of case C corresponding to the INDEX'th entry in the
 221    model */
 222 static double
 223 predictor_value (const struct ccase *c,
 224                     const struct variable **x, size_t n_x,
 225                     const struct categoricals *cats,
 226                     size_t index)
 227 {
 228   /* Values of the scalar predictor variables */
 229   if (index < n_x)
 230     return case_data (c, x[index])->f;
 231
 232   /* Coded values of categorical predictor variables (or interactions) */
 233   if (cats && index - n_x  < categoricals_df_total (cats))
 234     {
 235       double x = categoricals_get_dummy_code_for_case (cats, index - n_x, c);
 236       return x;
 237     }
 238
 239   /* The constant term */
 240   return 1.0;
 241 }
 242
 243
 244 /*
 245   Return the probability beta_hat (that is the estimator logit(y) )
 246   corresponding to the coefficient estimator for case C
 247 */
 248 static double
 249 pi_hat (const struct lr_spec *cmd,
 250         const struct lr_result *res,
 251         const struct variable **x, size_t n_x,
 252         const struct ccase *c)
 253 {
 254   int v0;
 255   double pi = 0;
 256   size_t n_coeffs = res->beta_hat->size;
 257
 258   if (cmd->constant)
 259     {
 260       pi += gsl_vector_get (res->beta_hat, res->beta_hat->size - 1);
 261       n_coeffs--;
 262     }
 263
 264   for (v0 = 0; v0 < n_coeffs; ++v0)
 265     {
 266       pi += gsl_vector_get (res->beta_hat, v0) *
 267         predictor_value (c, x, n_x, res->cats, v0);
 268     }
 269
 270   pi = 1.0 / (1.0 + exp(-pi));
 271
 272   return pi;
 273 }
 274
 275
 276 /*
 277   Calculates the Hessian matrix X' V  X,
 278   where: X is the n by N_X matrix comprising the n cases in INPUT
 279   V is a diagonal matrix { (pi_hat_0)(1 - pi_hat_0), (pi_hat_1)(1 - pi_hat_1), ... (pi_hat_{N-1})(1 - pi_hat_{N-1})}
 280   (the partial derivative of the predicted values)
 281
 282   If ALL predicted values derivatives are close to zero or one, then CONVERGED
 283   will be set to true.
 284 */
 285 static void
 286 hessian (const struct lr_spec *cmd,
 287          struct lr_result *res,
 288          struct casereader *input,
 289          const struct variable **x, size_t n_x,
 290          bool *converged)
 291 {
 292   struct casereader *reader;
 293   struct ccase *c;
 294
 295   double max_w = -DBL_MAX;
 296
 297   gsl_matrix_set_zero (res->hessian);
 298
 299   for (reader = casereader_clone (input);
 300        (c = casereader_read (reader)) != NULL; case_unref (c))
 301     {
 302       int v0, v1;
 303       double pi = pi_hat (cmd, res, x, n_x, c);
 304
 305       double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
 306       double w = pi * (1 - pi);
 307       if (w > max_w)
 308         max_w = w;
 309       w *= weight;
 310
 311       for (v0 = 0; v0 < res->beta_hat->size; ++v0)
 312         {
 313           double in0 = predictor_value (c, x, n_x, res->cats, v0);
 314           for (v1 = 0; v1 < res->beta_hat->size; ++v1)
 315             {
 316               double in1 = predictor_value (c, x, n_x, res->cats, v1);
 317               double *o = gsl_matrix_ptr (res->hessian, v0, v1);
 318               *o += in0 * w * in1;
 319             }
 320         }
 321     }
 322   casereader_destroy (reader);
 323
 324   if ( max_w < cmd->min_epsilon)
 325     {
 326       *converged = true;
 327       msg (MN, _("All predicted values are either 1 or 0"));
 328     }
 329 }
 330
 331
 332 /* Calculates the value  X' (y - pi)
 333    where X is the design model,
 334    y is the vector of observed independent variables
 335    pi is the vector of estimates for y
 336
 337    Side effects:
 338      the likelihood is stored in LIKELIHOOD;
 339      the predicted values are placed in the respective tn, fn, tp fp values in RES
 340 */
 341 static gsl_vector *
 342 xt_times_y_pi (const struct lr_spec *cmd,
 343                struct lr_result *res,
 344                struct casereader *input,
 345                const struct variable **x, size_t n_x,
 346                const struct variable *y_var,
 347                double *llikelihood)
 348 {
 349   struct casereader *reader;
 350   struct ccase *c;
 351   gsl_vector *output = gsl_vector_calloc (res->beta_hat->size);
 352
 353   *llikelihood = 0.0;
 354   res->tn = res->tp = res->fn = res->fp = 0;
 355   for (reader = casereader_clone (input);
 356        (c = casereader_read (reader)) != NULL; case_unref (c))
 357     {
 358       double pred_y = 0;
 359       int v0;
 360       double pi = pi_hat (cmd, res, x, n_x, c);
 361       double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
 362
 363
 364       double y = map_dependent_var (cmd, res, case_data (c, y_var));
 365
 366       *llikelihood += (weight * y) * log (pi) + log (1 - pi) * weight * (1 - y);
 367
 368       for (v0 = 0; v0 < res->beta_hat->size; ++v0)
 369         {
 370           double in0 = predictor_value (c, x, n_x, res->cats, v0);
 371           double *o = gsl_vector_ptr (output, v0);
 372           *o += in0 * (y - pi) * weight;
 373           pred_y += gsl_vector_get (res->beta_hat, v0) * in0;
 374         }
 375
 376       /* Count the number of cases which would be correctly/incorrectly classified by this
 377          estimated model */
 378       if (pred_y <= cmd->ilogit_cut_point)
 379         {
 380           if (y == 0)
 381             res->tn += weight;
 382           else
 383             res->fn += weight;
 384         }
 385       else
 386         {
 387           if (y == 0)
 388             res->fp += weight;
 389           else
 390             res->tp += weight;
 391         }
 392     }
 393
 394   casereader_destroy (reader);
 395
 396   return output;
 397 }
 398
 399 \f
 400
 401 /* "payload" functions for the categoricals.
 402    The only function is to accumulate the frequency of each
 403    category.
 404  */
 405
 406 static void *
 407 frq_create  (const void *aux1 UNUSED, void *aux2 UNUSED)
 408 {
 409   return xzalloc (sizeof (double));
 410 }
 411
 412 static void
 413 frq_update  (const void *aux1 UNUSED, void *aux2 UNUSED,
 414              void *ud, const struct ccase *c UNUSED , double weight)
 415 {
 416   double *freq = ud;
 417   *freq += weight;
 418 }
 419
 420 static void
 421 frq_destroy (const void *aux1 UNUSED, void *aux2 UNUSED, void *user_data UNUSED)
 422 {
 423   free (user_data);
 424 }
 425
 426 \f
 427
 428 /*
 429    Makes an initial pass though the data, doing the following:
 430
 431    * Checks that the dependent variable is  dichotomous,
 432    * Creates and initialises the categoricals,
 433    * Accumulates summary results,
 434    * Calculates necessary initial values.
 435    * Creates an initial value for \hat\beta the vector of beta_hats of \beta
 436
 437    Returns true if successful
 438 */
 439 static bool
 440 initial_pass (const struct lr_spec *cmd, struct lr_result *res, struct casereader *input)
 441 {
 442   const int width = var_get_width (cmd->dep_var);
 443
 444   struct ccase *c;
 445   struct casereader *reader;
 446
 447   double sum;
 448   double sumA = 0.0;
 449   double sumB = 0.0;
 450
 451   bool v0set = false;
 452   bool v1set = false;
 453
 454   size_t n_coefficients = cmd->n_predictor_vars;
 455   if (cmd->constant)
 456     n_coefficients++;
 457
 458   /* Create categoricals if appropriate */
 459   if (cmd->n_cat_predictors > 0)
 460     {
 461       res->cp.create = frq_create;
 462       res->cp.update = frq_update;
 463       res->cp.calculate = NULL;
 464       res->cp.destroy = frq_destroy;
 465
 466       res->cats = categoricals_create (cmd->cat_predictors, cmd->n_cat_predictors,
 467                                        cmd->wv, cmd->exclude, MV_ANY);
 468
 469       categoricals_set_payload (res->cats, &res->cp, cmd, res);
 470     }
 471
 472   res->cc = 0;
 473   for (reader = casereader_clone (input);
 474        (c = casereader_read (reader)) != NULL; case_unref (c))
 475     {
 476       int v;
 477       bool missing = false;
 478       double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
 479       const union value *depval = case_data (c, cmd->dep_var);
 480
 481       for (v = 0; v < cmd->n_indep_vars; ++v)
 482         {
 483           const union value *val = case_data (c, cmd->indep_vars[v]);
 484           if (var_is_value_missing (cmd->indep_vars[v], val, cmd->exclude))
 485             {
 486               missing = true;
 487               break;
 488             }
 489         }
 490
 491       /* Accumulate the missing and non-missing counts */
 492       if (missing)
 493         {
 494           res->n_missing++;
 495           continue;
 496         }
 497       res->n_nonmissing++;
 498
 499       /* Find the values of the dependent variable */
 500       if (!v0set)
 501         {
 502           value_clone (&res->y0, depval, width);
 503           v0set = true;
 504         }
 505       else if (!v1set)
 506         {
 507           if ( !value_equal (&res->y0, depval, width))
 508             {
 509               value_clone (&res->y1, depval, width);
 510               v1set = true;
 511             }
 512         }
 513       else
 514         {
 515           if (! value_equal (&res->y0, depval, width)
 516               &&
 517               ! value_equal (&res->y1, depval, width)
 518               )
 519             {
 520               msg (ME, _("Dependent variable's values are not dichotomous."));
 521               goto error;
 522             }
 523         }
 524
 525       if (v0set && value_equal (&res->y0, depval, width))
 526           sumA += weight;
 527
 528       if (v1set && value_equal (&res->y1, depval, width))
 529           sumB += weight;
 530
 531
 532       res->cc += weight;
 533
 534       categoricals_update (res->cats, c);
 535     }
 536   casereader_destroy (reader);
 537
 538   categoricals_done (res->cats);
 539
 540   sum = sumB;
 541
 542   /* Ensure that Y0 is less than Y1.  Otherwise the mapping gets
 543      inverted, which is confusing to users */
 544   if (var_is_numeric (cmd->dep_var) && value_compare_3way (&res->y0, &res->y1, width) > 0)
 545     {
 546       union value tmp;
 547       value_clone (&tmp, &res->y0, width);
 548       value_copy (&res->y0, &res->y1, width);
 549       value_copy (&res->y1, &tmp, width);
 550       value_destroy (&tmp, width);
 551       sum = sumA;
 552     }
 553
 554   n_coefficients += categoricals_df_total (res->cats);
 555   res->beta_hat = gsl_vector_calloc (n_coefficients);
 556
 557   if (cmd->constant)
 558     {
 559       double mean = sum / res->cc;
 560       gsl_vector_set (res->beta_hat, res->beta_hat->size - 1, log (mean / (1 - mean)));
 561     }
 562
 563   return true;
 564
 565  error:
 566   casereader_destroy (reader);
 567   return false;
 568 }
 569
 570
 571
 572 /* Start of the logistic regression routine proper */
 573 static bool
 574 run_lr (const struct lr_spec *cmd, struct casereader *input,
 575         const struct dataset *ds UNUSED)
 576 {
 577   int i;
 578
 579   bool converged = false;
 580
 581   /* Set the log likelihoods to a sentinel value */
 582   double log_likelihood = SYSMIS;
 583   double prev_log_likelihood = SYSMIS;
 584   double initial_log_likelihood = SYSMIS;
 585
 586   struct lr_result work;
 587   work.n_missing = 0;
 588   work.n_nonmissing = 0;
 589   work.warn_bad_weight = true;
 590   work.cats = NULL;
 591   work.beta_hat = NULL;
 592
 593   /* Get the initial estimates of \beta and their standard errors.
 594      And perform other auxilliary initialisation.  */
 595   if (! initial_pass (cmd, &work, input))
 596     return false;
 597
 598   for (i = 0; i < cmd->n_cat_predictors; ++i)
 599     {
 600       if (1 >= categoricals_n_count (work.cats, i))
 601         {
 602           struct string str;
 603           ds_init_empty (&str);
 604
 605           interaction_to_string (cmd->cat_predictors[i], &str);
 606
 607           msg (ME, _("Category %s does not have at least two distinct values. Logistic regression will not be run."),
 608                ds_cstr(&str));
 609           ds_destroy (&str);
 610           return false;
 611         }
 612     }
 613
 614   output_depvarmap (cmd, &work);
 615
 616   case_processing_summary (&work);
 617
 618
 619   input = casereader_create_filter_missing (input,
 620                                             cmd->indep_vars,
 621                                             cmd->n_indep_vars,
 622                                             cmd->exclude,
 623                                             NULL,
 624                                             NULL);
 625
 626
 627   work.hessian = gsl_matrix_calloc (work.beta_hat->size, work.beta_hat->size);
 628
 629   /* Start the Newton Raphson iteration process... */
 630   for( i = 0 ; i < cmd->max_iter ; ++i)
 631     {
 632       double min, max;
 633       gsl_vector *v ;
 634
 635
 636       hessian (cmd, &work, input,
 637                cmd->predictor_vars, cmd->n_predictor_vars,
 638                &converged);
 639
 640       gsl_linalg_cholesky_decomp (work.hessian);
 641       gsl_linalg_cholesky_invert (work.hessian);
 642
 643       v = xt_times_y_pi (cmd, &work, input,
 644                          cmd->predictor_vars, cmd->n_predictor_vars,
 645                          cmd->dep_var,
 646                          &log_likelihood);
 647
 648       {
 649         /* delta = M.v */
 650         gsl_vector *delta = gsl_vector_alloc (v->size);
 651         gsl_blas_dgemv (CblasNoTrans, 1.0, work.hessian, v, 0, delta);
 652         gsl_vector_free (v);
 653
 654
 655         gsl_vector_add (work.beta_hat, delta);
 656
 657         gsl_vector_minmax (delta, &min, &max);
 658
 659         if ( fabs (min) < cmd->bcon && fabs (max) < cmd->bcon)
 660           {
 661             msg (MN, _("Estimation terminated at iteration number %d because parameter estimates changed by less than %g"),
 662                  i + 1, cmd->bcon);
 663             converged = true;
 664           }
 665
 666         gsl_vector_free (delta);
 667       }
 668
 669       if (i > 0)
 670         {
 671           if (-log_likelihood > -(1.0 - cmd->lcon) * prev_log_likelihood)
 672             {
 673               msg (MN, _("Estimation terminated at iteration number %d because Log Likelihood decreased by less than %g%%"), i + 1, 100 * cmd->lcon);
 674               converged = true;
 675             }
 676         }
 677       if (i == 0)
 678         initial_log_likelihood = log_likelihood;
 679       prev_log_likelihood = log_likelihood;
 680
 681       if (converged)
 682         break;
 683     }
 684   casereader_destroy (input);
 685
 686
 687   if ( ! converged)
 688     msg (MW, _("Estimation terminated at iteration number %d because maximum iterations has been reached"), i );
 689
 690
 691   output_model_summary (&work, initial_log_likelihood, log_likelihood);
 692
 693   if (work.cats)
 694     output_categories (cmd, &work);
 695
 696   output_classification_table (cmd, &work);
 697   output_variables (cmd, &work);
 698
 699   gsl_matrix_free (work.hessian);
 700   gsl_vector_free (work.beta_hat);
 701
 702   categoricals_destroy (work.cats);
 703
 704   return true;
 705 }
 706
 707 struct variable_node
 708 {
 709   struct hmap_node node;      /* Node in hash map. */
 710   const struct variable *var; /* The variable */
 711 };
 712
 713 static struct variable_node *
 714 lookup_variable (const struct hmap *map, const struct variable *var, unsigned int hash)
 715 {
 716   struct variable_node *vn = NULL;
 717   HMAP_FOR_EACH_WITH_HASH (vn, struct variable_node, node, hash, map)
 718     {
 719       if (vn->var == var)
 720         break;
 721
 722       fprintf (stderr, "Warning: Hash table collision\n");
 723     }
 724
 725   return vn;
 726 }
 727
 728
 729 /* Parse the LOGISTIC REGRESSION command syntax */
 730 int
 731 cmd_logistic (struct lexer *lexer, struct dataset *ds)
 732 {
 733   /* Temporary location for the predictor variables.
 734      These may or may not include the categorical predictors */
 735   const struct variable **pred_vars;
 736   size_t n_pred_vars;
 737   double cp = 0.5;
 738
 739   int v, x;
 740   struct lr_spec lr;
 741   lr.dict = dataset_dict (ds);
 742   lr.n_predictor_vars = 0;
 743   lr.predictor_vars = NULL;
 744   lr.exclude = MV_ANY;
 745   lr.wv = dict_get_weight (lr.dict);
 746   lr.max_iter = 20;
 747   lr.lcon = 0.0000;
 748   lr.bcon = 0.001;
 749   lr.min_epsilon = 0.00000001;
 750   lr.constant = true;
 751   lr.confidence = 95;
 752   lr.print = PRINT_DEFAULT;
 753   lr.cat_predictors = NULL;
 754   lr.n_cat_predictors = 0;
 755   lr.indep_vars = NULL;
 756
 757
 758   if (lex_match_id (lexer, "VARIABLES"))
 759     lex_match (lexer, T_EQUALS);
 760
 761   if (! (lr.dep_var = parse_variable_const (lexer, lr.dict)))
 762     goto error;
 763
 764   lex_force_match (lexer, T_WITH);
 765
 766   if (!parse_variables_const (lexer, lr.dict,
 767                               &pred_vars, &n_pred_vars,
 768                               PV_NO_DUPLICATE))
 769     goto error;
 770
 771
 772   while (lex_token (lexer) != T_ENDCMD)
 773     {
 774       lex_match (lexer, T_SLASH);
 775
 776       if (lex_match_id (lexer, "MISSING"))
 777         {
 778           lex_match (lexer, T_EQUALS);
 779           while (lex_token (lexer) != T_ENDCMD
 780                  && lex_token (lexer) != T_SLASH)
 781             {
 782               if (lex_match_id (lexer, "INCLUDE"))
 783                 {
 784                   lr.exclude = MV_SYSTEM;
 785                 }
 786               else if (lex_match_id (lexer, "EXCLUDE"))
 787                 {
 788                   lr.exclude = MV_ANY;
 789                 }
 790               else
 791                 {
 792                   lex_error (lexer, NULL);
 793                   goto error;
 794                 }
 795             }
 796         }
 797       else if (lex_match_id (lexer, "ORIGIN"))
 798         {
 799           lr.constant = false;
 800         }
 801       else if (lex_match_id (lexer, "NOORIGIN"))
 802         {
 803           lr.constant = true;
 804         }
 805       else if (lex_match_id (lexer, "NOCONST"))
 806         {
 807           lr.constant = false;
 808         }
 809       else if (lex_match_id (lexer, "EXTERNAL"))
 810         {
 811           /* This is for compatibility.  It does nothing */
 812         }
 813       else if (lex_match_id (lexer, "CATEGORICAL"))
 814         {
 815           lex_match (lexer, T_EQUALS);
 816           do
 817             {
 818               lr.cat_predictors = xrealloc (lr.cat_predictors,
 819                                   sizeof (*lr.cat_predictors) * ++lr.n_cat_predictors);
 820               lr.cat_predictors[lr.n_cat_predictors - 1] = 0;
 821             }
 822           while (parse_design_interaction (lexer, lr.dict,
 823                                            lr.cat_predictors + lr.n_cat_predictors - 1));
 824           lr.n_cat_predictors--;
 825         }
 826       else if (lex_match_id (lexer, "PRINT"))
 827         {
 828           lex_match (lexer, T_EQUALS);
 829           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
 830             {
 831               if (lex_match_id (lexer, "DEFAULT"))
 832                 {
 833                   lr.print |= PRINT_DEFAULT;
 834                 }
 835               else if (lex_match_id (lexer, "SUMMARY"))
 836                 {
 837                   lr.print |= PRINT_SUMMARY;
 838                 }
 839 #if 0
 840               else if (lex_match_id (lexer, "CORR"))
 841                 {
 842                   lr.print |= PRINT_CORR;
 843                 }
 844               else if (lex_match_id (lexer, "ITER"))
 845                 {
 846                   lr.print |= PRINT_ITER;
 847                 }
 848               else if (lex_match_id (lexer, "GOODFIT"))
 849                 {
 850                   lr.print |= PRINT_GOODFIT;
 851                 }
 852 #endif
 853               else if (lex_match_id (lexer, "CI"))
 854                 {
 855                   lr.print |= PRINT_CI;
 856                   if (lex_force_match (lexer, T_LPAREN))
 857                     {
 858                       if (! lex_force_int (lexer))
 859                         {
 860                           lex_error (lexer, NULL);
 861                           goto error;
 862                         }
 863                       lr.confidence = lex_integer (lexer);
 864                       lex_get (lexer);
 865                       if ( ! lex_force_match (lexer, T_RPAREN))
 866                         {
 867                           lex_error (lexer, NULL);
 868                           goto error;
 869                         }
 870                     }
 871                 }
 872               else if (lex_match_id (lexer, "ALL"))
 873                 {
 874                   lr.print = ~0x0000;
 875                 }
 876               else
 877                 {
 878                   lex_error (lexer, NULL);
 879                   goto error;
 880                 }
 881             }
 882         }
 883       else if (lex_match_id (lexer, "CRITERIA"))
 884         {
 885           lex_match (lexer, T_EQUALS);
 886           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
 887             {
 888               if (lex_match_id (lexer, "BCON"))
 889                 {
 890                   if (lex_force_match (lexer, T_LPAREN))
 891                     {
 892                       if (! lex_force_num (lexer))
 893                         {
 894                           lex_error (lexer, NULL);
 895                           goto error;
 896                         }
 897                       lr.bcon = lex_number (lexer);
 898                       lex_get (lexer);
 899                       if ( ! lex_force_match (lexer, T_RPAREN))
 900                         {
 901                           lex_error (lexer, NULL);
 902                           goto error;
 903                         }
 904                     }
 905                 }
 906               else if (lex_match_id (lexer, "ITERATE"))
 907                 {
 908                   if (lex_force_match (lexer, T_LPAREN))
 909                     {
 910                       if (! lex_force_int (lexer))
 911                         {
 912                           lex_error (lexer, NULL);
 913                           goto error;
 914                         }
 915                       lr.max_iter = lex_integer (lexer);
 916                       lex_get (lexer);
 917                       if ( ! lex_force_match (lexer, T_RPAREN))
 918                         {
 919                           lex_error (lexer, NULL);
 920                           goto error;
 921                         }
 922                     }
 923                 }
 924               else if (lex_match_id (lexer, "LCON"))
 925                 {
 926                   if (lex_force_match (lexer, T_LPAREN))
 927                     {
 928                       if (! lex_force_num (lexer))
 929                         {
 930                           lex_error (lexer, NULL);
 931                           goto error;
 932                         }
 933                       lr.lcon = lex_number (lexer);
 934                       lex_get (lexer);
 935                       if ( ! lex_force_match (lexer, T_RPAREN))
 936                         {
 937                           lex_error (lexer, NULL);
 938                           goto error;
 939                         }
 940                     }
 941                 }
 942               else if (lex_match_id (lexer, "EPS"))
 943                 {
 944                   if (lex_force_match (lexer, T_LPAREN))
 945                     {
 946                       if (! lex_force_num (lexer))
 947                         {
 948                           lex_error (lexer, NULL);
 949                           goto error;
 950                         }
 951                       lr.min_epsilon = lex_number (lexer);
 952                       lex_get (lexer);
 953                       if ( ! lex_force_match (lexer, T_RPAREN))
 954                         {
 955                           lex_error (lexer, NULL);
 956                           goto error;
 957                         }
 958                     }
 959                 }
 960               else if (lex_match_id (lexer, "CUT"))
 961                 {
 962                   if (lex_force_match (lexer, T_LPAREN))
 963                     {
 964                       if (! lex_force_num (lexer))
 965                         {
 966                           lex_error (lexer, NULL);
 967                           goto error;
 968                         }
 969                       cp = lex_number (lexer);
 970
 971                       if (cp < 0 || cp > 1.0)
 972                         {
 973                           msg (ME, _("Cut point value must be in the range [0,1]"));
 974                           goto error;
 975                         }
 976                       lex_get (lexer);
 977                       if ( ! lex_force_match (lexer, T_RPAREN))
 978                         {
 979                           lex_error (lexer, NULL);
 980                           goto error;
 981                         }
 982                     }
 983                 }
 984               else
 985                 {
 986                   lex_error (lexer, NULL);
 987                   goto error;
 988                 }
 989             }
 990         }
 991       else
 992         {
 993           lex_error (lexer, NULL);
 994           goto error;
 995         }
 996     }
 997
 998   lr.ilogit_cut_point = - log (1/cp - 1);
 999
1000
1001   /* Copy the predictor variables from the temporary location into the
1002      final one, dropping any categorical variables which appear there.
1003      FIXME: This is O(NxM).
1004   */
1005   {
1006   struct variable_node *vn, *next;
1007   struct hmap allvars;
1008   hmap_init (&allvars);
1009   for (v = x = 0; v < n_pred_vars; ++v)
1010     {
1011       bool drop = false;
1012       const struct variable *var = pred_vars[v];
1013       int cv = 0;
1014
1015       unsigned int hash = hash_pointer (var, 0);
1016       struct variable_node *vn = lookup_variable (&allvars, var, hash);
1017       if (vn == NULL)
1018         {
1019           vn = xmalloc (sizeof *vn);
1020           vn->var = var;
1021           hmap_insert (&allvars, &vn->node,  hash);
1022         }
1023
1024       for (cv = 0; cv < lr.n_cat_predictors ; ++cv)
1025         {
1026           int iv;
1027           const struct interaction *iact = lr.cat_predictors[cv];
1028           for (iv = 0 ; iv < iact->n_vars ; ++iv)
1029             {
1030               const struct variable *ivar = iact->vars[iv];
1031               unsigned int hash = hash_pointer (ivar, 0);
1032               struct variable_node *vn = lookup_variable (&allvars, ivar, hash);
1033               if (vn == NULL)
1034                 {
1035                   vn = xmalloc (sizeof *vn);
1036                   vn->var = ivar;
1037
1038                   hmap_insert (&allvars, &vn->node,  hash);
1039                 }
1040
1041               if (var == ivar)
1042                 {
1043                   drop = true;
1044                 }
1045             }
1046         }
1047
1048       if (drop)
1049         continue;
1050
1051       lr.predictor_vars = xrealloc (lr.predictor_vars, sizeof *lr.predictor_vars * (x + 1));
1052       lr.predictor_vars[x++] = var;
1053       lr.n_predictor_vars++;
1054     }
1055   free (pred_vars);
1056
1057   lr.n_indep_vars = hmap_count (&allvars);
1058   lr.indep_vars = xmalloc (lr.n_indep_vars * sizeof *lr.indep_vars);
1059
1060   /* Interate over each variable and push it into the array */
1061   x = 0;
1062   HMAP_FOR_EACH_SAFE (vn, next, struct variable_node, node, &allvars)
1063     {
1064       lr.indep_vars[x++] = vn->var;
1065       free (vn);
1066     }
1067   hmap_destroy (&allvars);
1068   }
1069
1070
1071   /* logistical regression for each split group */
1072   {
1073     struct casegrouper *grouper;
1074     struct casereader *group;
1075     bool ok;
1076
1077     grouper = casegrouper_create_splits (proc_open (ds), lr.dict);
1078     while (casegrouper_get_next_group (grouper, &group))
1079       ok = run_lr (&lr, group, ds);
1080     ok = casegrouper_destroy (grouper);
1081     ok = proc_commit (ds) && ok;
1082   }
1083
1084   free (lr.predictor_vars);
1085   free (lr.cat_predictors);
1086   free (lr.indep_vars);
1087
1088   return CMD_SUCCESS;
1089
1090  error:
1091
1092   free (lr.predictor_vars);
1093   free (lr.cat_predictors);
1094   free (lr.indep_vars);
1095
1096   return CMD_FAILURE;
1097 }
1098
1099
1100 \f
1101
1102 /* Show the Dependent Variable Encoding box.
1103    This indicates how the dependent variable
1104    is mapped to the internal zero/one values.
1105 */
1106 static void
1107 output_depvarmap (const struct lr_spec *cmd, const struct lr_result *res)
1108 {
1109   const int heading_columns = 0;
1110   const int heading_rows = 1;
1111   struct tab_table *t;
1112   struct string str;
1113
1114   const int nc = 2;
1115   int nr = heading_rows + 2;
1116
1117   t = tab_create (nc, nr);
1118   tab_title (t, _("Dependent Variable Encoding"));
1119
1120   tab_headers (t, heading_columns, 0, heading_rows, 0);
1121
1122   tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1123
1124   tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1125   tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1126
1127   tab_text (t,  0, 0, TAB_CENTER | TAT_TITLE, _("Original Value"));
1128   tab_text (t,  1, 0, TAB_CENTER | TAT_TITLE, _("Internal Value"));
1129
1130
1131
1132   ds_init_empty (&str);
1133   var_append_value_name (cmd->dep_var, &res->y0, &str);
1134   tab_text (t,  0, 0 + heading_rows,  0, ds_cstr (&str));
1135
1136   ds_clear (&str);
1137   var_append_value_name (cmd->dep_var, &res->y1, &str);
1138   tab_text (t,  0, 1 + heading_rows,  0, ds_cstr (&str));
1139
1140
1141   tab_double (t, 1, 0 + heading_rows, 0, map_dependent_var (cmd, res, &res->y0), &F_8_0);
1142   tab_double (t, 1, 1 + heading_rows, 0, map_dependent_var (cmd, res, &res->y1), &F_8_0);
1143   ds_destroy (&str);
1144
1145   tab_submit (t);
1146 }
1147
1148
1149 /* Show the Variables in the Equation box */
1150 static void
1151 output_variables (const struct lr_spec *cmd,
1152                   const struct lr_result *res)
1153 {
1154   int row = 0;
1155   const int heading_columns = 1;
1156   int heading_rows = 1;
1157   struct tab_table *t;
1158
1159   int nc = 8;
1160   int nr ;
1161   int i = 0;
1162   int ivar = 0;
1163   int idx_correction = 0;
1164
1165   if (cmd->print & PRINT_CI)
1166     {
1167       nc += 2;
1168       heading_rows += 1;
1169       row++;
1170     }
1171   nr = heading_rows + cmd->n_predictor_vars;
1172   if (cmd->constant)
1173     nr++;
1174
1175   if (res->cats)
1176     nr += categoricals_df_total (res->cats) + cmd->n_cat_predictors;
1177
1178   t = tab_create (nc, nr);
1179   tab_title (t, _("Variables in the Equation"));
1180
1181   tab_headers (t, heading_columns, 0, heading_rows, 0);
1182
1183   tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1184
1185   tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1186   tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1187
1188   tab_text (t,  0, row + 1, TAB_CENTER | TAT_TITLE, _("Step 1"));
1189
1190   tab_text (t,  2, row, TAB_CENTER | TAT_TITLE, _("B"));
1191   tab_text (t,  3, row, TAB_CENTER | TAT_TITLE, _("S.E."));
1192   tab_text (t,  4, row, TAB_CENTER | TAT_TITLE, _("Wald"));
1193   tab_text (t,  5, row, TAB_CENTER | TAT_TITLE, _("df"));
1194   tab_text (t,  6, row, TAB_CENTER | TAT_TITLE, _("Sig."));
1195   tab_text (t,  7, row, TAB_CENTER | TAT_TITLE, _("Exp(B)"));
1196
1197   if (cmd->print & PRINT_CI)
1198     {
1199       tab_joint_text_format (t, 8, 0, 9, 0,
1200                              TAB_CENTER | TAT_TITLE, _("%d%% CI for Exp(B)"), cmd->confidence);
1201
1202       tab_text (t,  8, row, TAB_CENTER | TAT_TITLE, _("Lower"));
1203       tab_text (t,  9, row, TAB_CENTER | TAT_TITLE, _("Upper"));
1204     }
1205
1206   for (row = heading_rows ; row < nr; ++row)
1207     {
1208       const int idx = row - heading_rows - idx_correction;
1209
1210       const double b = gsl_vector_get (res->beta_hat, idx);
1211       const double sigma2 = gsl_matrix_get (res->hessian, idx, idx);
1212       const double wald = pow2 (b) / sigma2;
1213       const double df = 1;
1214
1215       if (idx < cmd->n_predictor_vars)
1216         {
1217           tab_text (t, 1, row, TAB_LEFT | TAT_TITLE,
1218                     var_to_string (cmd->predictor_vars[idx]));
1219         }
1220       else if (i < cmd->n_cat_predictors)
1221         {
1222           double wald;
1223           bool summary = false;
1224           struct string str;
1225           const struct interaction *cat_predictors = cmd->cat_predictors[i];
1226           const int df = categoricals_df (res->cats, i);
1227
1228           ds_init_empty (&str);
1229           interaction_to_string (cat_predictors, &str);
1230
1231           if (ivar == 0)
1232             {
1233               /* Calculate the Wald statistic,
1234                  which is \beta' C^-1 \beta .
1235                  where \beta is the vector of the coefficient estimates comprising this
1236                  categorial variable. and C is the corresponding submatrix of the
1237                  hessian matrix.
1238               */
1239               gsl_matrix_const_view mv =
1240                 gsl_matrix_const_submatrix (res->hessian, idx, idx, df, df);
1241               gsl_matrix *subhessian = gsl_matrix_alloc (mv.matrix.size1, mv.matrix.size2);
1242               gsl_vector_const_view vv = gsl_vector_const_subvector (res->beta_hat, idx, df);
1243               gsl_vector *temp = gsl_vector_alloc (df);
1244
1245               gsl_matrix_memcpy (subhessian, &mv.matrix);
1246               gsl_linalg_cholesky_decomp (subhessian);
1247               gsl_linalg_cholesky_invert (subhessian);
1248
1249               gsl_blas_dgemv (CblasTrans, 1.0, subhessian, &vv.vector, 0, temp);
1250               gsl_blas_ddot (temp, &vv.vector, &wald);
1251
1252               tab_double (t, 4, row, 0, wald, 0);
1253               tab_double (t, 5, row, 0, df, &F_8_0);
1254               tab_double (t, 6, row, 0, gsl_cdf_chisq_Q (wald, df), 0);
1255
1256               idx_correction ++;
1257               summary = true;
1258               gsl_matrix_free (subhessian);
1259               gsl_vector_free (temp);
1260             }
1261           else
1262             {
1263               ds_put_format (&str, "(%d)", ivar);
1264             }
1265
1266           tab_text (t, 1, row, TAB_LEFT | TAT_TITLE, ds_cstr (&str));
1267           if (ivar++ == df)
1268             {
1269               ++i; /* next interaction */
1270               ivar = 0;
1271             }
1272
1273           ds_destroy (&str);
1274
1275           if (summary)
1276             continue;
1277         }
1278       else
1279         {
1280           tab_text (t, 1, row, TAB_LEFT | TAT_TITLE, _("Constant"));
1281         }
1282
1283       tab_double (t, 2, row, 0, b, 0);
1284       tab_double (t, 3, row, 0, sqrt (sigma2), 0);
1285       tab_double (t, 4, row, 0, wald, 0);
1286       tab_double (t, 5, row, 0, df, &F_8_0);
1287       tab_double (t, 6, row, 0, gsl_cdf_chisq_Q (wald, df), 0);
1288       tab_double (t, 7, row, 0, exp (b), 0);
1289
1290       if (cmd->print & PRINT_CI)
1291         {
1292           int last_ci = nr;
1293           double wc = gsl_cdf_ugaussian_Pinv (0.5 + cmd->confidence / 200.0);
1294           wc *= sqrt (sigma2);
1295
1296           if (cmd->constant)
1297             last_ci--;
1298
1299           if (row < last_ci)
1300             {
1301               tab_double (t, 8, row, 0, exp (b - wc), 0);
1302               tab_double (t, 9, row, 0, exp (b + wc), 0);
1303             }
1304         }
1305     }
1306
1307   tab_submit (t);
1308 }
1309
1310
1311 /* Show the model summary box */
1312 static void
1313 output_model_summary (const struct lr_result *res,
1314                       double initial_log_likelihood, double log_likelihood)
1315 {
1316   const int heading_columns = 0;
1317   const int heading_rows = 1;
1318   struct tab_table *t;
1319
1320   const int nc = 4;
1321   int nr = heading_rows + 1;
1322   double cox;
1323
1324   t = tab_create (nc, nr);
1325   tab_title (t, _("Model Summary"));
1326
1327   tab_headers (t, heading_columns, 0, heading_rows, 0);
1328
1329   tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1330
1331   tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1332   tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1333
1334   tab_text (t,  0, 0, TAB_LEFT | TAT_TITLE, _("Step 1"));
1335   tab_text (t,  1, 0, TAB_CENTER | TAT_TITLE, _("-2 Log likelihood"));
1336   tab_double (t,  1, 1, 0, -2 * log_likelihood, 0);
1337
1338
1339   tab_text (t,  2, 0, TAB_CENTER | TAT_TITLE, _("Cox & Snell R Square"));
1340   cox =  1.0 - exp((initial_log_likelihood - log_likelihood) * (2 / res->cc));
1341   tab_double (t,  2, 1, 0, cox, 0);
1342
1343   tab_text (t,  3, 0, TAB_CENTER | TAT_TITLE, _("Nagelkerke R Square"));
1344   tab_double (t,  3, 1, 0, cox / ( 1.0 - exp(initial_log_likelihood * (2 / res->cc))), 0);
1345
1346
1347   tab_submit (t);
1348 }
1349
1350 /* Show the case processing summary box */
1351 static void
1352 case_processing_summary (const struct lr_result *res)
1353 {
1354   const int heading_columns = 1;
1355   const int heading_rows = 1;
1356   struct tab_table *t;
1357
1358   const int nc = 3;
1359   const int nr = heading_rows + 3;
1360   casenumber total;
1361
1362   t = tab_create (nc, nr);
1363   tab_title (t, _("Case Processing Summary"));
1364
1365   tab_headers (t, heading_columns, 0, heading_rows, 0);
1366
1367   tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1368
1369   tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1370   tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1371
1372   tab_text (t,  0, 0, TAB_LEFT | TAT_TITLE, _("Unweighted Cases"));
1373   tab_text (t,  1, 0, TAB_CENTER | TAT_TITLE, _("N"));
1374   tab_text (t,  2, 0, TAB_CENTER | TAT_TITLE, _("Percent"));
1375
1376
1377   tab_text (t,  0, 1, TAB_LEFT | TAT_TITLE, _("Included in Analysis"));
1378   tab_text (t,  0, 2, TAB_LEFT | TAT_TITLE, _("Missing Cases"));
1379   tab_text (t,  0, 3, TAB_LEFT | TAT_TITLE, _("Total"));
1380
1381   tab_double (t,  1, 1, 0, res->n_nonmissing, &F_8_0);
1382   tab_double (t,  1, 2, 0, res->n_missing, &F_8_0);
1383
1384   total = res->n_nonmissing + res->n_missing;
1385   tab_double (t,  1, 3, 0, total , &F_8_0);
1386
1387   tab_double (t,  2, 1, 0, 100 * res->n_nonmissing / (double) total, 0);
1388   tab_double (t,  2, 2, 0, 100 * res->n_missing / (double) total, 0);
1389   tab_double (t,  2, 3, 0, 100 * total / (double) total, 0);
1390
1391   tab_submit (t);
1392 }
1393
1394 static void
1395 output_categories (const struct lr_spec *cmd, const struct lr_result *res)
1396 {
1397   const struct fmt_spec *wfmt =
1398     cmd->wv ? var_get_print_format (cmd->wv) : &F_8_0;
1399
1400   int cumulative_df;
1401   int i = 0;
1402   const int heading_columns = 2;
1403   const int heading_rows = 2;
1404   struct tab_table *t;
1405
1406   int nc ;
1407   int nr ;
1408
1409   int v;
1410   int r = 0;
1411
1412   int max_df = 0;
1413   int total_cats = 0;
1414   for (i = 0; i < cmd->n_cat_predictors; ++i)
1415     {
1416       size_t n = categoricals_n_count (res->cats, i);
1417       size_t df = categoricals_df (res->cats, i);
1418       if (max_df < df)
1419         max_df = df;
1420       total_cats += n;
1421     }
1422
1423   nc = heading_columns + 1 + max_df;
1424   nr = heading_rows + total_cats;
1425
1426   t = tab_create (nc, nr);
1427   tab_title (t, _("Categorical Variables' Codings"));
1428
1429   tab_headers (t, heading_columns, 0, heading_rows, 0);
1430
1431   tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
1432
1433   tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1434   tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1435
1436
1437   tab_text (t, heading_columns, 1, TAB_CENTER | TAT_TITLE, _("Frequency"));
1438
1439   tab_joint_text_format (t, heading_columns + 1, 0, nc - 1, 0,
1440                          TAB_CENTER | TAT_TITLE, _("Parameter coding"));
1441
1442
1443   for (i = 0; i < max_df; ++i)
1444     {
1445       int c = heading_columns + 1 + i;
1446       tab_text_format (t,  c, 1, TAB_CENTER | TAT_TITLE, _("(%d)"), i + 1);
1447     }
1448
1449   cumulative_df = 0;
1450   for (v = 0; v < cmd->n_cat_predictors; ++v)
1451     {
1452       int cat;
1453       const struct interaction *cat_predictors = cmd->cat_predictors[v];
1454       int df =  categoricals_df (res->cats, v);
1455       struct string str;
1456       ds_init_empty (&str);
1457
1458       interaction_to_string (cat_predictors, &str);
1459
1460       tab_text (t, 0, heading_rows + r, TAB_LEFT | TAT_TITLE, ds_cstr (&str) );
1461
1462       ds_destroy (&str);
1463
1464       for (cat = 0; cat < categoricals_n_count (res->cats, v) ; ++cat)
1465         {
1466           struct string str;
1467           const struct ccase *c = categoricals_get_case_by_category_real (res->cats, v, cat);
1468           const double *freq = categoricals_get_user_data_by_category_real (res->cats, v, cat);
1469
1470           int x;
1471           ds_init_empty (&str);
1472
1473           for (x = 0; x < cat_predictors->n_vars; ++x)
1474             {
1475               const union value *val = case_data (c, cat_predictors->vars[x]);
1476               var_append_value_name (cat_predictors->vars[x], val, &str);
1477
1478               if (x < cat_predictors->n_vars - 1)
1479                 ds_put_cstr (&str, " ");
1480             }
1481
1482           tab_text   (t, 1, heading_rows + r, 0, ds_cstr (&str));
1483           ds_destroy (&str);
1484           tab_double (t, 2, heading_rows + r, 0, *freq, wfmt);
1485
1486           for (x = 0; x < df; ++x)
1487             {
1488               tab_double (t, heading_columns + 1 + x, heading_rows + r, 0, (cat == x), &F_8_0);
1489             }
1490           ++r;
1491         }
1492       cumulative_df += df;
1493     }
1494
1495   tab_submit (t);
1496
1497 }
1498
1499
1500 static void
1501 output_classification_table (const struct lr_spec *cmd, const struct lr_result *res)
1502 {
1503   const struct fmt_spec *wfmt =
1504     cmd->wv ? var_get_print_format (cmd->wv) : &F_8_0;
1505
1506   const int heading_columns = 3;
1507   const int heading_rows = 3;
1508
1509   struct string sv0, sv1;
1510
1511   const int nc = heading_columns + 3;
1512   const int nr = heading_rows + 3;
1513
1514   struct tab_table *t = tab_create (nc, nr);
1515
1516   ds_init_empty (&sv0);
1517   ds_init_empty (&sv1);
1518
1519   tab_title (t, _("Classification Table"));
1520
1521   tab_headers (t, heading_columns, 0, heading_rows, 0);
1522
1523   tab_box (t, TAL_2, TAL_2, -1, -1, 0, 0, nc - 1, nr - 1);
1524   tab_box (t, -1, -1, -1, TAL_1, heading_columns, 0, nc - 1, nr - 1);
1525
1526   tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
1527   tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
1528
1529   tab_text (t,  0, heading_rows, TAB_CENTER | TAT_TITLE, _("Step 1"));
1530
1531
1532   tab_joint_text (t, heading_columns, 0, nc - 1, 0,
1533                   TAB_CENTER | TAT_TITLE, _("Predicted"));
1534
1535   tab_joint_text (t, heading_columns, 1, heading_columns + 1, 1,
1536                   0, var_to_string (cmd->dep_var) );
1537
1538   tab_joint_text (t, 1, 2, 2, 2,
1539                   TAB_LEFT | TAT_TITLE, _("Observed"));
1540
1541   tab_text (t, 1, 3, TAB_LEFT, var_to_string (cmd->dep_var) );
1542
1543
1544   tab_joint_text (t, nc - 1, 1, nc - 1, 2,
1545                   TAB_CENTER | TAT_TITLE, _("Percentage\nCorrect"));
1546
1547
1548   tab_joint_text (t, 1, nr - 1, 2, nr - 1,
1549                   TAB_LEFT | TAT_TITLE, _("Overall Percentage"));
1550
1551
1552   tab_hline (t, TAL_1, 1, nc - 1, nr - 1);
1553
1554   var_append_value_name (cmd->dep_var, &res->y0, &sv0);
1555   var_append_value_name (cmd->dep_var, &res->y1, &sv1);
1556
1557   tab_text (t, 2, heading_rows,     TAB_LEFT,  ds_cstr (&sv0));
1558   tab_text (t, 2, heading_rows + 1, TAB_LEFT,  ds_cstr (&sv1));
1559
1560   tab_text (t, heading_columns,     2, 0,  ds_cstr (&sv0));
1561   tab_text (t, heading_columns + 1, 2, 0,  ds_cstr (&sv1));
1562
1563   ds_destroy (&sv0);
1564   ds_destroy (&sv1);
1565
1566   tab_double (t, heading_columns, 3,     0, res->tn, wfmt);
1567   tab_double (t, heading_columns + 1, 4, 0, res->tp, wfmt);
1568
1569   tab_double (t, heading_columns + 1, 3, 0, res->fp, wfmt);
1570   tab_double (t, heading_columns,     4, 0, res->fn, wfmt);
1571
1572   tab_double (t, heading_columns + 2, 3, 0, 100 * res->tn / (res->tn + res->fp), 0);
1573   tab_double (t, heading_columns + 2, 4, 0, 100 * res->tp / (res->tp + res->fn), 0);
1574
1575   tab_double (t, heading_columns + 2, 5, 0,
1576               100 * (res->tp + res->tn) / (res->tp  + res->tn + res->fp + res->fn), 0);
1577
1578
1579   tab_submit (t);
1580 }