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/hash-functions.h"
  64 #include "libpspp/hmap.h"
  65 #include "libpspp/ll.h"
  66 #include "libpspp/message.h"
  67 #include "libpspp/misc.h"
  68 #include "math/categoricals.h"
  69 #include "math/interaction.h"
  70 #include "output/pivot-table.h"
  71
  72 #include "gettext.h"
  73 #define N_(msgid) msgid
  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_num (c, x[index]);
 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)
 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, 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       if (var_is_value_missing (cmd->dep_var, depval) & cmd->exclude)
 482         {
 483           missing = true;
 484         }
 485       else
 486       for (v = 0; v < cmd->n_indep_vars; ++v)
 487         {
 488           const union value *val = case_data (c, cmd->indep_vars[v]);
 489           if (var_is_value_missing (cmd->indep_vars[v], val) & cmd->exclude)
 490             {
 491               missing = true;
 492               break;
 493             }
 494         }
 495
 496       /* Accumulate the missing and non-missing counts */
 497       if (missing)
 498         {
 499           res->n_missing++;
 500           continue;
 501         }
 502       res->n_nonmissing++;
 503
 504       /* Find the values of the dependent variable */
 505       if (!v0set)
 506         {
 507           value_clone (&res->y0, depval, width);
 508           v0set = true;
 509         }
 510       else if (!v1set)
 511         {
 512           if (!value_equal (&res->y0, depval, width))
 513             {
 514               value_clone (&res->y1, depval, width);
 515               v1set = true;
 516             }
 517         }
 518       else
 519         {
 520           if (!value_equal (&res->y0, depval, width)
 521               &&
 522               !value_equal (&res->y1, depval, width)
 523         )
 524             {
 525               msg (ME, _("Dependent variable's values are not dichotomous."));
 526               case_unref (c);
 527               goto error;
 528             }
 529         }
 530
 531       if (v0set && value_equal (&res->y0, depval, width))
 532           sumA += weight;
 533
 534       if (v1set && value_equal (&res->y1, depval, width))
 535           sumB += weight;
 536
 537
 538       res->cc += weight;
 539
 540       categoricals_update (res->cats, c);
 541     }
 542   casereader_destroy (reader);
 543
 544   categoricals_done (res->cats);
 545
 546   sum = sumB;
 547
 548   /* Ensure that Y0 is less than Y1.  Otherwise the mapping gets
 549      inverted, which is confusing to users */
 550   if (var_is_numeric (cmd->dep_var) && value_compare_3way (&res->y0, &res->y1, width) > 0)
 551     {
 552       union value tmp;
 553       value_clone (&tmp, &res->y0, width);
 554       value_copy (&res->y0, &res->y1, width);
 555       value_copy (&res->y1, &tmp, width);
 556       value_destroy (&tmp, width);
 557       sum = sumA;
 558     }
 559
 560   n_coefficients += categoricals_df_total (res->cats);
 561   res->beta_hat = gsl_vector_calloc (n_coefficients);
 562
 563   if (cmd->constant)
 564     {
 565       double mean = sum / res->cc;
 566       gsl_vector_set (res->beta_hat, res->beta_hat->size - 1, log (mean / (1 - mean)));
 567     }
 568
 569   return true;
 570
 571  error:
 572   casereader_destroy (reader);
 573   return false;
 574 }
 575
 576
 577
 578 /* Start of the logistic regression routine proper */
 579 static bool
 580 run_lr (const struct lr_spec *cmd, struct casereader *input,
 581         const struct dataset *ds UNUSED)
 582 {
 583   int i;
 584
 585   bool converged = false;
 586
 587   /* Set the log likelihoods to a sentinel value */
 588   double log_likelihood = SYSMIS;
 589   double prev_log_likelihood = SYSMIS;
 590   double initial_log_likelihood = SYSMIS;
 591
 592   struct lr_result work;
 593   work.n_missing = 0;
 594   work.n_nonmissing = 0;
 595   work.warn_bad_weight = true;
 596   work.cats = NULL;
 597   work.beta_hat = NULL;
 598   work.hessian = NULL;
 599
 600   /* Get the initial estimates of \beta and their standard errors.
 601      And perform other auxiliary initialisation.  */
 602   if (!initial_pass (cmd, &work, input))
 603     goto error;
 604
 605   for (i = 0; i < cmd->n_cat_predictors; ++i)
 606     {
 607       if (1 >= categoricals_n_count (work.cats, i))
 608         {
 609           struct string str;
 610           ds_init_empty (&str);
 611
 612           interaction_to_string (cmd->cat_predictors[i], &str);
 613
 614           msg (ME, _("Category %s does not have at least two distinct values. Logistic regression will not be run."),
 615                ds_cstr(&str));
 616           ds_destroy (&str);
 617           goto error;
 618         }
 619     }
 620
 621   output_depvarmap (cmd, &work);
 622
 623   case_processing_summary (&work);
 624
 625
 626   input = casereader_create_filter_missing (input,
 627                                             cmd->indep_vars,
 628                                             cmd->n_indep_vars,
 629                                             cmd->exclude,
 630                                             NULL,
 631                                             NULL);
 632
 633   input = casereader_create_filter_missing (input,
 634                                             &cmd->dep_var,
 635                                             1,
 636                                             cmd->exclude,
 637                                             NULL,
 638                                             NULL);
 639
 640   work.hessian = gsl_matrix_calloc (work.beta_hat->size, work.beta_hat->size);
 641
 642   /* Start the Newton Raphson iteration process... */
 643   for(i = 0; i < cmd->max_iter; ++i)
 644     {
 645       double min, max;
 646       gsl_vector *v;
 647
 648
 649       hessian (cmd, &work, input,
 650                cmd->predictor_vars, cmd->n_predictor_vars,
 651                &converged);
 652
 653       gsl_linalg_cholesky_decomp (work.hessian);
 654       gsl_linalg_cholesky_invert (work.hessian);
 655
 656       v = xt_times_y_pi (cmd, &work, input,
 657                          cmd->predictor_vars, cmd->n_predictor_vars,
 658                          cmd->dep_var,
 659                          &log_likelihood);
 660
 661       {
 662         /* delta = M.v */
 663         gsl_vector *delta = gsl_vector_alloc (v->size);
 664         gsl_blas_dgemv (CblasNoTrans, 1.0, work.hessian, v, 0, delta);
 665         gsl_vector_free (v);
 666
 667
 668         gsl_vector_add (work.beta_hat, delta);
 669
 670         gsl_vector_minmax (delta, &min, &max);
 671
 672         if (fabs (min) < cmd->bcon && fabs (max) < cmd->bcon)
 673           {
 674             msg (MN, _("Estimation terminated at iteration number %d because parameter estimates changed by less than %g"),
 675                  i + 1, cmd->bcon);
 676             converged = true;
 677           }
 678
 679         gsl_vector_free (delta);
 680       }
 681
 682       if (i > 0)
 683         {
 684           if (-log_likelihood > -(1.0 - cmd->lcon) * prev_log_likelihood)
 685             {
 686               msg (MN, _("Estimation terminated at iteration number %d because Log Likelihood decreased by less than %g%%"), i + 1, 100 * cmd->lcon);
 687               converged = true;
 688             }
 689         }
 690       if (i == 0)
 691         initial_log_likelihood = log_likelihood;
 692       prev_log_likelihood = log_likelihood;
 693
 694       if (converged)
 695         break;
 696     }
 697
 698
 699
 700   if (!converged)
 701     msg (MW, _("Estimation terminated at iteration number %d because maximum iterations has been reached"), i);
 702
 703
 704   output_model_summary (&work, initial_log_likelihood, log_likelihood);
 705
 706   if (work.cats)
 707     output_categories (cmd, &work);
 708
 709   output_classification_table (cmd, &work);
 710   output_variables (cmd, &work);
 711
 712   casereader_destroy (input);
 713   gsl_matrix_free (work.hessian);
 714   gsl_vector_free (work.beta_hat);
 715   categoricals_destroy (work.cats);
 716
 717   return true;
 718
 719  error:
 720   casereader_destroy (input);
 721   gsl_matrix_free (work.hessian);
 722   gsl_vector_free (work.beta_hat);
 723   categoricals_destroy (work.cats);
 724
 725   return false;
 726 }
 727
 728 struct variable_node
 729 {
 730   struct hmap_node node;      /* Node in hash map. */
 731   const struct variable *var; /* The variable */
 732 };
 733
 734 static struct variable_node *
 735 lookup_variable (const struct hmap *map, const struct variable *var, unsigned int hash)
 736 {
 737   struct variable_node *vn;
 738   HMAP_FOR_EACH_WITH_HASH (vn, struct variable_node, node, hash, map)
 739     if (vn->var == var)
 740       return vn;
 741
 742   return NULL;
 743 }
 744
 745 static void
 746 insert_variable (struct hmap *map, const struct variable *var, unsigned int hash)
 747 {
 748   if (!lookup_variable (map, var, hash))
 749     {
 750       struct variable_node *vn = xmalloc (sizeof *vn);
 751       *vn = (struct variable_node) { .var = var };
 752       hmap_insert (map, &vn->node, hash);
 753     }
 754 }
 755
 756 /* Parse the LOGISTIC REGRESSION command syntax */
 757 int
 758 cmd_logistic (struct lexer *lexer, struct dataset *ds)
 759 {
 760   /* Temporary location for the predictor variables.
 761      These may or may not include the categorical predictors */
 762   const struct variable **pred_vars = NULL;
 763   size_t n_pred_vars = 0;
 764   double cp = 0.5;
 765
 766   struct dictionary *dict = dataset_dict (ds);
 767   struct lr_spec lr = {
 768     .dict = dict,
 769     .exclude = MV_ANY,
 770     .wv = dict_get_weight (dict),
 771     .max_iter = 20,
 772     .lcon = 0.0000,
 773     .bcon = 0.001,
 774     .min_epsilon = 0.00000001,
 775     .constant = true,
 776     .confidence = 95,
 777     .print = PRINT_DEFAULT,
 778   };
 779
 780   if (lex_match_id (lexer, "VARIABLES"))
 781     lex_match (lexer, T_EQUALS);
 782
 783   lr.dep_var = parse_variable_const (lexer, lr.dict);
 784   if (!lr.dep_var)
 785     goto error;
 786
 787   if (!lex_force_match (lexer, T_WITH))
 788     goto error;
 789
 790   if (!parse_variables_const (lexer, lr.dict, &pred_vars, &n_pred_vars,
 791                               PV_NO_DUPLICATE))
 792     goto error;
 793
 794   while (lex_token (lexer) != T_ENDCMD)
 795     {
 796       lex_match (lexer, T_SLASH);
 797
 798       if (lex_match_id (lexer, "MISSING"))
 799         {
 800           lex_match (lexer, T_EQUALS);
 801           while (lex_token (lexer) != T_ENDCMD
 802                  && lex_token (lexer) != T_SLASH)
 803             {
 804               if (lex_match_id (lexer, "INCLUDE"))
 805                 lr.exclude = MV_SYSTEM;
 806               else if (lex_match_id (lexer, "EXCLUDE"))
 807                 lr.exclude = MV_ANY;
 808               else
 809                 {
 810                   lex_error_expecting (lexer, "INCLUDE", "EXCLUDE");
 811                   goto error;
 812                 }
 813             }
 814         }
 815       else if (lex_match_id (lexer, "ORIGIN"))
 816         lr.constant = false;
 817       else if (lex_match_id (lexer, "NOORIGIN"))
 818         lr.constant = true;
 819       else if (lex_match_id (lexer, "NOCONST"))
 820         lr.constant = false;
 821       else if (lex_match_id (lexer, "EXTERNAL"))
 822         {
 823           /* This is for compatibility.  It does nothing */
 824         }
 825       else if (lex_match_id (lexer, "CATEGORICAL"))
 826         {
 827           lex_match (lexer, T_EQUALS);
 828           struct variable **cats;
 829           size_t n_cats;
 830           if (!parse_variables (lexer, lr.dict, &cats, &n_cats, PV_NO_DUPLICATE))
 831             goto error;
 832
 833           lr.cat_predictors = xrealloc (lr.cat_predictors,
 834                                         sizeof *lr.cat_predictors
 835                                         * (n_cats + lr.n_cat_predictors));
 836           for (size_t i = 0; i < n_cats; i++)
 837             lr.cat_predictors[lr.n_cat_predictors++] = interaction_create (cats[i]);
 838           free (cats);
 839         }
 840       else if (lex_match_id (lexer, "PRINT"))
 841         {
 842           lex_match (lexer, T_EQUALS);
 843           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
 844             {
 845               if (lex_match_id (lexer, "DEFAULT"))
 846                 lr.print |= PRINT_DEFAULT;
 847               else if (lex_match_id (lexer, "SUMMARY"))
 848                 lr.print |= PRINT_SUMMARY;
 849 #if 0
 850               else if (lex_match_id (lexer, "CORR"))
 851                 lr.print |= PRINT_CORR;
 852               else if (lex_match_id (lexer, "ITER"))
 853                 lr.print |= PRINT_ITER;
 854               else if (lex_match_id (lexer, "GOODFIT"))
 855                 lr.print |= PRINT_GOODFIT;
 856 #endif
 857               else if (lex_match_id (lexer, "CI"))
 858                 {
 859                   lr.print |= PRINT_CI;
 860                   if (!lex_force_match (lexer, T_LPAREN)
 861                       || !lex_force_num (lexer))
 862                     goto error;
 863                   lr.confidence = lex_number (lexer);
 864                   lex_get (lexer);
 865                   if (!lex_force_match (lexer, T_RPAREN))
 866                     goto error;
 867                 }
 868               else if (lex_match_id (lexer, "ALL"))
 869                 lr.print = ~0x0000;
 870               else
 871                 {
 872                   lex_error_expecting (lexer, "DEFAULT", "SUMMARY",
 873 #if 0
 874                                        "CORR", "ITER", "GOODFIT",
 875 #endif
 876                                        "CI", "ALL");
 877                   goto error;
 878                 }
 879             }
 880         }
 881       else if (lex_match_id (lexer, "CRITERIA"))
 882         {
 883           lex_match (lexer, T_EQUALS);
 884           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
 885             {
 886               if (lex_match_id (lexer, "BCON"))
 887                 {
 888                   if (!lex_force_match (lexer, T_LPAREN)
 889                       || !lex_force_num (lexer))
 890                     goto error;
 891                   lr.bcon = lex_number (lexer);
 892                   lex_get (lexer);
 893                   if (!lex_force_match (lexer, T_RPAREN))
 894                     goto error;
 895                 }
 896               else if (lex_match_id (lexer, "ITERATE"))
 897                 {
 898                   if (!lex_force_match (lexer, T_LPAREN)
 899                       || !lex_force_int_range (lexer, "ITERATE", 0, INT_MAX))
 900                     goto error;
 901                   lr.max_iter = lex_integer (lexer);
 902                   lex_get (lexer);
 903                   if (!lex_force_match (lexer, T_RPAREN))
 904                     goto error;
 905                 }
 906               else if (lex_match_id (lexer, "LCON"))
 907                 {
 908                   if (!lex_force_match (lexer, T_LPAREN)
 909                       || !lex_force_num (lexer))
 910                     goto error;
 911                   lr.lcon = lex_number (lexer);
 912                   lex_get (lexer);
 913                   if (!lex_force_match (lexer, T_RPAREN))
 914                     goto error;
 915                 }
 916               else if (lex_match_id (lexer, "EPS"))
 917                 {
 918                   if (!lex_force_match (lexer, T_LPAREN)
 919                       || !lex_force_num (lexer))
 920                     goto error;
 921                   lr.min_epsilon = lex_number (lexer);
 922                   lex_get (lexer);
 923                   if (!lex_force_match (lexer, T_RPAREN))
 924                     goto error;
 925                 }
 926               else if (lex_match_id (lexer, "CUT"))
 927                 {
 928                   if (!lex_force_match (lexer, T_LPAREN)
 929                        || !lex_force_num_range_closed (lexer, "CUT", 0, 1))
 930                     goto error;
 931
 932                   cp = lex_number (lexer);
 933
 934                   lex_get (lexer);
 935                   if (!lex_force_match (lexer, T_RPAREN))
 936                     goto error;
 937                 }
 938               else
 939                 {
 940                   lex_error_expecting (lexer, "BCON", "ITERATE", "LCON", "EPS",
 941                                        "CUT");
 942                   goto error;
 943                 }
 944             }
 945         }
 946       else
 947         {
 948           lex_error_expecting (lexer, "MISSING", "ORIGIN", "NOORIGIN",
 949                                "NOCONST", "EXTERNAL", "CATEGORICAL",
 950                                "PRINT", "CRITERIA");
 951           goto error;
 952         }
 953     }
 954
 955   lr.ilogit_cut_point = - log (1/cp - 1);
 956
 957   /* Copy the predictor variables from the temporary location into the
 958      final one, dropping any categorical variables which appear there.
 959      FIXME: This is O(NxM).
 960   */
 961   struct hmap allvars = HMAP_INITIALIZER (allvars);
 962   size_t allocated_predictor_vars = 0;
 963   for (size_t v = 0; v < n_pred_vars; ++v)
 964     {
 965       bool drop = false;
 966       const struct variable *var = pred_vars[v];
 967
 968       unsigned int hash = hash_pointer (var, 0);
 969       insert_variable (&allvars, var, hash);
 970
 971       for (size_t cv = 0; cv < lr.n_cat_predictors; ++cv)
 972         {
 973           const struct interaction *iact = lr.cat_predictors[cv];
 974           for (size_t iv = 0; iv < iact->n_vars; ++iv)
 975             {
 976               const struct variable *ivar = iact->vars[iv];
 977               unsigned int hash = hash_pointer (ivar, 0);
 978               insert_variable (&allvars, ivar, hash);
 979
 980               if (var == ivar)
 981                 drop = true;
 982             }
 983         }
 984
 985       if (drop)
 986         continue;
 987
 988       if (lr.n_predictor_vars >= allocated_predictor_vars)
 989         lr.predictor_vars = x2nrealloc (lr.predictor_vars,
 990                                         &allocated_predictor_vars,
 991                                         sizeof *lr.predictor_vars);
 992       lr.predictor_vars[lr.n_predictor_vars++] = var;
 993     }
 994
 995   lr.n_indep_vars = hmap_count (&allvars);
 996   lr.indep_vars = xmalloc (lr.n_indep_vars * sizeof *lr.indep_vars);
 997
 998   /* Interate over each variable and push it into the array */
 999   size_t x = 0;
1000   struct variable_node *vn, *next;
1001   HMAP_FOR_EACH_SAFE (vn, next, struct variable_node, node, &allvars)
1002     {
1003       lr.indep_vars[x++] = vn->var;
1004       hmap_delete (&allvars, &vn->node);
1005       free (vn);
1006     }
1007   assert (x == lr.n_indep_vars);
1008   hmap_destroy (&allvars);
1009
1010   /* Run logistical regression for each split group. */
1011   struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), lr.dict);
1012   struct casereader *group;
1013   bool ok = true;
1014   while (casegrouper_get_next_group (grouper, &group))
1015     ok = run_lr (&lr, group, ds) && ok;
1016   ok = casegrouper_destroy (grouper) && ok;
1017   ok = proc_commit (ds) && ok;
1018
1019   for (size_t i = 0; i < lr.n_cat_predictors; ++i)
1020     interaction_destroy (lr.cat_predictors[i]);
1021   free (lr.predictor_vars);
1022   free (lr.cat_predictors);
1023   free (lr.indep_vars);
1024   free (pred_vars);
1025
1026   return CMD_SUCCESS;
1027
1028  error:
1029   for (size_t i = 0; i < lr.n_cat_predictors; ++i)
1030     interaction_destroy (lr.cat_predictors[i]);
1031   free (lr.predictor_vars);
1032   free (lr.cat_predictors);
1033   free (lr.indep_vars);
1034   free (pred_vars);
1035
1036   return CMD_FAILURE;
1037 }
1038
1039
1040 \f
1041
1042 /* Show the Dependent Variable Encoding box.
1043    This indicates how the dependent variable
1044    is mapped to the internal zero/one values.
1045 */
1046 static void
1047 output_depvarmap (const struct lr_spec *cmd, const struct lr_result *res)
1048 {
1049   struct pivot_table *table = pivot_table_create (
1050     N_("Dependent Variable Encoding"));
1051
1052   pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Mapping"),
1053                           N_("Internal Value"));
1054
1055   struct pivot_dimension *original = pivot_dimension_create (
1056     table, PIVOT_AXIS_ROW, N_("Original Value"));
1057   original->root->show_label = true;
1058
1059   for (int i = 0; i < 2; i++)
1060     {
1061       const union value *v = i ? &res->y1 : &res->y0;
1062       int orig_idx = pivot_category_create_leaf (
1063         original->root, pivot_value_new_var_value (cmd->dep_var, v));
1064       pivot_table_put2 (table, 0, orig_idx, pivot_value_new_number (
1065                           map_dependent_var (cmd, res, v)));
1066     }
1067
1068   pivot_table_submit (table);
1069 }
1070
1071
1072 /* Show the Variables in the Equation box */
1073 static void
1074 output_variables (const struct lr_spec *cmd,
1075                   const struct lr_result *res)
1076 {
1077   struct pivot_table *table = pivot_table_create (
1078     N_("Variables in the Equation"));
1079
1080   struct pivot_dimension *statistics = pivot_dimension_create (
1081     table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1082     N_("B"), PIVOT_RC_OTHER,
1083     N_("S.E."), PIVOT_RC_OTHER,
1084     N_("Wald"), PIVOT_RC_OTHER,
1085     N_("df"), PIVOT_RC_INTEGER,
1086     N_("Sig."), PIVOT_RC_SIGNIFICANCE,
1087     N_("Exp(B)"), PIVOT_RC_OTHER);
1088   if (cmd->print & PRINT_CI)
1089     {
1090       struct pivot_category *group = pivot_category_create_group__ (
1091         statistics->root,
1092         pivot_value_new_text_format (N_("%d%% CI for Exp(B)"),
1093                                      cmd->confidence));
1094       pivot_category_create_leaves (group, N_("Lower"), N_("Upper"));
1095     }
1096
1097   struct pivot_dimension *variables = pivot_dimension_create (
1098     table, PIVOT_AXIS_ROW, N_("Variables"));
1099   struct pivot_category *step1 = pivot_category_create_group (
1100     variables->root, N_("Step 1"));
1101
1102   int ivar = 0;
1103   int idx_correction = 0;
1104   int i = 0;
1105
1106   int nr = cmd->n_predictor_vars;
1107   if (cmd->constant)
1108     nr++;
1109   if (res->cats)
1110     nr += categoricals_df_total (res->cats) + cmd->n_cat_predictors;
1111
1112   for (int row = 0; row < nr; row++)
1113     {
1114       const int idx = row - idx_correction;
1115
1116       int var_idx;
1117       if (idx < cmd->n_predictor_vars)
1118         var_idx = pivot_category_create_leaf (
1119           step1, pivot_value_new_variable (cmd->predictor_vars[idx]));
1120       else if (i < cmd->n_cat_predictors)
1121         {
1122           const struct interaction *cat_predictors = cmd->cat_predictors[i];
1123           struct string str = DS_EMPTY_INITIALIZER;
1124           interaction_to_string (cat_predictors, &str);
1125           if (ivar != 0)
1126             ds_put_format (&str, "(%d)", ivar);
1127           var_idx = pivot_category_create_leaf (
1128             step1, pivot_value_new_user_text_nocopy (ds_steal_cstr (&str)));
1129
1130           int df = categoricals_df (res->cats, i);
1131           bool summary = ivar == 0;
1132           if (summary)
1133             {
1134               /* Calculate the Wald statistic,
1135                  which is \beta' C^-1 \beta .
1136                  where \beta is the vector of the coefficient estimates comprising this
1137                  categorial variable. and C is the corresponding submatrix of the
1138                  hessian matrix.
1139               */
1140               gsl_matrix_const_view mv =
1141                 gsl_matrix_const_submatrix (res->hessian, idx, idx, df, df);
1142               gsl_matrix *subhessian = gsl_matrix_alloc (mv.matrix.size1, mv.matrix.size2);
1143               gsl_vector_const_view vv = gsl_vector_const_subvector (res->beta_hat, idx, df);
1144               gsl_vector *temp = gsl_vector_alloc (df);
1145
1146               gsl_matrix_memcpy (subhessian, &mv.matrix);
1147               gsl_linalg_cholesky_decomp (subhessian);
1148               gsl_linalg_cholesky_invert (subhessian);
1149
1150               gsl_blas_dgemv (CblasTrans, 1.0, subhessian, &vv.vector, 0, temp);
1151               double wald;
1152               gsl_blas_ddot (temp, &vv.vector, &wald);
1153
1154               double entries[] = { wald, df, gsl_cdf_chisq_Q (wald, df) };
1155               for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
1156                 pivot_table_put2 (table, j + 2, var_idx,
1157                                   pivot_value_new_number (entries[j]));
1158
1159               idx_correction++;
1160               gsl_matrix_free (subhessian);
1161               gsl_vector_free (temp);
1162             }
1163
1164           if (ivar++ == df)
1165             {
1166               ++i; /* next interaction */
1167               ivar = 0;
1168             }
1169
1170           if (summary)
1171             continue;
1172         }
1173       else
1174         var_idx = pivot_category_create_leaves (step1, N_("Constant"));
1175
1176       double b = gsl_vector_get (res->beta_hat, idx);
1177       double sigma2 = gsl_matrix_get (res->hessian, idx, idx);
1178       double wald = pow2 (b) / sigma2;
1179       double df = 1;
1180       double wc = (gsl_cdf_ugaussian_Pinv (0.5 + cmd->confidence / 200.0)
1181                    * sqrt (sigma2));
1182       bool show_ci = cmd->print & PRINT_CI && row < nr - cmd->constant;
1183
1184       double entries[] = {
1185         b,
1186         sqrt (sigma2),
1187         wald,
1188         df,
1189         gsl_cdf_chisq_Q (wald, df),
1190         exp (b),
1191         show_ci ? exp (b - wc) : SYSMIS,
1192         show_ci ? exp (b + wc) : SYSMIS,
1193       };
1194       for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
1195         if (entries[j] != SYSMIS)
1196           pivot_table_put2 (table, j, var_idx,
1197                             pivot_value_new_number (entries[j]));
1198     }
1199
1200   pivot_table_submit (table);
1201 }
1202
1203
1204 /* Show the model summary box */
1205 static void
1206 output_model_summary (const struct lr_result *res,
1207                       double initial_log_likelihood, double log_likelihood)
1208 {
1209   struct pivot_table *table = pivot_table_create (N_("Model Summary"));
1210
1211   pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1212                           N_("-2 Log likelihood"), PIVOT_RC_OTHER,
1213                           N_("Cox & Snell R Square"), PIVOT_RC_OTHER,
1214                           N_("Nagelkerke R Square"), PIVOT_RC_OTHER);
1215
1216   struct pivot_dimension *step = pivot_dimension_create (
1217     table, PIVOT_AXIS_ROW, N_("Step"));
1218   step->root->show_label = true;
1219   pivot_category_create_leaf (step->root, pivot_value_new_integer (1));
1220
1221   double cox = (1.0 - exp ((initial_log_likelihood - log_likelihood)
1222                            * (2 / res->cc)));
1223   double entries[] = {
1224     -2 * log_likelihood,
1225     cox,
1226     cox / (1.0 - exp(initial_log_likelihood * (2 / res->cc)))
1227   };
1228   for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1229     pivot_table_put2 (table, i, 0, pivot_value_new_number (entries[i]));
1230
1231   pivot_table_submit (table);
1232 }
1233
1234 /* Show the case processing summary box */
1235 static void
1236 case_processing_summary (const struct lr_result *res)
1237 {
1238   struct pivot_table *table = pivot_table_create (
1239     N_("Case Processing Summary"));
1240
1241   pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1242                           N_("N"), PIVOT_RC_COUNT,
1243                           N_("Percent"), PIVOT_RC_PERCENT);
1244
1245   struct pivot_dimension *cases = pivot_dimension_create (
1246     table, PIVOT_AXIS_ROW, N_("Unweighted Cases"),
1247     N_("Included in Analysis"), N_("Missing Cases"), N_("Total"));
1248   cases->root->show_label = true;
1249
1250   double total = res->n_nonmissing + res->n_missing;
1251   struct entry
1252     {
1253       int stat_idx;
1254       int case_idx;
1255       double x;
1256     }
1257   entries[] = {
1258     { 0, 0, res->n_nonmissing },
1259     { 0, 1, res->n_missing },
1260     { 0, 2, total },
1261     { 1, 0, 100.0 * res->n_nonmissing / total },
1262     { 1, 1, 100.0 * res->n_missing / total },
1263     { 1, 2, 100.0 },
1264   };
1265   for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1266     pivot_table_put2 (table, entries[i].stat_idx, entries[i].case_idx,
1267                       pivot_value_new_number (entries[i].x));
1268
1269   pivot_table_submit (table);
1270 }
1271
1272 static void
1273 output_categories (const struct lr_spec *cmd, const struct lr_result *res)
1274 {
1275   struct pivot_table *table = pivot_table_create (
1276     N_("Categorical Variables' Codings"));
1277   pivot_table_set_weight_var (table, dict_get_weight (cmd->dict));
1278
1279   int max_df = 0;
1280   int total_cats = 0;
1281   for (int i = 0; i < cmd->n_cat_predictors; ++i)
1282     {
1283       size_t n = categoricals_n_count (res->cats, i);
1284       size_t df = categoricals_df (res->cats, i);
1285       if (max_df < df)
1286         max_df = df;
1287       total_cats += n;
1288     }
1289
1290   struct pivot_dimension *codings = pivot_dimension_create (
1291     table, PIVOT_AXIS_COLUMN, N_("Codings"),
1292     N_("Frequency"), PIVOT_RC_COUNT);
1293   struct pivot_category *coding_group = pivot_category_create_group (
1294     codings->root, N_("Parameter coding"));
1295   for (int i = 0; i < max_df; ++i)
1296     pivot_category_create_leaf_rc (
1297       coding_group,
1298       pivot_value_new_user_text_nocopy (xasprintf ("(%d)", i + 1)),
1299       PIVOT_RC_INTEGER);
1300
1301   struct pivot_dimension *categories = pivot_dimension_create (
1302     table, PIVOT_AXIS_ROW, N_("Categories"));
1303
1304   int cumulative_df = 0;
1305   for (int v = 0; v < cmd->n_cat_predictors; ++v)
1306     {
1307       int cat;
1308       const struct interaction *cat_predictors = cmd->cat_predictors[v];
1309       int df = categoricals_df (res->cats, v);
1310
1311       struct string str = DS_EMPTY_INITIALIZER;
1312       interaction_to_string (cat_predictors, &str);
1313       struct pivot_category *var_group = pivot_category_create_group__ (
1314         categories->root,
1315         pivot_value_new_user_text_nocopy (ds_steal_cstr (&str)));
1316
1317       for (cat = 0; cat < categoricals_n_count (res->cats, v); ++cat)
1318         {
1319           const struct ccase *c = categoricals_get_case_by_category_real (
1320             res->cats, v, cat);
1321           struct string label = DS_EMPTY_INITIALIZER;
1322           for (int x = 0; x < cat_predictors->n_vars; ++x)
1323             {
1324               if (!ds_is_empty (&label))
1325                 ds_put_byte (&label, ' ');
1326
1327               const union value *val = case_data (c, cat_predictors->vars[x]);
1328               var_append_value_name (cat_predictors->vars[x], val, &label);
1329             }
1330           int cat_idx = pivot_category_create_leaf (
1331             var_group,
1332             pivot_value_new_user_text_nocopy (ds_steal_cstr (&label)));
1333
1334           double *freq = categoricals_get_user_data_by_category_real (
1335             res->cats, v, cat);
1336           pivot_table_put2 (table, 0, cat_idx, pivot_value_new_number (*freq));
1337
1338           for (int x = 0; x < df; ++x)
1339             pivot_table_put2 (table, x + 1, cat_idx,
1340                               pivot_value_new_number (cat == x));
1341         }
1342       cumulative_df += df;
1343     }
1344
1345   pivot_table_submit (table);
1346 }
1347
1348 static void
1349 create_classification_dimension (const struct lr_spec *cmd,
1350                                  const struct lr_result *res,
1351                                  struct pivot_table *table,
1352                                  enum pivot_axis_type axis_type,
1353                                  const char *label, const char *total)
1354 {
1355   struct pivot_dimension *d = pivot_dimension_create (
1356     table, axis_type, label);
1357   d->root->show_label = true;
1358   struct pivot_category *pred_group = pivot_category_create_group__ (
1359     d->root, pivot_value_new_variable (cmd->dep_var));
1360   for (int i = 0; i < 2; i++)
1361     {
1362       const union value *y = i ? &res->y1 : &res->y0;
1363       pivot_category_create_leaf_rc (
1364         pred_group, pivot_value_new_var_value (cmd->dep_var, y),
1365         PIVOT_RC_COUNT);
1366     }
1367   pivot_category_create_leaves (d->root, total, PIVOT_RC_PERCENT);
1368 }
1369
1370 static void
1371 output_classification_table (const struct lr_spec *cmd, const struct lr_result *res)
1372 {
1373   struct pivot_table *table = pivot_table_create (N_("Classification Table"));
1374   pivot_table_set_weight_var (table, cmd->wv);
1375
1376   create_classification_dimension (cmd, res, table, PIVOT_AXIS_COLUMN,
1377                                    N_("Predicted"), N_("Percentage Correct"));
1378   create_classification_dimension (cmd, res, table, PIVOT_AXIS_ROW,
1379                                    N_("Observed"), N_("Overall Percentage"));
1380
1381   pivot_dimension_create (table, PIVOT_AXIS_ROW, N_("Step"), N_("Step 1"));
1382
1383   struct entry
1384     {
1385       int pred_idx;
1386       int obs_idx;
1387       double x;
1388     }
1389   entries[] = {
1390     { 0, 0, res->tn },
1391     { 0, 1, res->fn },
1392     { 1, 0, res->fp },
1393     { 1, 1, res->tp },
1394     { 2, 0, 100 * res->tn / (res->tn + res->fp) },
1395     { 2, 1, 100 * res->tp / (res->tp + res->fn) },
1396     { 2, 2,
1397       100 * (res->tp + res->tn) / (res->tp  + res->tn + res->fp + res->fn)},
1398   };
1399   for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1400     {
1401       const struct entry *e = &entries[i];
1402       pivot_table_put3 (table, e->pred_idx, e->obs_idx, 0,
1403                         pivot_value_new_number (e->x));
1404     }
1405
1406   pivot_table_submit (table);
1407 }