X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Ft-test.q;h=5c902dfd225038c42ad584c5bd560deaa53c3ffa;hb=72147c12357446b304264b6944b8a1d92c45f53c;hp=9e332df87be2a9bcb1f88e74aefc0d96ea8018d0;hpb=97d4f38945476834fd7fce612b663f19f2b291f8;p=pspp

diff --git a/src/language/stats/t-test.q b/src/language/stats/t-test.q
index 9e332df87b..5c902dfd22 100644
--- a/src/language/stats/t-test.q
+++ b/src/language/stats/t-test.q
@@ -32,6 +32,8 @@
 #include <data/procedure.h>
 #include <data/value-labels.h>
 #include <data/variable.h>
+#include <data/casefilter.h>
+
 #include <language/command.h>
 #include <language/dictionary/split-file.h>
 #include <language/lexer/lexer.h>
@@ -71,11 +73,6 @@
 /* (functions) */
 
 
-
-
-/* Function to use for testing for missing values */
-static is_missing_func *value_is_missing;
-
 /* Variable for the GROUPS subcommand, if given. */
 static struct variable *indep_var;
 
@@ -157,7 +154,7 @@ struct pair
 
 static struct pair *pairs=0;
 
-static int parse_value (union value * v, int type) ;
+static int parse_value (struct lexer *lexer, union value * v, enum var_type);
 
 /* Structures and Functions for the Statistics Summary Box */
 struct ssbox;
@@ -218,31 +215,36 @@ enum {
 };
 
 
-static int common_calc (const struct ccase *, void *);
+static int common_calc (const struct dictionary *dict, 
+			const struct ccase *, void *, 
+			const struct casefilter *filter);
 static void common_precalc (struct cmd_t_test *);
 static void common_postcalc (struct cmd_t_test *);
 
-static int one_sample_calc (const struct ccase *, void *);
+static int one_sample_calc (const struct dictionary *dict, const struct ccase *, void *, const struct casefilter *);
 static void one_sample_precalc (struct cmd_t_test *);
 static void one_sample_postcalc (struct cmd_t_test *);
 
-static int  paired_calc (const struct ccase *, void *);
+static int  paired_calc (const struct dictionary *dict, const struct ccase *, 
+			 struct cmd_t_test*, const struct casefilter *);
 static void paired_precalc (struct cmd_t_test *);
 static void paired_postcalc (struct cmd_t_test *);
 
 static void group_precalc (struct cmd_t_test *);
-static int  group_calc (const struct ccase *, struct cmd_t_test *);
+static int  group_calc (const struct dictionary *dict, const struct ccase *, 
+			struct cmd_t_test *, const struct casefilter *);
 static void group_postcalc (struct cmd_t_test *);
 
 
 static bool calculate(const struct ccase *first,
-                      const struct casefile *cf, void *_mode);
+                      const struct casefile *cf, void *_mode, 
+		      const struct dataset *ds);
 
 static  int mode;
 
 static struct cmd_t_test cmd;
 
-static int bad_weight_warn;
+static bool bad_weight_warn = false;
 
 
 static int compare_group_binary(const struct group_statistics *a, 
@@ -256,11 +258,11 @@ static unsigned  hash_group_binary(const struct group_statistics *g,
 
 
 int
-cmd_t_test(void)
+cmd_t_test (struct lexer *lexer, struct dataset *ds)
 {
   bool ok;
   
-  if ( !parse_t_test(&cmd, NULL) )
+  if ( !parse_t_test (lexer, ds, &cmd, NULL) )
     return CMD_FAILURE;
 
   if (! cmd.sbc_criteria)
@@ -307,7 +309,8 @@ cmd_t_test(void)
 	  struct hsh_table *hash;
 	  struct variable *v;
 
-	  hash = hsh_create (n_pairs, compare_var_names, hash_var_name, 0, 0);
+	  hash = hsh_create (n_pairs, compare_vars_by_name, hash_var_by_name,
+          0, 0);
 
 	  for (i=0; i < n_pairs; ++i)
 	    {
@@ -336,16 +339,9 @@ cmd_t_test(void)
       return CMD_FAILURE;
     }
 
+  bad_weight_warn = true;
 
-  /* If /MISSING=INCLUDE is set, then user missing values are ignored */
-  if (cmd.incl == TTS_INCLUDE ) 
-    value_is_missing = mv_is_value_system_missing;
-  else
-    value_is_missing = mv_is_value_missing;
-
-  bad_weight_warn = 1;
-
-  ok = multipass_procedure_with_splits (calculate, &cmd);
+  ok = multipass_procedure_with_splits (ds, calculate, &cmd);
 
   n_pairs=0;
   free(pairs);
@@ -367,29 +363,29 @@ cmd_t_test(void)
 }
 
 static int
-tts_custom_groups (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
+tts_custom_groups (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
 {
   int n_group_values=0;
 
-  lex_match('=');
+  lex_match (lexer, '=');
 
-  indep_var = parse_variable ();
+  indep_var = parse_variable (lexer, dataset_dict (ds));
   if (!indep_var)
     {
-      lex_error ("expecting variable name in GROUPS subcommand");
+      lex_error (lexer, "expecting variable name in GROUPS subcommand");
       return 0;
     }
 
-  if (indep_var->type == T_STRING && indep_var->width > MAX_SHORT_STRING)
+  if (var_is_long_string (indep_var))
     {
       msg (SE, _("Long string variable %s is not valid here."),
-	   indep_var->name);
+	   var_get_name (indep_var));
       return 0;
     }
 
-  if (!lex_match ('('))
+  if (!lex_match (lexer, '('))
     {
-      if (indep_var->type == NUMERIC)
+      if (var_is_numeric (indep_var))
 	{
 	  gp.v.g_value[0].f = 1;
 	  gp.v.g_value[1].f = 2;
@@ -408,15 +404,14 @@ tts_custom_groups (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
 	}
     }
 
-  if (!parse_value (&gp.v.g_value[0], indep_var->type))
+  if (!parse_value (lexer, &gp.v.g_value[0], var_get_type (indep_var)))
       return 0;
 
-  lex_match (',');
-  if (lex_match (')'))
+  lex_match (lexer, ',');
+  if (lex_match (lexer, ')'))
     {
-      if (indep_var->type != NUMERIC)
+      if (var_is_alpha (indep_var))
 	{
-
 	  msg (SE, _("When applying GROUPS to a string variable, two "
 		     "values must be specified."));
 	  return 0;
@@ -428,11 +423,11 @@ tts_custom_groups (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
       return 1;
     }
 
-  if (!parse_value (&gp.v.g_value[1], indep_var->type))
+  if (!parse_value (lexer, &gp.v.g_value[1], var_get_type (indep_var)))
     return 0;
 
   n_group_values = 2;
-  if (!lex_force_match (')'))
+  if (!lex_force_match (lexer, ')'))
     return 0;
 
   if ( n_group_values == 2 ) 
@@ -446,7 +441,7 @@ tts_custom_groups (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
 
 
 static int
-tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
+tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
 {
   struct variable **vars;
   size_t n_vars;
@@ -456,10 +451,10 @@ tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
   size_t n_after_WITH = SIZE_MAX;
   int paired ; /* Was the PAIRED keyword given ? */
 
-  lex_match('=');
+  lex_match (lexer, '=');
 
   n_vars=0;
-  if (!parse_variables (default_dict, &vars, &n_vars,
+  if (!parse_variables (lexer, dataset_dict (ds), &vars, &n_vars,
 			PV_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH))
     {
       free (vars);
@@ -468,10 +463,10 @@ tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
   assert (n_vars);
 
   n_before_WITH = 0;
-  if (lex_match (T_WITH))
+  if (lex_match (lexer, T_WITH))
     {
       n_before_WITH = n_vars;
-      if (!parse_variables (default_dict, &vars, &n_vars,
+      if (!parse_variables (lexer, dataset_dict (ds), &vars, &n_vars,
 			    PV_DUPLICATE | PV_APPEND
 			    | PV_NUMERIC | PV_NO_SCRATCH))
 	{
@@ -481,7 +476,7 @@ tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
       n_after_WITH = n_vars - n_before_WITH;
     }
 
-  paired = (lex_match ('(') && lex_match_id ("PAIRED") && lex_match (')'));
+  paired = (lex_match (lexer, '(') && lex_match_id (lexer, "PAIRED") && lex_match (lexer, ')'));
 
   /* Determine the number of pairs needed */
   if (paired)
@@ -571,22 +566,22 @@ tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
 /* Parses the current token (numeric or string, depending on type)
     value v and returns success. */
 static int
-parse_value (union value * v, int type )
+parse_value (struct lexer *lexer, union value * v, enum var_type type)
 {
-  if (type == NUMERIC)
+  if (type == VAR_NUMERIC)
     {
-      if (!lex_force_num ())
+      if (!lex_force_num (lexer))
 	return 0;
-      v->f = tokval;
+      v->f = lex_tokval (lexer);
     }
   else
     {
-      if (!lex_force_string ())
+      if (!lex_force_string (lexer))
 	return 0;
-      strncpy (v->s, ds_cstr (&tokstr), ds_length (&tokstr));
+      strncpy (v->s, ds_cstr (lex_tokstr (lexer)), ds_length (lex_tokstr (lexer)));
     }
 
-  lex_get ();
+  lex_get (lexer);
 
   return 1;
 }
@@ -707,7 +702,7 @@ ssbox_independent_samples_init(struct ssbox *this,
   ssbox_base_init(this, hsize,vsize);
   tab_vline (this->t, TAL_GAP, 1, 0,vsize - 1);
   tab_title (this->t, _("Group Statistics"));
-  tab_text (this->t, 1, 0, TAB_CENTER | TAT_TITLE, indep_var->name);
+  tab_text (this->t, 1, 0, TAB_CENTER | TAT_TITLE, var_get_name (indep_var));
   tab_text (this->t, 2, 0, TAB_CENTER | TAT_TITLE, _("N"));
   tab_text (this->t, 3, 0, TAB_CENTER | TAT_TITLE, _("Mean"));
   tab_text (this->t, 4, 0, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
@@ -722,16 +717,16 @@ ssbox_independent_samples_populate(struct ssbox *ssb,
 {
   int i;
 
-  char *val_lab0=0;
-  char *val_lab1=0;
+  const char *val_lab0;
+  const char *val_lab1;
   double indep_value[2];
 
   char prefix[2][3]={"",""};
 
-  if ( indep_var->type == NUMERIC ) 
+  if ( var_is_numeric (indep_var) ) 
     {
-      val_lab0 = val_labs_find( indep_var->val_labs,gp.v.g_value[0]); 
-      val_lab1 = val_labs_find( indep_var->val_labs,gp.v.g_value[1]);
+      val_lab0 = var_lookup_value_label (indep_var, &gp.v.g_value[0]); 
+      val_lab1 = var_lookup_value_label (indep_var, &gp.v.g_value[1]);
     }
   else
     {
@@ -760,7 +755,8 @@ ssbox_independent_samples_populate(struct ssbox *ssb,
       struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
       int count=0;
 
-      tab_text (ssb->t, 0, i*2+1, TAB_LEFT, cmd->v_variables[i]->name);
+      tab_text (ssb->t, 0, i*2+1, TAB_LEFT,
+                var_get_name (cmd->v_variables[i]));
 
       if (val_lab0)
 	tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF, 
@@ -861,7 +857,8 @@ ssbox_paired_populate(struct ssbox *ssb,struct cmd_t_test *cmd UNUSED)
 
 	  /* Titles */
 
-	  tab_text (ssb->t, 1, i*2+j+1, TAB_LEFT, pairs[i].v[j]->name);
+	  tab_text (ssb->t, 1, i*2+j+1, TAB_LEFT,
+                    var_get_name (pairs[i].v[j]));
 
 	  /* Values */
 	  tab_float (ssb->t,2, i*2+j+1, TAB_RIGHT, pairs[i].mean[j], 8, 2);
@@ -885,7 +882,7 @@ ssbox_one_sample_populate(struct ssbox *ssb, struct cmd_t_test *cmd)
     {
       struct group_statistics *gs = &group_proc_get (cmd->v_variables[i])->ugs;
 
-      tab_text (ssb->t, 0, i+1, TAB_LEFT, cmd->v_variables[i]->name);
+      tab_text (ssb->t, 0, i+1, TAB_LEFT, var_get_name (cmd->v_variables[i]));
       tab_float (ssb->t,1, i+1, TAB_RIGHT, gs->n, 2, 0);
       tab_float (ssb->t,2, i+1, TAB_RIGHT, gs->mean, 8, 2);
       tab_float (ssb->t,3, i+1, TAB_RIGHT, gs->std_dev, 8, 2);
@@ -1044,7 +1041,7 @@ trbox_independent_samples_populate(struct trbox *self,
       assert(gs1);
 
 	  
-      tab_text (self->t, 0, i*2+3, TAB_LEFT, cmd->v_variables[i]->name);
+      tab_text (self->t, 0, i*2+3, TAB_LEFT, var_get_name (cmd->v_variables[i]));
 
       tab_text (self->t, 1, i*2+3, TAB_LEFT, _("Equal variances assumed"));
 
@@ -1198,7 +1195,8 @@ trbox_paired_populate(struct trbox *trb,
       tab_text (trb->t, 0, i+3, TAB_LEFT | TAT_PRINTF, _("Pair %d"),i); 
 
       tab_text (trb->t, 1, i+3, TAB_LEFT | TAT_PRINTF, "%s - %s",
-		pairs[i].v[0]->name, pairs[i].v[1]->name);
+		var_get_name (pairs[i].v[0]),
+                var_get_name (pairs[i].v[1]));
 
       tab_float(trb->t, 2, i+3, TAB_RIGHT, pairs[i].mean_diff, 8, 4);
 
@@ -1292,7 +1290,7 @@ trbox_one_sample_populate(struct trbox *trb, struct cmd_t_test *cmd)
       struct group_statistics *gs = &group_proc_get (cmd->v_variables[i])->ugs;
 
 
-      tab_text (trb->t, 0, i+3, TAB_LEFT, cmd->v_variables[i]->name);
+      tab_text (trb->t, 0, i+3, TAB_LEFT, var_get_name (cmd->v_variables[i]));
 
       t = (gs->mean - cmd->n_testval[0] ) * sqrt(gs->n) / gs->std_dev ;
 
@@ -1388,7 +1386,9 @@ pscbox(void)
 	       _("Pair %d"), i);
       
       tab_text(table, 1,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF, 
-	       _("%s & %s"), pairs[i].v[0]->name, pairs[i].v[1]->name);
+	       _("%s & %s"),
+               var_get_name (pairs[i].v[0]),
+               var_get_name (pairs[i].v[1]));
 
 
       /* row data */
@@ -1411,53 +1411,37 @@ pscbox(void)
 
 /* Per case calculations common to all variants of the T test */
 static int 
-common_calc (const struct ccase *c, void *_cmd)
+common_calc (const struct dictionary *dict, 
+	     const struct ccase *c, 
+	     void *_cmd, 
+	     const struct casefilter *filter)
 {
   int i;
   struct cmd_t_test *cmd = (struct cmd_t_test *)_cmd;  
 
-  double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn);
+  double weight = dict_get_case_weight (dict, c, &bad_weight_warn);
 
 
-  /* Skip the entire case if /MISSING=LISTWISE is set */
-  if ( cmd->miss == TTS_LISTWISE ) 
-    {
-      for(i=0; i< cmd->n_variables ; ++i) 
-	{
-	  struct variable *v = cmd->v_variables[i];
-	  const union value *val = case_data (c, v->fv);
-
-	  if (value_is_missing(&v->miss, val) )
-	    {
-	      return 0;
-	    }
-	}
-    }
-
   /* Listwise has to be implicit if the independent variable is missing ?? */
   if ( cmd->sbc_groups )
     {
-      const union value *gv = case_data (c, indep_var->fv);
-      if ( value_is_missing(&indep_var->miss, gv) )
-	{
-	  return 0;
-	}
+      if ( casefilter_variable_missing (filter, c, indep_var) )
+	return 0;
     }
 
-
-  for(i=0; i< cmd->n_variables ; ++i) 
+  for(i = 0; i < cmd->n_variables ; ++i) 
     {
-      struct group_statistics *gs;
       struct variable *v = cmd->v_variables[i];
-      const union value *val = case_data (c, v->fv);
 
-      gs= &group_proc_get (cmd->v_variables[i])->ugs;
-
-      if (! value_is_missing(&v->miss, val) )
+      if (! casefilter_variable_missing (filter, c, v) )
 	{
-	  gs->n+=weight;
-	  gs->sum+=weight * val->f;
-	  gs->ssq+=weight * val->f * val->f;
+	  struct group_statistics *gs;
+	  const union value *val = case_data (c, v);
+	  gs = &group_proc_get (cmd->v_variables[i])->ugs;
+
+	  gs->n += weight;
+	  gs->sum += weight * val->f;
+	  gs->ssq += weight * val->f * val->f;
 	}
     }
   return 0;
@@ -1483,11 +1467,10 @@ common_precalc ( struct cmd_t_test *cmd )
 
 /* Post calculations common to all variants of the T test */
 void 
-common_postcalc (  struct cmd_t_test *cmd )
+common_postcalc (struct cmd_t_test *cmd)
 {
   int i=0;
 
-
   for(i=0; i< cmd->n_variables ; ++i) 
     {
       struct group_statistics *gs;
@@ -1510,38 +1493,26 @@ common_postcalc (  struct cmd_t_test *cmd )
 
 /* Per case calculations for one sample t test  */
 static int 
-one_sample_calc (const struct ccase *c, void *cmd_)
+one_sample_calc (const struct dictionary *dict, 
+		 const struct ccase *c, void *cmd_, 
+		 const struct casefilter *filter)
 {
   int i;
-  struct cmd_t_test *cmd = (struct cmd_t_test *)cmd_;
 
+  struct cmd_t_test *cmd = (struct cmd_t_test *)cmd_;
 
-  double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn);
+  double weight = dict_get_case_weight (dict, c, &bad_weight_warn);
 
-  /* Skip the entire case if /MISSING=LISTWISE is set */
-  if ( cmd->miss == TTS_LISTWISE ) 
-    {
-      for(i=0; i< cmd->n_variables ; ++i) 
-	{
-	  struct variable *v = cmd->v_variables[i];
-	  const union value *val = case_data (c, v->fv);
-
-	  if (value_is_missing(&v->miss, val) )
-	    {
-	      return 0;
-	    }
-	}
-    }
 
   for(i=0; i< cmd->n_variables ; ++i) 
     {
       struct group_statistics *gs;
       struct variable *v = cmd->v_variables[i];
-      const union value *val = case_data (c, v->fv);
+      const union value *val = case_data (c, v);
 
       gs= &group_proc_get (cmd->v_variables[i])->ugs;
-      
-      if ( ! value_is_missing(&v->miss, val))
+
+      if ( ! casefilter_variable_missing (filter, c, v))
 	gs->sum_diff += weight * (val->f - cmd->n_testval[0]);
     }
 
@@ -1600,57 +1571,36 @@ paired_precalc (struct cmd_t_test *cmd UNUSED)
 
 
 static int  
-paired_calc (const struct ccase *c, void *cmd_)
+paired_calc (const struct dictionary *dict, const struct ccase *c, 
+	     struct cmd_t_test *cmd UNUSED, const struct casefilter *filter)
 {
   int i;
 
-  struct cmd_t_test *cmd  = (struct cmd_t_test *) cmd_;
-
-  double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn);
-
-  /* Skip the entire case if /MISSING=LISTWISE is set , 
-   AND one member of a pair is missing */
-  if ( cmd->miss == TTS_LISTWISE ) 
-    {
-      for(i=0; i < n_pairs ; ++i )
-      	{
-	  struct variable *v0 = pairs[i].v[0];
-	  struct variable *v1 = pairs[i].v[1];
-
-	  const union value *val0 = case_data (c, v0->fv);
-	  const union value *val1 = case_data (c, v1->fv);
-	  
-	  if ( value_is_missing(&v0->miss, val0) ||
-	       value_is_missing(&v1->miss, val1) )
-	    {
-	      return 0;
-	    }
-	}
-    }
+  double weight = dict_get_case_weight (dict, c, &bad_weight_warn);
 
   for(i=0; i < n_pairs ; ++i )
     {
       struct variable *v0 = pairs[i].v[0];
       struct variable *v1 = pairs[i].v[1];
 
-      const union value *val0 = case_data (c, v0->fv);
-      const union value *val1 = case_data (c, v1->fv);
+      const union value *val0 = case_data (c, v0);
+      const union value *val1 = case_data (c, v1);
 
-      if ( ( !value_is_missing(&v0->miss, val0)
-             && !value_is_missing(&v1->miss, val1) ) )
-      {
-	pairs[i].n += weight;
-	pairs[i].sum[0] += weight * val0->f;
-	pairs[i].sum[1] += weight * val1->f;
+      if (  ! casefilter_variable_missing (filter, c, v0) && 
+	    ! casefilter_variable_missing (filter, c, v1) )
+	{
+	  pairs[i].n += weight;
+	  pairs[i].sum[0] += weight * val0->f;
+	  pairs[i].sum[1] += weight * val1->f;
 
-	pairs[i].ssq[0] += weight * pow2(val0->f);
-	pairs[i].ssq[1] += weight * pow2(val1->f);
+	  pairs[i].ssq[0] += weight * pow2(val0->f);
+	  pairs[i].ssq[1] += weight * pow2(val1->f);
 
-	pairs[i].sum_of_prod += weight * val0->f * val1->f ;
+	  pairs[i].sum_of_prod += weight * val0->f * val1->f ;
 
-	pairs[i].sum_of_diffs += weight * ( val0->f - val1->f ) ;
-	pairs[i].ssq_diffs += weight * pow2(val0->f - val1->f);
-      }
+	  pairs[i].sum_of_diffs += weight * ( val0->f - val1->f ) ;
+	  pairs[i].ssq_diffs += weight * pow2(val0->f - val1->f);
+	}
     }
 
   return 0;
@@ -1708,7 +1658,7 @@ group_precalc (struct cmd_t_test *cmd )
       /* There's always 2 groups for a T - TEST */
       ttpr->n_groups = 2;
 
-      gp.indep_width = indep_var->width;
+      gp.indep_width = var_get_width (indep_var);
       
       ttpr->group_hash = hsh_create(2, 
 				    (hsh_compare_func *) compare_group_binary,
@@ -1745,39 +1695,26 @@ group_precalc (struct cmd_t_test *cmd )
 }
 
 static int  
-group_calc (const struct ccase *c, struct cmd_t_test *cmd)
+group_calc (const struct dictionary *dict, 
+	    const struct ccase *c, struct cmd_t_test *cmd, 
+	    const struct casefilter *filter)
 {
   int i;
 
-  const union value *gv = case_data (c, indep_var->fv);
+  const double weight = 
+    dict_get_case_weight (dict, c, &bad_weight_warn);
 
-  const double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn);
+  const union value *gv;
 
-  if ( value_is_missing(&indep_var->miss, gv) )
-    {
-      return 0;
-    }
-
-  if ( cmd->miss == TTS_LISTWISE ) 
-    {
-      for(i=0; i< cmd->n_variables ; ++i) 
-	{
-	  struct variable *v = cmd->v_variables[i];
-	  const union value *val = case_data (c, v->fv);
-
-	  if (value_is_missing(&v->miss, val) )
-	    {
-	      return 0;
-	    }
-	}
-    }
+  if ( casefilter_variable_missing (filter, c, indep_var))
+    return 0;
 
-  gv = case_data (c, indep_var->fv);
+  gv = case_data (c, indep_var);
 
   for(i=0; i< cmd->n_variables ; ++i) 
     {
       struct variable *var = cmd->v_variables[i];
-      const union value *val = case_data (c, var->fv);
+      const union value *val = case_data (c, var);
       struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
       struct group_statistics *gs;
 
@@ -1788,11 +1725,11 @@ group_calc (const struct ccase *c, struct cmd_t_test *cmd)
       if ( ! gs ) 
       	return 0;
 
-      if ( !value_is_missing(&var->miss, val) )
+      if ( ! casefilter_variable_missing (filter, c, var) )
 	{
-	  gs->n+=weight;
-	  gs->sum+=weight * val->f;
-	  gs->ssq+=weight * pow2(val->f);
+	  gs->n += weight;
+	  gs->sum += weight * val->f;
+	  gs->ssq += weight * pow2(val->f);
 	}
     }
 
@@ -1805,7 +1742,7 @@ group_postcalc ( struct cmd_t_test *cmd )
 {
   int i;
 
-  for(i=0; i< cmd->n_variables ; ++i) 
+  for (i = 0; i < cmd->n_variables ; ++i) 
     {
       struct variable *var = cmd->v_variables[i];
       struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
@@ -1838,8 +1775,10 @@ group_postcalc ( struct cmd_t_test *cmd )
 
 
 static bool
-calculate(const struct ccase *first, const struct casefile *cf, void *cmd_)
+calculate(const struct ccase *first, const struct casefile *cf, 
+	  void *cmd_, const struct dataset *ds)
 {
+  const struct dictionary *dict = dataset_dict (ds);
   struct ssbox stat_summary_box;
   struct trbox test_results_box;
 
@@ -1848,61 +1787,69 @@ calculate(const struct ccase *first, const struct casefile *cf, void *cmd_)
 
   struct cmd_t_test *cmd = (struct cmd_t_test *) cmd_;
 
-  output_split_file_values (first);
-  common_precalc(cmd);
-  for(r = casefile_get_reader (cf);
+  struct casefilter *filter = casefilter_create (cmd->miss != TTS_INCLUDE, 
+						 NULL, 0);
+
+  if ( cmd->miss == TTS_LISTWISE ) 
+    casefilter_add_variables (filter,
+			      cmd->v_variables, cmd->n_variables);
+				
+  output_split_file_values (ds, first);
+  common_precalc (cmd);
+  for(r = casefile_get_reader (cf, filter);
       casereader_read (r, &c) ;
       case_destroy (&c)) 
     {
-      common_calc(&c,cmd);
+      common_calc (dict, &c, cmd, filter);
     }
+
   casereader_destroy (r);
-  common_postcalc(cmd);
+  common_postcalc (cmd);
 
   switch(mode)
     {
     case T_1_SAMPLE:
-      one_sample_precalc(cmd);
-      for(r = casefile_get_reader (cf);
+      one_sample_precalc (cmd);
+      for(r = casefile_get_reader (cf, filter);
 	  casereader_read (r, &c) ;
           case_destroy (&c)) 
 	{
-	  one_sample_calc(&c,cmd);
+	  one_sample_calc (dict, &c, cmd, filter);
 	}
       casereader_destroy (r);
-      one_sample_postcalc(cmd);
-
+      one_sample_postcalc (cmd);
       break;
     case T_PAIRED:
       paired_precalc(cmd);
-      for(r = casefile_get_reader (cf);
+      for(r = casefile_get_reader (cf, filter);
 	  casereader_read (r, &c) ;
           case_destroy (&c)) 
 	{
-	  paired_calc(&c,cmd);
+	  paired_calc (dict, &c, cmd, filter);
 	}
       casereader_destroy (r);
-      paired_postcalc(cmd);
+      paired_postcalc (cmd);
 
       break;
     case T_IND_SAMPLES:
 
       group_precalc(cmd);
-      for(r = casefile_get_reader (cf);
+      for(r = casefile_get_reader (cf, filter);
 	  casereader_read (r, &c) ;
           case_destroy (&c)) 
 	{
-	  group_calc(&c,cmd);
+	  group_calc (dict, &c, cmd, filter);
 	}
       casereader_destroy (r);
       group_postcalc(cmd);
 
-      levene(cf, indep_var, cmd->n_variables, cmd->v_variables,
-	     (cmd->miss == TTS_LISTWISE)?LEV_LISTWISE:LEV_ANALYSIS ,
-	     value_is_missing);
+      levene (dict, cf, indep_var, cmd->n_variables, cmd->v_variables,
+	      filter);
       break;
     }
 
+  casefilter_destroy (filter);
+
   ssbox_create(&stat_summary_box,cmd,mode);
   ssbox_populate(&stat_summary_box,cmd);
   ssbox_finalize(&stat_summary_box);