6365fb8278a3877d041d624f7ecfd81c5e3c9ef4
[pspp] / 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 = NULL;
738   HMAP_FOR_EACH_WITH_HASH (vn, struct variable_node, node, hash, map)
739     {
740       if (vn->var == var)
741         break;
742     }
743
744   return vn;
745 }
746
747
748 /* Parse the LOGISTIC REGRESSION command syntax */
749 int
750 cmd_logistic (struct lexer *lexer, struct dataset *ds)
751 {
752   int i;
753   /* Temporary location for the predictor variables.
754      These may or may not include the categorical predictors */
755   const struct variable **pred_vars;
756   size_t n_pred_vars;
757   double cp = 0.5;
758
759   int v, x;
760   struct lr_spec lr;
761   lr.dict = dataset_dict (ds);
762   lr.n_predictor_vars = 0;
763   lr.predictor_vars = NULL;
764   lr.exclude = MV_ANY;
765   lr.wv = dict_get_weight (lr.dict);
766   lr.max_iter = 20;
767   lr.lcon = 0.0000;
768   lr.bcon = 0.001;
769   lr.min_epsilon = 0.00000001;
770   lr.constant = true;
771   lr.confidence = 95;
772   lr.print = PRINT_DEFAULT;
773   lr.cat_predictors = NULL;
774   lr.n_cat_predictors = 0;
775   lr.indep_vars = NULL;
776
777
778   if (lex_match_id (lexer, "VARIABLES"))
779     lex_match (lexer, T_EQUALS);
780
781   if (! (lr.dep_var = parse_variable_const (lexer, lr.dict)))
782     goto error;
783
784   if (! lex_force_match (lexer, T_WITH))
785     goto error;
786
787   if (!parse_variables_const (lexer, lr.dict,
788                               &pred_vars, &n_pred_vars,
789                               PV_NO_DUPLICATE))
790     goto error;
791
792
793   while (lex_token (lexer) != T_ENDCMD)
794     {
795       lex_match (lexer, T_SLASH);
796
797       if (lex_match_id (lexer, "MISSING"))
798         {
799           lex_match (lexer, T_EQUALS);
800           while (lex_token (lexer) != T_ENDCMD
801                  && lex_token (lexer) != T_SLASH)
802             {
803               if (lex_match_id (lexer, "INCLUDE"))
804                 {
805                   lr.exclude = MV_SYSTEM;
806                 }
807               else if (lex_match_id (lexer, "EXCLUDE"))
808                 {
809                   lr.exclude = MV_ANY;
810                 }
811               else
812                 {
813                   lex_error (lexer, NULL);
814                   goto error;
815                 }
816             }
817         }
818       else if (lex_match_id (lexer, "ORIGIN"))
819         {
820           lr.constant = false;
821         }
822       else if (lex_match_id (lexer, "NOORIGIN"))
823         {
824           lr.constant = true;
825         }
826       else if (lex_match_id (lexer, "NOCONST"))
827         {
828           lr.constant = false;
829         }
830       else if (lex_match_id (lexer, "EXTERNAL"))
831         {
832           /* This is for compatibility.  It does nothing */
833         }
834       else if (lex_match_id (lexer, "CATEGORICAL"))
835         {
836           lex_match (lexer, T_EQUALS);
837           struct variable **cats;
838           size_t n_cats;
839           if (!parse_variables (lexer, lr.dict, &cats, &n_cats, PV_NO_DUPLICATE))
840             goto error;
841
842           lr.cat_predictors = xrealloc (lr.cat_predictors,
843                                         sizeof *lr.cat_predictors
844                                         * (n_cats + lr.n_cat_predictors));
845           for (size_t i = 0; i < n_cats; i++)
846             lr.cat_predictors[lr.n_cat_predictors++] = interaction_create (cats[i]);
847           free (cats);
848         }
849       else if (lex_match_id (lexer, "PRINT"))
850         {
851           lex_match (lexer, T_EQUALS);
852           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
853             {
854               if (lex_match_id (lexer, "DEFAULT"))
855                 {
856                   lr.print |= PRINT_DEFAULT;
857                 }
858               else if (lex_match_id (lexer, "SUMMARY"))
859                 {
860                   lr.print |= PRINT_SUMMARY;
861                 }
862 #if 0
863               else if (lex_match_id (lexer, "CORR"))
864                 {
865                   lr.print |= PRINT_CORR;
866                 }
867               else if (lex_match_id (lexer, "ITER"))
868                 {
869                   lr.print |= PRINT_ITER;
870                 }
871               else if (lex_match_id (lexer, "GOODFIT"))
872                 {
873                   lr.print |= PRINT_GOODFIT;
874                 }
875 #endif
876               else if (lex_match_id (lexer, "CI"))
877                 {
878                   lr.print |= PRINT_CI;
879                   if (lex_force_match (lexer, T_LPAREN))
880                     {
881                       if (! lex_force_num (lexer))
882                         {
883                           lex_error (lexer, NULL);
884                           goto error;
885                         }
886                       lr.confidence = lex_number (lexer);
887                       lex_get (lexer);
888                       if (! lex_force_match (lexer, T_RPAREN))
889                         {
890                           lex_error (lexer, NULL);
891                           goto error;
892                         }
893                     }
894                 }
895               else if (lex_match_id (lexer, "ALL"))
896                 {
897                   lr.print = ~0x0000;
898                 }
899               else
900                 {
901                   lex_error (lexer, NULL);
902                   goto error;
903                 }
904             }
905         }
906       else if (lex_match_id (lexer, "CRITERIA"))
907         {
908           lex_match (lexer, T_EQUALS);
909           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
910             {
911               if (lex_match_id (lexer, "BCON"))
912                 {
913                   if (lex_force_match (lexer, T_LPAREN))
914                     {
915                       if (! lex_force_num (lexer))
916                         {
917                           lex_error (lexer, NULL);
918                           goto error;
919                         }
920                       lr.bcon = lex_number (lexer);
921                       lex_get (lexer);
922                       if (! lex_force_match (lexer, T_RPAREN))
923                         {
924                           lex_error (lexer, NULL);
925                           goto error;
926                         }
927                     }
928                 }
929               else if (lex_match_id (lexer, "ITERATE"))
930                 {
931                   if (lex_force_match (lexer, T_LPAREN))
932                     {
933                       if (! lex_force_int_range (lexer, "ITERATE", 0, INT_MAX))
934                         {
935                           lex_error (lexer, NULL);
936                           goto error;
937                         }
938                       lr.max_iter = lex_integer (lexer);
939                       lex_get (lexer);
940                       if (! lex_force_match (lexer, T_RPAREN))
941                         {
942                           lex_error (lexer, NULL);
943                           goto error;
944                         }
945                     }
946                 }
947               else if (lex_match_id (lexer, "LCON"))
948                 {
949                   if (lex_force_match (lexer, T_LPAREN))
950                     {
951                       if (! lex_force_num (lexer))
952                         {
953                           lex_error (lexer, NULL);
954                           goto error;
955                         }
956                       lr.lcon = lex_number (lexer);
957                       lex_get (lexer);
958                       if (! lex_force_match (lexer, T_RPAREN))
959                         {
960                           lex_error (lexer, NULL);
961                           goto error;
962                         }
963                     }
964                 }
965               else if (lex_match_id (lexer, "EPS"))
966                 {
967                   if (lex_force_match (lexer, T_LPAREN))
968                     {
969                       if (! lex_force_num (lexer))
970                         {
971                           lex_error (lexer, NULL);
972                           goto error;
973                         }
974                       lr.min_epsilon = lex_number (lexer);
975                       lex_get (lexer);
976                       if (! lex_force_match (lexer, T_RPAREN))
977                         {
978                           lex_error (lexer, NULL);
979                           goto error;
980                         }
981                     }
982                 }
983               else if (lex_match_id (lexer, "CUT"))
984                 {
985                   if (lex_force_match (lexer, T_LPAREN))
986                     {
987                       if (!lex_force_num_range_closed (lexer, "CUT", 0, 1))
988                         goto error;
989
990                       cp = lex_number (lexer);
991
992                       lex_get (lexer);
993                       if (! lex_force_match (lexer, T_RPAREN))
994                         {
995                           lex_error (lexer, NULL);
996                           goto error;
997                         }
998                     }
999                 }
1000               else
1001                 {
1002                   lex_error (lexer, NULL);
1003                   goto error;
1004                 }
1005             }
1006         }
1007       else
1008         {
1009           lex_error (lexer, NULL);
1010           goto error;
1011         }
1012     }
1013
1014   lr.ilogit_cut_point = - log (1/cp - 1);
1015
1016
1017   /* Copy the predictor variables from the temporary location into the
1018      final one, dropping any categorical variables which appear there.
1019      FIXME: This is O(NxM).
1020   */
1021   {
1022   struct variable_node *vn, *next;
1023   struct hmap allvars;
1024   hmap_init (&allvars);
1025   for (v = x = 0; v < n_pred_vars; ++v)
1026     {
1027       bool drop = false;
1028       const struct variable *var = pred_vars[v];
1029       int cv = 0;
1030
1031       unsigned int hash = hash_pointer (var, 0);
1032       struct variable_node *vn = lookup_variable (&allvars, var, hash);
1033       if (vn == NULL)
1034         {
1035           vn = xmalloc (sizeof *vn);
1036           vn->var = var;
1037           hmap_insert (&allvars, &vn->node,  hash);
1038         }
1039
1040       for (cv = 0; cv < lr.n_cat_predictors ; ++cv)
1041         {
1042           int iv;
1043           const struct interaction *iact = lr.cat_predictors[cv];
1044           for (iv = 0 ; iv < iact->n_vars ; ++iv)
1045             {
1046               const struct variable *ivar = iact->vars[iv];
1047               unsigned int hash = hash_pointer (ivar, 0);
1048               struct variable_node *vn = lookup_variable (&allvars, ivar, hash);
1049               if (vn == NULL)
1050                 {
1051                   vn = xmalloc (sizeof *vn);
1052                   vn->var = ivar;
1053
1054                   hmap_insert (&allvars, &vn->node,  hash);
1055                 }
1056
1057               if (var == ivar)
1058                 {
1059                   drop = true;
1060                 }
1061             }
1062         }
1063
1064       if (drop)
1065         continue;
1066
1067       lr.predictor_vars = xrealloc (lr.predictor_vars, sizeof *lr.predictor_vars * (x + 1));
1068       lr.predictor_vars[x++] = var;
1069       lr.n_predictor_vars++;
1070     }
1071   free (pred_vars);
1072
1073   lr.n_indep_vars = hmap_count (&allvars);
1074   lr.indep_vars = xmalloc (lr.n_indep_vars * sizeof *lr.indep_vars);
1075
1076   /* Interate over each variable and push it into the array */
1077   x = 0;
1078   HMAP_FOR_EACH_SAFE (vn, next, struct variable_node, node, &allvars)
1079     {
1080       lr.indep_vars[x++] = vn->var;
1081       free (vn);
1082     }
1083   hmap_destroy (&allvars);
1084   }
1085
1086
1087   /* logistical regression for each split group */
1088   {
1089     struct casegrouper *grouper;
1090     struct casereader *group;
1091     bool ok;
1092
1093     grouper = casegrouper_create_splits (proc_open (ds), lr.dict);
1094     while (casegrouper_get_next_group (grouper, &group))
1095       ok = run_lr (&lr, group, ds);
1096     ok = casegrouper_destroy (grouper);
1097     ok = proc_commit (ds) && ok;
1098   }
1099
1100   for (i = 0 ; i < lr.n_cat_predictors; ++i)
1101     {
1102       interaction_destroy (lr.cat_predictors[i]);
1103     }
1104   free (lr.predictor_vars);
1105   free (lr.cat_predictors);
1106   free (lr.indep_vars);
1107
1108   return CMD_SUCCESS;
1109
1110  error:
1111
1112   for (i = 0 ; i < lr.n_cat_predictors; ++i)
1113     {
1114       interaction_destroy (lr.cat_predictors[i]);
1115     }
1116   free (lr.predictor_vars);
1117   free (lr.cat_predictors);
1118   free (lr.indep_vars);
1119
1120   return CMD_FAILURE;
1121 }
1122
1123
1124 \f
1125
1126 /* Show the Dependent Variable Encoding box.
1127    This indicates how the dependent variable
1128    is mapped to the internal zero/one values.
1129 */
1130 static void
1131 output_depvarmap (const struct lr_spec *cmd, const struct lr_result *res)
1132 {
1133   struct pivot_table *table = pivot_table_create (
1134     N_("Dependent Variable Encoding"));
1135
1136   pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Mapping"),
1137                           N_("Internal Value"));
1138
1139   struct pivot_dimension *original = pivot_dimension_create (
1140     table, PIVOT_AXIS_ROW, N_("Original Value"));
1141   original->root->show_label = true;
1142
1143   for (int i = 0; i < 2; i++)
1144     {
1145       const union value *v = i ? &res->y1 : &res->y0;
1146       int orig_idx = pivot_category_create_leaf (
1147         original->root, pivot_value_new_var_value (cmd->dep_var, v));
1148       pivot_table_put2 (table, 0, orig_idx, pivot_value_new_number (
1149                           map_dependent_var (cmd, res, v)));
1150     }
1151
1152   pivot_table_submit (table);
1153 }
1154
1155
1156 /* Show the Variables in the Equation box */
1157 static void
1158 output_variables (const struct lr_spec *cmd,
1159                   const struct lr_result *res)
1160 {
1161   struct pivot_table *table = pivot_table_create (
1162     N_("Variables in the Equation"));
1163
1164   struct pivot_dimension *statistics = pivot_dimension_create (
1165     table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1166     N_("B"), PIVOT_RC_OTHER,
1167     N_("S.E."), PIVOT_RC_OTHER,
1168     N_("Wald"), PIVOT_RC_OTHER,
1169     N_("df"), PIVOT_RC_INTEGER,
1170     N_("Sig."), PIVOT_RC_SIGNIFICANCE,
1171     N_("Exp(B)"), PIVOT_RC_OTHER);
1172   if (cmd->print & PRINT_CI)
1173     {
1174       struct pivot_category *group = pivot_category_create_group__ (
1175         statistics->root,
1176         pivot_value_new_text_format (N_("%d%% CI for Exp(B)"),
1177                                      cmd->confidence));
1178       pivot_category_create_leaves (group, N_("Lower"), N_("Upper"));
1179     }
1180
1181   struct pivot_dimension *variables = pivot_dimension_create (
1182     table, PIVOT_AXIS_ROW, N_("Variables"));
1183   struct pivot_category *step1 = pivot_category_create_group (
1184     variables->root, N_("Step 1"));
1185
1186   int ivar = 0;
1187   int idx_correction = 0;
1188   int i = 0;
1189
1190   int nr = cmd->n_predictor_vars;
1191   if (cmd->constant)
1192     nr++;
1193   if (res->cats)
1194     nr += categoricals_df_total (res->cats) + cmd->n_cat_predictors;
1195
1196   for (int row = 0; row < nr; row++)
1197     {
1198       const int idx = row - idx_correction;
1199
1200       int var_idx;
1201       if (idx < cmd->n_predictor_vars)
1202         var_idx = pivot_category_create_leaf (
1203           step1, pivot_value_new_variable (cmd->predictor_vars[idx]));
1204       else if (i < cmd->n_cat_predictors)
1205         {
1206           const struct interaction *cat_predictors = cmd->cat_predictors[i];
1207           struct string str = DS_EMPTY_INITIALIZER;
1208           interaction_to_string (cat_predictors, &str);
1209           if (ivar != 0)
1210             ds_put_format (&str, "(%d)", ivar);
1211           var_idx = pivot_category_create_leaf (
1212             step1, pivot_value_new_user_text_nocopy (ds_steal_cstr (&str)));
1213
1214           int df = categoricals_df (res->cats, i);
1215           bool summary = ivar == 0;
1216           if (summary)
1217             {
1218               /* Calculate the Wald statistic,
1219                  which is \beta' C^-1 \beta .
1220                  where \beta is the vector of the coefficient estimates comprising this
1221                  categorial variable. and C is the corresponding submatrix of the
1222                  hessian matrix.
1223               */
1224               gsl_matrix_const_view mv =
1225                 gsl_matrix_const_submatrix (res->hessian, idx, idx, df, df);
1226               gsl_matrix *subhessian = gsl_matrix_alloc (mv.matrix.size1, mv.matrix.size2);
1227               gsl_vector_const_view vv = gsl_vector_const_subvector (res->beta_hat, idx, df);
1228               gsl_vector *temp = gsl_vector_alloc (df);
1229
1230               gsl_matrix_memcpy (subhessian, &mv.matrix);
1231               gsl_linalg_cholesky_decomp (subhessian);
1232               gsl_linalg_cholesky_invert (subhessian);
1233
1234               gsl_blas_dgemv (CblasTrans, 1.0, subhessian, &vv.vector, 0, temp);
1235               double wald;
1236               gsl_blas_ddot (temp, &vv.vector, &wald);
1237
1238               double entries[] = { wald, df, gsl_cdf_chisq_Q (wald, df) };
1239               for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
1240                 pivot_table_put2 (table, j + 2, var_idx,
1241                                   pivot_value_new_number (entries[j]));
1242
1243               idx_correction++;
1244               gsl_matrix_free (subhessian);
1245               gsl_vector_free (temp);
1246             }
1247
1248           if (ivar++ == df)
1249             {
1250               ++i; /* next interaction */
1251               ivar = 0;
1252             }
1253
1254           if (summary)
1255             continue;
1256         }
1257       else
1258         var_idx = pivot_category_create_leaves (step1, N_("Constant"));
1259
1260       double b = gsl_vector_get (res->beta_hat, idx);
1261       double sigma2 = gsl_matrix_get (res->hessian, idx, idx);
1262       double wald = pow2 (b) / sigma2;
1263       double df = 1;
1264       double wc = (gsl_cdf_ugaussian_Pinv (0.5 + cmd->confidence / 200.0)
1265                    * sqrt (sigma2));
1266       bool show_ci = cmd->print & PRINT_CI && row < nr - cmd->constant;
1267
1268       double entries[] = {
1269         b,
1270         sqrt (sigma2),
1271         wald,
1272         df,
1273         gsl_cdf_chisq_Q (wald, df),
1274         exp (b),
1275         show_ci ? exp (b - wc) : SYSMIS,
1276         show_ci ? exp (b + wc) : SYSMIS,
1277       };
1278       for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
1279         if (entries[j] != SYSMIS)
1280           pivot_table_put2 (table, j, var_idx,
1281                             pivot_value_new_number (entries[j]));
1282     }
1283
1284   pivot_table_submit (table);
1285 }
1286
1287
1288 /* Show the model summary box */
1289 static void
1290 output_model_summary (const struct lr_result *res,
1291                       double initial_log_likelihood, double log_likelihood)
1292 {
1293   struct pivot_table *table = pivot_table_create (N_("Model Summary"));
1294
1295   pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1296                           N_("-2 Log likelihood"), PIVOT_RC_OTHER,
1297                           N_("Cox & Snell R Square"), PIVOT_RC_OTHER,
1298                           N_("Nagelkerke R Square"), PIVOT_RC_OTHER);
1299
1300   struct pivot_dimension *step = pivot_dimension_create (
1301     table, PIVOT_AXIS_ROW, N_("Step"));
1302   step->root->show_label = true;
1303   pivot_category_create_leaf (step->root, pivot_value_new_integer (1));
1304
1305   double cox = (1.0 - exp ((initial_log_likelihood - log_likelihood)
1306                            * (2 / res->cc)));
1307   double entries[] = {
1308     -2 * log_likelihood,
1309     cox,
1310     cox / (1.0 - exp(initial_log_likelihood * (2 / res->cc)))
1311   };
1312   for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1313     pivot_table_put2 (table, i, 0, pivot_value_new_number (entries[i]));
1314
1315   pivot_table_submit (table);
1316 }
1317
1318 /* Show the case processing summary box */
1319 static void
1320 case_processing_summary (const struct lr_result *res)
1321 {
1322   struct pivot_table *table = pivot_table_create (
1323     N_("Case Processing Summary"));
1324
1325   pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
1326                           N_("N"), PIVOT_RC_COUNT,
1327                           N_("Percent"), PIVOT_RC_PERCENT);
1328
1329   struct pivot_dimension *cases = pivot_dimension_create (
1330     table, PIVOT_AXIS_ROW, N_("Unweighted Cases"),
1331     N_("Included in Analysis"), N_("Missing Cases"), N_("Total"));
1332   cases->root->show_label = true;
1333
1334   double total = res->n_nonmissing + res->n_missing;
1335   struct entry
1336     {
1337       int stat_idx;
1338       int case_idx;
1339       double x;
1340     }
1341   entries[] = {
1342     { 0, 0, res->n_nonmissing },
1343     { 0, 1, res->n_missing },
1344     { 0, 2, total },
1345     { 1, 0, 100.0 * res->n_nonmissing / total },
1346     { 1, 1, 100.0 * res->n_missing / total },
1347     { 1, 2, 100.0 },
1348   };
1349   for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1350     pivot_table_put2 (table, entries[i].stat_idx, entries[i].case_idx,
1351                       pivot_value_new_number (entries[i].x));
1352
1353   pivot_table_submit (table);
1354 }
1355
1356 static void
1357 output_categories (const struct lr_spec *cmd, const struct lr_result *res)
1358 {
1359   struct pivot_table *table = pivot_table_create (
1360     N_("Categorical Variables' Codings"));
1361   pivot_table_set_weight_var (table, dict_get_weight (cmd->dict));
1362
1363   int max_df = 0;
1364   int total_cats = 0;
1365   for (int i = 0; i < cmd->n_cat_predictors; ++i)
1366     {
1367       size_t n = categoricals_n_count (res->cats, i);
1368       size_t df = categoricals_df (res->cats, i);
1369       if (max_df < df)
1370         max_df = df;
1371       total_cats += n;
1372     }
1373
1374   struct pivot_dimension *codings = pivot_dimension_create (
1375     table, PIVOT_AXIS_COLUMN, N_("Codings"),
1376     N_("Frequency"), PIVOT_RC_COUNT);
1377   struct pivot_category *coding_group = pivot_category_create_group (
1378     codings->root, N_("Parameter coding"));
1379   for (int i = 0; i < max_df; ++i)
1380     pivot_category_create_leaf_rc (
1381       coding_group,
1382       pivot_value_new_user_text_nocopy (xasprintf ("(%d)", i + 1)),
1383       PIVOT_RC_INTEGER);
1384
1385   struct pivot_dimension *categories = pivot_dimension_create (
1386     table, PIVOT_AXIS_ROW, N_("Categories"));
1387
1388   int cumulative_df = 0;
1389   for (int v = 0; v < cmd->n_cat_predictors; ++v)
1390     {
1391       int cat;
1392       const struct interaction *cat_predictors = cmd->cat_predictors[v];
1393       int df = categoricals_df (res->cats, v);
1394
1395       struct string str = DS_EMPTY_INITIALIZER;
1396       interaction_to_string (cat_predictors, &str);
1397       struct pivot_category *var_group = pivot_category_create_group__ (
1398         categories->root,
1399         pivot_value_new_user_text_nocopy (ds_steal_cstr (&str)));
1400
1401       for (cat = 0; cat < categoricals_n_count (res->cats, v) ; ++cat)
1402         {
1403           const struct ccase *c = categoricals_get_case_by_category_real (
1404             res->cats, v, cat);
1405           struct string label = DS_EMPTY_INITIALIZER;
1406           for (int x = 0; x < cat_predictors->n_vars; ++x)
1407             {
1408               if (!ds_is_empty (&label))
1409                 ds_put_byte (&label, ' ');
1410
1411               const union value *val = case_data (c, cat_predictors->vars[x]);
1412               var_append_value_name (cat_predictors->vars[x], val, &label);
1413             }
1414           int cat_idx = pivot_category_create_leaf (
1415             var_group,
1416             pivot_value_new_user_text_nocopy (ds_steal_cstr (&label)));
1417
1418           double *freq = categoricals_get_user_data_by_category_real (
1419             res->cats, v, cat);
1420           pivot_table_put2 (table, 0, cat_idx, pivot_value_new_number (*freq));
1421
1422           for (int x = 0; x < df; ++x)
1423             pivot_table_put2 (table, x + 1, cat_idx,
1424                               pivot_value_new_number (cat == x));
1425         }
1426       cumulative_df += df;
1427     }
1428
1429   pivot_table_submit (table);
1430 }
1431
1432 static void
1433 create_classification_dimension (const struct lr_spec *cmd,
1434                                  const struct lr_result *res,
1435                                  struct pivot_table *table,
1436                                  enum pivot_axis_type axis_type,
1437                                  const char *label, const char *total)
1438 {
1439   struct pivot_dimension *d = pivot_dimension_create (
1440     table, axis_type, label);
1441   d->root->show_label = true;
1442   struct pivot_category *pred_group = pivot_category_create_group__ (
1443     d->root, pivot_value_new_variable (cmd->dep_var));
1444   for (int i = 0; i < 2; i++)
1445     {
1446       const union value *y = i ? &res->y1 : &res->y0;
1447       pivot_category_create_leaf_rc (
1448         pred_group, pivot_value_new_var_value (cmd->dep_var, y),
1449         PIVOT_RC_COUNT);
1450     }
1451   pivot_category_create_leaves (d->root, total, PIVOT_RC_PERCENT);
1452 }
1453
1454 static void
1455 output_classification_table (const struct lr_spec *cmd, const struct lr_result *res)
1456 {
1457   struct pivot_table *table = pivot_table_create (N_("Classification Table"));
1458   pivot_table_set_weight_var (table, cmd->wv);
1459
1460   create_classification_dimension (cmd, res, table, PIVOT_AXIS_COLUMN,
1461                                    N_("Predicted"), N_("Percentage Correct"));
1462   create_classification_dimension (cmd, res, table, PIVOT_AXIS_ROW,
1463                                    N_("Observed"), N_("Overall Percentage"));
1464
1465   pivot_dimension_create (table, PIVOT_AXIS_ROW, N_("Step"), N_("Step 1"));
1466
1467   struct entry
1468     {
1469       int pred_idx;
1470       int obs_idx;
1471       double x;
1472     }
1473   entries[] = {
1474     { 0, 0, res->tn },
1475     { 0, 1, res->fn },
1476     { 1, 0, res->fp },
1477     { 1, 1, res->tp },
1478     { 2, 0, 100 * res->tn / (res->tn + res->fp) },
1479     { 2, 1, 100 * res->tp / (res->tp + res->fn) },
1480     { 2, 2,
1481       100 * (res->tp + res->tn) / (res->tp  + res->tn + res->fp + res->fn)},
1482   };
1483   for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
1484     {
1485       const struct entry *e = &entries[i];
1486       pivot_table_put3 (table, e->pred_idx, e->obs_idx, 0,
1487                         pivot_value_new_number (e->x));
1488     }
1489
1490   pivot_table_submit (table);
1491 }