X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Flogistic.c;h=75f1d2a13fb4f6a439fb0a6e4428b3cc3a45cec1;hb=50e00137bfcc4eb3d4ae753a5e57e7a444194c96;hp=91a16488bd2d548716487425ecfd804b4e2b5754;hpb=3cd65292e3cc6bd6532214dcc8c8ddc65bdc2972;p=pspp

diff --git a/src/language/stats/logistic.c b/src/language/stats/logistic.c
index 91a16488bd..75f1d2a13f 100644
--- a/src/language/stats/logistic.c
+++ b/src/language/stats/logistic.c
@@ -15,21 +15,21 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 
-/* 
-   References: 
+/*
+   References:
    1. "Coding Logistic Regression with Newton-Raphson", James McCaffrey
    http://msdn.microsoft.com/en-us/magazine/jj618304.aspx
 
    2. "SPSS Statistical Algorithms" Chapter LOGISTIC REGRESSION Algorithms
 
 
-   The Newton Raphson method finds successive approximations to $\bf b$ where 
+   The Newton Raphson method finds successive approximations to $\bf b$ where
    approximation ${\bf b}_t$ is (hopefully) better than the previous ${\bf b}_{t-1}$.
 
    $ {\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})$
    where:
 
-   $\bf X$ is the $n \times p$ design matrix, $n$ being the number of cases, 
+   $\bf X$ is the $n \times p$ design matrix, $n$ being the number of cases,
    $p$ the number of parameters, \par
    $\bf W$ is the diagonal matrix whose diagonal elements are
    $\hat{\pi}_0(1 - \hat{\pi}_0), \, \hat{\pi}_1(1 - \hat{\pi}_2)\dots \hat{\pi}_{n-1}(1 - \hat{\pi}_{n-1})$
@@ -39,7 +39,7 @@
 
 #include <config.h>
 
-#include <gsl/gsl_blas.h> 
+#include <gsl/gsl_blas.h>
 
 #include <gsl/gsl_linalg.h>
 #include <gsl/gsl_cdf.h>
@@ -60,15 +60,17 @@
 #include "language/lexer/value-parser.h"
 #include "language/lexer/variable-parser.h"
 #include "libpspp/assertion.h"
+#include "libpspp/hash-functions.h"
+#include "libpspp/hmap.h"
 #include "libpspp/ll.h"
 #include "libpspp/message.h"
 #include "libpspp/misc.h"
 #include "math/categoricals.h"
 #include "math/interaction.h"
-
-#include "output/tab.h"
+#include "output/pivot-table.h"
 
 #include "gettext.h"
+#define N_(msgid) msgid
 #define _(msgid) gettext (msgid)
 
 
@@ -101,6 +103,12 @@ struct lr_spec
   struct interaction **cat_predictors;
   size_t n_cat_predictors;
 
+
+  /* The union of the categorical and non-categorical variables */
+  const struct variable **indep_vars;
+  size_t n_indep_vars;
+
+
   /* Which classes of missing vars are to be excluded */
   enum mv_class exclude;
 
@@ -127,7 +135,8 @@ struct lr_spec
   /* What results should be presented */
   unsigned int print;
 
-  double cut_point;
+  /* Inverse logit of the cut point */
+  double ilogit_cut_point;
 };
 
 
@@ -137,7 +146,7 @@ struct lr_spec
 */
 struct lr_result
 {
-  /* Used to indicate if a pass should flag a warning when 
+  /* Used to indicate if a pass should flag a warning when
      invalid (ie negative or missing) weight values are encountered */
   bool warn_bad_weight;
 
@@ -160,6 +169,14 @@ struct lr_result
    categorical predictors */
   struct categoricals *cats;
   struct payload cp;
+
+
+  /* The estimates of the predictor coefficients */
+  gsl_vector *beta_hat;
+
+  /* The predicted classifications:
+     True Negative, True Positive, False Negative, False Positive */
+  double tn, tp, fn, fp;
 };
 
 
@@ -185,14 +202,14 @@ map_dependent_var (const struct lr_spec *cmd, const struct lr_result *res, const
   return SYSMIS;
 }
 
+static void output_classification_table (const struct lr_spec *cmd, const struct lr_result *res);
 
 static void output_categories (const struct lr_spec *cmd, const struct lr_result *res);
 
 static void output_depvarmap (const struct lr_spec *cmd, const struct lr_result *);
 
-static void output_variables (const struct lr_spec *cmd, 
-			      const struct lr_result *,
-			      const gsl_vector *);
+static void output_variables (const struct lr_spec *cmd,
+			      const struct lr_result *);
 
 static void output_model_summary (const struct lr_result *,
 				  double initial_likelihood, double likelihood);
@@ -203,14 +220,14 @@ static void case_processing_summary (const struct lr_result *);
 /* Return the value of case C corresponding to the INDEX'th entry in the
    model */
 static double
-predictor_value (const struct ccase *c, 
-                    const struct variable **x, size_t n_x, 
+predictor_value (const struct ccase *c,
+                    const struct variable **x, size_t n_x,
                     const struct categoricals *cats,
                     size_t index)
 {
   /* Values of the scalar predictor variables */
-  if (index < n_x) 
-    return case_data (c, x[index])->f;
+  if (index < n_x)
+    return case_num (c, x[index]);
 
   /* Coded values of categorical predictor variables (or interactions) */
   if (cats && index - n_x  < categoricals_df_total (cats))
@@ -225,29 +242,28 @@ predictor_value (const struct ccase *c,
 
 
 /*
-  Return the probability estimator (that is the estimator of logit(y) )
-  corresponding to the coefficient estimator beta_hat for case C
+  Return the probability beta_hat (that is the estimator logit(y))
+  corresponding to the coefficient estimator for case C
 */
-static double 
-pi_hat (const struct lr_spec *cmd, 
-	struct lr_result *res,
-	const gsl_vector *beta_hat,
+static double
+pi_hat (const struct lr_spec *cmd,
+	const struct lr_result *res,
 	const struct variable **x, size_t n_x,
 	const struct ccase *c)
 {
   int v0;
   double pi = 0;
-  size_t n_coeffs = beta_hat->size;
+  size_t n_coeffs = res->beta_hat->size;
 
   if (cmd->constant)
     {
-      pi += gsl_vector_get (beta_hat, beta_hat->size - 1);
+      pi += gsl_vector_get (res->beta_hat, res->beta_hat->size - 1);
       n_coeffs--;
     }
-  
+
   for (v0 = 0; v0 < n_coeffs; ++v0)
     {
-      pi += gsl_vector_get (beta_hat, v0) * 
+      pi += gsl_vector_get (res->beta_hat, v0) *
 	predictor_value (c, x, n_x, res->cats, v0);
     }
 
@@ -260,18 +276,17 @@ pi_hat (const struct lr_spec *cmd,
 /*
   Calculates the Hessian matrix X' V  X,
   where: X is the n by N_X matrix comprising the n cases in INPUT
-  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})} 
+  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})}
   (the partial derivative of the predicted values)
 
   If ALL predicted values derivatives are close to zero or one, then CONVERGED
   will be set to true.
 */
 static void
-hessian (const struct lr_spec *cmd, 
+hessian (const struct lr_spec *cmd,
 	 struct lr_result *res,
 	 struct casereader *input,
 	 const struct variable **x, size_t n_x,
-	 const gsl_vector *beta_hat,
 	 bool *converged)
 {
   struct casereader *reader;
@@ -285,7 +300,7 @@ hessian (const struct lr_spec *cmd,
        (c = casereader_read (reader)) != NULL; case_unref (c))
     {
       int v0, v1;
-      double pi = pi_hat (cmd, res, beta_hat, x, n_x, c);
+      double pi = pi_hat (cmd, res, x, n_x, c);
 
       double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
       double w = pi * (1 - pi);
@@ -293,10 +308,10 @@ hessian (const struct lr_spec *cmd,
 	max_w = w;
       w *= weight;
 
-      for (v0 = 0; v0 < beta_hat->size; ++v0)
+      for (v0 = 0; v0 < res->beta_hat->size; ++v0)
 	{
 	  double in0 = predictor_value (c, x, n_x, res->cats, v0);
-	  for (v1 = 0; v1 < beta_hat->size; ++v1)
+	  for (v1 = 0; v1 < res->beta_hat->size; ++v1)
 	    {
 	      double in1 = predictor_value (c, x, n_x, res->cats, v1);
 	      double *o = gsl_matrix_ptr (res->hessian, v0, v1);
@@ -306,7 +321,7 @@ hessian (const struct lr_spec *cmd,
     }
   casereader_destroy (reader);
 
-  if ( max_w < cmd->min_epsilon)
+  if (max_w < cmd->min_epsilon)
     {
       *converged = true;
       msg (MN, _("All predicted values are either 1 or 0"));
@@ -315,11 +330,13 @@ hessian (const struct lr_spec *cmd,
 
 
 /* Calculates the value  X' (y - pi)
-   where X is the design model, 
+   where X is the design model,
    y is the vector of observed independent variables
    pi is the vector of estimates for y
 
-   As a side effect, the likelihood is stored in LIKELIHOOD
+   Side effects:
+     the likelihood is stored in LIKELIHOOD;
+     the predicted values are placed in the respective tn, fn, tp fp values in RES
 */
 static gsl_vector *
 xt_times_y_pi (const struct lr_spec *cmd,
@@ -327,31 +344,50 @@ xt_times_y_pi (const struct lr_spec *cmd,
 	       struct casereader *input,
 	       const struct variable **x, size_t n_x,
 	       const struct variable *y_var,
-	       const gsl_vector *beta_hat,
-	       double *likelihood)
+	       double *llikelihood)
 {
   struct casereader *reader;
   struct ccase *c;
-  gsl_vector *output = gsl_vector_calloc (beta_hat->size);
+  gsl_vector *output = gsl_vector_calloc (res->beta_hat->size);
 
-  *likelihood = 1.0;
+  *llikelihood = 0.0;
+  res->tn = res->tp = res->fn = res->fp = 0;
   for (reader = casereader_clone (input);
        (c = casereader_read (reader)) != NULL; case_unref (c))
     {
+      double pred_y = 0;
       int v0;
-      double pi = pi_hat (cmd, res, beta_hat, x, n_x, c);
+      double pi = pi_hat (cmd, res, x, n_x, c);
       double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
 
 
       double y = map_dependent_var (cmd, res, case_data (c, y_var));
 
-      *likelihood *= pow (pi, weight * y) * pow (1 - pi, weight * (1 - y));
+      *llikelihood += (weight * y) * log (pi) + log (1 - pi) * weight * (1 - y);
 
-      for (v0 = 0; v0 < beta_hat->size; ++v0)
+      for (v0 = 0; v0 < res->beta_hat->size; ++v0)
 	{
 	  double in0 = predictor_value (c, x, n_x, res->cats, v0);
 	  double *o = gsl_vector_ptr (output, v0);
       	  *o += in0 * (y - pi) * weight;
+	  pred_y += gsl_vector_get (res->beta_hat, v0) * in0;
+	}
+
+      /* Count the number of cases which would be correctly/incorrectly classified by this
+	 estimated model */
+      if (pred_y <= cmd->ilogit_cut_point)
+	{
+	  if (y == 0)
+	    res->tn += weight;
+	  else
+	    res->fn += weight;
+	}
+      else
+	{
+	  if (y == 0)
+	    res->fp += weight;
+	  else
+	    res->tp += weight;
 	}
     }
 
@@ -381,32 +417,33 @@ frq_update  (const void *aux1 UNUSED, void *aux2 UNUSED,
   *freq += weight;
 }
 
-static void 
-frq_destroy (const void *aux1 UNUSED, void *aux2 UNUSED, void *user_data UNUSED)
+static void
+frq_destroy (const void *aux1 UNUSED, void *aux2 UNUSED, void *user_data)
 {
   free (user_data);
 }
 
 
 
-/* 
+/*
    Makes an initial pass though the data, doing the following:
 
    * Checks that the dependent variable is  dichotomous,
    * Creates and initialises the categoricals,
    * Accumulates summary results,
    * Calculates necessary initial values.
+   * Creates an initial value for \hat\beta the vector of beta_hats of \beta
 
-   Returns an initial value for \hat\beta the vector of estimators of \beta
+   Returns true if successful
 */
-static gsl_vector * 
-beta_hat_initial (const struct lr_spec *cmd, struct lr_result *res, struct casereader *input)
+static bool
+initial_pass (const struct lr_spec *cmd, struct lr_result *res, struct casereader *input)
 {
   const int width = var_get_width (cmd->dep_var);
 
   struct ccase *c;
   struct casereader *reader;
-  gsl_vector *b0 ;
+
   double sum;
   double sumA = 0.0;
   double sumB = 0.0;
@@ -427,7 +464,7 @@ beta_hat_initial (const struct lr_spec *cmd, struct lr_result *res, struct caser
       res->cp.destroy = frq_destroy;
 
       res->cats = categoricals_create (cmd->cat_predictors, cmd->n_cat_predictors,
-				       cmd->wv, cmd->exclude, MV_ANY);
+				       cmd->wv, MV_ANY);
 
       categoricals_set_payload (res->cats, &res->cp, cmd, res);
     }
@@ -441,10 +478,15 @@ beta_hat_initial (const struct lr_spec *cmd, struct lr_result *res, struct caser
       double weight = dict_get_case_weight (cmd->dict, c, &res->warn_bad_weight);
       const union value *depval = case_data (c, cmd->dep_var);
 
-      for (v = 0; v < cmd->n_predictor_vars; ++v)
+      if (var_is_value_missing (cmd->dep_var, depval) & cmd->exclude)
 	{
-	  const union value *val = case_data (c, cmd->predictor_vars[v]);
-	  if (var_is_value_missing (cmd->predictor_vars[v], val, cmd->exclude))
+	  missing = true;
+	}
+      else
+      for (v = 0; v < cmd->n_indep_vars; ++v)
+	{
+	  const union value *val = case_data (c, cmd->indep_vars[v]);
+	  if (var_is_value_missing (cmd->indep_vars[v], val) & cmd->exclude)
 	    {
 	      missing = true;
 	      break;
@@ -467,7 +509,7 @@ beta_hat_initial (const struct lr_spec *cmd, struct lr_result *res, struct caser
 	}
       else if (!v1set)
 	{
-	  if ( !value_equal (&res->y0, depval, width))
+	  if (!value_equal (&res->y0, depval, width))
 	    {
 	      value_clone (&res->y1, depval, width);
 	      v1set = true;
@@ -478,9 +520,10 @@ beta_hat_initial (const struct lr_spec *cmd, struct lr_result *res, struct caser
 	  if (! value_equal (&res->y0, depval, width)
 	      &&
 	      ! value_equal (&res->y1, depval, width)
-	      )
+	)
 	    {
 	      msg (ME, _("Dependent variable's values are not dichotomous."));
+              case_unref (c);
 	      goto error;
 	    }
 	}
@@ -515,19 +558,19 @@ beta_hat_initial (const struct lr_spec *cmd, struct lr_result *res, struct caser
     }
 
   n_coefficients += categoricals_df_total (res->cats);
-  b0 = gsl_vector_calloc (n_coefficients);
+  res->beta_hat = gsl_vector_calloc (n_coefficients);
 
-  if ( cmd->constant)
+  if (cmd->constant)
     {
       double mean = sum / res->cc;
-      gsl_vector_set (b0, b0->size - 1, log (mean / (1 - mean)));
+      gsl_vector_set (res->beta_hat, res->beta_hat->size - 1, log (mean / (1 - mean)));
     }
 
-  return b0;
+  return true;
 
  error:
   casereader_destroy (reader);
-  return NULL;
+  return false;
 }
 
 
@@ -539,26 +582,41 @@ run_lr (const struct lr_spec *cmd, struct casereader *input,
 {
   int i;
 
-  gsl_vector *beta_hat;
-
   bool converged = false;
 
-  /* Set the likelihoods to a negative sentinel value */
-  double likelihood = -1;
-  double prev_likelihood = -1;
-  double initial_likelihood = -1;
+  /* Set the log likelihoods to a sentinel value */
+  double log_likelihood = SYSMIS;
+  double prev_log_likelihood = SYSMIS;
+  double initial_log_likelihood = SYSMIS;
 
   struct lr_result work;
   work.n_missing = 0;
   work.n_nonmissing = 0;
   work.warn_bad_weight = true;
   work.cats = NULL;
+  work.beta_hat = NULL;
+  work.hessian = NULL;
+
+  /* Get the initial estimates of \beta and their standard errors.
+     And perform other auxiliary initialisation.  */
+  if (! initial_pass (cmd, &work, input))
+    goto error;
+
+  for (i = 0; i < cmd->n_cat_predictors; ++i)
+    {
+      if (1 >= categoricals_n_count (work.cats, i))
+	{
+	  struct string str;
+	  ds_init_empty (&str);
 
+	  interaction_to_string (cmd->cat_predictors[i], &str);
 
-  /* Get the initial estimates of \beta and their standard errors */
-  beta_hat = beta_hat_initial (cmd, &work, input);
-  if (NULL == beta_hat)
-    return false;
+	  msg (ME, _("Category %s does not have at least two distinct values. Logistic regression will not be run."),
+	       ds_cstr(&str));
+	  ds_destroy (&str);
+	  goto error;
+      	}
+    }
 
   output_depvarmap (cmd, &work);
 
@@ -566,26 +624,31 @@ run_lr (const struct lr_spec *cmd, struct casereader *input,
 
 
   input = casereader_create_filter_missing (input,
-					    cmd->predictor_vars,
-					    cmd->n_predictor_vars,
+					    cmd->indep_vars,
+					    cmd->n_indep_vars,
 					    cmd->exclude,
 					    NULL,
 					    NULL);
 
+  input = casereader_create_filter_missing (input,
+					    &cmd->dep_var,
+					    1,
+					    cmd->exclude,
+					    NULL,
+					    NULL);
 
-  work.hessian = gsl_matrix_calloc (beta_hat->size, beta_hat->size);
+  work.hessian = gsl_matrix_calloc (work.beta_hat->size, work.beta_hat->size);
 
   /* Start the Newton Raphson iteration process... */
-  for( i = 0 ; i < cmd->max_iter ; ++i)
+  for(i = 0 ; i < cmd->max_iter ; ++i)
     {
       double min, max;
       gsl_vector *v ;
 
-      
+
       hessian (cmd, &work, input,
-		   cmd->predictor_vars, cmd->n_predictor_vars,
-		   beta_hat,
-		   &converged);
+	       cmd->predictor_vars, cmd->n_predictor_vars,
+	       &converged);
 
       gsl_linalg_cholesky_decomp (work.hessian);
       gsl_linalg_cholesky_invert (work.hessian);
@@ -593,8 +656,7 @@ run_lr (const struct lr_spec *cmd, struct casereader *input,
       v = xt_times_y_pi (cmd, &work, input,
 			 cmd->predictor_vars, cmd->n_predictor_vars,
 			 cmd->dep_var,
-			 beta_hat,
-			 &likelihood);
+			 &log_likelihood);
 
       {
 	/* delta = M.v */
@@ -603,11 +665,11 @@ run_lr (const struct lr_spec *cmd, struct casereader *input,
 	gsl_vector_free (v);
 
 
-	gsl_vector_add (beta_hat, delta);
+	gsl_vector_add (work.beta_hat, delta);
 
 	gsl_vector_minmax (delta, &min, &max);
 
-	if ( fabs (min) < cmd->bcon && fabs (max) < cmd->bcon)
+	if (fabs (min) < cmd->bcon && fabs (max) < cmd->bcon)
 	  {
 	    msg (MN, _("Estimation terminated at iteration number %d because parameter estimates changed by less than %g"),
 		 i + 1, cmd->bcon);
@@ -617,51 +679,82 @@ run_lr (const struct lr_spec *cmd, struct casereader *input,
 	gsl_vector_free (delta);
       }
 
-      if ( prev_likelihood >= 0)
+      if (i > 0)
 	{
-	  if (-log (likelihood) > -(1.0 - cmd->lcon) * log (prev_likelihood))
+	  if (-log_likelihood > -(1.0 - cmd->lcon) * prev_log_likelihood)
 	    {
 	      msg (MN, _("Estimation terminated at iteration number %d because Log Likelihood decreased by less than %g%%"), i + 1, 100 * cmd->lcon);
 	      converged = true;
 	    }
 	}
       if (i == 0)
-	initial_likelihood = likelihood;
-      prev_likelihood = likelihood;
+	initial_log_likelihood = log_likelihood;
+      prev_log_likelihood = log_likelihood;
 
       if (converged)
 	break;
     }
-  casereader_destroy (input);
-  assert (initial_likelihood >= 0);
 
-  if ( ! converged) 
-    msg (MW, _("Estimation terminated at iteration number %d because maximum iterations has been reached"), i );
 
 
-  output_model_summary (&work, initial_likelihood, likelihood);
+  if (! converged)
+    msg (MW, _("Estimation terminated at iteration number %d because maximum iterations has been reached"), i);
+
+
+  output_model_summary (&work, initial_log_likelihood, log_likelihood);
 
   if (work.cats)
     output_categories (cmd, &work);
 
-  output_variables (cmd, &work, beta_hat);
+  output_classification_table (cmd, &work);
+  output_variables (cmd, &work);
 
+  casereader_destroy (input);
   gsl_matrix_free (work.hessian);
-  gsl_vector_free (beta_hat); 
-  
+  gsl_vector_free (work.beta_hat);
   categoricals_destroy (work.cats);
 
   return true;
+
+ error:
+  casereader_destroy (input);
+  gsl_matrix_free (work.hessian);
+  gsl_vector_free (work.beta_hat);
+  categoricals_destroy (work.cats);
+
+  return false;
 }
 
+struct variable_node
+{
+  struct hmap_node node;      /* Node in hash map. */
+  const struct variable *var; /* The variable */
+};
+
+static struct variable_node *
+lookup_variable (const struct hmap *map, const struct variable *var, unsigned int hash)
+{
+  struct variable_node *vn = NULL;
+  HMAP_FOR_EACH_WITH_HASH (vn, struct variable_node, node, hash, map)
+    {
+      if (vn->var == var)
+	break;
+    }
+
+  return vn;
+}
+
+
 /* Parse the LOGISTIC REGRESSION command syntax */
 int
 cmd_logistic (struct lexer *lexer, struct dataset *ds)
 {
+  int i;
   /* Temporary location for the predictor variables.
      These may or may not include the categorical predictors */
   const struct variable **pred_vars;
   size_t n_pred_vars;
+  double cp = 0.5;
 
   int v, x;
   struct lr_spec lr;
@@ -674,13 +767,12 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
   lr.lcon = 0.0000;
   lr.bcon = 0.001;
   lr.min_epsilon = 0.00000001;
-  lr.cut_point = 0.5;
   lr.constant = true;
   lr.confidence = 95;
   lr.print = PRINT_DEFAULT;
   lr.cat_predictors = NULL;
   lr.n_cat_predictors = 0;
-
+  lr.indep_vars = NULL;
 
 
   if (lex_match_id (lexer, "VARIABLES"))
@@ -689,7 +781,8 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
   if (! (lr.dep_var = parse_variable_const (lexer, lr.dict)))
     goto error;
 
-  lex_force_match (lexer, T_WITH);
+  if (! lex_force_match (lexer, T_WITH))
+    goto error;
 
   if (!parse_variables_const (lexer, lr.dict,
 			      &pred_vars, &n_pred_vars,
@@ -747,7 +840,7 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
 				  sizeof (*lr.cat_predictors) * ++lr.n_cat_predictors);
 	      lr.cat_predictors[lr.n_cat_predictors - 1] = 0;
 	    }
-	  while (parse_design_interaction (lexer, lr.dict, 
+	  while (parse_design_interaction (lexer, lr.dict,
 					   lr.cat_predictors + lr.n_cat_predictors - 1));
 	  lr.n_cat_predictors--;
 	}
@@ -783,14 +876,14 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
 		  lr.print |= PRINT_CI;
 		  if (lex_force_match (lexer, T_LPAREN))
 		    {
-		      if (! lex_force_int (lexer))
+		      if (! lex_force_num (lexer))
 			{
 			  lex_error (lexer, NULL);
 			  goto error;
 			}
-		      lr.confidence = lex_integer (lexer);
+		      lr.confidence = lex_number (lexer);
 		      lex_get (lexer);
-		      if ( ! lex_force_match (lexer, T_RPAREN))
+		      if (! lex_force_match (lexer, T_RPAREN))
 			{
 			  lex_error (lexer, NULL);
 			  goto error;
@@ -824,7 +917,7 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
 			}
 		      lr.bcon = lex_number (lexer);
 		      lex_get (lexer);
-		      if ( ! lex_force_match (lexer, T_RPAREN))
+		      if (! lex_force_match (lexer, T_RPAREN))
 			{
 			  lex_error (lexer, NULL);
 			  goto error;
@@ -835,14 +928,14 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
 		{
 		  if (lex_force_match (lexer, T_LPAREN))
 		    {
-		      if (! lex_force_int (lexer))
+		      if (! lex_force_int_range (lexer, "ITERATE", 0, INT_MAX))
 			{
 			  lex_error (lexer, NULL);
 			  goto error;
 			}
 		      lr.max_iter = lex_integer (lexer);
 		      lex_get (lexer);
-		      if ( ! lex_force_match (lexer, T_RPAREN))
+		      if (! lex_force_match (lexer, T_RPAREN))
 			{
 			  lex_error (lexer, NULL);
 			  goto error;
@@ -860,7 +953,7 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
 			}
 		      lr.lcon = lex_number (lexer);
 		      lex_get (lexer);
-		      if ( ! lex_force_match (lexer, T_RPAREN))
+		      if (! lex_force_match (lexer, T_RPAREN))
 			{
 			  lex_error (lexer, NULL);
 			  goto error;
@@ -878,7 +971,24 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
 			}
 		      lr.min_epsilon = lex_number (lexer);
 		      lex_get (lexer);
-		      if ( ! lex_force_match (lexer, T_RPAREN))
+		      if (! lex_force_match (lexer, T_RPAREN))
+			{
+			  lex_error (lexer, NULL);
+			  goto error;
+			}
+		    }
+		}
+	      else if (lex_match_id (lexer, "CUT"))
+		{
+		  if (lex_force_match (lexer, T_LPAREN))
+		    {
+                      if (!lex_force_num_range_closed (lexer, "CUT", 0, 1))
+                        goto error;
+
+		      cp = lex_number (lexer);
+
+		      lex_get (lexer);
+		      if (! lex_force_match (lexer, T_RPAREN))
 			{
 			  lex_error (lexer, NULL);
 			  goto error;
@@ -899,30 +1009,56 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
 	}
     }
 
-  /* Copy the predictor variables from the temporary location into the 
+  lr.ilogit_cut_point = - log (1/cp - 1);
+
+
+  /* Copy the predictor variables from the temporary location into the
      final one, dropping any categorical variables which appear there.
      FIXME: This is O(NxM).
   */
+  {
+  struct variable_node *vn, *next;
+  struct hmap allvars;
+  hmap_init (&allvars);
   for (v = x = 0; v < n_pred_vars; ++v)
     {
       bool drop = false;
       const struct variable *var = pred_vars[v];
       int cv = 0;
+
+      unsigned int hash = hash_pointer (var, 0);
+      struct variable_node *vn = lookup_variable (&allvars, var, hash);
+      if (vn == NULL)
+	{
+	  vn = xmalloc (sizeof *vn);
+	  vn->var = var;
+	  hmap_insert (&allvars, &vn->node,  hash);
+	}
+
       for (cv = 0; cv < lr.n_cat_predictors ; ++cv)
 	{
 	  int iv;
 	  const struct interaction *iact = lr.cat_predictors[cv];
 	  for (iv = 0 ; iv < iact->n_vars ; ++iv)
 	    {
-	      if (var == iact->vars[iv])
+	      const struct variable *ivar = iact->vars[iv];
+	      unsigned int hash = hash_pointer (ivar, 0);
+	      struct variable_node *vn = lookup_variable (&allvars, ivar, hash);
+	      if (vn == NULL)
+		{
+		  vn = xmalloc (sizeof *vn);
+		  vn->var = ivar;
+
+		  hmap_insert (&allvars, &vn->node,  hash);
+		}
+
+	      if (var == ivar)
 		{
 		  drop = true;
-		  goto dropped;
 		}
 	    }
 	}
 
-    dropped:
       if (drop)
 	continue;
 
@@ -932,8 +1068,21 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
     }
   free (pred_vars);
 
+  lr.n_indep_vars = hmap_count (&allvars);
+  lr.indep_vars = xmalloc (lr.n_indep_vars * sizeof *lr.indep_vars);
+
+  /* Interate over each variable and push it into the array */
+  x = 0;
+  HMAP_FOR_EACH_SAFE (vn, next, struct variable_node, node, &allvars)
+    {
+      lr.indep_vars[x++] = vn->var;
+      free (vn);
+    }
+  hmap_destroy (&allvars);
+  }
+
 
-  /* Run logistical regression for each split group */
+  /* logistical regression for each split group */
   {
     struct casegrouper *grouper;
     struct casereader *group;
@@ -946,14 +1095,26 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
     ok = proc_commit (ds) && ok;
   }
 
+  for (i = 0 ; i < lr.n_cat_predictors; ++i)
+    {
+      interaction_destroy (lr.cat_predictors[i]);
+    }
   free (lr.predictor_vars);
   free (lr.cat_predictors);
+  free (lr.indep_vars);
+
   return CMD_SUCCESS;
 
  error:
 
+  for (i = 0 ; i < lr.n_cat_predictors; ++i)
+    {
+      interaction_destroy (lr.cat_predictors[i]);
+    }
   free (lr.predictor_vars);
   free (lr.cat_predictors);
+  free (lr.indep_vars);
+
   return CMD_FAILURE;
 }
 
@@ -967,141 +1128,101 @@ cmd_logistic (struct lexer *lexer, struct dataset *ds)
 static void
 output_depvarmap (const struct lr_spec *cmd, const struct lr_result *res)
 {
-  const int heading_columns = 0;
-  const int heading_rows = 1;
-  struct tab_table *t;
-  struct string str;
-
-  const int nc = 2;
-  int nr = heading_rows + 2;
-
-  t = tab_create (nc, nr);
-  tab_title (t, _("Dependent Variable Encoding"));
-
-  tab_headers (t, heading_columns, 0, heading_rows, 0);
-
-  tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
-
-  tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
-  tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
-
-  tab_text (t,  0, 0, TAB_CENTER | TAT_TITLE, _("Original Value"));
-  tab_text (t,  1, 0, TAB_CENTER | TAT_TITLE, _("Internal Value"));
-
+  struct pivot_table *table = pivot_table_create (
+    N_("Dependent Variable Encoding"));
 
+  pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Mapping"),
+                          N_("Internal Value"));
 
-  ds_init_empty (&str);
-  var_append_value_name (cmd->dep_var, &res->y0, &str);
-  tab_text (t,  0, 0 + heading_rows,  0, ds_cstr (&str));
+  struct pivot_dimension *original = pivot_dimension_create (
+    table, PIVOT_AXIS_ROW, N_("Original Value"));
+  original->root->show_label = true;
 
-  ds_clear (&str);
-  var_append_value_name (cmd->dep_var, &res->y1, &str);
-  tab_text (t,  0, 1 + heading_rows,  0, ds_cstr (&str));
-
-
-  tab_double (t, 1, 0 + heading_rows, 0, map_dependent_var (cmd, res, &res->y0), &F_8_0);
-  tab_double (t, 1, 1 + heading_rows, 0, map_dependent_var (cmd, res, &res->y1), &F_8_0);
-  ds_destroy (&str);
+  for (int i = 0; i < 2; i++)
+    {
+      const union value *v = i ? &res->y1 : &res->y0;
+      int orig_idx = pivot_category_create_leaf (
+        original->root, pivot_value_new_var_value (cmd->dep_var, v));
+      pivot_table_put2 (table, 0, orig_idx, pivot_value_new_number (
+                          map_dependent_var (cmd, res, v)));
+    }
 
-  tab_submit (t);
+  pivot_table_submit (table);
 }
 
 
 /* Show the Variables in the Equation box */
 static void
-output_variables (const struct lr_spec *cmd, 
-		  const struct lr_result *res,
-		  const gsl_vector *beta)
+output_variables (const struct lr_spec *cmd,
+		  const struct lr_result *res)
 {
-  int row = 0;
-  const int heading_columns = 1;
-  int heading_rows = 1;
-  struct tab_table *t;
+  struct pivot_table *table = pivot_table_create (
+    N_("Variables in the Equation"));
+
+  struct pivot_dimension *statistics = pivot_dimension_create (
+    table, PIVOT_AXIS_COLUMN, N_("Statistics"),
+    N_("B"), PIVOT_RC_OTHER,
+    N_("S.E."), PIVOT_RC_OTHER,
+    N_("Wald"), PIVOT_RC_OTHER,
+    N_("df"), PIVOT_RC_INTEGER,
+    N_("Sig."), PIVOT_RC_SIGNIFICANCE,
+    N_("Exp(B)"), PIVOT_RC_OTHER);
+  if (cmd->print & PRINT_CI)
+    {
+      struct pivot_category *group = pivot_category_create_group__ (
+        statistics->root,
+        pivot_value_new_text_format (N_("%d%% CI for Exp(B)"),
+                                     cmd->confidence));
+      pivot_category_create_leaves (group, N_("Lower"), N_("Upper"));
+    }
+
+  struct pivot_dimension *variables = pivot_dimension_create (
+    table, PIVOT_AXIS_ROW, N_("Variables"));
+  struct pivot_category *step1 = pivot_category_create_group (
+    variables->root, N_("Step 1"));
 
-  int nc = 8;
-  int nr ;
-  int i = 0;
   int ivar = 0;
   int idx_correction = 0;
+  int i = 0;
 
-  if (cmd->print & PRINT_CI)
-    {
-      nc += 2;
-      heading_rows += 1;
-      row++;
-    }
-  nr = heading_rows + cmd->n_predictor_vars;
+  int nr = cmd->n_predictor_vars;
   if (cmd->constant)
     nr++;
-
   if (res->cats)
     nr += categoricals_df_total (res->cats) + cmd->n_cat_predictors;
 
-  t = tab_create (nc, nr);
-  tab_title (t, _("Variables in the Equation"));
-
-  tab_headers (t, heading_columns, 0, heading_rows, 0);
-
-  tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
-
-  tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
-  tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
-
-  tab_text (t,  0, row + 1, TAB_CENTER | TAT_TITLE, _("Step 1"));
-
-  tab_text (t,  2, row, TAB_CENTER | TAT_TITLE, _("B"));
-  tab_text (t,  3, row, TAB_CENTER | TAT_TITLE, _("S.E."));
-  tab_text (t,  4, row, TAB_CENTER | TAT_TITLE, _("Wald"));
-  tab_text (t,  5, row, TAB_CENTER | TAT_TITLE, _("df"));
-  tab_text (t,  6, row, TAB_CENTER | TAT_TITLE, _("Sig."));
-  tab_text (t,  7, row, TAB_CENTER | TAT_TITLE, _("Exp(B)"));
-
-  if (cmd->print & PRINT_CI)
+  for (int row = 0; row < nr; row++)
     {
-      tab_joint_text_format (t, 8, 0, 9, 0,
-			     TAB_CENTER | TAT_TITLE, _("%d%% CI for Exp(B)"), cmd->confidence);
-
-      tab_text (t,  8, row, TAB_CENTER | TAT_TITLE, _("Lower"));
-      tab_text (t,  9, row, TAB_CENTER | TAT_TITLE, _("Upper"));
-    }
- 
-  for (row = heading_rows ; row < nr; ++row)
-    {
-      const int idx = row - heading_rows - idx_correction;
-
-      const double b = gsl_vector_get (beta, idx);
-      const double sigma2 = gsl_matrix_get (res->hessian, idx, idx);
-      const double wald = pow2 (b) / sigma2;
-      const double df = 1;
+      const int idx = row - idx_correction;
 
+      int var_idx;
       if (idx < cmd->n_predictor_vars)
-	{
-	  tab_text (t, 1, row, TAB_LEFT | TAT_TITLE, 
-		    var_to_string (cmd->predictor_vars[idx]));
-	}
+        var_idx = pivot_category_create_leaf (
+          step1, pivot_value_new_variable (cmd->predictor_vars[idx]));
       else if (i < cmd->n_cat_predictors)
 	{
-	  double wald;
-	  bool summary = false;
-	  struct string str;
 	  const struct interaction *cat_predictors = cmd->cat_predictors[i];
-	  const int df = categoricals_df (res->cats, i);
-
-	  ds_init_empty (&str);
+	  struct string str = DS_EMPTY_INITIALIZER;
 	  interaction_to_string (cat_predictors, &str);
-
-	  if (ivar == 0)
+	  if (ivar != 0)
+            ds_put_format (&str, "(%d)", ivar);
+          var_idx = pivot_category_create_leaf (
+            step1, pivot_value_new_user_text_nocopy (ds_steal_cstr (&str)));
+
+	  int df = categoricals_df (res->cats, i);
+	  bool summary = ivar == 0;
+          if (summary)
 	    {
 	      /* Calculate the Wald statistic,
 		 which is \beta' C^-1 \beta .
 		 where \beta is the vector of the coefficient estimates comprising this
-		 categorial variable. and C is the corresponding submatrix of the 
+		 categorial variable. and C is the corresponding submatrix of the
 		 hessian matrix.
 	      */
 	      gsl_matrix_const_view mv =
 		gsl_matrix_const_submatrix (res->hessian, idx, idx, df, df);
 	      gsl_matrix *subhessian = gsl_matrix_alloc (mv.matrix.size1, mv.matrix.size2);
-	      gsl_vector_const_view vv = gsl_vector_const_subvector (beta, idx, df);
+	      gsl_vector_const_view vv = gsl_vector_const_subvector (res->beta_hat, idx, df);
 	      gsl_vector *temp = gsl_vector_alloc (df);
 
 	      gsl_matrix_memcpy (subhessian, &mv.matrix);
@@ -1109,167 +1230,137 @@ output_variables (const struct lr_spec *cmd,
 	      gsl_linalg_cholesky_invert (subhessian);
 
 	      gsl_blas_dgemv (CblasTrans, 1.0, subhessian, &vv.vector, 0, temp);
+              double wald;
 	      gsl_blas_ddot (temp, &vv.vector, &wald);
 
-	      tab_double (t, 4, row, 0, wald, 0);
-	      tab_double (t, 5, row, 0, df, &F_8_0);
-	      tab_double (t, 6, row, 0, gsl_cdf_chisq_Q (wald, df), 0);
+              double entries[] = { wald, df, gsl_cdf_chisq_Q (wald, df) };
+              for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
+                pivot_table_put2 (table, j + 2, var_idx,
+                                  pivot_value_new_number (entries[j]));
 
-	      idx_correction ++;
-	      summary = true;
+	      idx_correction++;
 	      gsl_matrix_free (subhessian);
 	      gsl_vector_free (temp);
       	    }
-	  else
-	    {
-	      ds_put_format (&str, "(%d)", ivar);
-	    }
 
-	  tab_text (t, 1, row, TAB_LEFT | TAT_TITLE, ds_cstr (&str));
 	  if (ivar++ == df)
 	    {
 	      ++i; /* next interaction */
 	      ivar = 0;
 	    }
 
-	  ds_destroy (&str);
-
 	  if (summary)
 	    continue;
 	}
       else
-	{
-	  tab_text (t, 1, row, TAB_LEFT | TAT_TITLE, _("Constant"));
-	}
-
-      tab_double (t, 2, row, 0, b, 0);
-      tab_double (t, 3, row, 0, sqrt (sigma2), 0);
-      tab_double (t, 4, row, 0, wald, 0);
-      tab_double (t, 5, row, 0, df, &F_8_0);
-      tab_double (t, 6, row, 0, gsl_cdf_chisq_Q (wald, df), 0);
-      tab_double (t, 7, row, 0, exp (b), 0);
-
-      if (cmd->print & PRINT_CI)
-	{
-	  double wc = gsl_cdf_ugaussian_Pinv (0.5 + cmd->confidence / 200.0);
-	  wc *= sqrt (sigma2);
-
-	  if (idx < cmd->n_predictor_vars)
-	    {
-	      tab_double (t, 8, row, 0, exp (b - wc), 0);
-	      tab_double (t, 9, row, 0, exp (b + wc), 0);
-	    }
-	}
+        var_idx = pivot_category_create_leaves (step1, N_("Constant"));
+
+      double b = gsl_vector_get (res->beta_hat, idx);
+      double sigma2 = gsl_matrix_get (res->hessian, idx, idx);
+      double wald = pow2 (b) / sigma2;
+      double df = 1;
+      double wc = (gsl_cdf_ugaussian_Pinv (0.5 + cmd->confidence / 200.0)
+                   * sqrt (sigma2));
+      bool show_ci = cmd->print & PRINT_CI && row < nr - cmd->constant;
+
+      double entries[] = {
+        b,
+        sqrt (sigma2),
+        wald,
+        df,
+        gsl_cdf_chisq_Q (wald, df),
+        exp (b),
+        show_ci ? exp (b - wc) : SYSMIS,
+        show_ci ? exp (b + wc) : SYSMIS,
+      };
+      for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
+        if (entries[j] != SYSMIS)
+          pivot_table_put2 (table, j, var_idx,
+                            pivot_value_new_number (entries[j]));
     }
 
-  tab_submit (t);
+  pivot_table_submit (table);
 }
 
 
 /* Show the model summary box */
 static void
 output_model_summary (const struct lr_result *res,
-		      double initial_likelihood, double likelihood)
+		      double initial_log_likelihood, double log_likelihood)
 {
-  const int heading_columns = 0;
-  const int heading_rows = 1;
-  struct tab_table *t;
-
-  const int nc = 4;
-  int nr = heading_rows + 1;
-  double cox;
-
-  t = tab_create (nc, nr);
-  tab_title (t, _("Model Summary"));
-
-  tab_headers (t, heading_columns, 0, heading_rows, 0);
-
-  tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
-
-  tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
-  tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
-
-  tab_text (t,  0, 0, TAB_LEFT | TAT_TITLE, _("Step 1"));
-  tab_text (t,  1, 0, TAB_CENTER | TAT_TITLE, _("-2 Log likelihood"));
-  tab_double (t,  1, 1, 0, -2 * log (likelihood), 0);
-
-
-  tab_text (t,  2, 0, TAB_CENTER | TAT_TITLE, _("Cox & Snell R Square"));
-  cox =  1.0 - pow (initial_likelihood /likelihood, 2 / res->cc);
-  tab_double (t,  2, 1, 0, cox, 0);
-
-  tab_text (t,  3, 0, TAB_CENTER | TAT_TITLE, _("Nagelkerke R Square"));
-  tab_double (t,  3, 1, 0, cox / ( 1.0 - pow (initial_likelihood, 2 / res->cc)), 0);
-
-
-  tab_submit (t);
+  struct pivot_table *table = pivot_table_create (N_("Model Summary"));
+
+  pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
+                          N_("-2 Log likelihood"), PIVOT_RC_OTHER,
+                          N_("Cox & Snell R Square"), PIVOT_RC_OTHER,
+                          N_("Nagelkerke R Square"), PIVOT_RC_OTHER);
+
+  struct pivot_dimension *step = pivot_dimension_create (
+    table, PIVOT_AXIS_ROW, N_("Step"));
+  step->root->show_label = true;
+  pivot_category_create_leaf (step->root, pivot_value_new_integer (1));
+
+  double cox = (1.0 - exp ((initial_log_likelihood - log_likelihood)
+                           * (2 / res->cc)));
+  double entries[] = {
+    -2 * log_likelihood,
+    cox,
+    cox / (1.0 - exp(initial_log_likelihood * (2 / res->cc)))
+  };
+  for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
+    pivot_table_put2 (table, i, 0, pivot_value_new_number (entries[i]));
+
+  pivot_table_submit (table);
 }
 
 /* Show the case processing summary box */
 static void
 case_processing_summary (const struct lr_result *res)
 {
-  const int heading_columns = 1;
-  const int heading_rows = 1;
-  struct tab_table *t;
+  struct pivot_table *table = pivot_table_create (
+    N_("Case Processing Summary"));
 
-  const int nc = 3;
-  const int nr = heading_rows + 3;
-  casenumber total;
+  pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
+                          N_("N"), PIVOT_RC_COUNT,
+                          N_("Percent"), PIVOT_RC_PERCENT);
 
-  t = tab_create (nc, nr);
-  tab_title (t, _("Case Processing Summary"));
+  struct pivot_dimension *cases = pivot_dimension_create (
+    table, PIVOT_AXIS_ROW, N_("Unweighted Cases"),
+    N_("Included in Analysis"), N_("Missing Cases"), N_("Total"));
+  cases->root->show_label = true;
 
-  tab_headers (t, heading_columns, 0, heading_rows, 0);
-
-  tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
-
-  tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
-  tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
-
-  tab_text (t,  0, 0, TAB_LEFT | TAT_TITLE, _("Unweighted Cases"));
-  tab_text (t,  1, 0, TAB_CENTER | TAT_TITLE, _("N"));
-  tab_text (t,  2, 0, TAB_CENTER | TAT_TITLE, _("Percent"));
-
-
-  tab_text (t,  0, 1, TAB_LEFT | TAT_TITLE, _("Included in Analysis"));
-  tab_text (t,  0, 2, TAB_LEFT | TAT_TITLE, _("Missing Cases"));
-  tab_text (t,  0, 3, TAB_LEFT | TAT_TITLE, _("Total"));
-
-  tab_double (t,  1, 1, 0, res->n_nonmissing, &F_8_0);
-  tab_double (t,  1, 2, 0, res->n_missing, &F_8_0);
-
-  total = res->n_nonmissing + res->n_missing;
-  tab_double (t,  1, 3, 0, total , &F_8_0);
-
-  tab_double (t,  2, 1, 0, 100 * res->n_nonmissing / (double) total, 0);
-  tab_double (t,  2, 2, 0, 100 * res->n_missing / (double) total, 0);
-  tab_double (t,  2, 3, 0, 100 * total / (double) total, 0);
-
-  tab_submit (t);
+  double total = res->n_nonmissing + res->n_missing;
+  struct entry
+    {
+      int stat_idx;
+      int case_idx;
+      double x;
+    }
+  entries[] = {
+    { 0, 0, res->n_nonmissing },
+    { 0, 1, res->n_missing },
+    { 0, 2, total },
+    { 1, 0, 100.0 * res->n_nonmissing / total },
+    { 1, 1, 100.0 * res->n_missing / total },
+    { 1, 2, 100.0 },
+  };
+  for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
+    pivot_table_put2 (table, entries[i].stat_idx, entries[i].case_idx,
+                      pivot_value_new_number (entries[i].x));
+
+  pivot_table_submit (table);
 }
 
 static void
 output_categories (const struct lr_spec *cmd, const struct lr_result *res)
 {
-  const struct fmt_spec *wfmt =
-    cmd->wv ? var_get_print_format (cmd->wv) : &F_8_0;
-
-  int cumulative_df;
-  int i = 0;
-  const int heading_columns = 2;
-  const int heading_rows = 2;
-  struct tab_table *t;
-
-  int nc ;
-  int nr ;
-
-  int v;
-  int r = 0;
+  struct pivot_table *table = pivot_table_create (
+    N_("Categorical Variables' Codings"));
+  pivot_table_set_weight_var (table, dict_get_weight (cmd->dict));
 
   int max_df = 0;
   int total_cats = 0;
-  for (i = 0; i < cmd->n_cat_predictors; ++i)
+  for (int i = 0; i < cmd->n_cat_predictors; ++i)
     {
       size_t n = categoricals_n_count (res->cats, i);
       size_t df = categoricals_df (res->cats, i);
@@ -1278,78 +1369,121 @@ output_categories (const struct lr_spec *cmd, const struct lr_result *res)
       total_cats += n;
     }
 
-  nc = heading_columns + 1 + max_df;
-  nr = heading_rows + total_cats;
-
-  t = tab_create (nc, nr);
-  tab_title (t, _("Categorical Variables' Codings"));
-
-  tab_headers (t, heading_columns, 0, heading_rows, 0);
-
-  tab_box (t, TAL_2, TAL_2, -1, TAL_1, 0, 0, nc - 1, nr - 1);
-
-  tab_hline (t, TAL_2, 0, nc - 1, heading_rows);
-  tab_vline (t, TAL_2, heading_columns, 0, nr - 1);
-
-
-  tab_text (t, heading_columns, 1, TAB_CENTER | TAT_TITLE, _("Frequency"));
-
-  tab_joint_text_format (t, heading_columns + 1, 0, nc - 1, 0,
-			 TAB_CENTER | TAT_TITLE, _("Parameter coding"));
-
-
-  for (i = 0; i < max_df; ++i)
-    {
-      int c = heading_columns + 1 + i;
-      tab_text_format (t,  c, 1, TAB_CENTER | TAT_TITLE, _("(%d)"), i + 1);
-    }
-
-  cumulative_df = 0;
-  for (v = 0; v < cmd->n_cat_predictors; ++v)
+  struct pivot_dimension *codings = pivot_dimension_create (
+    table, PIVOT_AXIS_COLUMN, N_("Codings"),
+    N_("Frequency"), PIVOT_RC_COUNT);
+  struct pivot_category *coding_group = pivot_category_create_group (
+    codings->root, N_("Parameter coding"));
+  for (int i = 0; i < max_df; ++i)
+    pivot_category_create_leaf_rc (
+      coding_group,
+      pivot_value_new_user_text_nocopy (xasprintf ("(%d)", i + 1)),
+      PIVOT_RC_INTEGER);
+
+  struct pivot_dimension *categories = pivot_dimension_create (
+    table, PIVOT_AXIS_ROW, N_("Categories"));
+
+  int cumulative_df = 0;
+  for (int v = 0; v < cmd->n_cat_predictors; ++v)
     {
       int cat;
       const struct interaction *cat_predictors = cmd->cat_predictors[v];
-      int df =  categoricals_df (res->cats, v);
-      struct string str;
-      ds_init_empty (&str);
+      int df = categoricals_df (res->cats, v);
 
+      struct string str = DS_EMPTY_INITIALIZER;
       interaction_to_string (cat_predictors, &str);
-
-      tab_text (t, 0, heading_rows + r, TAB_LEFT | TAT_TITLE, ds_cstr (&str) );
-
-      ds_destroy (&str);
+      struct pivot_category *var_group = pivot_category_create_group__ (
+        categories->root,
+        pivot_value_new_user_text_nocopy (ds_steal_cstr (&str)));
 
       for (cat = 0; cat < categoricals_n_count (res->cats, v) ; ++cat)
 	{
-	  struct string str;
-	  const struct ccase *c = categoricals_get_case_by_category_real (res->cats, v, cat);
-	  const double *freq = categoricals_get_user_data_by_category_real (res->cats, v, cat);
-	  
-	  int x;
-	  ds_init_empty (&str);
-
-	  for (x = 0; x < cat_predictors->n_vars; ++x)
+	  const struct ccase *c = categoricals_get_case_by_category_real (
+            res->cats, v, cat);
+          struct string label = DS_EMPTY_INITIALIZER;
+	  for (int x = 0; x < cat_predictors->n_vars; ++x)
 	    {
-	      const union value *val = case_data (c, cat_predictors->vars[x]);
-	      var_append_value_name (cat_predictors->vars[x], val, &str);
+              if (!ds_is_empty (&label))
+                ds_put_byte (&label, ' ');
 
-	      if (x < cat_predictors->n_vars - 1)
-		ds_put_cstr (&str, " ");
+	      const union value *val = case_data (c, cat_predictors->vars[x]);
+	      var_append_value_name (cat_predictors->vars[x], val, &label);
 	    }
-	  
-	  tab_text   (t, 1, heading_rows + r, 0, ds_cstr (&str));
-	  ds_destroy (&str);
-       	  tab_double (t, 2, heading_rows + r, 0, *freq, wfmt);
+          int cat_idx = pivot_category_create_leaf (
+            var_group,
+            pivot_value_new_user_text_nocopy (ds_steal_cstr (&label)));
 
-	  for (x = 0; x < df; ++x)
-	    {
-	      tab_double (t, heading_columns + 1 + x, heading_rows + r, 0, (cat == x), &F_8_0);
-	    }
-	  ++r;
+	  double *freq = categoricals_get_user_data_by_category_real (
+            res->cats, v, cat);
+          pivot_table_put2 (table, 0, cat_idx, pivot_value_new_number (*freq));
+
+	  for (int x = 0; x < df; ++x)
+            pivot_table_put2 (table, x + 1, cat_idx,
+                              pivot_value_new_number (cat == x));
 	}
       cumulative_df += df;
     }
 
-  tab_submit (t);
+  pivot_table_submit (table);
+}
+
+static void
+create_classification_dimension (const struct lr_spec *cmd,
+                                 const struct lr_result *res,
+                                 struct pivot_table *table,
+                                 enum pivot_axis_type axis_type,
+                                 const char *label, const char *total)
+{
+  struct pivot_dimension *d = pivot_dimension_create (
+    table, axis_type, label);
+  d->root->show_label = true;
+  struct pivot_category *pred_group = pivot_category_create_group__ (
+    d->root, pivot_value_new_variable (cmd->dep_var));
+  for (int i = 0; i < 2; i++)
+    {
+      const union value *y = i ? &res->y1 : &res->y0;
+      pivot_category_create_leaf_rc (
+        pred_group, pivot_value_new_var_value (cmd->dep_var, y),
+        PIVOT_RC_COUNT);
+    }
+  pivot_category_create_leaves (d->root, total, PIVOT_RC_PERCENT);
+}
+
+static void
+output_classification_table (const struct lr_spec *cmd, const struct lr_result *res)
+{
+  struct pivot_table *table = pivot_table_create (N_("Classification Table"));
+  pivot_table_set_weight_var (table, cmd->wv);
+
+  create_classification_dimension (cmd, res, table, PIVOT_AXIS_COLUMN,
+                                   N_("Predicted"), N_("Percentage Correct"));
+  create_classification_dimension (cmd, res, table, PIVOT_AXIS_ROW,
+                                   N_("Observed"), N_("Overall Percentage"));
+
+  pivot_dimension_create (table, PIVOT_AXIS_ROW, N_("Step"), N_("Step 1"));
+
+  struct entry
+    {
+      int pred_idx;
+      int obs_idx;
+      double x;
+    }
+  entries[] = {
+    { 0, 0, res->tn },
+    { 0, 1, res->fn },
+    { 1, 0, res->fp },
+    { 1, 1, res->tp },
+    { 2, 0, 100 * res->tn / (res->tn + res->fp) },
+    { 2, 1, 100 * res->tp / (res->tp + res->fn) },
+    { 2, 2,
+      100 * (res->tp + res->tn) / (res->tp  + res->tn + res->fp + res->fn)},
+  };
+  for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
+    {
+      const struct entry *e = &entries[i];
+      pivot_table_put3 (table, e->pred_idx, e->obs_idx, 0,
+                        pivot_value_new_number (e->x));
+    }
 
+  pivot_table_submit (table);
 }