Change how checking for missing values works.

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

diff --git a/src/language/stats/means.c b/src/language/stats/means.c
index 40ee4a9035eb14e192e62dd9411f4c9178d737ca..4ebd60d83ab496239d21ef1a556e44ebeefd75c4 100644 (file)
--- a/src/language/stats/means.c
+++ b/src/language/stats/means.c
@@ -198,6 +198,8 @@ means_destroy_cells (const struct means *means, struct cell *cell,
   destroy_cell (means, table, cell);
 }
 
+#if 0
+
 static void
 dump_cell (const struct cell *cell, const struct mtable *mt, int level)
 {
@@ -258,6 +260,8 @@ dump_tree (const struct cell *cell, const struct mtable *table,
     }
 }
 
+#endif
+
 /* Generate a hash based on the values of the N variables in
    the array VARS which are taken from the case C.  */
 static unsigned int
@@ -296,7 +300,7 @@ generate_cell (const struct means *means,
               const struct workspace *ws)
 {
   int n_vars = count_one_bits (not_wild);
-  struct cell *cell = xzalloc ((sizeof *cell));
+  struct cell *cell = XZALLOC (struct cell);
   cell->values = xcalloc (n_vars, sizeof *cell->values);
   cell->vars = xcalloc (n_vars, sizeof *cell->vars);
   cell->not_wild = not_wild;
@@ -533,7 +537,7 @@ populate_table (const struct means *means, const struct mtable *mt,
                 const struct cell *cell,
                 struct pivot_table *pt)
 {
-  size_t *indexes = xcalloc (pt->n_dimensions, sizeof *indexes);
+  size_t *indexes = XCALLOC (pt->n_dimensions, size_t);
   for (int v = 0; v < mt->n_dep_vars; ++v)
     {
       for (int s = 0; s < means->n_statistics; ++s)
@@ -747,7 +751,6 @@ means_shipout_single (const struct mtable *mt, const struct means *means,
                      const struct workspace *ws)
 {
   struct pivot_table *pt = pivot_table_create (N_("Report"));
-  pt->omit_empty = true;
 
   struct pivot_dimension *dim_cells =
     pivot_dimension_create (pt, PIVOT_AXIS_COLUMN, N_("Statistics"));
@@ -789,7 +792,6 @@ means_shipout_multivar (const struct mtable *mt, const struct means *means,
     }
 
   struct pivot_table *pt = pivot_table_create (ds_cstr (&dss));
-  pt->omit_empty = true;
   ds_destroy (&dss);
 
   struct pivot_dimension *dim_cells =
@@ -866,7 +868,7 @@ control_var_missing (const struct means *means,
       const struct variable *var = layer->factor_vars[ws->control_idx[l]];
       const union value *vv = case_data (c, var);
 
-      miss = var_is_value_missing (var, vv, means->ctrl_exclude);
+      miss = (var_is_value_missing (var, vv) & means->ctrl_exclude) != 0;
       if (miss)
        break;
     }
@@ -928,7 +930,7 @@ service_cell_map (const struct means *means, const struct mtable *mt,
             {
               const struct variable *dep_var = mt->dep_vars[v];
              const union value *vv = case_data (c, dep_var);
-             if (var_is_value_missing (dep_var, vv, means->dep_exclude))
+             if (var_is_value_missing (dep_var, vv) & means->dep_exclude)
                continue;
 
               for (int stat = 0; stat < means->n_statistics; ++stat)
@@ -937,7 +939,7 @@ service_cell_map (const struct means *means, const struct mtable *mt,
                                                               NULL);
                   stat_update *su = cell_spec[means->statistics[stat]].su;
                   su (cell->stat[stat + v * means->n_statistics], weight,
-                     case_data (c, dep_var)->f);
+                     case_num (c, dep_var));
                 }
             }
         }
@@ -968,10 +970,8 @@ prepare_means (struct means *cmd)
         {
           struct workspace *ws = mt->ws + i;
          ws->root_cell = NULL;
-          ws->control_idx = xzalloc (mt->n_layers
-                                        * sizeof *ws->control_idx);
-          ws->instances = xzalloc (mt->n_layers
-                                        * sizeof *ws->instances);
+          ws->control_idx = xcalloc (mt->n_layers, sizeof *ws->control_idx);
+          ws->instances = xcalloc (mt->n_layers, sizeof *ws->instances);
           int cmb = i;
           for (int l = mt->n_layers - 1; l >= 0; --l)
             {
@@ -1047,7 +1047,7 @@ update_summaries (const struct means *means, struct mtable *mt,
          const struct variable *var = mt->dep_vars[dv];
          const union value *vv = case_data (c, var);
          /* First check if the dependent variable is missing.  */
-         if (var_is_value_missing (var, vv, means->dep_exclude))
+         if (var_is_value_missing (var, vv) & means->dep_exclude)
            summ->n_missing += weight;
          /* If the dep var is not missing, then check each
             control variable.  */
@@ -1058,7 +1058,7 @@ update_summaries (const struct means *means, struct mtable *mt,
                const struct variable *var
                  = layer->factor_vars[ws->control_idx[l]];
                const union value *vv = case_data (c, var);
-               if (var_is_value_missing (var, vv, means->ctrl_exclude))
+               if (var_is_value_missing (var, vv) & means->ctrl_exclude)
                  {
                    summ->n_missing += weight;
                    break;
@@ -1147,9 +1147,9 @@ cmd_means (struct lexer *lexer, struct dataset *ds)
        for (int t = 0; t < means.n_tables; ++t)
        {
          struct mtable *mt = means.table + t;
-         mt->summ = xzalloc (mt->n_combinations * mt->n_dep_vars
-                             * sizeof (*mt->summ));
-         mt->ws = xzalloc (mt->n_combinations * sizeof (*mt->ws));
+         mt->summ = xcalloc (mt->n_combinations * mt->n_dep_vars,
+                             sizeof (*mt->summ));
+         mt->ws = xcalloc (mt->n_combinations, sizeof (*mt->ws));
        }
        run_means (&means, group, ds);
        for (int t = 0; t < means.n_tables; ++t)