Change license from GPLv2+ to GPLv3+.
[pspp-builds.git] / src / language / stats / frequencies.q
index 535e69070f8e2761d09c7ef245f6475a68d5af57..9d90e06bd96cd63c346d5d036706a6ce18ba3799 100644 (file)
@@ -1,20 +1,18 @@
-/* PSPP - computes sample statistics.
+/* PSPP - a program for statistical analysis.
    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
 
-   This program is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-   02110-1301, USA. */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 /*
   TODO:
@@ -29,6 +27,8 @@
 #include <gsl/gsl_histogram.h>
 
 #include <data/case.h>
+#include <data/casegrouper.h>
+#include <data/casereader.h>
 #include <data/dictionary.h>
 #include <data/format.h>
 #include <data/procedure.h>
@@ -45,7 +45,6 @@
 #include <libpspp/hash.h>
 #include <libpspp/magic.h>
 #include <libpspp/message.h>
-#include <libpspp/message.h>
 #include <libpspp/misc.h>
 #include <libpspp/pool.h>
 #include <libpspp/str.h>
@@ -72,7 +71,7 @@
    FREQUENCIES (frq_):
      *+variables=custom;
      +format=cond:condense/onepage(*n:onepage_limit,"%s>=0")/!standard,
-            table:limit(n:limit,"%s>0")/notable/!table, 
+            table:limit(n:limit,"%s>0")/notable/!table,
             labels:!labels/nolabels,
             sort:!avalue/dvalue/afreq/dfreq,
             spaces:!single/double,
@@ -147,7 +146,7 @@ struct percentile
   double value;    /* the %ile's value */
   double x1;       /* The datum value <= the percentile */
   double x2;       /* The datum value >= the percentile */
-  int flag;        
+  int flag;
   int flag2;       /* Set to 1 if this percentile value has been found */
 };
 
@@ -157,7 +156,7 @@ static void add_percentile (double x) ;
 static struct percentile *percentiles;
 static int n_percentiles;
 
-static int implicit_50th ; 
+static int implicit_50th ;
 
 /* Groups of statistics. */
 #define BI          BIT_INDEX
@@ -197,7 +196,7 @@ static int normal;          /* FIXME */
 
 /* Variables for which to calculate statistics. */
 static size_t n_variables;
-static struct variable **v_variables;
+static const struct variable **v_variables;
 
 /* Arenas used to store semi-permanent storage. */
 static struct pool *int_pool;  /* Integer mode. */
@@ -269,17 +268,17 @@ get_var_freqs (const struct variable *v)
 
 static void determine_charts (void);
 
-static void calc_stats (struct variable *v, double d[frq_n_stats]);
+static void calc_stats (const struct variable *v, double d[frq_n_stats]);
 
-static void precalc (const struct ccase *, void *, const struct dataset *);
-static bool calc (const struct ccase *, void *, const struct dataset *);
-static bool postcalc (void *, const struct dataset *);
+static void precalc (struct casereader *, struct dataset *);
+static void calc (const struct ccase *, const struct dataset *);
+static void postcalc (void);
 
-static void postprocess_freq_tab (struct variable *);
-static void dump_full (struct variable *);
-static void dump_condensed (struct variable *);
-static void dump_statistics (struct variable *, int show_varname);
-static void cleanup_freq_tab (struct variable *);
+static void postprocess_freq_tab (const struct variable *);
+static void dump_full (const struct variable *);
+static void dump_condensed (const struct variable *);
+static void dump_statistics (const struct variable *, int show_varname);
+static void cleanup_freq_tab (const struct variable *);
 
 static hsh_compare_func compare_value_numeric_a, compare_value_alpha_a;
 static hsh_compare_func compare_value_numeric_d, compare_value_alpha_d;
@@ -290,7 +289,7 @@ static hsh_compare_func compare_freq_numeric_d, compare_freq_alpha_d;
 static void do_piechart(const struct variable *var,
                        const struct freq_tab *frq_tab);
 
-gsl_histogram * 
+gsl_histogram *
 freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var);
 
 
@@ -318,8 +317,10 @@ cmd_frequencies (struct lexer *lexer, struct dataset *ds)
 static int
 internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds)
 {
-  int i;
+  struct casegrouper *grouper;
+  struct casereader *input, *group;
   bool ok;
+  int i;
 
   n_percentiles = 0;
   percentiles = NULL;
@@ -361,9 +362,9 @@ internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds)
     cmd.sort = FRQ_AVALUE;
 
   /* Work out what percentiles need to be calculated */
-  if ( cmd.sbc_percentiles ) 
+  if ( cmd.sbc_percentiles )
     {
-      for ( i = 0 ; i < MAXLISTS ; ++i ) 
+      for ( i = 0 ; i < MAXLISTS ; ++i )
        {
          int pl;
          subc_list_double *ptl_list = &cmd.dl_percentiles[i];
@@ -371,19 +372,33 @@ internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds)
              add_percentile (subc_list_double_at(ptl_list, pl) / 100.0 );
        }
     }
-  if ( cmd.sbc_ntiles ) 
+  if ( cmd.sbc_ntiles )
     {
-      for ( i = 0 ; i < cmd.sbc_ntiles ; ++i ) 
+      for ( i = 0 ; i < cmd.sbc_ntiles ; ++i )
        {
          int j;
-         for (j = 0; j <= cmd.n_ntiles[i]; ++j ) 
+         for (j = 0; j <= cmd.n_ntiles[i]; ++j )
              add_percentile (j / (double) cmd.n_ntiles[i]);
        }
     }
-  
+
 
   /* Do it! */
-  ok = procedure_with_splits (ds, precalc, calc, postcalc, NULL);
+  input = casereader_create_filter_weight (proc_open (ds), dataset_dict (ds),
+                                           NULL, NULL);
+  grouper = casegrouper_create_splits (input, dataset_dict (ds));
+  for (; casegrouper_get_next_group (grouper, &group);
+       casereader_destroy (group))
+    {
+      struct ccase c;
+
+      precalc (group, ds);
+      for (; casereader_read (group, &c); case_destroy (&c))
+        calc (&c, ds);
+      postcalc ();
+    }
+  ok = casegrouper_destroy (grouper);
+  ok = proc_commit (ds) && ok;
 
   free_frequencies(&cmd);
 
@@ -394,7 +409,7 @@ internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds)
 static void
 determine_charts (void)
 {
-  int count = (!!cmd.sbc_histogram) + (!!cmd.sbc_barchart) + 
+  int count = (!!cmd.sbc_histogram) + (!!cmd.sbc_barchart) +
     (!!cmd.sbc_hbar) + (!!cmd.sbc_piechart);
 
   if (!count)
@@ -496,14 +511,11 @@ determine_charts (void)
 }
 
 /* Add data from case C to the frequency table. */
-static bool
-calc (const struct ccase *c, void *aux UNUSED, const struct dataset *ds)
+static void
+calc (const struct ccase *c, const struct dataset *ds)
 {
-  double weight;
+  double weight = dict_get_case_weight (dataset_dict (ds), c, NULL);
   size_t i;
-  bool bad_warn = true;
-
-  weight = dict_get_case_weight (dataset_dict (ds), c, &bad_warn);
 
   for (i = 0; i < n_variables; i++)
     {
@@ -530,7 +542,8 @@ calc (const struct ccase *c, void *aux UNUSED, const struct dataset *ds)
                  struct freq *fp = pool_alloc (gen_pool, sizeof *fp);
                   fp->count = weight;
                   fp->value = pool_clone (gen_pool,
-                                      val, MAX (MAX_SHORT_STRING, vf->width));
+                                          val,
+                                          MAX (MAX_SHORT_STRING, vf->width));
                   *fpp = fp;
                }
            }
@@ -552,24 +565,27 @@ calc (const struct ccase *c, void *aux UNUSED, const struct dataset *ds)
           NOT_REACHED ();
        }
     }
-  return true;
 }
 
 /* Prepares each variable that is the target of FREQUENCIES by setting
    up its hash table. */
 static void
-precalc (const struct ccase *first, void *aux UNUSED, const struct dataset *ds)
+precalc (struct casereader *input, struct dataset *ds)
 {
+  struct ccase c;
   size_t i;
 
-  output_split_file_values (ds, first);
+  if (!casereader_peek (input, 0, &c))
+    return;
+  output_split_file_values (ds, &c);
+  case_destroy (&c);
 
   pool_destroy (gen_pool);
   gen_pool = pool_create ();
-  
+
   for (i = 0; i < n_variables; i++)
     {
-      struct variable *v = v_variables[i];
+      const struct variable *v = v_variables[i];
       struct freq_tab *ft = &get_var_freqs (v)->tab;
 
       if (ft->mode == FRQM_GENERAL)
@@ -590,14 +606,14 @@ precalc (const struct ccase *first, void *aux UNUSED, const struct dataset *ds)
 
 /* Finishes up with the variables after frequencies have been
    calculated.  Displays statistics, percentiles, ... */
-static bool
-postcalc (void *aux UNUSED, const struct dataset *ds  UNUSED)
+static void
+postcalc (void)
 {
   size_t i;
 
   for (i = 0; i < n_variables; i++)
     {
-      struct variable *v = v_variables[i];
+      const struct variable *v = v_variables[i];
       struct var_freqs *vf = get_var_freqs (v);
       struct freq_tab *ft = &vf->tab;
       int n_categories;
@@ -635,7 +651,7 @@ postcalc (void *aux UNUSED, const struct dataset *ds  UNUSED)
 
 
 
-      if ( chart == GFT_HIST) 
+      if ( chart == GFT_HIST)
        {
          double d[frq_n_stats];
          struct normal_curve norm;
@@ -656,7 +672,7 @@ postcalc (void *aux UNUSED, const struct dataset *ds  UNUSED)
        }
 
 
-      if ( chart == GFT_PIE) 
+      if ( chart == GFT_PIE)
        {
          do_piechart(v_variables[i], ft);
        }
@@ -666,15 +682,13 @@ postcalc (void *aux UNUSED, const struct dataset *ds  UNUSED)
       cleanup_freq_tab (v);
 
     }
-
-  return true;
 }
 
 /* Returns the comparison function that should be used for
    sorting a frequency table by FRQ_SORT using VAR_TYPE
    variables. */
 static hsh_compare_func *
-get_freq_comparator (int frq_sort, enum var_type var_type) 
+get_freq_comparator (int frq_sort, enum var_type var_type)
 {
   bool is_numeric = var_type == VAR_NUMERIC;
   switch (frq_sort)
@@ -695,17 +709,17 @@ get_freq_comparator (int frq_sort, enum var_type var_type)
 /* Returns true iff the value in struct freq F is non-missing
    for variable V. */
 static bool
-not_missing (const void *f_, const void *v_) 
+not_missing (const void *f_, const void *v_)
 {
   const struct freq *f = f_;
   const struct variable *v = v_;
 
-  return !var_is_value_missing (v, f->value);
+  return !var_is_value_missing (v, f->value, MV_ANY);
 }
 
 /* Summarizes the frequency table data for variable V. */
 static void
-postprocess_freq_tab (struct variable *v)
+postprocess_freq_tab (const struct variable *v)
 {
   hsh_compare_func *compare;
   struct freq_tab *ft;
@@ -724,10 +738,10 @@ postprocess_freq_tab (struct variable *v)
 
   /* Copy dereferenced data into freqs. */
   freqs = xnmalloc (count, sizeof *freqs);
-  for (i = 0; i < count; i++) 
+  for (i = 0; i < count; i++)
     {
       struct freq *f = data[i];
-      freqs[i] = *f; 
+      freqs[i] = *f;
     }
 
   /* Put data into ft. */
@@ -742,15 +756,15 @@ postprocess_freq_tab (struct variable *v)
 
   /* Summary statistics. */
   ft->valid_cases = 0.0;
-  for(i = 0 ;  i < ft->n_valid ; ++i ) 
+  for(i = 0 ;  i < ft->n_valid ; ++i )
     {
       f = &ft->valid[i];
       ft->valid_cases += f->count;
 
     }
 
-  ft->total_cases = ft->valid_cases ; 
-  for(i = 0 ;  i < ft->n_missing ; ++i ) 
+  ft->total_cases = ft->valid_cases ;
+  for(i = 0 ;  i < ft->n_missing ; ++i )
     {
       f = &ft->missing[i];
       ft->total_cases += f->count;
@@ -760,7 +774,7 @@ postprocess_freq_tab (struct variable *v)
 
 /* Frees the frequency table for variable V. */
 static void
-cleanup_freq_tab (struct variable *v)
+cleanup_freq_tab (const struct variable *v)
 {
   struct freq_tab *ft = &get_var_freqs (v)->tab;
   assert (ft->mode == FRQM_GENERAL);
@@ -784,7 +798,7 @@ frq_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_freque
                          || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL))
     return 2;
 
-  if (!parse_variables (lexer, dataset_dict (ds), &v_variables, &n_variables,
+  if (!parse_variables_const (lexer, dataset_dict (ds), &v_variables, &n_variables,
                        PV_APPEND | PV_NO_SCRATCH))
     return 0;
 
@@ -815,7 +829,7 @@ frq_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_freque
 
   for (i = old_n_variables; i < n_variables; i++)
     {
-      struct variable *v = v_variables[i];
+      const struct variable *v = v_variables[i];
       struct var_freqs *vf;
 
       if (var_get_aux (v) != NULL)
@@ -841,13 +855,13 @@ frq_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_freque
          vf->tab.vector = pool_nalloc (int_pool,
                                         max - min + 1, sizeof *vf->tab.vector);
        }
-      else 
+      else
         vf->tab.vector = NULL;
       vf->n_groups = 0;
       vf->groups = NULL;
       vf->width = var_get_width (v);
       vf->print = *var_get_print_format (v);
-      if (vf->width > MAX_SHORT_STRING && get_algorithm () == COMPATIBLE) 
+      if (vf->width > MAX_SHORT_STRING && get_algorithm () == COMPATIBLE)
         {
           enum fmt_type type = var_get_print_format (v)->type;
           vf->width = MAX_SHORT_STRING;
@@ -875,9 +889,9 @@ frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequenc
 
        /* Variable list. */
        size_t n;
-       struct variable **v;
+       const struct variable **v;
 
-       if (!parse_variables (lexer, dataset_dict (ds), &v, &n,
+       if (!parse_variables_const (lexer, dataset_dict (ds), &v, &n,
                               PV_NO_DUPLICATE | PV_NUMERIC))
          return 0;
        if (lex_match (lexer, '('))
@@ -904,7 +918,7 @@ frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequenc
                return 0;
              }
          }
-       else 
+       else
           {
             nl = 0;
             dl = NULL;
@@ -914,10 +928,10 @@ frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequenc
           if (var_get_aux (v[i]) == NULL)
             msg (SE, _("Variables %s specified on GROUPED but not on "
                        "VARIABLES."), var_get_name (v[i]));
-          else 
+          else
             {
               struct var_freqs *vf = get_var_freqs (v[i]);
-                
+
               if (vf->groups != NULL)
                 msg (SE, _("Variables %s specified multiple times on GROUPED "
                            "subcommand."), var_get_name (v[i]));
@@ -951,7 +965,7 @@ add_percentile (double x)
   for (i = 0; i < n_percentiles; i++)
     {
       /* Do nothing if it's already in the list */
-      if ( fabs(x - percentiles[i].p) < DBL_EPSILON ) 
+      if ( fabs(x - percentiles[i].p) < DBL_EPSILON )
        return;
 
       if (x < percentiles[i].p)
@@ -1100,20 +1114,26 @@ compare_freq_alpha_d (const void *a_, const void *b_, const void *v_)
 static void
 full_dim (struct tab_table *t, struct outp_driver *d)
 {
-  int lab = cmd.labels == FRQ_LABELS;
-  int i;
+  int i = 0;
+  int columns = 5;
 
-  if (lab)
+  if (cmd.labels == FRQ_LABELS)
+    {
     t->w[0] = MIN (tab_natural_width (t, d, 0), d->prop_em_width * 15);
-  for (i = lab; i < lab + 5; i++)
+      i = 1;
+      columns ++;
+    }
+
+  for (;i < columns; i++)
     t->w[i] = MAX (tab_natural_width (t, d, i), d->prop_em_width * 8);
+
   for (i = 0; i < t->nr; i++)
     t->h[i] = d->font_height;
 }
 
 /* Displays a full frequency table for variable V. */
 static void
-dump_full (struct variable *v)
+dump_full (const struct variable *v)
 {
   int n_categories;
   struct var_freqs *vf;
@@ -1148,7 +1168,7 @@ dump_full (struct variable *v)
     {-1, -1, NULL},
   };
 
-  int lab = cmd.labels == FRQ_LABELS;
+  const bool lab = (cmd.labels == FRQ_LABELS);
 
   vf = get_var_freqs (v);
   ft = &vf->tab;
@@ -1159,8 +1179,9 @@ dump_full (struct variable *v)
 
   if (lab)
     tab_text (t, 0, 1, TAB_CENTER | TAT_TITLE, _("Value Label"));
+
   for (p = vec; p->s; p++)
-    tab_text (t, p->c - (p->r ? !lab : 0), p->r,
+    tab_text (t, lab ? p->c : p->c - 1, p->r,
                  TAB_CENTER | TAT_TITLE, gettext (p->s));
 
   r = 2;
@@ -1176,11 +1197,6 @@ dump_full (struct variable *v)
 
       if (lab)
        {
-#if 0
-<<<<<<< frequencies.q
-         const char *label = val_labs_find (v->val_labs, f->value[0]);
-=======
-#endif
          const char *label = var_lookup_value_label (v, &f->value[0]);
          if (label != NULL)
            tab_text (t, 0, r, TAB_LEFT, label);
@@ -1248,7 +1264,7 @@ condensed_dim (struct tab_table *t, struct outp_driver *d)
 
 /* Display condensed frequency table for variable V. */
 static void
-dump_condensed (struct variable *v)
+dump_condensed (const struct variable *v)
 {
   int n_categories;
   struct var_freqs *vf;
@@ -1308,12 +1324,12 @@ dump_condensed (struct variable *v)
 /* Calculates all the pertinent statistics for variable V, putting
    them in array D[].  FIXME: This could be made much more optimal. */
 static void
-calc_stats (struct variable *v, double d[frq_n_stats])
+calc_stats (const struct variable *v, double d[frq_n_stats])
 {
   struct freq_tab *ft = &get_var_freqs (v)->tab;
   double W = ft->valid_cases;
   struct moments *m;
-  struct freq *f=0; 
+  struct freq *f=0;
   int most_often;
   double X_mode;
 
@@ -1324,10 +1340,10 @@ calc_stats (struct variable *v, double d[frq_n_stats])
 
   /* Calculate percentiles. */
 
-  /* If the 50th percentile was not explicitly requested then we must 
+  /* If the 50th percentile was not explicitly requested then we must
      calculate it anyway --- it's the median */
   median_value = 0 ;
-  for (i = 0; i < n_percentiles; i++) 
+  for (i = 0; i < n_percentiles; i++)
     {
       if (percentiles[i].p == 0.5)
        {
@@ -1336,13 +1352,13 @@ calc_stats (struct variable *v, double d[frq_n_stats])
        }
     }
 
-  if ( 0 == median_value )  
+  if ( 0 == median_value )
     {
       add_percentile (0.5);
       implicit_50th = 1;
     }
 
-  for (i = 0; i < n_percentiles; i++) 
+  for (i = 0; i < n_percentiles; i++)
     {
       percentiles[i].flag = 0;
       percentiles[i].flag2 = 0;
@@ -1352,21 +1368,21 @@ calc_stats (struct variable *v, double d[frq_n_stats])
   for (idx = 0; idx < ft->n_valid; ++idx)
     {
       static double prev_value = SYSMIS;
-      f = &ft->valid[idx]; 
+      f = &ft->valid[idx];
       rank += f->count ;
-      for (i = 0; i < n_percentiles; i++) 
+      for (i = 0; i < n_percentiles; i++)
         {
          double tp;
-         if ( percentiles[i].flag2  ) continue ; 
+         if ( percentiles[i].flag2  ) continue ;
 
-         if ( get_algorithm() != COMPATIBLE ) 
-           tp = 
+         if ( get_algorithm() != COMPATIBLE )
+           tp =
              (ft->valid_cases - 1) *  percentiles[i].p;
          else
-           tp = 
+           tp =
              (ft->valid_cases + 1) *  percentiles[i].p - 1;
 
-         if ( percentiles[i].flag ) 
+         if ( percentiles[i].flag )
            {
              percentiles[i].x2 = f->value[0].f;
              percentiles[i].x1 = prev_value;
@@ -1374,9 +1390,9 @@ calc_stats (struct variable *v, double d[frq_n_stats])
              continue;
            }
 
-          if (rank >  tp ) 
+          if (rank >  tp )
          {
-           if ( f->count > 1 && rank - (f->count - 1) > tp ) 
+           if ( f->count > 1 && rank - (f->count - 1) > tp )
              {
                percentiles[i].x2 = percentiles[i].x1 = f->value[0].f;
                percentiles[i].flag2 = 1;
@@ -1392,10 +1408,10 @@ calc_stats (struct variable *v, double d[frq_n_stats])
       prev_value = f->value[0].f;
     }
 
-  for (i = 0; i < n_percentiles; i++) 
+  for (i = 0; i < n_percentiles; i++)
     {
       /* Catches the case when p == 100% */
-      if ( ! percentiles[i].flag2 ) 
+      if ( ! percentiles[i].flag2 )
        percentiles[i].x1 = percentiles[i].x2 = f->value[0].f;
 
       /*
@@ -1404,13 +1420,13 @@ calc_stats (struct variable *v, double d[frq_n_stats])
       */
     }
 
-  for (i = 0; i < n_percentiles; i++) 
+  for (i = 0; i < n_percentiles; i++)
     {
       struct freq_tab *ft = &get_var_freqs (v)->tab;
       double s;
 
       double dummy;
-      if ( get_algorithm() != COMPATIBLE ) 
+      if ( get_algorithm() != COMPATIBLE )
        {
          s = modf((ft->valid_cases - 1) * percentiles[i].p , &dummy);
        }
@@ -1419,11 +1435,11 @@ calc_stats (struct variable *v, double d[frq_n_stats])
          s = modf((ft->valid_cases + 1) * percentiles[i].p -1, &dummy);
        }
 
-      percentiles[i].value = percentiles[i].x1 + 
-       ( percentiles[i].x2 - percentiles[i].x1) * s ; 
+      percentiles[i].value = percentiles[i].x1 +
+       ( percentiles[i].x2 - percentiles[i].x1) * s ;
 
-      if ( percentiles[i].p == 0.50) 
-       median_value = &percentiles[i].value; 
+      if ( percentiles[i].p == 0.50)
+       median_value = &percentiles[i].value;
     }
 
 
@@ -1432,12 +1448,12 @@ calc_stats (struct variable *v, double d[frq_n_stats])
   X_mode = SYSMIS;
   for (f = ft->valid; f < ft->missing; f++)
     {
-      if (most_often < f->count) 
+      if (most_often < f->count)
         {
           most_often = f->count;
           X_mode = f->value[0].f;
         }
-      else if (most_often == f->count) 
+      else if (most_often == f->count)
         {
           /* A duplicate mode is undefined.
              FIXME: keep track of *all* the modes. */
@@ -1454,7 +1470,7 @@ calc_stats (struct variable *v, double d[frq_n_stats])
   moments_calculate (m, NULL, &d[frq_mean], &d[frq_variance],
                      &d[frq_skew], &d[frq_kurt]);
   moments_destroy (m);
-                     
+
   /* Formulas below are taken from _SPSS Statistical Algorithms_. */
   d[frq_min] = ft->valid[0].value[0].f;
   d[frq_max] = ft->valid[ft->n_valid - 1].value[0].f;
@@ -1470,7 +1486,7 @@ calc_stats (struct variable *v, double d[frq_n_stats])
 
 /* Displays a table of all the statistics requested for variable V. */
 static void
-dump_statistics (struct variable *v, int show_varname)
+dump_statistics (const struct variable *v, int show_varname)
 {
   struct freq_tab *ft;
   double stat_value[frq_n_stats];
@@ -1479,7 +1495,7 @@ dump_statistics (struct variable *v, int show_varname)
 
   int n_explicit_percentiles = n_percentiles;
 
-  if ( implicit_50th && n_percentiles > 0 ) 
+  if ( implicit_50th && n_percentiles > 0 )
     --n_percentiles;
 
   if (var_is_alpha (v))
@@ -1501,7 +1517,7 @@ dump_statistics (struct variable *v, int show_varname)
 
   tab_vline (t, TAL_1 , 2, 0, tab_nr(t) - 1);
   tab_vline (t, TAL_GAP , 1, 0, tab_nr(t) - 1 ) ;
-  
+
   r=2; /* N missing and N valid are always dumped */
 
   for (i = 0; i < frq_n_stats; i++)
@@ -1521,10 +1537,10 @@ dump_statistics (struct variable *v, int show_varname)
   tab_float(t, 2, 1, TAB_NONE, ft->total_cases - ft->valid_cases, 11, 0);
 
 
-  for (i = 0; i < n_explicit_percentiles; i++, r++) 
+  for (i = 0; i < n_explicit_percentiles; i++, r++)
     {
-      if ( i == 0 ) 
-       { 
+      if ( i == 0 )
+       {
          tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Percentiles"));
        }
 
@@ -1560,9 +1576,9 @@ freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var)
   struct freq *frq;
 
   /* Find out the extremes of the x value */
-  for ( frq = hsh_first(fh, &hi); frq != 0; frq = hsh_next(fh, &hi) ) 
+  for ( frq = hsh_first(fh, &hi); frq != 0; frq = hsh_next(fh, &hi) )
     {
-      if ( var_is_value_missing(var, frq->value))
+      if (var_is_value_missing(var, frq->value, MV_ANY))
        continue;
 
       if ( frq->value[0].f < x_min ) x_min = frq->value[0].f ;
@@ -1571,7 +1587,7 @@ freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var)
 
   hist = histogram_create(bins, x_min, x_max);
 
-  for( i = 0 ; i < ft->n_valid ; ++i ) 
+  for( i = 0 ; i < ft->n_valid ; ++i )
     {
       frq = &ft->valid[i];
       gsl_histogram_accumulate(hist, frq->value[0].f, frq->count);
@@ -1582,7 +1598,7 @@ freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var)
 
 
 static struct slice *
-freq_tab_to_slice_array(const struct freq_tab *frq_tab, 
+freq_tab_to_slice_array(const struct freq_tab *frq_tab,
                        const struct variable *var,
                        int *n_slices);
 
@@ -1592,7 +1608,7 @@ freq_tab_to_slice_array(const struct freq_tab *frq_tab,
    The caller is responsible for freeing slices
 */
 static struct slice *
-freq_tab_to_slice_array(const struct freq_tab *frq_tab, 
+freq_tab_to_slice_array(const struct freq_tab *frq_tab,
                        const struct variable *var,
                        int *n_slices)
 {
@@ -1600,10 +1616,10 @@ freq_tab_to_slice_array(const struct freq_tab *frq_tab,
   struct slice *slices;
 
   *n_slices = frq_tab->n_valid;
-  
+
   slices = xnmalloc (*n_slices, sizeof *slices);
 
-  for (i = 0 ; i < *n_slices ; ++i ) 
+  for (i = 0 ; i < *n_slices ; ++i )
     {
       const struct freq *frq = &frq_tab->valid[i];
 
@@ -1631,7 +1647,7 @@ do_piechart(const struct variable *var, const struct freq_tab *frq_tab)
 }
 
 
-/* 
+/*
    Local Variables:
    mode: c
    End: