X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Froc.c;h=8b5cc3d0495e2abc4e16f1541ea1cb40a117a2bf;hb=26684c551800f8a6471c4a031a0fc99a07a98dc7;hp=7d13c2c2cb7cf32c13c9d5c5051cf1328441517a;hpb=f790dbda9d498eef9c9c0a49078adbeecf768d56;p=pspp

diff --git a/src/language/stats/roc.c b/src/language/stats/roc.c
index 7d13c2c2cb..8b5cc3d049 100644
--- a/src/language/stats/roc.c
+++ b/src/language/stats/roc.c
@@ -33,9 +33,8 @@
 #include "language/lexer/variable-parser.h"
 #include "libpspp/misc.h"
 #include "math/sort.h"
-#include "output/chart-item.h"
 #include "output/charts/roc-chart.h"
-#include "output/tab.h"
+#include "output/pivot-table.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
@@ -102,7 +101,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds)
 			      PV_APPEND | PV_NO_DUPLICATE | PV_NUMERIC))
     goto error;
 
-  if ( ! lex_force_match (lexer, T_BY))
+  if (! lex_force_match (lexer, T_BY))
     {
       goto error;
     }
@@ -113,7 +112,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds)
       goto error;
     }
 
-  if ( !lex_force_match (lexer, T_LPAREN))
+  if (!lex_force_match (lexer, T_LPAREN))
     {
       goto error;
     }
@@ -123,7 +122,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds)
   parse_value (lexer, &roc.state_value, roc.state_var);
 
 
-  if ( !lex_force_match (lexer, T_RPAREN))
+  if (!lex_force_match (lexer, T_RPAREN))
     {
       goto error;
     }
@@ -286,16 +285,16 @@ cmd_roc (struct lexer *lexer, struct dataset *ds)
 	}
     }
 
-  if ( ! run_roc (ds, &roc))
+  if (! run_roc (ds, &roc))
     goto error;
 
-  if ( roc.state_var)
+  if (roc.state_var)
     value_destroy (&roc.state_value, roc.state_var_width);
   free (roc.vars);
   return CMD_SUCCESS;
 
  error:
-  if ( roc.state_var)
+  if (roc.state_var)
     value_destroy (&roc.state_value, roc.state_var_width);
   free (roc.vars);
   return CMD_FAILURE;
@@ -333,13 +332,11 @@ dump_casereader (struct casereader *reader)
   struct ccase *c;
   struct casereader *r = casereader_clone (reader);
 
-  for ( ; (c = casereader_read (r) ); case_unref (c))
+  for (; (c = casereader_read (r)); case_unref (c))
     {
       int i;
-      for (i = 0 ; i < case_get_value_cnt (c); ++i)
-	{
-	  printf ("%g ", case_data_idx (c, i)->f);
-	}
+      for (i = 0 ; i < case_get_n_values (c); ++i)
+        printf ("%g ", case_num_idx (c, i));
       printf ("\n");
     }
 
@@ -359,13 +356,13 @@ match_positives (const struct ccase *c, void *aux)
 {
   struct cmd_roc *roc = aux;
   const struct variable *wv = dict_get_weight (roc->dict);
-  const double weight = wv ? case_data (c, wv)->f : 1.0;
+  const double weight = wv ? case_num (c, wv) : 1.0;
 
   const bool positive =
-  ( 0 == value_compare_3way (case_data (c, roc->state_var), &roc->state_value,
+  (0 == value_compare_3way (case_data (c, roc->state_var), &roc->state_value,
     var_get_width (roc->state_var)));
 
-  if ( positive )
+  if (positive)
     {
       roc->pos++;
       roc->pos_weighted += weight;
@@ -426,23 +423,21 @@ accumulate_counts (struct casereader *input,
   struct ccase *cpc;
   double prev_cp = SYSMIS;
 
-  for ( ; (cpc = casereader_read (input) ); case_unref (cpc))
+  for (; (cpc = casereader_read (input)); case_unref (cpc))
     {
       struct ccase *new_case;
-      const double cp = case_data_idx (cpc, ROC_CUTPOINT)->f;
+      const double cp = case_num_idx (cpc, ROC_CUTPOINT);
 
       assert (cp != SYSMIS);
 
       /* We don't want duplicates here */
-      if ( cp == prev_cp )
+      if (cp == prev_cp)
 	continue;
 
       new_case = case_clone (cpc);
 
-      if ( pos_cond (result, cp))
-	case_data_rw_idx (new_case, true_index)->f += weight;
-      else
-	case_data_rw_idx (new_case, false_index)->f += weight;
+      int index = pos_cond (result, cp) ? true_index : false_index;
+      *case_num_rw_idx (new_case, index) += weight;
 
       prev_cp = cp;
 
@@ -504,14 +499,14 @@ process_group (const struct variable *var, struct casereader *reader,
 
   *cc = 0;
 
-  for ( ; (c1 = casereader_read (r1) ); case_unref (c1))
+  for (; (c1 = casereader_read (r1)); case_unref (c1))
     {
       struct ccase *new_case = case_create (proto);
       struct ccase *c2;
       struct casereader *r2 = casereader_clone (rclone);
 
-      const double weight1 = case_data_idx (c1, weight_idx)->f;
-      const double d1 = case_data (c1, var)->f;
+      const double weight1 = case_num_idx (c1, weight_idx);
+      const double d1 = case_num (c1, var);
       double n_eq = 0.0;
       double n_pred = 0.0;
 
@@ -521,25 +516,25 @@ process_group (const struct variable *var, struct casereader *reader,
 
       *cc += weight1;
 
-      for ( ; (c2 = casereader_read (r2) ); case_unref (c2))
+      for (; (c2 = casereader_read (r2)); case_unref (c2))
 	{
-	  const double d2 = case_data (c2, var)->f;
-	  const double weight2 = case_data_idx (c2, weight_idx)->f;
+	  const double d2 = case_num (c2, var);
+	  const double weight2 = case_num_idx (c2, weight_idx);
 
-	  if ( d1 == d2 )
+	  if (d1 == d2)
 	    {
 	      n_eq += weight2;
 	      continue;
 	    }
-	  else  if ( pred (d2, d1))
+	  else  if (pred (d2, d1))
 	    {
 	      n_pred += weight2;
 	    }
 	}
 
-      case_data_rw_idx (new_case, VALUE)->f = d1;
-      case_data_rw_idx (new_case, N_EQ)->f = n_eq;
-      case_data_rw_idx (new_case, N_PRED)->f = n_pred;
+      *case_num_rw_idx (new_case, VALUE) = d1;
+      *case_num_rw_idx (new_case, N_EQ) = n_eq;
+      *case_num_rw_idx (new_case, N_PRED) = n_pred;
 
       casewriter_write (wtr, new_case);
 
@@ -625,11 +620,11 @@ append_cutpoint (struct casewriter *writer, double cutpoint)
 {
   struct ccase *cc = case_create (casewriter_get_proto (writer));
 
-  case_data_rw_idx (cc, ROC_CUTPOINT)->f = cutpoint;
-  case_data_rw_idx (cc, ROC_TP)->f = 0;
-  case_data_rw_idx (cc, ROC_FN)->f = 0;
-  case_data_rw_idx (cc, ROC_TN)->f = 0;
-  case_data_rw_idx (cc, ROC_FP)->f = 0;
+  *case_num_rw_idx (cc, ROC_CUTPOINT) = cutpoint;
+  *case_num_rw_idx (cc, ROC_TP) = 0;
+  *case_num_rw_idx (cc, ROC_FN) = 0;
+  *case_num_rw_idx (cc, ROC_TN) = 0;
+  *case_num_rw_idx (cc, ROC_FP) = 0;
 
   casewriter_write (writer, cc);
 }
@@ -669,7 +664,7 @@ prepare_cutpoints (struct cmd_roc *roc, struct roc_state *rs, struct casereader
       }
 
     caseproto_unref (proto);
-    subcase_destroy (&ordering);
+    subcase_uninit (&ordering);
   }
 
   for (; (c = casereader_read (r)) != NULL; case_unref (c))
@@ -679,15 +674,16 @@ prepare_cutpoints (struct cmd_roc *roc, struct roc_state *rs, struct casereader
 	  const union value *v = case_data (c, roc->vars[i]);
 	  const double result = v->f;
 
-	  if ( mv_is_value_missing (var_get_missing_values (roc->vars[i]), v, roc->exclude))
+	  if (mv_is_value_missing (var_get_missing_values (roc->vars[i]), v)
+              & roc->exclude)
 	    continue;
 
 	  minimize (&rs[i].min, result);
 	  maximize (&rs[i].max, result);
 
-	  if ( rs[i].prev_result != SYSMIS && rs[i].prev_result != result )
+	  if (rs[i].prev_result != SYSMIS && rs[i].prev_result != result)
 	    {
-	      const double mean = (result + rs[i].prev_result ) / 2.0;
+	      const double mean = (result + rs[i].prev_result) / 2.0;
 	      append_cutpoint (rs[i].cutpoint_wtr, mean);
 	    }
 
@@ -712,7 +708,7 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 {
   int i;
 
-  struct roc_state *rs = xcalloc (roc->n_vars, sizeof *rs);
+  struct roc_state *rs = XCALLOC (roc->n_vars,  struct roc_state);
 
   struct casereader *negatives = NULL;
   struct casereader *positives = NULL;
@@ -777,7 +773,7 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
       struct casereader *n_pos_reader =
 	process_positive_group (var, pos, dict, &rs[i]);
 
-      if ( negatives == NULL)
+      if (negatives == NULL)
 	{
 	  negatives = casewriter_make_reader (neg_wtr);
 	}
@@ -788,22 +784,22 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 
       /* Merge the n_pos and n_neg casereaders */
       w = sort_create_writer (&up_ordering, n_proto);
-      for ( ; (cpos = casereader_read (n_pos_reader) ); case_unref (cpos))
+      for (; (cpos = casereader_read (n_pos_reader)); case_unref (cpos))
 	{
 	  struct ccase *pos_case = case_create (n_proto);
 	  struct ccase *cneg;
-	  const double jpos = case_data_idx (cpos, VALUE)->f;
+	  const double jpos = case_num_idx (cpos, VALUE);
 
 	  while ((cneg = casereader_read (n_neg_reader)))
 	    {
 	      struct ccase *nc = case_create (n_proto);
 
-	      const double jneg = case_data_idx (cneg, VALUE)->f;
+	      const double jneg = case_num_idx (cneg, VALUE);
 
-	      case_data_rw_idx (nc, VALUE)->f = jneg;
-	      case_data_rw_idx (nc, N_POS_EQ)->f = 0;
+	      *case_num_rw_idx (nc, VALUE) = jneg;
+	      *case_num_rw_idx (nc, N_POS_EQ) = 0;
 
-	      case_data_rw_idx (nc, N_POS_GT)->f = SYSMIS;
+	      *case_num_rw_idx (nc, N_POS_GT) = SYSMIS;
 
 	      *case_data_rw_idx (nc, N_NEG_EQ) = *case_data_idx (cneg, N_EQ);
 	      *case_data_rw_idx (nc, N_NEG_LT) = *case_data_idx (cneg, N_PRED);
@@ -811,15 +807,15 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 	      casewriter_write (w, nc);
 
 	      case_unref (cneg);
-	      if ( jneg > jpos)
+	      if (jneg > jpos)
 		break;
 	    }
 
-	  case_data_rw_idx (pos_case, VALUE)->f = jpos;
+	  *case_num_rw_idx (pos_case, VALUE) = jpos;
 	  *case_data_rw_idx (pos_case, N_POS_EQ) = *case_data_idx (cpos, N_EQ);
 	  *case_data_rw_idx (pos_case, N_POS_GT) = *case_data_idx (cpos, N_PRED);
-	  case_data_rw_idx (pos_case, N_NEG_EQ)->f = 0;
-	  case_data_rw_idx (pos_case, N_NEG_LT)->f = SYSMIS;
+	  *case_num_rw_idx (pos_case, N_NEG_EQ) = 0;
+	  *case_num_rw_idx (pos_case, N_NEG_LT) = SYSMIS;
 
 	  casewriter_write (w, pos_case);
 	}
@@ -839,15 +835,15 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 	double prev_pos_gt = rs[i].n1;
 	w = sort_create_writer (&down_ordering, n_proto);
 
-	for ( ; (c = casereader_read (r) ); case_unref (c))
+	for (; (c = casereader_read (r)); case_unref (c))
 	  {
-	    double n_pos_gt = case_data_idx (c, N_POS_GT)->f;
+	    double n_pos_gt = case_num_idx (c, N_POS_GT);
 	    struct ccase *nc = case_clone (c);
 
-	    if ( n_pos_gt == SYSMIS)
+	    if (n_pos_gt == SYSMIS)
 	      {
 		n_pos_gt = prev_pos_gt;
-		case_data_rw_idx (nc, N_POS_GT)->f = n_pos_gt;
+		*case_num_rw_idx (nc, N_POS_GT) = n_pos_gt;
 	      }
 
 	    casewriter_write (w, nc);
@@ -864,15 +860,15 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 	double prev_neg_lt = rs[i].n2;
 	w = sort_create_writer (&up_ordering, n_proto);
 
-	for ( ; (c = casereader_read (r) ); case_unref (c))
+	for (; (c = casereader_read (r)); case_unref (c))
 	  {
-	    double n_neg_lt = case_data_idx (c, N_NEG_LT)->f;
+	    double n_neg_lt = case_num_idx (c, N_NEG_LT);
 	    struct ccase *nc = case_clone (c);
 
-	    if ( n_neg_lt == SYSMIS)
+	    if (n_neg_lt == SYSMIS)
 	      {
 		n_neg_lt = prev_neg_lt;
-		case_data_rw_idx (nc, N_NEG_LT)->f = n_neg_lt;
+		*case_num_rw_idx (nc, N_NEG_LT) = n_neg_lt;
 	      }
 
 	    casewriter_write (w, nc);
@@ -885,39 +881,39 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 
       {
 	struct ccase *prev_case = NULL;
-	for ( ; (c = casereader_read (r) ); case_unref (c))
+	for (; (c = casereader_read (r)); case_unref (c))
 	  {
 	    struct ccase *next_case = casereader_peek (r, 0);
 
-	    const double j = case_data_idx (c, VALUE)->f;
-	    double n_pos_eq = case_data_idx (c, N_POS_EQ)->f;
-	    double n_pos_gt = case_data_idx (c, N_POS_GT)->f;
-	    double n_neg_eq = case_data_idx (c, N_NEG_EQ)->f;
-	    double n_neg_lt = case_data_idx (c, N_NEG_LT)->f;
+	    const double j = case_num_idx (c, VALUE);
+	    double n_pos_eq = case_num_idx (c, N_POS_EQ);
+	    double n_pos_gt = case_num_idx (c, N_POS_GT);
+	    double n_neg_eq = case_num_idx (c, N_NEG_EQ);
+	    double n_neg_lt = case_num_idx (c, N_NEG_LT);
 
-	    if ( prev_case && j == case_data_idx (prev_case, VALUE)->f)
+	    if (prev_case && j == case_num_idx (prev_case, VALUE))
 	      {
-		if ( 0 ==  case_data_idx (c, N_POS_EQ)->f)
+		if (0 ==  case_num_idx (c, N_POS_EQ))
 		  {
-		    n_pos_eq = case_data_idx (prev_case, N_POS_EQ)->f;
-		    n_pos_gt = case_data_idx (prev_case, N_POS_GT)->f;
+		    n_pos_eq = case_num_idx (prev_case, N_POS_EQ);
+		    n_pos_gt = case_num_idx (prev_case, N_POS_GT);
 		  }
 
-		if ( 0 ==  case_data_idx (c, N_NEG_EQ)->f)
+		if (0 ==  case_num_idx (c, N_NEG_EQ))
 		  {
-		    n_neg_eq = case_data_idx (prev_case, N_NEG_EQ)->f;
-		    n_neg_lt = case_data_idx (prev_case, N_NEG_LT)->f;
+		    n_neg_eq = case_num_idx (prev_case, N_NEG_EQ);
+		    n_neg_lt = case_num_idx (prev_case, N_NEG_LT);
 		  }
 	      }
 
-	    if ( NULL == next_case || j != case_data_idx (next_case, VALUE)->f)
+	    if (NULL == next_case || j != case_num_idx (next_case, VALUE))
 	      {
 		rs[i].auc += n_pos_gt * n_neg_eq + (n_pos_eq * n_neg_eq) / 2.0;
 
 		rs[i].q1hat +=
-		  n_neg_eq * ( pow2 (n_pos_gt) + n_pos_gt * n_pos_eq + pow2 (n_pos_eq) / 3.0);
+		  n_neg_eq * (pow2 (n_pos_gt) + n_pos_gt * n_pos_eq + pow2 (n_pos_eq) / 3.0);
 		rs[i].q2hat +=
-		  n_pos_eq * ( pow2 (n_neg_lt) + n_neg_lt * n_neg_eq + pow2 (n_neg_eq) / 3.0);
+		  n_pos_eq * (pow2 (n_neg_lt) + n_neg_lt * n_neg_eq + pow2 (n_neg_eq) / 3.0);
 
 	      }
 
@@ -929,13 +925,13 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 	case_unref (prev_case);
 
 	rs[i].auc /=  rs[i].n1 * rs[i].n2;
-	if ( roc->invert )
+	if (roc->invert)
 	  rs[i].auc = 1 - rs[i].auc;
 
-	if ( roc->bi_neg_exp )
+	if (roc->bi_neg_exp)
 	  {
-	    rs[i].q1hat = rs[i].auc / ( 2 - rs[i].auc);
-	    rs[i].q2hat = 2 * pow2 (rs[i].auc) / ( 1 + rs[i].auc);
+	    rs[i].q1hat = rs[i].auc / (2 - rs[i].auc);
+	    rs[i].q2hat = 2 * pow2 (rs[i].auc) / (1 + rs[i].auc);
 	  }
 	else
 	  {
@@ -949,8 +945,8 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
   casereader_destroy (negatives);
 
   caseproto_unref (n_proto);
-  subcase_destroy (&up_ordering);
-  subcase_destroy (&down_ordering);
+  subcase_uninit (&up_ordering);
+  subcase_uninit (&down_ordering);
 
   output_roc (rs, roc);
 
@@ -963,229 +959,160 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 static void
 show_auc  (struct roc_state *rs, const struct cmd_roc *roc)
 {
-  int i;
-  const int n_fields = roc->print_se ? 5 : 1;
-  const int n_cols = roc->n_vars > 1 ? n_fields + 1: n_fields;
-  const int n_rows = 2 + roc->n_vars;
-  struct tab_table *tbl = tab_create (n_cols, n_rows);
-
-  if ( roc->n_vars > 1)
-    tab_title (tbl, _("Area Under the Curve"));
-  else
-    tab_title (tbl, _("Area Under the Curve (%s)"), var_to_string (roc->vars[0]));
-
-  tab_headers (tbl, n_cols - n_fields, 0, 1, 0);
+  struct pivot_table *table = pivot_table_create (N_("Area Under the Curve"));
 
-
-  tab_text (tbl, n_cols - n_fields, 1, TAT_TITLE, _("Area"));
-
-  tab_hline (tbl, TAL_2, 0, n_cols - 1, 2);
-
-  tab_box (tbl,
-	   TAL_2, TAL_2,
-	   -1, TAL_1,
-	   0, 0,
-	   n_cols - 1,
-	   n_rows - 1);
-
-  if ( roc->print_se )
+  struct pivot_dimension *statistics = pivot_dimension_create (
+    table, PIVOT_AXIS_COLUMN, N_("Statistics"),
+    N_("Area"), PIVOT_RC_OTHER);
+  if (roc->print_se)
     {
-      tab_text (tbl, n_cols - 4, 1, TAT_TITLE, _("Std. Error"));
-      tab_text (tbl, n_cols - 3, 1, TAT_TITLE, _("Asymptotic Sig."));
-
-      tab_text (tbl, n_cols - 2, 1, TAT_TITLE, _("Lower Bound"));
-      tab_text (tbl, n_cols - 1, 1, TAT_TITLE, _("Upper Bound"));
-
-      tab_joint_text_format (tbl, n_cols - 2, 0, 4, 0,
-			     TAT_TITLE | TAB_CENTER,
-			     _("Asymp. %g%% Confidence Interval"), roc->ci);
-      tab_vline (tbl, 0, n_cols - 1, 0, 0);
-      tab_hline (tbl, TAL_1, n_cols - 2, n_cols - 1, 1);
+      pivot_category_create_leaves (
+        statistics->root,
+        N_("Std. Error"), PIVOT_RC_OTHER,
+        N_("Asymptotic Sig."), PIVOT_RC_SIGNIFICANCE);
+      struct pivot_category *interval = pivot_category_create_group__ (
+        statistics->root,
+        pivot_value_new_text_format (N_("Asymp. %g%% Confidence Interval"),
+                                     roc->ci));
+      pivot_category_create_leaves (interval,
+                                    N_("Lower Bound"), PIVOT_RC_OTHER,
+                                    N_("Upper Bound"), PIVOT_RC_OTHER);
     }
 
-  if ( roc->n_vars > 1)
-    tab_text (tbl, 0, 1, TAT_TITLE, _("Variable under test"));
+  struct pivot_dimension *variables = pivot_dimension_create (
+    table, PIVOT_AXIS_ROW, N_("Variable under test"));
+  variables->root->show_label = true;
 
-  if ( roc->n_vars > 1)
-    tab_vline (tbl, TAL_2, 1, 0, n_rows - 1);
-
-
-  for ( i = 0 ; i < roc->n_vars ; ++i )
+  for (size_t i = 0 ; i < roc->n_vars ; ++i)
     {
-      tab_text (tbl, 0, 2 + i, TAT_TITLE, var_to_string (roc->vars[i]));
+      int var_idx = pivot_category_create_leaf (
+        variables->root, pivot_value_new_variable (roc->vars[i]));
 
-      tab_double (tbl, n_cols - n_fields, 2 + i, 0, rs[i].auc, NULL, RC_OTHER);
+      pivot_table_put2 (table, 0, var_idx, pivot_value_new_number (rs[i].auc));
 
-      if ( roc->print_se )
+      if (roc->print_se)
 	{
-	  double se ;
-	  const double sd_0_5 = sqrt ((rs[i].n1 + rs[i].n2 + 1) /
-				      (12 * rs[i].n1 * rs[i].n2));
-	  double ci ;
-	  double yy ;
-
-	  se = rs[i].auc * (1 - rs[i].auc) + (rs[i].n1 - 1) * (rs[i].q1hat - pow2 (rs[i].auc)) +
-	    (rs[i].n2 - 1) * (rs[i].q2hat - pow2 (rs[i].auc));
-
+	  double se = (rs[i].auc * (1 - rs[i].auc)
+                       + (rs[i].n1 - 1) * (rs[i].q1hat - pow2 (rs[i].auc))
+                       + (rs[i].n2 - 1) * (rs[i].q2hat - pow2 (rs[i].auc)));
 	  se /= rs[i].n1 * rs[i].n2;
-
 	  se = sqrt (se);
 
-	  tab_double (tbl, n_cols - 4, 2 + i, 0,
-		      se,
-		      NULL, RC_OTHER);
-
-	  ci = 1 - roc->ci / 100.0;
-	  yy = gsl_cdf_gaussian_Qinv (ci, se) ;
-
-	  tab_double (tbl, n_cols - 2, 2 + i, 0,
-		      rs[i].auc - yy,
-		      NULL, RC_OTHER);
-
-	  tab_double (tbl, n_cols - 1, 2 + i, 0,
-		      rs[i].auc + yy,
-		      NULL, RC_OTHER);
-
-	  tab_double (tbl, n_cols - 3, 2 + i, 0,
-		      2.0 * gsl_cdf_ugaussian_Q (fabs ((rs[i].auc - 0.5 ) / sd_0_5)),
-		      NULL, RC_PVALUE);
+	  double ci = 1 - roc->ci / 100.0;
+	  double yy = gsl_cdf_gaussian_Qinv (ci, se);
+
+	  double sd_0_5 = sqrt ((rs[i].n1 + rs[i].n2 + 1) /
+                                (12 * rs[i].n1 * rs[i].n2));
+          double sig = 2.0 * gsl_cdf_ugaussian_Q (fabs ((rs[i].auc - 0.5)
+                                                        / sd_0_5));
+          double entries[] = { se, sig, rs[i].auc - yy, rs[i].auc + yy };
+          for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
+            pivot_table_put2 (table, i + 1, var_idx,
+                              pivot_value_new_number (entries[i]));
 	}
     }
 
-  tab_submit (tbl);
+  pivot_table_submit (table);
 }
 
 
 static void
 show_summary (const struct cmd_roc *roc)
 {
-  const int n_cols = 3;
-  const int n_rows = 4;
-  struct tab_table *tbl = tab_create (n_cols, n_rows);
-
-  tab_title (tbl, _("Case Summary"));
-
-  tab_headers (tbl, 1, 0, 2, 0);
-
-  tab_box (tbl,
-	   TAL_2, TAL_2,
-	   -1, -1,
-	   0, 0,
-	   n_cols - 1,
-	   n_rows - 1);
-
-  tab_hline (tbl, TAL_2, 0, n_cols - 1, 2);
-  tab_vline (tbl, TAL_2, 1, 0, n_rows - 1);
+  struct pivot_table *table = pivot_table_create (N_("Case Summary"));
 
+  struct pivot_dimension *statistics = pivot_dimension_create (
+    table, PIVOT_AXIS_COLUMN, N_("Valid N (listwise)"),
+    N_("Unweighted"), PIVOT_RC_INTEGER,
+    N_("Weighted"), PIVOT_RC_OTHER);
+  statistics->root->show_label = true;
 
-  tab_hline (tbl, TAL_2, 1, n_cols - 1, 1);
-  tab_vline (tbl, TAL_1, 2, 1, n_rows - 1);
+  struct pivot_dimension *cases = pivot_dimension_create__ (
+    table, PIVOT_AXIS_ROW, pivot_value_new_variable (roc->state_var));
+  cases->root->show_label = true;
+  pivot_category_create_leaves (cases->root, N_("Positive"), N_("Negative"));
 
-
-  tab_text (tbl, 0, 1, TAT_TITLE | TAB_LEFT, var_to_string (roc->state_var));
-  tab_text (tbl, 1, 1, TAT_TITLE, _("Unweighted"));
-  tab_text (tbl, 2, 1, TAT_TITLE, _("Weighted"));
-
-  tab_joint_text (tbl, 1, 0, 2, 0,
-		  TAT_TITLE | TAB_CENTER,
-		  _("Valid N (listwise)"));
-
-
-  tab_text (tbl, 0, 2, TAB_LEFT, _("Positive"));
-  tab_text (tbl, 0, 3, TAB_LEFT, _("Negative"));
-
-
-  tab_double (tbl, 1, 2, 0, roc->pos, NULL, RC_INTEGER);
-  tab_double (tbl, 1, 3, 0, roc->neg, NULL, RC_INTEGER);
-
-  tab_double (tbl, 2, 2, 0, roc->pos_weighted, NULL, RC_OTHER);
-  tab_double (tbl, 2, 3, 0, roc->neg_weighted, NULL, RC_OTHER);
-
-  tab_submit (tbl);
+  struct entry
+    {
+      int stat_idx;
+      int case_idx;
+      double x;
+    }
+  entries[] = {
+    { 0, 0, roc->pos },
+    { 0, 1, roc->neg },
+    { 1, 0, roc->pos_weighted },
+    { 1, 1, roc->neg_weighted },
+  };
+  for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
+    {
+      const struct entry *e = &entries[i];
+      pivot_table_put2 (table, e->stat_idx, e->case_idx,
+                        pivot_value_new_number (e->x));
+    }
+  pivot_table_submit (table);
 }
 
-
 static void
 show_coords (struct roc_state *rs, const struct cmd_roc *roc)
 {
-  int x = 1;
-  int i;
-  const int n_cols = roc->n_vars > 1 ? 4 : 3;
-  int n_rows = 1;
-  struct tab_table *tbl ;
-
-  for (i = 0; i < roc->n_vars; ++i)
-    n_rows += casereader_count_cases (rs[i].cutpoint_rdr);
-
-  tbl = tab_create (n_cols, n_rows);
-
-  if ( roc->n_vars > 1)
-    tab_title (tbl, _("Coordinates of the Curve"));
-  else
-    tab_title (tbl, _("Coordinates of the Curve (%s)"), var_to_string (roc->vars[0]));
-
-
-  tab_headers (tbl, 1, 0, 1, 0);
+  struct pivot_table *table = pivot_table_create (
+    N_("Coordinates of the Curve"));
 
-  tab_hline (tbl, TAL_2, 0, n_cols - 1, 1);
+  pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
+                          N_("Positive if greater than or equal to"),
+                          N_("Sensitivity"), N_("1 - Specificity"));
 
-  if ( roc->n_vars > 1)
-    tab_text (tbl, 0, 0, TAT_TITLE, _("Test variable"));
+  struct pivot_dimension *coordinates = pivot_dimension_create (
+    table, PIVOT_AXIS_ROW, N_("Coordinates"));
+  coordinates->hide_all_labels = true;
 
-  tab_text (tbl, n_cols - 3, 0, TAT_TITLE, _("Positive if greater than or equal to"));
-  tab_text (tbl, n_cols - 2, 0, TAT_TITLE, _("Sensitivity"));
-  tab_text (tbl, n_cols - 1, 0, TAT_TITLE, _("1 - Specificity"));
+  struct pivot_dimension *variables = pivot_dimension_create (
+    table, PIVOT_AXIS_ROW, N_("Test variable"));
+  variables->root->show_label = true;
 
-  tab_box (tbl,
-	   TAL_2, TAL_2,
-	   -1, TAL_1,
-	   0, 0,
-	   n_cols - 1,
-	   n_rows - 1);
 
-  if ( roc->n_vars > 1)
-    tab_vline (tbl, TAL_2, 1, 0, n_rows - 1);
-
-  for (i = 0; i < roc->n_vars; ++i)
+  int n_coords = 0;
+  for (size_t i = 0; i < roc->n_vars; ++i)
     {
-      struct ccase *cc;
       struct casereader *r = casereader_clone (rs[i].cutpoint_rdr);
 
-      if ( roc->n_vars > 1)
-	tab_text (tbl, 0, x, TAT_TITLE, var_to_string (roc->vars[i]));
+      int var_idx = pivot_category_create_leaf (
+        variables->root, pivot_value_new_variable (roc->vars[i]));
 
-      if ( i > 0)
-	tab_hline (tbl, TAL_1, 0, n_cols - 1, x);
+      struct ccase *cc;
+      int coord_idx = 0;
+      for (; (cc = casereader_read (r)) != NULL; case_unref (cc))
+	{
+	  const double se = case_num_idx (cc, ROC_TP) /
+	    (case_num_idx (cc, ROC_TP) + case_num_idx (cc, ROC_FN));
 
+	  const double sp = case_num_idx (cc, ROC_TN) /
+	    (case_num_idx (cc, ROC_TN) + case_num_idx (cc, ROC_FP));
 
-      for (; (cc = casereader_read (r)) != NULL;
-	   case_unref (cc), x++)
-	{
-	  const double se = case_data_idx (cc, ROC_TP)->f /
-	    (
-	     case_data_idx (cc, ROC_TP)->f
-	     +
-	     case_data_idx (cc, ROC_FN)->f
-	     );
-
-	  const double sp = case_data_idx (cc, ROC_TN)->f /
-	    (
-	     case_data_idx (cc, ROC_TN)->f
-	     +
-	     case_data_idx (cc, ROC_FP)->f
-	     );
-
-	  tab_double (tbl, n_cols - 3, x, 0, case_data_idx (cc, ROC_CUTPOINT)->f,
-		      var_get_print_format (roc->vars[i]), RC_OTHER);
-
-	  tab_double (tbl, n_cols - 2, x, 0, se, NULL, RC_OTHER);
-	  tab_double (tbl, n_cols - 1, x, 0, 1 - sp, NULL, RC_OTHER);
+          if (coord_idx >= n_coords)
+            {
+              assert (coord_idx == n_coords);
+              pivot_category_create_leaf (
+                coordinates->root, pivot_value_new_integer (++n_coords));
+            }
+
+          pivot_table_put3 (
+            table, 0, coord_idx, var_idx,
+            pivot_value_new_var_value (roc->vars[i],
+                                       case_data_idx (cc, ROC_CUTPOINT)));
+
+          pivot_table_put3 (table, 1, coord_idx, var_idx,
+                            pivot_value_new_number (se));
+          pivot_table_put3 (table, 2, coord_idx, var_idx,
+                            pivot_value_new_number (1 - sp));
+          coord_idx++;
 	}
 
       casereader_destroy (r);
     }
 
-  tab_submit (tbl);
+  pivot_table_submit (table);
 }
 
 
@@ -1194,7 +1121,7 @@ output_roc (struct roc_state *rs, const struct cmd_roc *roc)
 {
   show_summary (roc);
 
-  if ( roc->curve )
+  if (roc->curve)
     {
       struct roc_chart *rc;
       size_t i;
@@ -1208,7 +1135,7 @@ output_roc (struct roc_state *rs, const struct cmd_roc *roc)
 
   show_auc (rs, roc);
 
-  if ( roc->print_coords )
+  if (roc->print_coords)
     show_coords (rs, roc);
 }