X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fctables.c;h=4f23b3607d46aab491e832c407bc1a00ad8a40cd;hb=b4ded33443bdf2fa31ed014480e505f1137237f5;hp=7023c05adbedaf01e8ae62c8ad13041edebd3340;hpb=bb02967c642e72d0cb304c480beb7b07b4d6fe35;p=pspp

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index 7023c05adb..4f23b3607d 100644
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -28,6 +28,7 @@
 #include "language/lexer/variable-parser.h"
 #include "libpspp/array.h"
 #include "libpspp/assertion.h"
+#include "libpspp/hash-functions.h"
 #include "libpspp/hmap.h"
 #include "libpspp/message.h"
 #include "libpspp/string-array.h"
@@ -163,7 +164,7 @@ struct ctables
     struct variable *base_weight; /* WEIGHT. */
     int hide_threshold;           /* HIDESMALLCOUNTS. */
 
-    struct ctables_table *tables;
+    struct ctables_table **tables;
     size_t n_tables;
   };
 
@@ -221,9 +222,28 @@ enum ctables_label_position
     CTLP_LAYER,
   };
 
+struct var_array
+  {
+    struct variable **vars;
+    size_t n;
+
+    struct ctables_summary_spec *summaries;
+    size_t n_summaries;
+    struct variable *summary_var;
+  };
+
+struct var_array2
+  {
+    struct var_array *vas;
+    size_t n;
+  };
+
 struct ctables_table
   {
     struct ctables_axis *axes[PIVOT_N_AXES];
+    struct var_array2 vaas[PIVOT_N_AXES];
+    enum pivot_axis_type summary_axis;
+    struct hmap ft;
 
     enum pivot_axis_type slabels_position;
     bool slabels_visible;
@@ -244,8 +264,6 @@ struct ctables_table
     struct ctables_chisq *chisq;
     struct ctables_pairwise *pairwise;
 
-    struct ctables_freqtab **fts;
-    size_t n_fts;
   };
 
 struct ctables_var
@@ -602,6 +620,21 @@ ctables_summary_default_format (enum ctables_summary_function function,
     }
 }
 
+static char *
+ctables_summary_default_label (enum ctables_summary_function function,
+                               double percentile)
+{
+  static const char *default_labels[] = {
+#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = LABEL,
+    SUMMARIES
+#undef S
+  };
+
+  return (function == CTSF_PTILE
+          ? xasprintf (_("Percentile %.2f"), percentile)
+          : xstrdup (gettext (default_labels[function])));
+}
+
 static const char *
 ctables_summary_function_name (enum ctables_summary_function function)
 {
@@ -778,17 +811,8 @@ ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx)
           label = ss_xstrdup (lex_tokss (ctx->lexer));
           lex_get (ctx->lexer);
         }
-      else if (function == CTSF_PTILE)
-        label = xasprintf (_("Percentile %.2f"), percentile);
       else
-        {
-          static const char *default_labels[] = {
-#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = LABEL,
-            SUMMARIES
-#undef S
-          };
-          label = xstrdup (gettext (default_labels[function]));
-        }
+        label = ctables_summary_default_label (function, percentile);
 
       /* Parse format. */
       struct fmt_spec format;
@@ -971,7 +995,7 @@ ctables_pairwise_destroy (struct ctables_pairwise *pairwise)
 }
 
 static void
-ctables_table_uninit (struct ctables_table *t)
+ctables_table_destroy (struct ctables_table *t)
 {
   if (!t)
     return;
@@ -988,6 +1012,7 @@ ctables_table_uninit (struct ctables_table *t)
   free (t->title);
   ctables_chisq_destroy (t->chisq);
   ctables_pairwise_destroy (t->pairwise);
+  free (t);
 }
 
 static void
@@ -1001,7 +1026,7 @@ ctables_destroy (struct ctables *ct)
   free (ct->missing);
   free (ct->vlabels);
   for (size_t i = 0; i < ct->n_tables; i++)
-    ctables_table_uninit (&ct->tables[i]);
+    ctables_table_destroy (ct->tables[i]);
   free (ct->tables);
   free (ct);
 }
@@ -1241,13 +1266,6 @@ ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict,
   return true;
 }
 
-struct var_array
-  {
-    const struct ctables_axis *summary;
-    struct variable **vars;
-    size_t n;
-  };
-
 static void
 var_array_uninit (struct var_array *va)
 {
@@ -1255,12 +1273,6 @@ var_array_uninit (struct var_array *va)
     free (va->vars);
 }
 
-struct var_array2
-  {
-    struct var_array *vas;
-    size_t n;
-  };
-
 static void
 var_array2_uninit (struct var_array2 *vaa)
 {
@@ -1289,6 +1301,7 @@ nest_fts (struct var_array2 va0, struct var_array2 va1)
 
         size_t allocate = a->n + b->n;
         struct variable **vars = xnmalloc (allocate, sizeof *vars);
+        enum pivot_axis_type *axes = xnmalloc (allocate, sizeof *axes);
         size_t n = 0;
         for (size_t k = 0; k < a->n; k++)
           vars[n++] = a->vars[k];
@@ -1296,11 +1309,19 @@ nest_fts (struct var_array2 va0, struct var_array2 va1)
           vars[n++] = b->vars[k];
         assert (n == allocate);
 
-        assert (!(a->summary && b->summary));
+        const struct var_array *summary_src;
+        if (!a->summary_var)
+          summary_src = b;
+        else if (!b->summary_var)
+          summary_src = a;
+        else
+          NOT_REACHED ();
         vaa.vas[vaa.n++] = (struct var_array) {
-          .summary = a->summary ? a->summary : b->summary,
           .vars = vars,
-          .n = n
+          .n = n,
+          .summaries = summary_src->summaries,
+          .n_summaries = summary_src->n_summaries,
+          .summary_var = summary_src->summary_var,
         };
       }
   var_array2_uninit (&va0);
@@ -1323,7 +1344,7 @@ stack_fts (struct var_array2 va0, struct var_array2 va1)
 }
 
 static struct var_array2
-enumerate_fts (const struct ctables_axis *a)
+enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a)
 {
   if (!a)
     return (struct var_array2) { .n = 0 };
@@ -1337,20 +1358,27 @@ enumerate_fts (const struct ctables_axis *a)
         *va = (struct var_array) { .n = 0 };
       else
         {
-          struct variable **v = xmalloc (sizeof *v);
-          *v = a->var.var;
-          *va = (struct var_array) { .vars = v, .n = 1 };
+          struct variable **vars = xmalloc (sizeof *vars);
+          *vars = a->var.var;
+          enum pivot_axis_type *axes = xmalloc (sizeof *axes);
+          *axes = axis_type;
+          *va = (struct var_array) { .vars = vars, .n = 1 };
+        }
+      if (a->n_summaries || a->scale)
+        {
+          va->summaries = a->summaries;
+          va->n_summaries = a->n_summaries;
+          va->summary_var = a->var.var;
         }
-      va->summary = a->scale || a->n_summaries ? a : NULL;
       return (struct var_array2) { .vas = va, .n = 1 };
 
     case CTAO_STACK:
-      return stack_fts (enumerate_fts (a->subs[0]),
-                        enumerate_fts (a->subs[1]));
+      return stack_fts (enumerate_fts (axis_type, a->subs[0]),
+                        enumerate_fts (axis_type, a->subs[1]));
 
     case CTAO_NEST:
-      return nest_fts (enumerate_fts (a->subs[0]),
-                       enumerate_fts (a->subs[1]));
+      return nest_fts (enumerate_fts (axis_type, a->subs[0]),
+                       enumerate_fts (axis_type, a->subs[1]));
     }
 
   NOT_REACHED ();
@@ -1378,6 +1406,7 @@ union ctables_summary
     /* XXX percentiles, median, mode, multiple response */
   };
 
+#if 0
 static void
 ctables_summary_init (union ctables_summary *s,
                       const struct ctables_summary_spec *ss)
@@ -1655,7 +1684,6 @@ ctables_summary_add (union ctables_summary *s,
     }
 }
 
-
 static double
 ctables_summary_value (union ctables_summary *s,
                        const struct ctables_summary_spec *ss)
@@ -1783,24 +1811,25 @@ ctables_summary_value (union ctables_summary *s,
 
   NOT_REACHED ();
 }
+#endif
 
 struct ctables_freq
   {
     struct hmap_node node;      /* Element in hash table. */
-    union ctables_summary *summaries;
-    union value values[];      /* The value. */
-  };
 
-struct ctables_freqtab
-  {
-    struct var_array vars;
-    struct hmap data;           /* Contains "struct ctables_freq"s. */
-    const struct ctables_summary_spec *summaries;
-    size_t n_summaries;
-    const struct variable *summary_var;
-    struct ctables_freq **sorted;
+    struct
+      {
+        size_t vaa_idx;
+        union value *values;
+        int leaf;
+      }
+    axes[PIVOT_N_AXES];
+
+    //union ctables_summary *summaries;
+    double count;
   };
 
+#if 0
 static struct ctables_freq *
 ctables_freq_create (struct ctables_freqtab *ft)
 {
@@ -1820,96 +1849,154 @@ ctables_freq_add (struct ctables_freqtab *ft, struct ctables_freq *f,
     ctables_summary_add (&f->summaries[i], &ft->summaries[i],
                          var, value, weight);
 }
+#endif
+
+struct ctables_freq_sort_aux
+  {
+    const struct ctables_table *t;
+    enum pivot_axis_type a;
+  };
 
 static int
-ctables_freq_compare_3way (const void *a_, const void *b_, const void *vars_)
+ctables_freq_compare_3way (const void *a_, const void *b_, const void *aux_)
 {
-  const struct var_array *vars = vars_;
-  struct ctables_freq *const *a = a_;
-  struct ctables_freq *const *b = b_;
-
-  for (size_t i = 0; i < vars->n; i++)
+  const struct ctables_freq_sort_aux *aux = aux_;
+  struct ctables_freq *const *ap = a_;
+  struct ctables_freq *const *bp = b_;
+  const struct ctables_freq *a = *ap;
+  const struct ctables_freq *b = *bp;
+
+  size_t a_idx = a->axes[aux->a].vaa_idx;
+  size_t b_idx = b->axes[aux->a].vaa_idx;
+  if (a_idx != b_idx)
+    return a_idx < b_idx ? -1 : 1;
+
+  const struct var_array *va = &aux->t->vaas[aux->a].vas[a_idx];
+  for (size_t i = 0; i < va->n; i++)
     {
-      int cmp = value_compare_3way (&(*a)->values[i], &(*b)->values[i],
-                                    var_get_width (vars->vars[i]));
+      int cmp = value_compare_3way (&a->axes[aux->a].values[i],
+                                    &b->axes[aux->a].values[i],
+                                    var_get_width (va->vars[i]));
       if (cmp)
         return cmp;
     }
   return 0;
 }
 
+/* Algorithm:
+
+   For each row:
+       For each ctables_table:
+           For each combination of row vars:
+               For each combination of column vars:
+                   For each combination of layer vars:
+                       Add entry
+   Make a table of row values:
+       Sort entries by row values
+       Assign a 0-based index to each actual value
+       Construct a dimension
+   Make a table of column values
+   Make a table of layer values
+   For each entry:
+       Fill the table entry using the indexes from before.
+ */
+
+static void
+ctables_freqtab_insert (struct ctables_table *t,
+                        const struct ccase *c,
+                        size_t ir, size_t ic, size_t il,
+                        double weight)
+{
+  size_t ix[PIVOT_N_AXES] = {
+    [PIVOT_AXIS_ROW] = ir,
+    [PIVOT_AXIS_COLUMN] = ic,
+    [PIVOT_AXIS_LAYER] = il,
+  };
+
+  size_t hash = 0;
+  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+    {
+      const struct var_array *va = &t->vaas[a].vas[ix[a]];
+      hash = hash_int (ix[a], hash);
+      for (size_t i = 0; i < va->n; i++)
+        hash = value_hash (case_data (c, va->vars[i]),
+                           var_get_width (va->vars[i]), hash);
+    }
+
+  struct ctables_freq *f;
+  HMAP_FOR_EACH_WITH_HASH (f, struct ctables_freq, node, hash, &t->ft)
+    {
+      for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+        {
+          const struct var_array *va = &t->vaas[a].vas[ix[a]];
+          if (f->axes[a].vaa_idx != ix[a])
+            goto not_equal;
+          for (size_t i = 0; i < va->n; i++)
+            if (!value_equal (case_data (c, va->vars[i]),
+                              &f->axes[a].values[i],
+                              var_get_width (va->vars[i])))
+              goto not_equal;
+        }
+
+      f->count += weight;
+      return;
+
+    not_equal: ;
+    }
+
+  f = xmalloc (sizeof *f);
+  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+    {
+      const struct var_array *va = &t->vaas[a].vas[ix[a]];
+      f->axes[a].vaa_idx = ix[a];
+      f->axes[a].values = (va->n
+                           ? xnmalloc (va->n, sizeof *f->axes[a].values)
+                           : NULL);
+      for (size_t i = 0; i < va->n; i++)
+        value_clone (&f->axes[a].values[i], case_data (c, va->vars[i]),
+                     var_get_width (va->vars[i]));
+    }
+  f->count = weight;
+  hmap_insert (&t->ft, &f->node, hash);
+}
+
 static bool
 ctables_execute (struct dataset *ds, struct ctables *ct)
 {
   for (size_t i = 0; i < ct->n_tables; i++)
     {
-      size_t allocated_fts = 0;
+      struct ctables_table *t = ct->tables[i];
+      for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+        if (t->axes[a])
+          t->vaas[a] = enumerate_fts (a, t->axes[a]);
+        else
+          {
+            struct var_array *va = xmalloc (sizeof *va);
+            *va = (struct var_array) { .n = 0 };
+            t->vaas[a] = (struct var_array2) { .vas = va, .n = 1 };
+          }
 
-      struct ctables_table *t = &ct->tables[i];
-      struct var_array2 vaa = enumerate_fts (t->axes[PIVOT_AXIS_ROW]);
-      vaa = nest_fts (vaa, enumerate_fts (t->axes[PIVOT_AXIS_COLUMN]));
-      vaa = nest_fts (vaa, enumerate_fts (t->axes[PIVOT_AXIS_LAYER]));
-      for (size_t i = 0; i < vaa.n; i++)
+      for (size_t i = 0; i < t->vaas[t->summary_axis].n; i++)
         {
-          for (size_t j = 0; j < vaa.vas[i].n; j++)
+          struct var_array *va = &t->vaas[t->summary_axis].vas[i];
+          if (!va->n_summaries)
             {
-              if (j)
-                fputs (", ", stdout);
-              fputs (var_get_name (vaa.vas[i].vars[j]), stdout);
-            }
-          putchar ('\n');
-        }
+              va->summaries = xmalloc (sizeof *va->summaries);
+              va->n_summaries = 1;
 
-      for (size_t j = 0; j < vaa.n; j++)
-        {
-          const struct var_array *va = &vaa.vas[j];
-          const struct ctables_summary_spec *summaries;
-          size_t n_summaries;
-          const struct variable *summary_var;
-          if (!va->summary)
-            {
-              static const struct ctables_summary_spec count = {
-                .function = CTSF_COUNT,
-                .label = (char *) N_("Count"),
-                .format = { .type = FMT_F, .w = 40 },
+              enum ctables_summary_function function
+                = va->summary_var ? CTSF_MEAN : CTSF_COUNT;
+              struct ctables_var var = { .is_mrset = false, .var = va->summary_var };
+
+              *va->summaries = (struct ctables_summary_spec) {
+                .function = function,
+                .format = ctables_summary_default_format (function, &var),
+                .label = ctables_summary_default_label (function, 0),
               };
-              summaries = &count;
-              n_summaries = 1;
-              summary_var = va->vars[0];
-            }
-          else if (va->summary->n_summaries)
-            {
-              summaries = va->summary->summaries;
-              n_summaries = va->summary->n_summaries;
-              summary_var = va->summary->var.var;
+              if (!va->summary_var)
+                va->summary_var = va->vars[0];
             }
-          else
-            {
-              static const struct ctables_summary_spec mean = {
-                .function = CTSF_MEAN,
-                .label = (char *) N_("Mean"),
-                .format = { .type = FMT_F, .w = 40, .d = 2}, /* XXX */
-              };
-              summaries = &mean;
-              n_summaries = 1;
-              summary_var = va->summary->var.var;
-            };
-
-          struct ctables_freqtab *ft = xmalloc (sizeof *ft);
-          *ft = (struct ctables_freqtab) {
-            .vars = *va,
-            .summaries = summaries,
-            .n_summaries = n_summaries,
-            .summary_var = summary_var,
-            .data = HMAP_INITIALIZER (ft->data),
-          };
-
-          if (t->n_fts >= allocated_fts)
-            t->fts = x2nrealloc (t->fts, &allocated_fts, sizeof *t->fts);
-          t->fts[t->n_fts++] = ft;
         }
-
-      free (vaa.vas);
     }
 
   struct casereader *input = casereader_create_filter_weight (proc_open (ds),
@@ -1924,144 +2011,154 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
 
       for (size_t i = 0; i < ct->n_tables; i++)
         {
-          struct ctables_table *t = &ct->tables[i];
-
-          for (size_t j = 0; j < t->n_fts; j++)
-            {
-              struct ctables_freqtab *ft = t->fts[j];
-
-              for (size_t k = 0; k < ft->vars.n; k++)
-                {
-                  const struct variable *var = ft->vars.vars[k];
-                  switch (var_is_value_missing (var, case_data (c, var)))
-                    {
-                    case MV_SYSTEM:
-                      goto next_ft;
-
-                    case MV_USER:
-                      if (!t->categories[var_get_dict_index (var)]
-                          || !t->categories[var_get_dict_index (var)]->include_missing)
-                        goto next_ft;
-                      break;
-                    }
-                }
-              size_t hash = 0;
-              for (size_t k = 0; k < ft->vars.n; k++)
-                {
-                  const struct variable *var = ft->vars.vars[k];
-                  hash = value_hash (case_data (c, var), var_get_width (var), hash);
-                }
-
-              struct ctables_freq *f;
-              HMAP_FOR_EACH_WITH_HASH (f, struct ctables_freq, node, hash, &ft->data)
-                {
-                  for (size_t k = 0; k < ft->vars.n; k++)
-                    {
-                      const struct variable *var = ft->vars.vars[k];
-                      if (!value_equal (case_data (c, var), &f->values[k],
-                                        var_get_width (var)))
-                        goto next_hash_node;
-                    }
-                  goto found;
-
-                next_hash_node: ;
-                }
-
-              f = ctables_freq_create (ft);
-              for (size_t k = 0; k < ft->vars.n; k++)
-                {
-                  const struct variable *var = ft->vars.vars[k];
-                  value_clone (&f->values[k], case_data (c, var),
-                               var_get_width (var));
-                }
-              hmap_insert (&ft->data, &f->node, hash);
-
-            found:
-              ctables_freq_add (ft, f, ft->summary_var,
-                                case_data (c, ft->summary_var), weight);
+          struct ctables_table *t = ct->tables[i];
 
-            next_ft: ;
-            }
+          for (size_t ir = 0; ir < t->vaas[PIVOT_AXIS_ROW].n; ir++)
+            for (size_t ic = 0; ic < t->vaas[PIVOT_AXIS_COLUMN].n; ic++)
+              for (size_t il = 0; il < t->vaas[PIVOT_AXIS_LAYER].n; il++)
+                ctables_freqtab_insert (t, c, ir, ic, il, weight);
         }
     }
   casereader_destroy (input);
 
   for (size_t i = 0; i < ct->n_tables; i++)
     {
-      struct ctables_table *t = &ct->tables[i];
+      struct ctables_table *t = ct->tables[i];
 
       struct pivot_table *pt = pivot_table_create (N_("Custom Tables"));
-      struct pivot_dimension *d = pivot_dimension_create (
-        pt, PIVOT_AXIS_ROW, N_("Rows"));
-      for (size_t j = 0; j < t->n_fts; j++)
+      pivot_table_set_look (pt, ct->look);
+      struct pivot_dimension *d[PIVOT_N_AXES];
+      for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          struct ctables_freqtab *ft = t->fts[j];
-          ft->sorted = xnmalloc (ft->data.count, sizeof *ft->sorted);
+          static const char *names[] = {
+            [PIVOT_AXIS_ROW] = N_("Rows"),
+            [PIVOT_AXIS_COLUMN] = N_("Columns"),
+            [PIVOT_AXIS_LAYER] = N_("Layers"),
+          };
+          d[a] = (t->axes[a] || a == t->summary_axis
+                  ? pivot_dimension_create (pt, a, names[a])
+                  : NULL);
+          if (!d[a])
+            continue;
+
+          assert (t->axes[a]);
+
+          struct ctables_freq **sorted = xnmalloc (t->ft.count, sizeof *sorted);
 
           struct ctables_freq *f;
           size_t n = 0;
-          HMAP_FOR_EACH (f, struct ctables_freq, node, &ft->data)
-            ft->sorted[n++] = f;
-          assert (n == ft->data.count);
-          sort (ft->sorted, n, sizeof *ft->sorted,
-                ctables_freq_compare_3way, &ft->vars);
-
-          struct pivot_category **groups = xnmalloc (ft->vars.n,
-                                                     sizeof *groups);
-          for (size_t k = 0; k < n; k++)
+          HMAP_FOR_EACH (f, struct ctables_freq, node, &t->ft)
+            sorted[n++] = f;
+          assert (n == t->ft.count);
+
+          struct ctables_freq_sort_aux aux = { .t = t, .a = a };
+          sort (sorted, n, sizeof *sorted, ctables_freq_compare_3way, &aux);
+
+          size_t max_depth = 0;
+          for (size_t j = 0; j < t->vaas[a].n; j++)
+            if (t->vaas[a].vas[j].n > max_depth)
+              max_depth = t->vaas[a].vas[j].n;
+
+          struct pivot_category **groups = xnmalloc (max_depth, sizeof *groups);
+          struct pivot_category *top = NULL;
+          int prev_leaf = 0;
+          for (size_t j = 0; j < n; j++)
             {
-              struct ctables_freq *prev = k > 0 ? ft->sorted[k - 1] : NULL;
-              struct ctables_freq *f = ft->sorted[k];
+              struct ctables_freq *f = sorted[j];
+              const struct var_array *va = &t->vaas[a].vas[f->axes[a].vaa_idx];
 
               size_t n_common = 0;
-              if (prev)
-                for (; n_common + 1 < ft->vars.n; n_common++)
-                  if (!value_equal (&prev->values[n_common],
-                                    &f->values[n_common],
-                                    var_get_type (ft->vars.vars[n_common])))
-                    break;
-
-              for (size_t m = n_common; m < ft->vars.n; m++)
+              bool new_subtable = false;
+              if (j > 0)
                 {
-                  struct pivot_category *parent = m > 0 ? groups[m - 1] : d->root;
-                  const struct variable *var = ft->vars.vars[m];
-                  enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (var)];
+                  struct ctables_freq *prev = sorted[j - 1];
+                  if (prev->axes[a].vaa_idx == f->axes[a].vaa_idx)
+                    {
+                      for (; n_common < va->n; n_common++)
+                        if (!value_equal (&prev->axes[a].values[n_common],
+                                          &f->axes[a].values[n_common],
+                                          var_get_type (va->vars[n_common])))
+                          break;
+                    }
+                  else
+                    new_subtable = true;
+                }
+              else
+                new_subtable = true;
 
+              if (new_subtable)
+                {
+                  enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[0])];
+                  top = d[a]->root;
                   if (vlabel != CTVL_NONE)
-                    parent = pivot_category_create_group__ (
-                      parent, pivot_value_new_variable (ft->vars.vars[m]));
+                    top = pivot_category_create_group__ (
+                      top, pivot_value_new_variable (va->vars[0]));
+                }
+              if (n_common == va->n)
+                {
+                  f->axes[a].leaf = prev_leaf;
+                  continue;
+                }
 
-                  if (m + 1 < ft->vars.n)
-                    parent = pivot_category_create_group__ (
-                      parent,
-                      pivot_value_new_var_value (ft->vars.vars[m], &f->values[m]));
-                  groups[m] = parent;
+              for (size_t k = n_common; k < va->n; k++)
+                {
+                  struct pivot_category *parent = k > 0 ? groups[k - 1] : top;
+
+                  struct pivot_value *label = pivot_value_new_var_value (
+                    va->vars[k], &f->axes[a].values[k]);
 
-                  if (m == ft->vars.n - 1)
+                  if (k == va->n - 1)
                     {
-                      struct pivot_category *c = pivot_category_create_group__ (
-                        parent,
-                        pivot_value_new_var_value (ft->vars.vars[ft->vars.n - 1],
-                                                   &f->values[ft->vars.n - 1]));
-                      for (size_t p = 0; p < ft->n_summaries; p++)
+                      if (a == t->summary_axis)
                         {
-                          double value = ctables_summary_value (
-                            &f->summaries[p], &ft->summaries[p]);
-                          int leaf = pivot_category_create_leaf (
-                            c, pivot_value_new_text (ft->summaries[p].label));
-                          pivot_table_put1 (pt, leaf, pivot_value_new_number (value));
+                          parent = pivot_category_create_group__ (parent, label);
+                          for (size_t m = 0; m < va->n_summaries; m++)
+                            {
+                              int leaf = pivot_category_create_leaf (
+                                parent, pivot_value_new_text (va->summaries[m].label));
+                              if (m == 0)
+                                prev_leaf = leaf;
+                            }
                         }
+                      else
+                        prev_leaf = pivot_category_create_leaf (parent, label);
+                      break;
                     }
+
+                  parent = pivot_category_create_group__ (parent, label);
+
+                  enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[k + 1])];
+                  if (vlabel != CTVL_NONE)
+                    parent = pivot_category_create_group__ (
+                      parent, pivot_value_new_variable (va->vars[k + 1]));
+                  groups[k] = parent;
                 }
+
+              f->axes[a].leaf = prev_leaf;
             }
+          free (sorted);
           free (groups);
         }
+      struct ctables_freq *f;
+      HMAP_FOR_EACH (f, struct ctables_freq, node, &t->ft)
+        {
+          size_t dindexes[3];
+          size_t n_dindexes = 0;
+
+          for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+            if (d[a])
+              dindexes[n_dindexes++] = f->axes[a].leaf;
+          pivot_table_put (pt, dindexes, n_dindexes,
+                           pivot_value_new_number (f->count));
+        }
+
       pivot_table_submit (pt);
     }
 
+#if 0
   for (size_t i = 0; i < ct->n_tables; i++)
     {
-      struct ctables_table *t = &ct->tables[i];
+      struct ctables_table *t = ct->tables[i];
 
       for (size_t j = 0; j < t->n_fts; j++)
         {
@@ -2081,13 +2178,13 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
               free (f);
             }
           hmap_destroy (&ft->data);
-          free (ft->sorted);
           var_array_uninit (&ft->vars);
           free (ft);
         }
       free (t->fts);
     }
-
+#endif
+  
   return proc_commit (ds);
 }
 
@@ -2107,6 +2204,7 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
     .vlabels = vlabels,
     .hide_threshold = 5,
   };
+  ct->look->omit_empty = false;
 
   if (!lex_force_match (lexer, T_SLASH))
     goto error;
@@ -2302,8 +2400,9 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
         ct->tables = x2nrealloc (ct->tables, &allocated_tables,
                                  sizeof *ct->tables);
 
-      struct ctables_table *t = &ct->tables[ct->n_tables++];
+      struct ctables_table *t = xmalloc (sizeof *t);
       *t = (struct ctables_table) {
+        .ft = HMAP_INITIALIZER (t->ft),
         .slabels_position = PIVOT_AXIS_COLUMN,
         .slabels_visible = true,
         .row_labels = CTLP_NORMAL,
@@ -2313,6 +2412,7 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
         .n_categories = dict_get_n_vars (dataset_dict (ds)),
         .cilevel = 95,
       };
+      ct->tables[ct->n_tables++] = t;
 
       lex_match (lexer, T_EQUALS);
       if (!ctables_axis_parse (lexer, dataset_dict (ds), ct, t, PIVOT_AXIS_ROW))
@@ -2340,27 +2440,58 @@ cmd_ctables (struct lexer *lexer, struct dataset *ds)
 
       const struct ctables_axis *scales[PIVOT_N_AXES];
       size_t n_scales = 0;
-      for (size_t i = 0; i < 3; i++)
+      for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
         {
-          scales[i] = find_scale (t->axes[i]);
-          if (scales[i])
+          scales[a] = find_scale (t->axes[a]);
+          if (scales[a])
             n_scales++;
         }
       if (n_scales > 1)
         {
-          msg (SE, _("Scale variables may appear only on one dimension."));
+          msg (SE, _("Scale variables may appear only on one axis."));
           if (scales[PIVOT_AXIS_ROW])
             msg_at (SN, scales[PIVOT_AXIS_ROW]->loc,
-                    _("This scale variable appears in the rows dimension."));
+                    _("This scale variable appears on the rows axis."));
           if (scales[PIVOT_AXIS_COLUMN])
             msg_at (SN, scales[PIVOT_AXIS_COLUMN]->loc,
-                    _("This scale variable appears in the columns dimension."));
+                    _("This scale variable appears on the columns axis."));
           if (scales[PIVOT_AXIS_LAYER])
             msg_at (SN, scales[PIVOT_AXIS_LAYER]->loc,
-                    _("This scale variable appears in the layer dimension."));
+                    _("This scale variable appears on the layer axis."));
           goto error;
         }
 
+      const struct ctables_axis *summaries[PIVOT_N_AXES];
+      size_t n_summaries = 0;
+      for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+        {
+          summaries[a] = (scales[a]
+                          ? scales[a]
+                          : find_categorical_summary_spec (t->axes[a]));
+          if (summaries[a])
+            n_summaries++;
+        }
+      if (n_summaries > 1)
+        {
+          msg (SE, _("Summaries may appear only on one axis."));
+          if (summaries[PIVOT_AXIS_ROW])
+            msg_at (SN, summaries[PIVOT_AXIS_ROW]->loc,
+                    _("This variable on the rows axis has a summary."));
+          if (summaries[PIVOT_AXIS_COLUMN])
+            msg_at (SN, summaries[PIVOT_AXIS_COLUMN]->loc,
+                    _("This variable on the columns axis has a summary."));
+          if (summaries[PIVOT_AXIS_LAYER])
+            msg_at (SN, summaries[PIVOT_AXIS_LAYER]->loc,
+                    _("This variable on the layers axis has a summary."));
+          goto error;
+        }
+      for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+        if (n_summaries ? summaries[a] : t->axes[a])
+          {
+            t->summary_axis = a;
+            break;
+          }
+
       if (lex_token (lexer) == T_ENDCMD)
         break;
       if (!lex_force_match (lexer, T_SLASH))