More tests for totals and subtotals, with fixes.

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

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index 6b6b46a035239564d3a54c43d353a9bcf06c84f1..652534ec774e74f23d58b4901ae1b41500886c69 100644 (file)
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -186,6 +186,7 @@ struct ctables_cell
     struct hmap_node node;
 
     /* The domains that contain this cell. */
+    bool contributes_to_domains;
     struct ctables_domain *domains[N_CTDTS];
 
     bool hide;
@@ -2366,6 +2367,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
   cell = xmalloc (sizeof *cell);
   cell->hide = false;
   cell->sv = sv;
+  cell->contributes_to_domains = true;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
       const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
@@ -2375,14 +2377,19 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
                         : NULL);
       for (size_t i = 0; i < nest->n; i++)
         {
+          const struct ctables_category *cat = cats[a][i];
+
           if (i != nest->scale_idx)
             {
-              const struct ctables_category *subtotal = cats[a][i]->subtotal;
+              const struct ctables_category *subtotal = cat->subtotal;
               if (subtotal && subtotal->type == CCT_HSUBTOTAL)
                 cell->hide = true;
+
+              if (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL)
+                cell->contributes_to_domains = false;
             }
 
-          cell->axes[a].cvs[i].category = cats[a][i];
+          cell->axes[a].cvs[i].category = cat;
           value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]),
                        var_get_width (nest->vars[i]));
         }
@@ -2411,8 +2418,9 @@ ctables_cell_add__ (struct ctables_table *t, const struct ccase *c,
   for (size_t i = 0; i < specs->n; i++)
     ctables_summary_add (&cell->summaries[i], &specs->specs[i], specs->var,
                          case_data (c, specs->var), weight);
-  for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
-    cell->domains[dt]->valid += weight;
+  if (cell->contributes_to_domains)
+    for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+      cell->domains[dt]->valid += weight;
 }
 
 static void
@@ -2447,6 +2455,34 @@ recurse_totals (struct ctables_table *t, const struct ccase *c,
     }
 }
 
+static void
+recurse_subtotals (struct ctables_table *t, const struct ccase *c,
+                   size_t ix[PIVOT_N_AXES],
+                   const struct ctables_category *cats[PIVOT_N_AXES][10],
+                   double weight,
+                   enum pivot_axis_type start_axis, size_t start_nest)
+{
+  for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++)
+    {
+      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
+      for (size_t i = start_nest; i < nest->n; i++)
+        {
+          if (i == nest->scale_idx)
+            continue;
+
+          const struct ctables_category *save = cats[a][i];
+          if (save->subtotal)
+            {
+              cats[a][i] = save->subtotal;
+              ctables_cell_add__ (t, c, ix, cats, weight);
+              recurse_subtotals (t, c, ix, cats, weight, a, i + 1);
+              cats[a][i] = save;
+            }
+        }
+      start_nest = 0;
+    }
+}
+
 static void
 ctables_cell_insert (struct ctables_table *t,
                      const struct ccase *c,
@@ -2484,24 +2520,7 @@ ctables_cell_insert (struct ctables_table *t,
   ctables_cell_add__ (t, c, ix, cats, weight);
 
   recurse_totals (t, c, ix, cats, weight, 0, 0);
-
-  for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
-    {
-      const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
-      for (size_t i = 0; i < nest->n; i++)
-        {
-          if (i == nest->scale_idx)
-            continue;
-
-          const struct ctables_category *save = cats[a][i];
-          if (save->subtotal)
-            {
-              cats[a][i] = save->subtotal;
-              ctables_cell_add__ (t, c, ix, cats, weight);
-              cats[a][i] = save;
-            }
-        }
-    }
+  recurse_subtotals (t, c, ix, cats, weight, 0, 0);
 }
 
 struct merge_item
@@ -2567,12 +2586,16 @@ ctables_table_output (struct ctables *ct, struct ctables_table *t)
     pivot_table_set_caption (
       pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
 
-  bool summary_dimension = t->summary_axis != t->slabels_axis;
+  bool summary_dimension = (t->summary_axis != t->slabels_axis
+                            || (!t->slabels_visible
+                                && t->summary_specs.n > 1));
   if (summary_dimension)
     {
       struct pivot_dimension *d = pivot_dimension_create (
-        pt, t->slabels_axis, N_("Summaries"));
+        pt, t->slabels_axis, N_("Statistics"));
       const struct ctables_summary_spec_set *specs = &t->summary_specs;
+      if (!t->slabels_visible)
+        d->hide_all_labels = true;
       for (size_t i = 0; i < specs->n; i++)
         pivot_category_create_leaf (
           d->root, pivot_value_new_text (specs->specs[i].label));
@@ -2700,7 +2723,7 @@ ctables_table_output (struct ctables *ct, struct ctables_table *t)
                     }
                 }
 
-              if (a == t->slabels_axis && a == t->summary_axis)
+              if (!summary_dimension && a == t->slabels_axis)
                 {
                   levels[n_levels++] = (struct ctables_level) {
                     .type = CTL_SUMMARY,
@@ -2718,17 +2741,16 @@ ctables_table_output (struct ctables *ct, struct ctables_table *t)
                   if (level->type == CTL_CATEGORY)
                     {
                       size_t var_idx = level->var_idx;
-                      if (prev->axes[a].cvs[var_idx].category
-                          != cell->axes[a].cvs[var_idx].category)
-                        {
-                          break;
-                        }
-                      else if (!value_equal (&prev->axes[a].cvs[var_idx].value,
-                                           &cell->axes[a].cvs[var_idx].value,
-                                             var_get_type (nest->vars[var_idx])))
-                        {
-                          break;
-                        }
+                      const struct ctables_category *c = cell->axes[a].cvs[var_idx].category;
+                      if (prev->axes[a].cvs[var_idx].category != c)
+                        break;
+                      else if (c->type != CCT_SUBTOTAL
+                               && c->type != CCT_HSUBTOTAL
+                               && c->type != CCT_TOTAL
+                               && !value_equal (&prev->axes[a].cvs[var_idx].value,
+                                                &cell->axes[a].cvs[var_idx].value,
+                                                var_get_type (nest->vars[var_idx])))
+                        break;
                     }
                 }
             }