parallel members to arrays

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index 510efcd5cd224df0ed4eb4f9a279f68fcf0fe88f..e5724296060970dba0c4ea2d6dd69c5aba4f086d 100644 (file)
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -171,6 +171,13 @@ struct ctables_domain
     double missing;
   };
 
+enum ctables_summary_variant
+  {
+    CSV_CELL,
+    CSV_TOTAL
+#define N_CSVS 2
+  };
+
 struct ctables_cell
   {
     /* In struct ctables's 'cells' hmap.  Indexed by all the values in all the
@@ -181,7 +188,7 @@ struct ctables_cell
     struct ctables_domain *domains[N_CTDTS];
 
     bool hide;
-    bool total;
+    enum ctables_summary_variant sv;
 
     struct
       {
@@ -297,8 +304,7 @@ struct ctables_nest
     size_t *domains[N_CTDTS];
     size_t n_domains[N_CTDTS];
 
-    struct ctables_summary_spec_set cell_sss;
-    struct ctables_summary_spec_set total_sss;
+    struct ctables_summary_spec_set specs[N_CSVS];
   };
 
 /* A stack of nestings, e.g. nest1 + nest2 + ... + nestN. */
@@ -500,8 +506,7 @@ struct ctables_axis
           {
             struct ctables_var var;
             bool scale;
-            struct ctables_summary_spec_set cell_sss;
-            struct ctables_summary_spec_set total_sss;
+            struct ctables_summary_spec_set specs[N_CSVS];
           };
 
         /* Nonterminals. */
@@ -643,8 +648,8 @@ ctables_axis_destroy (struct ctables_axis *axis)
   switch (axis->op)
     {
     case CTAO_VAR:
-      ctables_summary_spec_set_uninit (&axis->cell_sss);
-      ctables_summary_spec_set_uninit (&axis->total_sss);
+      for (size_t i = 0; i < N_CSVS; i++)
+        ctables_summary_spec_set_uninit (&axis->specs[i]);
       break;
 
     case CTAO_STACK:
@@ -735,7 +740,7 @@ static bool
 add_summary_spec (struct ctables_axis *axis,
                   enum ctables_summary_function function, double percentile,
                   const char *label, const struct fmt_spec *format,
-                  const struct msg_location *loc, bool totals)
+                  const struct msg_location *loc, enum ctables_summary_variant sv)
 {
   if (axis->op == CTAO_VAR)
     {
@@ -770,8 +775,7 @@ add_summary_spec (struct ctables_axis *axis,
           break;
         }
 
-      struct ctables_summary_spec_set *set = (totals ? &axis->total_sss
-                                              : &axis->cell_sss);
+      struct ctables_summary_spec_set *set = &axis->specs[sv];
       if (set->n >= set->allocated)
         set->specs = x2nrealloc (set->specs, &set->allocated,
                                  sizeof *set->specs);
@@ -790,7 +794,7 @@ add_summary_spec (struct ctables_axis *axis,
     {
       for (size_t i = 0; i < 2; i++)
         if (!add_summary_spec (axis->subs[i], function, percentile, label,
-                               format, loc, totals))
+                               format, loc, sv))
           return false;
       return true;
     }
@@ -982,7 +986,7 @@ find_categorical_summary_spec (const struct ctables_axis *axis)
   if (!axis)
     return NULL;
   else if (axis->op == CTAO_VAR)
-    return !axis->scale && axis->cell_sss.n ? axis : NULL;
+    return !axis->scale && axis->specs[CSV_CELL].n ? axis : NULL;
   else
     {
       for (size_t i = 0; i < 2; i++)
@@ -1481,9 +1485,9 @@ nest_fts (struct ctables_stack s0, struct ctables_stack s1)
         assert (n == allocate);
 
         const struct ctables_nest *summary_src;
-        if (!a->cell_sss.var)
+        if (!a->specs[CSV_CELL].var)
           summary_src = b;
-        else if (!b->cell_sss.var)
+        else if (!b->specs[CSV_CELL].var)
           summary_src = a;
         else
           NOT_REACHED ();
@@ -1493,8 +1497,10 @@ nest_fts (struct ctables_stack s0, struct ctables_stack s1)
                         : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx
                         : SIZE_MAX),
           .n = n,
-          .cell_sss = summary_src->cell_sss,
-          .total_sss = summary_src->total_sss,
+          .specs = {
+            [CSV_CELL] = summary_src->specs[CSV_CELL],
+            [CSV_TOTAL] = summary_src->specs[CSV_TOTAL],
+          },
         };
       }
   ctables_stack_uninit (&s0);
@@ -1536,13 +1542,12 @@ enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a)
         .n = 1,
         .scale_idx = a->scale ? 0 : SIZE_MAX,
       };
-      if (a->cell_sss.n || a->scale)
-        {
-          nest->cell_sss = a->cell_sss;
-          nest->total_sss = a->total_sss;
-          nest->cell_sss.var = a->var.var;
-          nest->total_sss.var = a->var.var;
-        }
+      if (a->specs[CSV_CELL].n || a->scale)
+        for (size_t i = 0; i < N_CSVS; i++)
+          {
+            nest->specs[i] = a->specs[i];
+            nest->specs[i].var = a->var.var;
+          }
       return (struct ctables_stack) { .nests = nest, .n = 1 };
 
     case CTAO_STACK:
@@ -2214,7 +2219,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
   const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
 
   size_t hash = 0;
-  bool total = false;
+  enum ctables_summary_variant sv = CSV_CELL;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
       const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
@@ -2229,7 +2234,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
               hash = value_hash (case_data (c, nest->vars[i]),
                                  var_get_width (nest->vars[i]), hash);
             else
-              total = true;
+              sv = CSV_TOTAL;
           }
     }
 
@@ -2260,7 +2265,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
 
   cell = xmalloc (sizeof *cell);
   cell->hide = false;
-  cell->total = total;
+  cell->sv = sv;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
       const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
@@ -2283,13 +2288,10 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
         }
     }
 
-  {
-    const struct ctables_summary_spec_set *sss
-      = (cell->total ? &ss->total_sss : &ss->cell_sss);
-    cell->summaries = xmalloc (sss->n * sizeof *cell->summaries);
-    for (size_t i = 0; i < sss->n; i++)
-      ctables_summary_init (&cell->summaries[i], &sss->specs[i]);
-  }
+  const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv];
+  cell->summaries = xmalloc (specs->n * sizeof *cell->summaries);
+  for (size_t i = 0; i < specs->n; i++)
+    ctables_summary_init (&cell->summaries[i], &specs->specs[i]);
   for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
     cell->domains[dt] = ctables_domain_insert (t, cell, dt);
   hmap_insert (&t->cells, &cell->node, hash);
@@ -2305,11 +2307,10 @@ ctables_cell_add__ (struct ctables_table *t, const struct ccase *c,
   struct ctables_cell *cell = ctables_cell_insert__ (t, c, ix, cats);
   const struct ctables_nest *ss = &t->stacks[t->summary_axis].nests[ix[t->summary_axis]];
 
-  const struct ctables_summary_spec_set *sss
-    = (cell->total ? &ss->total_sss : &ss->cell_sss);
-  for (size_t i = 0; i < sss->n; i++)
-    ctables_summary_add (&cell->summaries[i], &sss->specs[i], sss->var,
-                         case_data (c, sss->var), weight);
+  const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv];
+  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;
 }
@@ -2477,9 +2478,9 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
       for (size_t i = 0; i < t->stacks[t->summary_axis].n; i++)
         {
           struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[i];
-          if (!nest->cell_sss.n)
+          if (!nest->specs[CSV_CELL].n)
             {
-              struct ctables_summary_spec_set *sss = &nest->cell_sss;
+              struct ctables_summary_spec_set *sss = &nest->specs[CSV_CELL];
               sss->specs = xmalloc (sizeof *sss->specs);
               sss->n = 1;
 
@@ -2495,10 +2496,10 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
               if (!sss->var)
                 sss->var = nest->vars[0];
 
-              nest->total_sss = nest->cell_sss;
+              nest->specs[CSV_TOTAL] = nest->specs[CSV_CELL];
             }
-          else if (!nest->total_sss.n)
-            nest->total_sss = nest->cell_sss;
+          else if (!nest->specs[CSV_TOTAL].n)
+            nest->specs[CSV_TOTAL] = nest->specs[CSV_CELL];
         }
     }
 
@@ -2639,12 +2640,11 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
                         {
                           if (label)
                             parent = pivot_category_create_group__ (parent, label);
-                          const struct ctables_summary_spec_set *sss
-                            = cell->total ? &nest->total_sss : &nest->cell_sss;
-                          for (size_t m = 0; m < sss->n; m++)
+                          const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv];
+                          for (size_t m = 0; m < specs->n; m++)
                             {
                               int leaf = pivot_category_create_leaf (
-                                parent, pivot_value_new_text (sss->specs[m].label));
+                                parent, pivot_value_new_text (specs->specs[m].label));
                               if (m == 0)
                                 prev_leaf = leaf;
                             }
@@ -2682,8 +2682,8 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
             continue;
 
           const struct ctables_nest *nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].stack_idx];
-          const struct ctables_summary_spec_set *sss = cell->total ? &nest->total_sss : &nest->cell_sss;
-          for (size_t j = 0; j < sss->n; j++)
+          const struct ctables_summary_spec_set *specs = &nest->specs[cell->sv];
+          for (size_t j = 0; j < specs->n; j++)
             {
               size_t dindexes[3];
               size_t n_dindexes = 0;
@@ -2697,9 +2697,9 @@ ctables_execute (struct dataset *ds, struct ctables *ct)
                     dindexes[n_dindexes++] = leaf;
                   }
 
-              double d = ctables_summary_value (cell, &cell->summaries[j], &sss->specs[j]);
+              double d = ctables_summary_value (cell, &cell->summaries[j], &specs->specs[j]);
               struct pivot_value *value = pivot_value_new_number (d);
-              value->numeric.format = sss->specs[j].format;
+              value->numeric.format = specs->specs[j].format;
               pivot_table_put (pt, dindexes, n_dindexes, value);
             }
         }