X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fdescriptives.c;h=beb5ec0b4182bd4fd48eef0f610f29b4d34129ce;hb=dbb294a59a93358b911ae3c3982301842c18e66b;hp=4b1ea6e2fa8bc0974fd8252b1bc233cc05597665;hpb=f5c108becd49d78f4898cab11352291f5689d24e;p=pspp

diff --git a/src/language/stats/descriptives.c b/src/language/stats/descriptives.c
index 4b1ea6e2fa..beb5ec0b41 100644
--- a/src/language/stats/descriptives.c
+++ b/src/language/stats/descriptives.c
@@ -1,46 +1,46 @@
-/* PSPP - computes sample statistics.
-   Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
+/* PSPP - a program for statistical analysis.
+   Copyright (C) 1997-2000, 2009-2014 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/>. */
 
 #include <config.h>
 
+#include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <stdlib.h>
 
-#include <data/casegrouper.h>
-#include <data/casereader.h>
-#include <data/dictionary.h>
-#include <data/procedure.h>
-#include <data/transformations.h>
-#include <data/variable.h>
-#include <language/command.h>
-#include <language/dictionary/split-file.h>
-#include <language/lexer/lexer.h>
-#include <language/lexer/variable-parser.h>
-#include <libpspp/alloc.h>
-#include <libpspp/array.h>
-#include <libpspp/compiler.h>
-#include <libpspp/magic.h>
-#include <libpspp/message.h>
-#include <libpspp/assertion.h>
-#include <math/moments.h>
-#include <output/manager.h>
-#include <output/table.h>
+#include "data/casegrouper.h"
+#include "data/casereader.h"
+#include "data/casewriter.h"
+#include "data/dataset.h"
+#include "data/dictionary.h"
+#include "data/transformations.h"
+#include "data/variable.h"
+#include "language/command.h"
+#include "language/dictionary/split-file.h"
+#include "language/lexer/lexer.h"
+#include "language/lexer/variable-parser.h"
+#include "libpspp/array.h"
+#include "libpspp/assertion.h"
+#include "libpspp/compiler.h"
+#include "libpspp/i18n.h"
+#include "libpspp/message.h"
+#include "math/moments.h"
+#include "output/tab.h"
+
+#include "gl/xalloc.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
@@ -76,6 +76,10 @@ struct dsc_trns
     size_t var_cnt;             /* Number of variables. */
     enum dsc_missing_type missing_type; /* Treatment of missing values. */
     enum mv_class exclude;      /* Classes of missing values to exclude. */
+    struct variable *filter;    /* Dictionary FILTER BY variable. */
+    struct casereader *z_reader; /* Reader for count, mean, stddev. */
+    casenumber count;            /* Number left in this SPLIT FILE group.*/
+    bool ok;
   };
 
 /* Statistics.  Used as bit indexes, so must be 32 or fewer. */
@@ -102,13 +106,13 @@ struct dsc_statistic_info
 static const struct dsc_statistic_info dsc_info[DSC_N_STATS] =
   {
     {"MEAN", N_("Mean"), MOMENT_MEAN},
-    {"SEMEAN", N_("S E Mean"), MOMENT_VARIANCE},
+    {"SEMEAN", N_("S.E. Mean"), MOMENT_VARIANCE},
     {"STDDEV", N_("Std Dev"), MOMENT_VARIANCE},
     {"VARIANCE", N_("Variance"), MOMENT_VARIANCE},
     {"KURTOSIS", N_("Kurtosis"), MOMENT_KURTOSIS},
-    {"SEKURTOSIS", N_("S E Kurt"), MOMENT_NONE},
+    {"SEKURTOSIS", N_("S.E. Kurt"), MOMENT_NONE},
     {"SKEWNESS", N_("Skewness"), MOMENT_SKEWNESS},
-    {"SESKEWNESS", N_("S E Skew"), MOMENT_NONE},
+    {"SESKEWNESS", N_("S.E. Skew"), MOMENT_NONE},
     {"RANGE", N_("Range"), MOMENT_NONE},
     {"MINIMUM", N_("Minimum"), MOMENT_NONE},
     {"MAXIMUM", N_("Maximum"), MOMENT_NONE},
@@ -125,7 +129,7 @@ static const struct dsc_statistic_info dsc_info[DSC_N_STATS] =
 struct dsc_var
   {
     const struct variable *v;         /* Variable to calculate on. */
-    char z_name[LONG_NAME_LEN + 1]; /* Name for z-score variable. */
+    char *z_name;                     /* Name for z-score variable. */
     double valid, missing;	/* Valid, missing counts. */
     struct moments *moments;    /* Moments. */
     double min, max;            /* Maximum and mimimum values. */
@@ -162,6 +166,9 @@ struct dsc_proc
     unsigned long show_stats;   /* Statistics to display. */
     unsigned long calc_stats;   /* Statistics to calculate. */
     enum moment max_moment;     /* Highest moment needed for stats. */
+
+    /* Z scores. */
+    struct casewriter *z_writer; /* Mean and stddev per SPLIT FILE group. */
   };
 
 /* Parsing. */
@@ -171,9 +178,9 @@ static void free_dsc_proc (struct dsc_proc *);
 /* Z-score functions. */
 static bool try_name (const struct dictionary *dict,
 		      struct dsc_proc *dsc, const char *name);
-static bool generate_z_varname (const struct dictionary *dict,
-				struct dsc_proc *dsc, char *z_name,
-				const char *name, int *z_cnt);
+static char *generate_z_varname (const struct dictionary *dict,
+                                 struct dsc_proc *dsc,
+                                 const char *name, int *z_cnt);
 static void dump_z_table (struct dsc_proc *);
 static void setup_z_trns (struct dsc_proc *, struct dataset *);
 
@@ -215,14 +222,15 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
   dsc->sort_by_stat = DSC_NONE;
   dsc->sort_ascending = 1;
   dsc->show_stats = dsc->calc_stats = DEFAULT_STATS;
+  dsc->z_writer = NULL;
 
   /* Parse DESCRIPTIVES. */
-  while (lex_token (lexer) != '.')
+  while (lex_token (lexer) != T_ENDCMD)
     {
       if (lex_match_id (lexer, "MISSING"))
         {
-          lex_match (lexer, '=');
-          while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
+          lex_match (lexer, T_EQUALS);
+          while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
             {
               if (lex_match_id (lexer, "VARIABLE"))
                 dsc->missing_type = DSC_VARIABLE;
@@ -235,15 +243,15 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
                   lex_error (lexer, NULL);
                   goto error;
                 }
-              lex_match (lexer, ',');
+              lex_match (lexer, T_COMMA);
             }
         }
       else if (lex_match_id (lexer, "SAVE"))
         save_z_scores = 1;
       else if (lex_match_id (lexer, "FORMAT"))
         {
-          lex_match (lexer, '=');
-          while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
+          lex_match (lexer, T_EQUALS);
+          while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
             {
               if (lex_match_id (lexer, "LABELS"))
                 dsc->show_var_labels = 1;
@@ -262,14 +270,14 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
                   lex_error (lexer, NULL);
                   goto error;
                 }
-              lex_match (lexer, ',');
+              lex_match (lexer, T_COMMA);
             }
         }
       else if (lex_match_id (lexer, "STATISTICS"))
         {
-          lex_match (lexer, '=');
+          lex_match (lexer, T_EQUALS);
           dsc->show_stats = 0;
-          while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
+          while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
             {
               if (lex_match (lexer, T_ALL))
                 dsc->show_stats |= (1ul << DSC_N_STATS) - 1;
@@ -277,14 +285,14 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
                 dsc->show_stats |= DEFAULT_STATS;
               else
 		dsc->show_stats |= 1ul << (match_statistic (lexer));
-              lex_match (lexer, ',');
+              lex_match (lexer, T_COMMA);
             }
           if (dsc->show_stats == 0)
             dsc->show_stats = DEFAULT_STATS;
         }
       else if (lex_match_id (lexer, "SORT"))
         {
-          lex_match (lexer, '=');
+          lex_match (lexer, T_EQUALS);
           if (lex_match_id (lexer, "NAME"))
             dsc->sort_by_stat = DSC_NAME;
           else
@@ -293,7 +301,7 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
 	      if (dsc->sort_by_stat == DSC_NONE )
 		dsc->sort_by_stat = DSC_MEAN;
 	    }
-          if (lex_match (lexer, '('))
+          if (lex_match (lexer, T_LPAREN))
             {
               if (lex_match_id (lexer, "A"))
                 dsc->sort_ascending = 1;
@@ -301,18 +309,18 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
                 dsc->sort_ascending = 0;
               else
                 lex_error (lexer, NULL);
-              lex_force_match (lexer, ')');
+              lex_force_match (lexer, T_RPAREN);
             }
         }
       else if (var_cnt == 0)
         {
-          if (lex_look_ahead (lexer) == '=')
+          if (lex_next_token (lexer, 1) == T_EQUALS)
             {
               lex_match_id (lexer, "VARIABLES");
-              lex_match (lexer, '=');
+              lex_match (lexer, T_EQUALS);
             }
 
-          while (lex_token (lexer) != '.' && lex_token (lexer) != '/')
+          while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
             {
               int i;
 
@@ -325,28 +333,29 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
                 {
                   struct dsc_var *dv = &dsc->vars[i];
                   dv->v = vars[i];
-                  dv->z_name[0] = '\0';
+                  dv->z_name = NULL;
                   dv->moments = NULL;
                 }
               dsc->var_cnt = var_cnt;
 
-              if (lex_match (lexer, '('))
+              if (lex_match (lexer, T_LPAREN))
                 {
                   if (lex_token (lexer) != T_ID)
                     {
                       lex_error (lexer, NULL);
                       goto error;
                     }
-                  if (try_name (dict, dsc, lex_tokid (lexer)))
+                  if (try_name (dict, dsc, lex_tokcstr (lexer)))
                     {
-                      strcpy (dsc->vars[dsc->var_cnt - 1].z_name, lex_tokid (lexer));
+                      struct dsc_var *dsc_var = &dsc->vars[dsc->var_cnt - 1];
+                      dsc_var->z_name = xstrdup (lex_tokcstr (lexer));
                       z_cnt++;
                     }
                   else
                     msg (SE, _("Z-score variable name %s would be"
-                               " a duplicate variable name."), lex_tokid (lexer));
+                               " a duplicate variable name."), lex_tokcstr (lexer));
                   lex_get (lexer);
-                  if (!lex_force_match (lexer, ')'))
+                  if (!lex_force_match (lexer, T_RPAREN))
 		    goto error;
                 }
             }
@@ -357,7 +366,7 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
           goto error;
         }
 
-      lex_match (lexer, '/');
+      lex_match (lexer, T_SLASH);
     }
   if (var_cnt == 0)
     {
@@ -368,20 +377,41 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
   /* Construct z-score varnames, show translation table. */
   if (z_cnt || save_z_scores)
     {
+      struct caseproto *proto;
+
       if (save_z_scores)
         {
           int gen_cnt = 0;
 
           for (i = 0; i < dsc->var_cnt; i++)
-            if (dsc->vars[i].z_name[0] == 0)
-              {
-                if (!generate_z_varname (dict, dsc, dsc->vars[i].z_name,
-                                         var_get_name (dsc->vars[i].v),
-                                         &gen_cnt))
-                  goto error;
-                z_cnt++;
-              }
+            {
+              struct dsc_var *dsc_var = &dsc->vars[i];
+              if (dsc_var->z_name == NULL)
+                {
+                  const char *name = var_get_name (dsc_var->v);
+                  dsc_var->z_name = generate_z_varname (dict, dsc, name,
+                                                        &gen_cnt);
+                  if (dsc_var->z_name == NULL)
+                    goto error;
+
+                  z_cnt++;
+                }
+            }
         }
+
+      /* It would be better to handle Z scores correctly (however we define
+         that) when TEMPORARY is in effect, but in the meantime this at least
+         prevents a use-after-free error.  See bug #38786.  */
+      if (proc_make_temporary_transformations_permanent (ds))
+        msg (SW, _("DESCRIPTIVES with Z scores ignores TEMPORARY.  "
+                   "Temporary transformations will be made permanent."));
+
+      proto = caseproto_create ();
+      for (i = 0; i < 1 + 2 * z_cnt; i++)
+        proto = caseproto_add_width (proto, 0);
+      dsc->z_writer = autopaging_writer_create (proto);
+      caseproto_unref (proto);
+
       dump_z_table (dsc);
     }
 
@@ -412,8 +442,8 @@ cmd_descriptives (struct lexer *lexer, struct dataset *ds)
     for (i = 0; i < dsc->var_cnt; i++)
       dsc->vars[i].moments = moments_create (dsc->max_moment);
 
-  /* Data pass.  FIXME: error handling. */
-  grouper = casegrouper_create_splits (proc_open (ds), dict);
+  /* Data pass. */
+  grouper = casegrouper_create_splits (proc_open_filtering (ds, false), dict);
   while (casegrouper_get_next_group (grouper, &group))
     calc_descriptives (dsc, group, ds);
   ok = casegrouper_destroy (grouper);
@@ -466,7 +496,12 @@ free_dsc_proc (struct dsc_proc *dsc)
     return;
 
   for (i = 0; i < dsc->var_cnt; i++)
-    moments_destroy (dsc->vars[i].moments);
+    {
+      struct dsc_var *dsc_var = &dsc->vars[i];
+      free (dsc_var->z_name);
+      moments_destroy (dsc_var->moments);
+    }
+  casewriter_destroy (dsc->z_writer);
   free (dsc->vars);
   free (dsc);
 }
@@ -484,33 +519,38 @@ try_name (const struct dictionary *dict, struct dsc_proc *dsc,
   if (dict_lookup_var (dict, name) != NULL)
     return false;
   for (i = 0; i < dsc->var_cnt; i++)
-    if (!strcasecmp (dsc->vars[i].z_name, name))
-      return false;
+    {
+      struct dsc_var *dsc_var = &dsc->vars[i];
+      if (dsc_var->z_name != NULL && !utf8_strcasecmp (dsc_var->z_name, name))
+        return false;
+    }
   return true;
 }
 
 /* Generates a name for a Z-score variable based on a variable
    named VAR_NAME, given that *Z_CNT generated variable names are
-   known to already exist.  If successful, returns true and
-   copies the new name into Z_NAME.  On failure, returns false. */
-static bool
-generate_z_varname (const struct dictionary *dict, struct dsc_proc *dsc, char *z_name,
+   known to already exist.  If successful, returns the new name
+   as a dynamically allocated string.  On failure, returns NULL. */
+static char *
+generate_z_varname (const struct dictionary *dict, struct dsc_proc *dsc,
                     const char *var_name, int *z_cnt)
 {
-  char name[LONG_NAME_LEN + 1];
+  char *z_name, *trunc_name;
 
   /* Try a name based on the original variable name. */
-  name[0] = 'Z';
-  str_copy_trunc (name + 1, sizeof name - 1, var_name);
-  if (try_name (dict, dsc, name))
-    {
-      strcpy (z_name, name);
-      return true;
-    }
+  z_name = xasprintf ("Z%s", var_name);
+  trunc_name = utf8_encoding_trunc (z_name, dict_get_encoding (dict),
+                                    ID_MAX_LEN);
+  free (z_name);
+  if (try_name (dict, dsc, trunc_name))
+    return trunc_name;
+  free (trunc_name);
 
   /* Generate a synthetic name. */
   for (;;)
     {
+      char name[8];
+
       (*z_cnt)++;
 
       if (*z_cnt <= 99)
@@ -526,14 +566,11 @@ generate_z_varname (const struct dictionary *dict, struct dsc_proc *dsc, char *z
 	  msg (SE, _("Ran out of generic names for Z-score variables.  "
 		     "There are only 126 generic names: ZSC001-ZSC0999, "
 		     "STDZ01-STDZ09, ZZZZ01-ZZZZ09, ZQZQ01-ZQZQ09."));
-	  return false;
+	  return NULL;
 	}
 
       if (try_name (dict, dsc, name))
-	{
-	  strcpy (z_name, name);
-	  return true;
-	}
+        return xstrdup (name);
     }
   NOT_REACHED();
 }
@@ -550,27 +587,25 @@ dump_z_table (struct dsc_proc *dsc)
     size_t i;
 
     for (i = 0; i < dsc->var_cnt; i++)
-      if (dsc->vars[i].z_name[0] != '\0')
+      if (dsc->vars[i].z_name != NULL)
 	cnt++;
   }
 
-  t = tab_create (2, cnt + 1, 0);
+  t = tab_create (2, cnt + 1);
   tab_title (t, _("Mapping of variables to corresponding Z-scores."));
-  tab_columns (t, SOM_COL_DOWN, 1);
   tab_headers (t, 0, 0, 1, 0);
   tab_box (t, TAL_1, TAL_1, TAL_0, TAL_1, 0, 0, 1, cnt);
   tab_hline (t, TAL_2, 0, 1, 1);
   tab_text (t, 0, 0, TAB_CENTER | TAT_TITLE, _("Source"));
   tab_text (t, 1, 0, TAB_CENTER | TAT_TITLE, _("Target"));
-  tab_dim (t, tab_natural_dimensions);
 
   {
     size_t i, y;
 
     for (i = 0, y = 1; i < dsc->var_cnt; i++)
-      if (dsc->vars[i].z_name[0] != '\0')
+      if (dsc->vars[i].z_name != NULL)
 	{
-	  tab_text (t, 0, y, TAB_LEFT, var_get_name (dsc->vars[i].v));
+	  tab_text (t, 0, y, TAB_LEFT, var_to_string (dsc->vars[i].v));
 	  tab_text (t, 1, y++, TAB_LEFT, dsc->vars[i].z_name);
 	}
   }
@@ -578,6 +613,15 @@ dump_z_table (struct dsc_proc *dsc)
   tab_submit (t);
 }
 
+static void
+descriptives_set_all_sysmis_zscores (const struct dsc_trns *t, struct ccase *c)
+{
+  const struct dsc_z_score *z;
+
+  for (z = t->z_scores; z < t->z_scores + t->z_score_cnt; z++)
+    case_data_rw (c, z->z_var)->f = SYSMIS;
+}
+
 /* Transformation function to calculate Z-scores. Will return SYSMIS if any of
    the following are true: 1) mean or standard deviation is SYSMIS 2) score is
    SYSMIS 3) score is user missing and they were not included in the original
@@ -585,34 +629,75 @@ dump_z_table (struct dsc_proc *dsc)
    (either system or user-missing values that weren't included).
 */
 static int
-descriptives_trns_proc (void *trns_, struct ccase * c,
+descriptives_trns_proc (void *trns_, struct ccase **c,
                         casenumber case_idx UNUSED)
 {
   struct dsc_trns *t = trns_;
   struct dsc_z_score *z;
   const struct variable **vars;
-  int all_sysmis = 0;
+
+  *c = case_unshare (*c);
+
+  if (t->filter)
+    {
+      double f = case_num (*c, t->filter);
+      if (f == 0.0 || var_is_num_missing (t->filter, f, MV_ANY))
+        {
+          descriptives_set_all_sysmis_zscores (t, *c);
+          return TRNS_CONTINUE;
+        }
+    }
+
+  if (t->count <= 0)
+    {
+      struct ccase *z_case;
+
+      z_case = casereader_read (t->z_reader);
+      if (z_case)
+        {
+          size_t z_idx = 0;
+
+          t->count = case_num_idx (z_case, z_idx++);
+          for (z = t->z_scores; z < t->z_scores + t->z_score_cnt; z++)
+            {
+              z->mean = case_num_idx (z_case, z_idx++);
+              z->std_dev = case_num_idx (z_case, z_idx++);
+            }
+          case_unref (z_case);
+        }
+      else
+        {
+          if (t->ok)
+            {
+              msg (SE, _("Internal error processing Z scores"));
+              t->ok = false;
+            }
+          descriptives_set_all_sysmis_zscores (t, *c);
+          return TRNS_CONTINUE;
+        }
+    }
+  t->count--;
 
   if (t->missing_type == DSC_LISTWISE)
     {
       assert(t->vars);
       for (vars = t->vars; vars < t->vars + t->var_cnt; vars++)
 	{
-	  double score = case_num (c, *vars);
+	  double score = case_num (*c, *vars);
 	  if (var_is_num_missing (*vars, score, t->exclude))
 	    {
-	      all_sysmis = 1;
-	      break;
+              descriptives_set_all_sysmis_zscores (t, *c);
+	      return TRNS_CONTINUE;
 	    }
 	}
     }
 
   for (z = t->z_scores; z < t->z_scores + t->z_score_cnt; z++)
     {
-      double input = case_num (c, z->src_var);
-      double *output = &case_data_rw (c, z->z_var)->f;
+      double input = case_num (*c, z->src_var);
+      double *output = &case_data_rw (*c, z->z_var)->f;
 
-      if (z->mean == SYSMIS || z->std_dev == SYSMIS || all_sysmis
+      if (z->mean == SYSMIS || z->std_dev == SYSMIS
           || var_is_num_missing (z->src_var, input, t->exclude))
 	*output = SYSMIS;
       else
@@ -626,11 +711,15 @@ static bool
 descriptives_trns_free (void *trns_)
 {
   struct dsc_trns *t = trns_;
+  bool ok = t->ok && !casereader_error (t->z_reader);
 
   free (t->z_scores);
+  casereader_destroy (t->z_reader);
   assert((t->missing_type != DSC_LISTWISE) ^ (t->vars != NULL));
   free (t->vars);
-  return true;
+  free (t);
+
+  return ok;
 }
 
 /* Sets up a transformation to calculate Z scores. */
@@ -641,7 +730,7 @@ setup_z_trns (struct dsc_proc *dsc, struct dataset *ds)
   size_t cnt, i;
 
   for (cnt = i = 0; i < dsc->var_cnt; i++)
-    if (dsc->vars[i].z_name[0] != '\0')
+    if (dsc->vars[i].z_name != NULL)
       cnt++;
 
   t = xmalloc (sizeof *t);
@@ -661,24 +750,30 @@ setup_z_trns (struct dsc_proc *dsc, struct dataset *ds)
       t->var_cnt = 0;
       t->vars = NULL;
     }
+  t->filter = dict_get_filter (dataset_dict (ds));
+  t->z_reader = casewriter_make_reader (dsc->z_writer);
+  t->count = 0;
+  t->ok = true;
+  dsc->z_writer = NULL;
 
   for (cnt = i = 0; i < dsc->var_cnt; i++)
     {
       struct dsc_var *dv = &dsc->vars[i];
-      if (dv->z_name[0] != '\0')
+      if (dv->z_name != NULL)
 	{
           struct dsc_z_score *z;
 	  struct variable *dst_var;
+          char *label;
 
 	  dst_var = dict_create_var_assert (dataset_dict (ds), dv->z_name, 0);
-          var_set_label (dst_var, xasprintf (_("Z-score of %s"),
-                                             var_to_string (dv->v)));
+
+          label = xasprintf (_("Z-score of %s"),var_to_string (dv->v));
+          var_set_label (dst_var, label);
+          free (label);
 
           z = &t->z_scores[cnt++];
           z->src_var = dv->v;
           z->z_var = dst_var;
-          z->mean = dv->stats[DSC_MEAN];
-          z->std_dev = dv->stats[DSC_STDDEV];
 	}
     }
 
@@ -696,21 +791,27 @@ static void
 calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
                    struct dataset *ds)
 {
+  struct variable *filter = dict_get_filter (dataset_dict (ds));
   struct casereader *pass1, *pass2;
-  struct ccase c;
+  casenumber count;
+  struct ccase *c;
+  size_t z_idx;
   size_t i;
 
-  if (!casereader_peek (group, 0, &c))
-    return;
-  output_split_file_values (ds, &c);
-  case_destroy (&c);
+  c = casereader_peek (group, 0);
+  if (c == NULL)
+    {
+      casereader_destroy (group);
+      return;
+    }
+  output_split_file_values (ds, c);
+  case_unref (c);
 
   group = casereader_create_filter_weight (group, dataset_dict (ds),
                                            NULL, NULL);
 
-  casereader_split (group, &pass1, &pass2);
-  if (dsc->max_moment <= MOMENT_MEAN)
-    casereader_destroy (pass2);
+  pass1 = group;
+  pass2 = dsc->max_moment <= MOMENT_MEAN ? NULL : casereader_clone (pass1);
 
   for (i = 0; i < dsc->var_cnt; i++)
     {
@@ -726,12 +827,20 @@ calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
   dsc->valid = 0.;
 
   /* First pass to handle most of the work. */
-  for (; casereader_read (pass1, &c); case_destroy (&c))
+  count = 0;
+  for (; (c = casereader_read (pass1)) != NULL; case_unref (c))
     {
-      double weight = dict_get_case_weight (dataset_dict (ds), &c, NULL);
+      double weight = dict_get_case_weight (dataset_dict (ds), c, NULL);
+
+      if (filter)
+        {
+          double f = case_num (c, filter);
+          if (f == 0.0 || var_is_num_missing (filter, f, MV_ANY))
+            continue;
+        }
 
       /* Check for missing values. */
-      if (listwise_missing (dsc, &c))
+      if (listwise_missing (dsc, c))
         {
           dsc->missing_listwise += weight;
           if (dsc->missing_type == DSC_LISTWISE)
@@ -742,7 +851,7 @@ calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
       for (i = 0; i < dsc->var_cnt; i++)
         {
           struct dsc_var *dv = &dsc->vars[i];
-          double x = case_num (&c, dv->v);
+          double x = case_num (c, dv->v);
 
           if (var_is_num_missing (dv->v, x, dsc->exclude))
             {
@@ -758,25 +867,37 @@ calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
           if (x > dv->max)
             dv->max = x;
         }
+
+      count++;
     }
   if (!casereader_destroy (pass1))
-    return;
+    {
+      casereader_destroy (pass2);
+      return;
+    }
 
   /* Second pass for higher-order moments. */
   if (dsc->max_moment > MOMENT_MEAN)
     {
-      for (; casereader_read (pass2, &c); case_destroy (&c))
+      for (; (c = casereader_read (pass2)) != NULL; case_unref (c))
         {
-          double weight = dict_get_case_weight (dataset_dict (ds), &c, NULL);
+          double weight = dict_get_case_weight (dataset_dict (ds), c, NULL);
+
+          if (filter)
+            {
+              double f = case_num (c, filter);
+              if (f == 0.0 || var_is_num_missing (filter, f, MV_ANY))
+                continue;
+            }
 
           /* Check for missing values. */
-          if (dsc->missing_type == DSC_LISTWISE && listwise_missing (dsc, &c))
+          if (dsc->missing_type == DSC_LISTWISE && listwise_missing (dsc, c))
             continue;
 
           for (i = 0; i < dsc->var_cnt; i++)
             {
               struct dsc_var *dv = &dsc->vars[i];
-              double x = case_num (&c, dv->v);
+              double x = case_num (c, dv->v);
 
               if (var_is_num_missing (dv->v, x, dsc->exclude))
                 continue;
@@ -790,6 +911,15 @@ calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
     }
 
   /* Calculate results. */
+  if (dsc->z_writer && count > 0)
+    {
+      c = case_create (casewriter_get_proto (dsc->z_writer));
+      z_idx = 0;
+      case_data_rw_idx (c, z_idx++)->f = count;
+    }
+  else
+    c = NULL;
+
   for (i = 0; i < dsc->var_cnt; i++)
     {
       struct dsc_var *dv = &dsc->vars[i];
@@ -823,8 +953,17 @@ calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
       dv->stats[DSC_MAX] = dv->max == -DBL_MAX ? SYSMIS : dv->max;
       if (dsc->calc_stats & (1ul << DSC_SUM))
         dv->stats[DSC_SUM] = W * dv->stats[DSC_MEAN];
+
+      if (dv->z_name && c != NULL)
+        {
+          case_data_rw_idx (c, z_idx++)->f = dv->stats[DSC_MEAN];
+          case_data_rw_idx (c, z_idx++)->f = dv->stats[DSC_STDDEV];
+        }
     }
 
+  if (c != NULL)
+    casewriter_write (dsc->z_writer, c);
+
   /* Output results. */
   display (dsc);
 }
@@ -868,13 +1007,12 @@ display (struct dsc_proc *dsc)
     sort (dsc->vars, dsc->var_cnt, sizeof *dsc->vars,
           descriptives_compare_dsc_vars, dsc);
 
-  t = tab_create (nc, dsc->var_cnt + 1, 0);
+  t = tab_create (nc, dsc->var_cnt + 1);
   tab_headers (t, 1, 0, 1, 0);
   tab_box (t, TAL_1, TAL_1, -1, -1, 0, 0, nc - 1, dsc->var_cnt);
   tab_box (t, -1, -1, -1, TAL_1, 1, 0, nc - 1, dsc->var_cnt);
   tab_hline (t, TAL_2, 0, nc - 1, 1);
   tab_vline (t, TAL_2, 1, 0, dsc->var_cnt);
-  tab_dim (t, tab_natural_dimensions);
 
   nc = 0;
   tab_text (t, nc++, 0, TAB_LEFT | TAT_TITLE, _("Variable"));
@@ -899,17 +1037,19 @@ display (struct dsc_proc *dsc)
       size_t j;
 
       nc = 0;
-      tab_text (t, nc++, i + 1, TAB_LEFT, var_get_name (dv->v));
-      tab_text (t, nc++, i + 1, TAT_PRINTF, "%g", dv->valid);
+      tab_text (t, nc++, i + 1, TAB_LEFT, var_to_string (dv->v));
+      tab_text_format (t, nc++, i + 1, 0, "%.*g", DBL_DIG + 1, dv->valid);
       if (dsc->format == DSC_SERIAL)
-	tab_text (t, nc++, i + 1, TAT_PRINTF, "%g", dv->missing);
+	tab_text_format (t, nc++, i + 1, 0, "%.*g", DBL_DIG + 1, dv->missing);
+
       for (j = 0; j < DSC_N_STATS; j++)
 	if (dsc->show_stats & (1ul << j))
-	  tab_float (t, nc++, i + 1, TAB_NONE, dv->stats[j], 10, 3);
+	  tab_double (t, nc++, i + 1, TAB_NONE, dv->stats[j], NULL);
     }
 
-  tab_title (t, _("Valid cases = %g; cases with missing value(s) = %g."),
-	     dsc->valid, dsc->missing_listwise);
+  tab_title (t, _("Valid cases = %.*g; cases with missing value(s) = %.*g."),
+	     DBL_DIG + 1, dsc->valid,
+             DBL_DIG + 1, dsc->missing_listwise);
 
   tab_submit (t);
 }
@@ -926,7 +1066,7 @@ descriptives_compare_dsc_vars (const void *a_, const void *b_, const void *dsc_)
   int result;
 
   if (dsc->sort_by_stat == DSC_NAME)
-    result = strcasecmp (var_get_name (a->v), var_get_name (b->v));
+    result = utf8_strcasecmp (var_get_name (a->v), var_get_name (b->v));
   else
     {
       double as = a->stats[dsc->sort_by_stat];