#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>
/* (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;
static struct pair *pairs=0;
-static int parse_value (union value * v, int type) ;
+static int parse_value (struct lexer *lexer, union value * v, int type) ;
/* Structures and Functions for the Statistics Summary Box */
struct ssbox;
static int common_calc (const struct dictionary *dict,
- const struct ccase *, void *);
+ 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 dictionary *dict, 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 dictionary *dict, 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 dictionary *dict, 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 *);
int
-cmd_t_test (struct dataset *ds)
+cmd_t_test (struct lexer *lexer, struct dataset *ds)
{
bool ok;
- if ( !parse_t_test (ds, &cmd, NULL) )
+ if ( !parse_t_test (lexer, ds, &cmd, NULL) )
return CMD_FAILURE;
if (! cmd.sbc_criteria)
return CMD_FAILURE;
}
-
- /* 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 = true;
ok = multipass_procedure_with_splits (ds, calculate, &cmd);
}
static int
-tts_custom_groups (struct dataset *ds, 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 (dataset_dict (ds));
+ 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;
}
return 0;
}
- if (!lex_match ('('))
+ if (!lex_match (lexer, '('))
{
if (indep_var->type == NUMERIC)
{
}
}
- if (!parse_value (&gp.v.g_value[0], indep_var->type))
+ if (!parse_value (lexer, &gp.v.g_value[0], indep_var->type))
return 0;
- lex_match (',');
- if (lex_match (')'))
+ lex_match (lexer, ',');
+ if (lex_match (lexer, ')'))
{
if (indep_var->type != NUMERIC)
{
return 1;
}
- if (!parse_value (&gp.v.g_value[1], indep_var->type))
+ if (!parse_value (lexer, &gp.v.g_value[1], indep_var->type))
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 dataset *ds, 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;
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 (dataset_dict (ds), &vars, &n_vars,
+ if (!parse_variables (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 (dataset_dict (ds), &vars, &n_vars,
+ if (!parse_variables (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)
/* 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, int type )
{
if (type == 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;
}
/* Per case calculations common to all variants of the T test */
static int
-common_calc (const struct dictionary *dict, 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 (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->fv);
+ 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 dictionary *dict,
- const struct ccase *c, void *cmd_)
+ 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 (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)
{
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->sum_diff += weight * (val->f - cmd->n_testval[0]);
}
static int
-paired_calc (const struct dictionary *dict, 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 (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;
- }
- }
- }
-
for(i=0; i < n_pairs ; ++i )
{
struct variable *v0 = pairs[i].v[0];
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) ) )
- {
- 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;
static int
group_calc (const struct dictionary *dict,
- const struct ccase *c, struct cmd_t_test *cmd)
+ 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);
- 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);
+ const union value *gv;
- 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);
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];
struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
struct cmd_t_test *cmd = (struct cmd_t_test *) cmd_;
+ 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);
+ common_precalc (cmd);
+ for(r = casefile_get_reader (cf, filter);
casereader_read (r, &c) ;
case_destroy (&c))
{
- common_calc(dict, &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 (dict, &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 (dict, &c,cmd);
+ paired_calc (dict, &c, cmd, filter);
}
casereader_destroy (r);
paired_postcalc (cmd);
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 (dict, &c, cmd);
+ group_calc (dict, &c, cmd, filter);
}
casereader_destroy (r);
group_postcalc(cmd);
levene (dict, cf, indep_var, cmd->n_variables, cmd->v_variables,
- (cmd->miss == TTS_LISTWISE)?LEV_LISTWISE:LEV_ANALYSIS ,
- value_is_missing);
+ filter);
break;
}
+ casefilter_destroy (filter);
+
ssbox_create(&stat_summary_box,cmd,mode);
ssbox_populate(&stat_summary_box,cmd);
ssbox_finalize(&stat_summary_box);
projects / pspp-builds.git / blobdiff