/* PSPP - computes sample statistics. -*-c-*-
Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
- Written by John Williams <johnr.williams@stonebow.otago.ac.nz>.
- Almost completly re-written by John Darrington 2004
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
#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>
#include <libpspp/alloc.h>
+#include <libpspp/assertion.h>
#include <libpspp/compiler.h>
#include <libpspp/hash.h>
#include <libpspp/magic.h>
"T-TEST" (tts_):
+groups=custom;
testval=double;
- variables=varlist("PV_NO_SCRATCH | PV_NUMERIC");
- pairs=custom;
- +missing=miss:!analysis/listwise,
- incl:include/!exclude;
- format=fmt:!labels/nolabels;
+ +variables=varlist("PV_NO_SCRATCH | PV_NUMERIC");
+ +pairs=custom;
+ missing=miss:!analysis/listwise,
+ incl:include/!exclude;
+ +format=fmt:!labels/nolabels;
criteria=:cin(d:criteria,"%s > 0. && %s < 1.").
*/
/* (declarations) */
/* (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;
struct pair
{
/* The variables comprising the pair */
- struct variable *v[2];
+ const struct variable *v[2];
/* The number of valid variable pairs */
double n;
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;
};
-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 casefile *cf, void *_mode);
+static bool calculate(const struct ccase *first,
+ 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,
int
-cmd_t_test(void)
+cmd_t_test (struct lexer *lexer, struct dataset *ds)
{
bool ok;
- if ( !parse_t_test(&cmd) )
+ if ( !parse_t_test (lexer, ds, &cmd, NULL) )
return CMD_FAILURE;
if (! cmd.sbc_criteria)
int i;
struct hsh_iterator hi;
- struct hsh_table *hash;
- struct variable *v;
+ struct const_hsh_table *hash;
+ const struct variable *v;
- hash = hsh_create (n_pairs, compare_var_names, hash_var_name, 0, 0);
+ hash = const_hsh_create (n_pairs, compare_vars_by_name, hash_var_by_name,
+ 0, 0);
for (i=0; i < n_pairs; ++i)
{
- hsh_insert(hash,pairs[i].v[0]);
- hsh_insert(hash,pairs[i].v[1]);
+ const_hsh_insert (hash, pairs[i].v[0]);
+ const_hsh_insert (hash, pairs[i].v[1]);
}
assert(cmd.n_variables == 0);
- cmd.n_variables = hsh_count(hash);
+ cmd.n_variables = const_hsh_count (hash);
cmd.v_variables = xnrealloc (cmd.v_variables, cmd.n_variables,
sizeof *cmd.v_variables);
/* Iterate through the hash */
- for (i=0,v = (struct variable *) hsh_first(hash,&hi);
+ for (i=0,v = const_hsh_first (hash, &hi);
v != 0;
- v=hsh_next(hash,&hi) )
+ v = const_hsh_next (hash, &hi) )
cmd.v_variables[i++]=v;
-
- hsh_destroy(hash);
+ const_hsh_destroy(hash);
}
}
else if ( !cmd.sbc_variables)
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);
}
static int
-tts_custom_groups (struct cmd_t_test *cmd 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;
}
}
- 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;
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 )
static int
-tts_custom_pairs (struct cmd_t_test *cmd UNUSED)
+tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
{
- struct variable **vars;
+ const struct variable **vars;
size_t n_vars;
size_t n_pairs_local;
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_const (lexer, dataset_dict (ds), &vars, &n_vars,
PV_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH))
{
free (vars);
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_const (lexer, dataset_dict (ds), &vars, &n_vars,
PV_DUPLICATE | PV_APPEND
| PV_NUMERIC | PV_NO_SCRATCH))
{
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)
msg (SE, _("PAIRED was specified but the number of variables "
"preceding WITH (%d) did not match the number "
"following (%d)."),
- n_before_WITH, n_after_WITH );
+ (int) n_before_WITH, (int) n_after_WITH );
return 0;
}
n_pairs_local = n_before_WITH;
/* 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_c_str (&tokstr), ds_length (&tokstr));
+ strncpy (v->s, ds_cstr (lex_tokstr (lexer)), ds_length (lex_tokstr (lexer)));
}
- lex_get ();
+ lex_get (lexer);
return 1;
}
ssbox_paired_init(ssb,cmd);
break;
default:
- assert(0);
+ NOT_REACHED ();
}
}
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"));
{
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
{
for (i=0; i < cmd->n_variables; ++i)
{
- struct variable *var = cmd->v_variables[i];
+ const struct variable *var = cmd->v_variables[i];
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,
/* 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);
{
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);
trbox_paired_init(trb,cmd);
break;
default:
- assert(0);
+ NOT_REACHED ();
}
}
double std_err_diff;
double mean_diff;
- struct variable *var = cmd->v_variables[i];
+ const struct variable *var = cmd->v_variables[i];
struct group_proc *grp_data = group_proc_get (var);
struct hsh_table *grp_hash = grp_data->group_hash;
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"));
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);
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 ;
_("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 */
/* 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;
+ const struct variable *v = cmd->v_variables[i];
- 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;
/* 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;
/* 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_;
+ double weight = dict_get_case_weight (dict, c, &bad_weight_warn);
- double weight = dict_get_case_weight(default_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 struct variable *v = cmd->v_variables[i];
+ 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]);
}
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 struct variable *v0 = pairs[i].v[0];
+ const 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;
/* 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,
}
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 struct variable *var = cmd->v_variables[i];
+ const union value *val = case_data (c, var);
struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
struct group_statistics *gs;
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);
}
}
{
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];
+ const struct variable *var = cmd->v_variables[i];
struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
struct hsh_iterator g;
struct group_statistics *gs;
static bool
-calculate(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;
struct cmd_t_test *cmd = (struct cmd_t_test *) cmd_;
- common_precalc(cmd);
- for(r = casefile_get_reader (cf);
+ struct casefilter *filter = casefilter_create ((cmd->miss != TTS_INCLUDE
+ ? MV_ANY : MV_SYSTEM),
+ 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);
flag = which_group(g,p);
}
else
- assert(0);
+ NOT_REACHED ();
return flag;
}