data filled in

[pspp] / src / language / stats / ctables.c

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index 22ca909d9897d933b246a75e4bcb920c53479a11..4f23b3607d46aab491e832c407bc1a00ad8a40cd 100644 (file)
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -1821,6 +1821,7 @@ struct ctables_freq
       {
         size_t vaa_idx;
         union value *values;
+        int leaf;
       }
     axes[PIVOT_N_AXES];
 
@@ -2034,12 +2035,14 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
             [PIVOT_AXIS_COLUMN] = N_("Columns"),
             [PIVOT_AXIS_LAYER] = N_("Layers"),
           };
-          d[a] = (t->axes[a]
+          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;
@@ -2049,7 +2052,7 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
           assert (n == t->ft.count);
 
           struct ctables_freq_sort_aux aux = { .t = t, .a = a };
-          n = sort_unique (sorted, n, sizeof *sorted, ctables_freq_compare_3way, &aux);
+          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++)
@@ -2058,6 +2061,7 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
 
           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 *f = sorted[j];
@@ -2081,45 +2085,73 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
                 }
               else
                 new_subtable = true;
+
               if (new_subtable)
-                top = pivot_category_create_group__ (
-                  d[a]->root, pivot_value_new_variable (va->vars[0]));
-              printf ("n_common=%zu\n", n_common);
+                {
+                  enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[0])];
+                  top = d[a]->root;
+                  if (vlabel != CTVL_NONE)
+                    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;
+                }
 
               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 (k == va->n - 1)
                     {
-                      pivot_category_create_leaf (
-                        parent,
-                        pivot_value_new_var_value (va->vars[va->n - 1],
-                                                   &f->axes[a].values[va->n - 1]));
+                      if (a == t->summary_axis)
+                        {
+                          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,
-                    pivot_value_new_var_value (va->vars[k], &f->axes[a].values[k]));
+                  parent = pivot_category_create_group__ (parent, label);
 
-                  parent = pivot_category_create_group__ (
-                    parent, pivot_value_new_variable (va->vars[k]));
+                  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;
-
-#if 0
-                      for (size_t p = 0; p < ft->n_summaries; p++)
-                        {
-                          if (a == t->slabels_position)
-                            pivot_category_create_leaf (
-                              c, pivot_value_new_text (ft->summaries[p].label));
-                          //pivot_table_put1 (pt, leaf, pivot_value_new_number (value));
-                        }
-#endif
-                    }
                 }
+
+              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);
     }