X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Ft-test.q;h=c0e90705c3e1fae05af88fcfab7244226697f246;hb=a9acce47d67e0ab35ce1690e4f1b1ac0121c2d78;hp=5584df7d6031cf0eb3367f65f752001402ecb2cb;hpb=18f6e8958244f938e9e9a03a4230cacf0d22a470;p=pspp-builds.git diff --git a/src/language/stats/t-test.q b/src/language/stats/t-test.q index 5584df7d..c0e90705 100644 --- a/src/language/stats/t-test.q +++ b/src/language/stats/t-test.q @@ -1,33 +1,30 @@ -/* PSPP - computes sample statistics. -*-c-*- - +/* PSPP - a program for statistical analysis. Copyright (C) 1997-9, 2000 Free Software Foundation, Inc. - Written by John Williams . - 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 - 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 . */ #include #include #include +#include #include #include #include -#include +#include +#include #include #include #include @@ -35,20 +32,19 @@ #include #include #include -#include +#include #include #include -#include -#include #include #include #include +#include #include #include #include #include -#include "size_max.h" +#include "xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -59,22 +55,17 @@ "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; @@ -90,13 +81,13 @@ struct group_properties enum comparison criterion; /* The width of the independent variable */ - int indep_width ; + int indep_width ; union { - /* The value of the independent variable at which groups are determined to + /* The value of the independent variable at which groups are determined to belong to one group or the other */ double critical_value; - + /* The values of the independent variable for each group */ union value g_value[2]; @@ -111,10 +102,10 @@ static struct group_properties gp ; /* PAIRS: Number of pairs to be compared ; each pair. */ static int n_pairs = 0 ; -struct pair +struct pair { /* The variables comprising the pair */ - struct variable *v[2]; + const struct variable *v[2]; /* The number of valid variable pairs */ double n; @@ -156,7 +147,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 val_type); /* Structures and Functions for the Statistics Summary Box */ struct ssbox; @@ -182,7 +173,7 @@ void ssbox_populate(struct ssbox *ssb, struct cmd_t_test *cmd); /* Submit and destroy a ssbox */ void ssbox_finalize(struct ssbox *ssb); -/* A function to create, populate and submit the Paired Samples Correlation +/* A function to create, populate and submit the Paired Samples Correlation box */ void pscbox(void); @@ -212,54 +203,61 @@ void trbox_finalize(struct trbox *trb); /* Which mode was T-TEST invoked */ enum { T_1_SAMPLE = 0 , - T_IND_SAMPLES, + T_IND_SAMPLES, T_PAIRED }; -static int common_calc (const struct ccase *, void *); +static int common_calc (const struct dictionary *dict, + const struct ccase *, void *, + enum mv_class); 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 *, enum mv_class); 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*, enum mv_class); 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 *, enum mv_class); static void group_postcalc (struct cmd_t_test *); -static bool calculate(const struct ccase *first, - const struct casefile *cf, void *_mode); +static void calculate(struct cmd_t_test *, + struct casereader *, + const struct dataset *); 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, - const struct group_statistics *b, +static int compare_group_binary(const struct group_statistics *a, + const struct group_statistics *b, const struct group_properties *p); -static unsigned hash_group_binary(const struct group_statistics *g, +static unsigned hash_group_binary(const struct group_statistics *g, const struct group_properties *p); int -cmd_t_test(void) +cmd_t_test (struct lexer *lexer, struct dataset *ds) { + struct casegrouper *grouper; + struct casereader *group; bool ok; - - if ( !parse_t_test(&cmd, NULL) ) + + if ( !parse_t_test (lexer, ds, &cmd, NULL) ) return CMD_FAILURE; if (! cmd.sbc_criteria) @@ -273,7 +271,7 @@ cmd_t_test(void) if ( m != 1) { - msg(SE, + msg(SE, _("TESTVAL, GROUPS and PAIRS subcommands are mutually exclusive.") ); free_t_test(&cmd); @@ -281,16 +279,16 @@ cmd_t_test(void) } } - if (cmd.sbc_testval) + if (cmd.sbc_testval) mode=T_1_SAMPLE; else if (cmd.sbc_groups) mode=T_IND_SAMPLES; else mode=T_PAIRED; - if ( mode == T_PAIRED) + if ( mode == T_PAIRED) { - if (cmd.sbc_variables) + if (cmd.sbc_variables) { msg(SE, _("VARIABLES subcommand is not appropriate with PAIRS")); free_t_test(&cmd); @@ -298,103 +296,101 @@ cmd_t_test(void) } else { - /* Iterate through the pairs and put each variable that is a + /* Iterate through the pairs and put each variable that is a member of a pair into cmd.v_variables */ 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) + else if ( !cmd.sbc_variables) { msg(SE, _("One or more VARIABLES must be specified.")); free_t_test(&cmd); 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); + /* Data pass. */ + grouper = casegrouper_create_splits (proc_open (ds), dataset_dict (ds)); + while (casegrouper_get_next_group (grouper, &group)) + calculate (&cmd, group, ds); + ok = casegrouper_destroy (grouper); + ok = proc_commit (ds) && ok; n_pairs=0; free(pairs); pairs=0; - if ( mode == T_IND_SAMPLES) + if ( mode == T_IND_SAMPLES) { int v; /* Destroy any group statistics we created */ - for (v = 0 ; v < cmd.n_variables ; ++v ) + for (v = 0 ; v < cmd.n_variables ; ++v ) { struct group_proc *grpp = group_proc_get (cmd.v_variables[v]); hsh_destroy (grpp->group_hash); } } - + free_t_test(&cmd); return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE; } 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; gp.criterion = CMP_EQ; - + n_group_values = 2; return 1; @@ -407,15 +403,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; @@ -427,14 +422,14 @@ 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 ) + if ( n_group_values == 2 ) gp.criterion = CMP_EQ ; else gp.criterion = CMP_LE ; @@ -445,9 +440,9 @@ 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; + const struct variable **vars; size_t n_vars; size_t n_pairs_local; @@ -455,10 +450,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_const (lexer, dataset_dict (ds), &vars, &n_vars, PV_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH)) { free (vars); @@ -467,10 +462,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_const (lexer, dataset_dict (ds), &vars, &n_vars, PV_DUPLICATE | PV_APPEND | PV_NUMERIC | PV_NO_SCRATCH)) { @@ -480,7 +475,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) @@ -489,9 +484,9 @@ tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED) { free (vars); 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 ); + "preceding WITH (%zu) did not match the number " + "following (%zu)."), + n_before_WITH, n_after_WITH); return 0; } n_pairs_local = n_before_WITH; @@ -519,7 +514,7 @@ tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED) pairs = xnrealloc (pairs, n_pairs + n_pairs_local, sizeof *pairs); /* Populate the pairs with the appropriate variables */ - if ( paired ) + if ( paired ) { int i; @@ -535,7 +530,7 @@ tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED) int i,j; size_t p = n_pairs; - for(i=0 ; i < n_before_WITH ; ++i ) + for(i=0 ; i < n_before_WITH ; ++i ) { for(j=0 ; j < n_after_WITH ; ++j) { @@ -549,8 +544,8 @@ tts_custom_pairs (struct cmd_t_test *cmd UNUSED, void *aux UNUSED) { size_t i,j; size_t p=n_pairs; - - for(i=0 ; i < n_vars ; ++i ) + + for(i=0 ; i < n_vars ; ++i ) { for(j=i+1 ; j < n_vars ; ++j) { @@ -570,22 +565,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 val_type type) { - if (type == NUMERIC) + if (type == VAL_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; } @@ -597,7 +592,7 @@ void ssbox_base_init(struct ssbox *this, int cols,int rows); void ssbox_base_finalize(struct ssbox *ssb); -void ssbox_one_sample_init(struct ssbox *this, +void ssbox_one_sample_init(struct ssbox *this, struct cmd_t_test *cmd ); void ssbox_independent_samples_init(struct ssbox *this, @@ -608,10 +603,10 @@ void ssbox_paired_init(struct ssbox *this, /* Factory to create an ssbox */ -void +void ssbox_create(struct ssbox *ssb, struct cmd_t_test *cmd, int mode) { - switch (mode) + switch (mode) { case T_1_SAMPLE: ssbox_one_sample_init(ssb,cmd); @@ -623,7 +618,7 @@ ssbox_create(struct ssbox *ssb, struct cmd_t_test *cmd, int mode) ssbox_paired_init(ssb,cmd); break; default: - assert(0); + NOT_REACHED (); } } @@ -646,7 +641,7 @@ ssbox_finalize(struct ssbox *ssb) /* Submit the box and clear up */ -void +void ssbox_base_finalize(struct ssbox *ssb) { tab_submit(ssb->t); @@ -655,14 +650,14 @@ ssbox_base_finalize(struct ssbox *ssb) /* Initialize a ssbox struct */ -void +void ssbox_base_init(struct ssbox *this, int cols,int rows) { this->finalize = ssbox_base_finalize; this->t = tab_create (cols, rows, 0); tab_columns (this->t, SOM_COL_DOWN, 1); - tab_headers (this->t,0,0,1,0); + tab_headers (this->t,0,0,1,0); tab_box (this->t, TAL_2, TAL_2, TAL_0, TAL_1, 0, 0, cols -1, rows -1 ); tab_hline(this->t, TAL_2,0,cols-1,1); tab_dim (this->t, tab_natural_dimensions); @@ -672,8 +667,8 @@ void ssbox_one_sample_populate(struct ssbox *ssb, struct cmd_t_test *cmd); /* Initialize the one_sample ssbox */ -void -ssbox_one_sample_init(struct ssbox *this, +void +ssbox_one_sample_init(struct ssbox *this, struct cmd_t_test *cmd ) { const int hsize=5; @@ -694,8 +689,8 @@ void ssbox_independent_samples_populate(struct ssbox *ssb, struct cmd_t_test *cmd); /* Initialize the independent samples ssbox */ -void -ssbox_independent_samples_init(struct ssbox *this, +void +ssbox_independent_samples_init(struct ssbox *this, struct cmd_t_test *cmd) { int hsize=6; @@ -706,7 +701,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")); @@ -715,22 +710,22 @@ ssbox_independent_samples_init(struct ssbox *this, /* Populate the ssbox for independent samples */ -void +void ssbox_independent_samples_populate(struct ssbox *ssb, struct cmd_t_test *cmd) { 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 { @@ -738,10 +733,10 @@ ssbox_independent_samples_populate(struct ssbox *ssb, val_lab1 = gp.v.g_value[1].s; } - if (gp.criterion == CMP_LE ) + if (gp.criterion == CMP_LE ) { - strcpy(prefix[0],"< "); - strcpy(prefix[1],">="); + strcpy(prefix[0],">="); + strcpy(prefix[1],"<"); indep_value[0] = gp.v.critical_value; indep_value[1] = gp.v.critical_value; } @@ -755,46 +750,47 @@ ssbox_independent_samples_populate(struct ssbox *ssb, 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, + tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF, "%s%s", prefix[0], val_lab0); else - tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF, + tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF, "%s%g", prefix[0], indep_value[0]); if (val_lab1) - tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF, + tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF, "%s%s", prefix[1], val_lab1); else - tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF, + tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF, "%s%g", prefix[1], indep_value[1]); /* Fill in the group statistics */ - for ( count = 0 ; count < 2 ; ++count ) + for ( count = 0 ; count < 2 ; ++count ) { union value search_val; struct group_statistics *gs; - if ( gp.criterion == CMP_LE ) + if ( gp.criterion == CMP_LE ) { - if ( count == 0 ) + if ( count == 0 ) { - /* less than ( < ) case */ - search_val.f = gp.v.critical_value - 1.0; + /* >= case */ + search_val.f = gp.v.critical_value + 1.0; } else { - /* >= case */ - search_val.f = gp.v.critical_value + 1.0; + /* less than ( < ) case */ + search_val.f = gp.v.critical_value - 1.0; } } else @@ -805,7 +801,7 @@ ssbox_independent_samples_populate(struct ssbox *ssb, gs = hsh_find(grp_hash, (void *) &search_val); assert(gs); - tab_float(ssb->t, 2 ,i*2+count+1, TAB_RIGHT, gs->n, 2, 0); + tab_float(ssb->t, 2 ,i*2+count+1, TAB_RIGHT, gs->n, 10, 0); tab_float(ssb->t, 3 ,i*2+count+1, TAB_RIGHT, gs->mean, 8, 2); tab_float(ssb->t, 4 ,i*2+count+1, TAB_RIGHT, gs->std_dev, 8, 3); tab_float(ssb->t, 5 ,i*2+count+1, TAB_RIGHT, gs->se_mean, 8, 3); @@ -818,7 +814,7 @@ void ssbox_paired_populate(struct ssbox *ssb, struct cmd_t_test *cmd); /* Initialize the paired values ssbox */ -void +void ssbox_paired_init(struct ssbox *this, struct cmd_t_test *cmd UNUSED) { int hsize=6; @@ -839,7 +835,7 @@ ssbox_paired_init(struct ssbox *this, struct cmd_t_test *cmd UNUSED) /* Populate the ssbox for paired values */ -void +void ssbox_paired_populate(struct ssbox *ssb,struct cmd_t_test *cmd UNUSED) { int i; @@ -852,7 +848,7 @@ ssbox_paired_populate(struct ssbox *ssb,struct cmd_t_test *cmd UNUSED) tab_text (ssb->t, 0, i*2+1, TAB_LEFT | TAT_PRINTF , _("Pair %d"),i); - for (j=0 ; j < 2 ; ++j) + for (j=0 ; j < 2 ; ++j) { struct group_statistics *gs; @@ -860,11 +856,12 @@ 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); - tab_float (ssb->t,3, i*2+j+1, TAB_RIGHT, pairs[i].n, 2, 0); + tab_float (ssb->t,3, i*2+j+1, TAB_RIGHT, pairs[i].n, 10, 0); tab_float (ssb->t,4, i*2+j+1, TAB_RIGHT, pairs[i].std_dev[j], 8, 3); tab_float (ssb->t,5, i*2+j+1, TAB_RIGHT, pairs[i].std_dev[j]/sqrt(pairs[i].n), 8, 3); @@ -873,7 +870,7 @@ ssbox_paired_populate(struct ssbox *ssb,struct cmd_t_test *cmd UNUSED) } /* Populate the one sample ssbox */ -void +void ssbox_one_sample_populate(struct ssbox *ssb, struct cmd_t_test *cmd) { int i; @@ -884,13 +881,13 @@ 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_float (ssb->t,1, i+1, TAB_RIGHT, gs->n, 2, 0); + 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, 10, 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); tab_float (ssb->t,4, i+1, TAB_RIGHT, gs->se_mean, 8, 3); } - + } @@ -921,11 +918,11 @@ void trbox_paired_populate(struct trbox *trb, /* Create a trbox according to mode*/ -void -trbox_create(struct trbox *trb, +void +trbox_create(struct trbox *trb, struct cmd_t_test *cmd, int mode) { - switch (mode) + switch (mode) { case T_1_SAMPLE: trbox_one_sample_init(trb,cmd); @@ -937,26 +934,26 @@ trbox_create(struct trbox *trb, trbox_paired_init(trb,cmd); break; default: - assert(0); + NOT_REACHED (); } } /* Populate a trbox according to cmd */ -void +void trbox_populate(struct trbox *trb, struct cmd_t_test *cmd) { trb->populate(trb,cmd); } /* Submit and destroy a trbox */ -void +void trbox_finalize(struct trbox *trb) { trb->finalize(trb); } /* Initialize the independent samples trbox */ -void +void trbox_independent_samples_init(struct trbox *self, struct cmd_t_test *cmd UNUSED) { @@ -974,7 +971,7 @@ trbox_independent_samples_init(struct trbox *self, tab_box(self->t,-1,-1,-1,TAL_1, 2,1,hsize-2,vsize-1); tab_hline(self->t,TAL_1, hsize-2,hsize-1,2); tab_box(self->t,-1,-1,-1,TAL_1, hsize-2,2,hsize-1,vsize-1); - tab_joint_text(self->t, 2, 0, 3, 0, + tab_joint_text(self->t, 2, 0, 3, 0, TAB_CENTER,_("Levene's Test for Equality of Variances")); tab_joint_text(self->t, 4,0,hsize-1,0, TAB_CENTER,_("t-test for Equality of Means")); @@ -989,14 +986,14 @@ trbox_independent_samples_init(struct trbox *self, tab_text(self->t,9,2, TAB_CENTER | TAT_TITLE,_("Lower")); tab_text(self->t,10,2, TAB_CENTER | TAT_TITLE,_("Upper")); - tab_joint_text(self->t, 9, 1, 10, 1, TAB_CENTER | TAT_PRINTF, + tab_joint_text(self->t, 9, 1, 10, 1, TAB_CENTER | TAT_PRINTF, _("%g%% Confidence Interval of the Difference"), cmd->criteria*100.0); } /* Populate the independent samples trbox */ -void +void trbox_independent_samples_populate(struct trbox *self, struct cmd_t_test *cmd ) { @@ -1016,17 +1013,17 @@ trbox_independent_samples_populate(struct trbox *self, 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; struct group_statistics *gs0 ; struct group_statistics *gs1 ; - + union value search_val; - - if ( gp.criterion == CMP_LE ) + + if ( gp.criterion == CMP_LE ) search_val.f = gp.v.critical_value - 1.0; else search_val = gp.v.g_value[0]; @@ -1034,7 +1031,7 @@ trbox_independent_samples_populate(struct trbox *self, gs0 = hsh_find(grp_hash, (void *) &search_val); assert(gs0); - if ( gp.criterion == CMP_LE ) + if ( gp.criterion == CMP_LE ) search_val.f = gp.v.critical_value + 1.0; else search_val = gp.v.g_value[1]; @@ -1042,8 +1039,8 @@ trbox_independent_samples_populate(struct trbox *self, gs1 = hsh_find(grp_hash, (void *) &search_val); 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")); @@ -1057,15 +1054,15 @@ trbox_independent_samples_populate(struct trbox *self, tab_float(self->t, 3, i*2+3, TAB_CENTER, q, 8,3 ); df = gs0->n + gs1->n - 2.0 ; - tab_float (self->t, 5, i*2+3, TAB_RIGHT, df, 2, 0); + tab_float (self->t, 5, i*2+3, TAB_RIGHT, df, 10, 0); pooled_variance = ( (gs0->n )*pow2(gs0->s_std_dev) - + - (gs1->n )*pow2(gs1->s_std_dev) + + + (gs1->n )*pow2(gs1->s_std_dev) ) / df ; t = (gs0->mean - gs1->mean) / sqrt(pooled_variance) ; - t /= sqrt((gs0->n + gs1->n)/(gs0->n*gs1->n)); + t /= sqrt((gs0->n + gs1->n)/(gs0->n*gs1->n)); tab_float (self->t, 4, i*2+3, TAB_RIGHT, t, 8, 3); @@ -1086,17 +1083,17 @@ trbox_independent_samples_populate(struct trbox *self, q = (1 - cmd->criteria)/2.0; /* 2-tailed test */ t = gsl_cdf_tdist_Qinv(q,df); - tab_float(self->t, 9, i*2+3, TAB_RIGHT, - mean_diff - t * std_err_diff, 8, 3); + tab_float(self->t, 9, i*2+3, TAB_RIGHT, + mean_diff - t * std_err_diff, 8, 3); - tab_float(self->t, 10, i*2+3, TAB_RIGHT, - mean_diff + t * std_err_diff, 8, 3); + tab_float(self->t, 10, i*2+3, TAB_RIGHT, + mean_diff + t * std_err_diff, 8, 3); { double se2; /* Now for the \sigma_1 != \sigma_2 case */ - tab_text (self->t, 1, i*2+3+1, + tab_text (self->t, 1, i*2+3+1, TAB_LEFT, _("Equal variances not assumed")); @@ -1105,12 +1102,12 @@ trbox_independent_samples_populate(struct trbox *self, t = mean_diff / sqrt(se2) ; tab_float (self->t, 4, i*2+3+1, TAB_RIGHT, t, 8, 3); - - df = pow2(se2) / ( - (pow2(pow2(gs0->s_std_dev)/(gs0->n - 1 )) + + df = pow2(se2) / ( + (pow2(pow2(gs0->s_std_dev)/(gs0->n - 1 )) /(gs0->n -1 ) ) - + + + (pow2(pow2(gs1->s_std_dev)/(gs1->n - 1 )) /(gs1->n -1 ) ) @@ -1133,18 +1130,18 @@ trbox_independent_samples_populate(struct trbox *self, tab_float(self->t, 8, i*2+3+1, TAB_RIGHT, std_err_diff, 8, 3); - tab_float(self->t, 9, i*2+3+1, TAB_RIGHT, - mean_diff - t * std_err_diff, 8, 3); + tab_float(self->t, 9, i*2+3+1, TAB_RIGHT, + mean_diff - t * std_err_diff, 8, 3); - tab_float(self->t, 10, i*2+3+1, TAB_RIGHT, - mean_diff + t * std_err_diff, 8, 3); + tab_float(self->t, 10, i*2+3+1, TAB_RIGHT, + mean_diff + t * std_err_diff, 8, 3); } } } /* Initialize the paired samples trbox */ -void +void trbox_paired_init(struct trbox *self, struct cmd_t_test *cmd UNUSED) { @@ -1164,7 +1161,7 @@ trbox_paired_init(struct trbox *self, tab_hline(self->t,TAL_1,5,6, 2); tab_vline(self->t,TAL_GAP,6,0,1); - tab_joint_text(self->t, 5, 1, 6, 1, TAB_CENTER | TAT_PRINTF, + tab_joint_text(self->t, 5, 1, 6, 1, TAB_CENTER | TAT_PRINTF, _("%g%% Confidence Interval of the Difference"), cmd->criteria*100.0); @@ -1179,7 +1176,7 @@ trbox_paired_init(struct trbox *self, } /* Populate the paired samples trbox */ -void +void trbox_paired_populate(struct trbox *trb, struct cmd_t_test *cmd UNUSED) { @@ -1193,11 +1190,12 @@ trbox_paired_populate(struct trbox *trb, double n = pairs[i].n; double t; double df = n - 1; - - tab_text (trb->t, 0, i+3, TAB_LEFT | TAT_PRINTF, _("Pair %d"),i); + + 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); @@ -1212,16 +1210,16 @@ trbox_paired_populate(struct trbox *trb, t = gsl_cdf_tdist_Qinv(q, df); - tab_float(trb->t, 5, i+3, TAB_RIGHT, - pairs[i].mean_diff - t * se_mean , 8, 4); + tab_float(trb->t, 5, i+3, TAB_RIGHT, + pairs[i].mean_diff - t * se_mean , 8, 4); - tab_float(trb->t, 6, i+3, TAB_RIGHT, - pairs[i].mean_diff + t * se_mean , 8, 4); + tab_float(trb->t, 6, i+3, TAB_RIGHT, + pairs[i].mean_diff + t * se_mean , 8, 4); t = (pairs[i].mean[0] - pairs[i].mean[1]) / sqrt ( ( pow2 (pairs[i].s_std_dev[0]) + pow2 (pairs[i].s_std_dev[1]) - - 2 * pairs[i].correlation * + 2 * pairs[i].correlation * pairs[i].s_std_dev[0] * pairs[i].s_std_dev[1] ) / (n - 1) ); @@ -1229,7 +1227,7 @@ trbox_paired_populate(struct trbox *trb, tab_float(trb->t, 7, i+3, TAB_RIGHT, t , 8,3 ); /* Degrees of freedom */ - tab_float(trb->t, 8, i+3, TAB_RIGHT, df , 2, 0 ); + tab_float(trb->t, 8, i+3, TAB_RIGHT, df , 10, 0 ); p = gsl_cdf_tdist_P(t,df); q = gsl_cdf_tdist_P(t,df); @@ -1240,7 +1238,7 @@ trbox_paired_populate(struct trbox *trb, } /* Initialize the one sample trbox */ -void +void trbox_one_sample_init(struct trbox *self, struct cmd_t_test *cmd ) { const int hsize=7; @@ -1253,13 +1251,13 @@ trbox_one_sample_init(struct trbox *self, struct cmd_t_test *cmd ) tab_hline(self->t, TAL_1, 1, hsize - 1, 1); tab_vline(self->t, TAL_2, 1, 0, vsize - 1); - tab_joint_text(self->t, 1, 0, hsize-1,0, TAB_CENTER | TAT_PRINTF, + tab_joint_text(self->t, 1, 0, hsize-1,0, TAB_CENTER | TAT_PRINTF, _("Test Value = %f"), cmd->n_testval[0]); tab_box(self->t, -1, -1, -1, TAL_1, 1,1,hsize-1,vsize-1); - tab_joint_text(self->t,5,1,6,1,TAB_CENTER | TAT_PRINTF, + tab_joint_text(self->t,5,1,6,1,TAB_CENTER | TAT_PRINTF, _("%g%% Confidence Interval of the Difference"), cmd->criteria*100.0); @@ -1276,7 +1274,7 @@ trbox_one_sample_init(struct trbox *self, struct cmd_t_test *cmd ) /* Populate the one sample trbox */ -void +void trbox_one_sample_populate(struct trbox *trb, struct cmd_t_test *cmd) { int i; @@ -1291,7 +1289,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 ; @@ -1305,7 +1303,7 @@ trbox_one_sample_populate(struct trbox *trb, struct cmd_t_test *cmd) p = gsl_cdf_tdist_P(t, df); q = gsl_cdf_tdist_Q(t, df); - /* Multiply by 2 to get 2-tailed significance, makeing sure we've got + /* Multiply by 2 to get 2-tailed significance, makeing sure we've got the correct tail*/ tab_float (trb->t, 3, i+3, TAB_RIGHT, 2.0*(t>0?q:p), 8,3); @@ -1324,14 +1322,14 @@ trbox_one_sample_populate(struct trbox *trb, struct cmd_t_test *cmd) } /* Base initializer for the generalized trbox */ -void +void trbox_base_init(struct trbox *self, size_t data_rows, int cols) { const size_t rows = 3 + data_rows; self->finalize = trbox_base_finalize; self->t = tab_create (cols, rows, 0); - tab_headers (self->t,0,0,3,0); + tab_headers (self->t,0,0,3,0); tab_box (self->t, TAL_2, TAL_2, TAL_0, TAL_0, 0, 0, cols -1, rows -1); tab_hline(self->t, TAL_2,0,cols-1,3); tab_dim (self->t, tab_natural_dimensions); @@ -1339,7 +1337,7 @@ trbox_base_init(struct trbox *self, size_t data_rows, int cols) /* Base finalizer for the trbox */ -void +void trbox_base_finalize(struct trbox *trb) { tab_submit(trb->t); @@ -1353,13 +1351,13 @@ pscbox(void) const int rows=1+n_pairs; const int cols=5; int i; - + struct tab_table *table; - + table = tab_create (cols,rows,0); tab_columns (table, SOM_COL_DOWN, 1); - tab_headers (table,0,0,1,0); + tab_headers (table,0,0,1,0); tab_box (table, TAL_2, TAL_2, TAL_0, TAL_1, 0, 0, cols -1, rows -1 ); tab_hline(table, TAL_2, 0, cols - 1, 1); tab_vline(table, TAL_2, 2, 0, rows - 1); @@ -1377,17 +1375,19 @@ pscbox(void) double df = pairs[i].n -2; - double correlation_t = + double correlation_t = pairs[i].correlation * sqrt(df) / sqrt(1 - pow2(pairs[i].correlation)); /* row headings */ - tab_text(table, 0,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF, + tab_text(table, 0,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF, _("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); + + tab_text(table, 1,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF, + _("%s & %s"), + var_get_name (pairs[i].v[0]), + var_get_name (pairs[i].v[1])); /* row data */ @@ -1409,70 +1409,54 @@ pscbox(void) /* Calculation Implementation */ /* Per case calculations common to all variants of the T test */ -static int -common_calc (const struct ccase *c, void *_cmd) +static int +common_calc (const struct dictionary *dict, + const struct ccase *c, + void *_cmd, + enum mv_class exclude) { int i; - struct cmd_t_test *cmd = (struct cmd_t_test *)_cmd; - - double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn); + struct cmd_t_test *cmd = (struct cmd_t_test *)_cmd; + double weight = dict_get_case_weight (dict, c, NULL); - /* 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 (var_is_value_missing (indep_var, case_data (c, indep_var), exclude)) + 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); + 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 (!var_is_value_missing (v, val, exclude)) { - gs->n+=weight; - gs->sum+=weight * val->f; - gs->ssq+=weight * val->f * val->f; + struct group_statistics *gs; + gs = &group_proc_get (v)->ugs; + + gs->n += weight; + gs->sum += weight * val->f; + gs->ssq += weight * val->f * val->f; } } return 0; } /* Pre calculations common to all variants of the T test */ -static void +static void common_precalc ( struct cmd_t_test *cmd ) { int i=0; - for(i=0; i< cmd->n_variables ; ++i) + for(i=0; i< cmd->n_variables ; ++i) { struct group_statistics *gs; gs= &group_proc_get (cmd->v_variables[i])->ugs; - + gs->sum=0; gs->n=0; gs->ssq=0; @@ -1481,17 +1465,16 @@ 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 ) +void +common_postcalc (struct cmd_t_test *cmd) { int i=0; - - for(i=0; i< cmd->n_variables ; ++i) + for(i=0; i< cmd->n_variables ; ++i) { struct group_statistics *gs; gs= &group_proc_get (cmd->v_variables[i])->ugs; - + gs->mean=gs->sum / gs->n; gs->s_std_dev= sqrt( ( (gs->ssq / gs->n ) - gs->mean * gs->mean ) @@ -1508,39 +1491,27 @@ 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_) +static int +one_sample_calc (const struct dictionary *dict, + const struct ccase *c, void *cmd_, + enum mv_class exclude) { 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); - - /* 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); + double weight = dict_get_case_weight (dict, c, NULL); - if (value_is_missing(&v->miss, val) ) - { - 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); + 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 (!var_is_value_missing (v, val, exclude)) gs->sum_diff += weight * (val->f - cmd->n_testval[0]); } @@ -1548,27 +1519,27 @@ one_sample_calc (const struct ccase *c, void *cmd_) } /* Pre calculations for one sample t test */ -static void +static void one_sample_precalc ( struct cmd_t_test *cmd ) { - int i=0; - - for(i=0; i< cmd->n_variables ; ++i) + int i=0; + + for(i=0; i< cmd->n_variables ; ++i) { struct group_statistics *gs; gs= &group_proc_get (cmd->v_variables[i])->ugs; - + gs->sum_diff=0; } } /* Post calculations for one sample t test */ -static void +static void one_sample_postcalc (struct cmd_t_test *cmd) { int i=0; - - for(i=0; i< cmd->n_variables ; ++i) + + for(i=0; i< cmd->n_variables ; ++i) { struct group_statistics *gs; gs= &group_proc_get (cmd->v_variables[i])->ugs; @@ -1579,7 +1550,7 @@ one_sample_postcalc (struct cmd_t_test *cmd) -static void +static void paired_precalc (struct cmd_t_test *cmd UNUSED) { int i; @@ -1598,64 +1569,43 @@ paired_precalc (struct cmd_t_test *cmd UNUSED) } -static int -paired_calc (const struct ccase *c, void *cmd_) +static int +paired_calc (const struct dictionary *dict, const struct ccase *c, + struct cmd_t_test *cmd UNUSED, enum mv_class exclude) { 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, NULL); 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 (!var_is_value_missing (v0, val0, exclude) && + !var_is_value_missing (v1, val1, exclude)) + { + 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 void +static void paired_postcalc (struct cmd_t_test *cmd UNUSED) { int i; @@ -1665,51 +1615,51 @@ paired_postcalc (struct cmd_t_test *cmd UNUSED) int j; const double n = pairs[i].n; - for (j=0; j < 2 ; ++j) + for (j=0; j < 2 ; ++j) { pairs[i].mean[j] = pairs[i].sum[j] / n ; - pairs[i].s_std_dev[j] = sqrt((pairs[i].ssq[j] / n - + pairs[i].s_std_dev[j] = sqrt((pairs[i].ssq[j] / n - pow2(pairs[i].mean[j])) ); - pairs[i].std_dev[j] = sqrt(n/(n-1)*(pairs[i].ssq[j] / n - + pairs[i].std_dev[j] = sqrt(n/(n-1)*(pairs[i].ssq[j] / n - pow2(pairs[i].mean[j])) ); } - - pairs[i].correlation = pairs[i].sum_of_prod / pairs[i].n - + + pairs[i].correlation = pairs[i].sum_of_prod / pairs[i].n - pairs[i].mean[0] * pairs[i].mean[1] ; /* correlation now actually contains the covariance */ - + pairs[i].correlation /= pairs[i].std_dev[0] * pairs[i].std_dev[1]; pairs[i].correlation *= pairs[i].n / ( pairs[i].n - 1 ); - + pairs[i].mean_diff = pairs[i].sum_of_diffs / n ; pairs[i].std_dev_diff = sqrt ( n / (n - 1) * ( ( pairs[i].ssq_diffs / n ) - - + - pow2(pairs[i].mean_diff ) ) ); } } -static void +static void group_precalc (struct cmd_t_test *cmd ) { int i; int j; - for(i=0; i< cmd->n_variables ; ++i) + for(i=0; i< cmd->n_variables ; ++i) { struct group_proc *ttpr = group_proc_get (cmd->v_variables[i]); /* There's always 2 groups for a T - TEST */ ttpr->n_groups = 2; - gp.indep_width = indep_var->width; - - ttpr->group_hash = hsh_create(2, + gp.indep_width = var_get_width (indep_var); + + ttpr->group_hash = hsh_create(2, (hsh_compare_func *) compare_group_binary, (hsh_hash_func *) hash_group_binary, (hsh_free_func *) free_group, @@ -1723,75 +1673,60 @@ group_precalc (struct cmd_t_test *cmd ) gs->sum = 0; gs->n = 0; gs->ssq = 0; - - if ( gp.criterion == CMP_EQ ) + + if ( gp.criterion == CMP_EQ ) { gs->id = gp.v.g_value[j]; } else { - if ( j == 0 ) + if ( j == 0 ) gs->id.f = gp.v.critical_value - 1.0 ; else gs->id.f = gp.v.critical_value + 1.0 ; } - - hsh_insert ( ttpr->group_hash, (void *) gs ); + hsh_insert ( ttpr->group_hash, (void *) gs ); } } } -static int -group_calc (const struct ccase *c, struct cmd_t_test *cmd) +static int +group_calc (const struct dictionary *dict, + const struct ccase *c, struct cmd_t_test *cmd, + enum mv_class exclude) { int i; - const union value *gv = case_data (c, indep_var->fv); - - const double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn); + const double weight = dict_get_case_weight (dict, c, NULL); - 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 (var_is_value_missing (indep_var, case_data (c, indep_var), exclude)) + return 0; - gv = case_data (c, indep_var->fv); + gv = case_data (c, indep_var); - for(i=0; i< cmd->n_variables ; ++i) + 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; gs = hsh_find(grp_hash, (void *) gv); - /* If the independent variable doesn't match either of the values + /* If the independent variable doesn't match either of the values for this case then move on to the next case */ - if ( ! gs ) + if ( ! gs ) return 0; - if ( !value_is_missing(&var->miss, val) ) + if (!var_is_value_missing (var, val, exclude)) { - 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); } } @@ -1799,25 +1734,25 @@ group_calc (const struct ccase *c, struct cmd_t_test *cmd) } -static void +static void 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]; + 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; int count=0; - for (gs = hsh_first (grp_hash,&g); - gs != 0; + for (gs = hsh_first (grp_hash,&g); + gs != 0; gs = hsh_next(grp_hash,&g)) { gs->mean = gs->sum / gs->n; - + gs->s_std_dev= sqrt( ( (gs->ssq / gs->n ) - gs->mean * gs->mean ) ) ; @@ -1826,7 +1761,7 @@ group_postcalc ( struct cmd_t_test *cmd ) gs->n/(gs->n-1) * ( (gs->ssq / gs->n ) - gs->mean * gs->mean ) ) ; - + gs->se_mean = gs->std_dev / sqrt(gs->n); count ++; } @@ -1836,105 +1771,109 @@ group_postcalc ( struct cmd_t_test *cmd ) -static bool -calculate(const struct ccase *first, const struct casefile *cf, void *cmd_) +static void +calculate(struct cmd_t_test *cmd, + struct casereader *input, const struct dataset *ds) { + const struct dictionary *dict = dataset_dict (ds); struct ssbox stat_summary_box; struct trbox test_results_box; - struct casereader *r; + struct casereader *pass1, *pass2, *pass3; + struct taint *taint; struct ccase c; - struct cmd_t_test *cmd = (struct cmd_t_test *) cmd_; + enum mv_class exclude = cmd->miss != TTS_INCLUDE ? MV_ANY : MV_SYSTEM; - output_split_file_values (first); - common_precalc(cmd); - for(r = casefile_get_reader (cf); - casereader_read (r, &c) ; - case_destroy (&c)) + if (!casereader_peek (input, 0, &c)) { - common_calc(&c,cmd); + casereader_destroy (input); + return; } - casereader_destroy (r); - common_postcalc(cmd); + output_split_file_values (ds, &c); + case_destroy (&c); + + if ( cmd->miss == TTS_LISTWISE ) + input = casereader_create_filter_missing (input, + cmd->v_variables, + cmd->n_variables, + exclude, NULL); + + input = casereader_create_filter_weight (input, dict, NULL, NULL); + + taint = taint_clone (casereader_get_taint (input)); + casereader_split (input, &pass1, &pass2); + + common_precalc (cmd); + for (; casereader_read (pass1, &c); case_destroy (&c)) + common_calc (dict, &c, cmd, exclude); + casereader_destroy (pass1); + common_postcalc (cmd); switch(mode) { case T_1_SAMPLE: - one_sample_precalc(cmd); - for(r = casefile_get_reader (cf); - casereader_read (r, &c) ; - case_destroy (&c)) - { - one_sample_calc(&c,cmd); - } - casereader_destroy (r); - one_sample_postcalc(cmd); - + one_sample_precalc (cmd); + for (; casereader_read (pass2, &c); case_destroy (&c)) + one_sample_calc (dict, &c, cmd, exclude); + one_sample_postcalc (cmd); break; case T_PAIRED: paired_precalc(cmd); - for(r = casefile_get_reader (cf); - casereader_read (r, &c) ; - case_destroy (&c)) - { - paired_calc(&c,cmd); - } - casereader_destroy (r); - paired_postcalc(cmd); - + for (; casereader_read (pass2, &c); case_destroy (&c)) + paired_calc (dict, &c, cmd, exclude); + paired_postcalc (cmd); break; case T_IND_SAMPLES: + pass3 = casereader_clone (pass2); group_precalc(cmd); - for(r = casefile_get_reader (cf); - casereader_read (r, &c) ; - case_destroy (&c)) - { - group_calc(&c,cmd); - } - casereader_destroy (r); + for(; casereader_read (pass2, &c); case_destroy (&c)) + group_calc (dict, &c, cmd, exclude); 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, pass3, indep_var, cmd->n_variables, cmd->v_variables, + exclude); break; } + casereader_destroy (pass2); - ssbox_create(&stat_summary_box,cmd,mode); - ssbox_populate(&stat_summary_box,cmd); - ssbox_finalize(&stat_summary_box); + if (!taint_has_tainted_successor (taint)) + { + ssbox_create(&stat_summary_box,cmd,mode); + ssbox_populate(&stat_summary_box,cmd); + ssbox_finalize(&stat_summary_box); - if ( mode == T_PAIRED) - pscbox(); + if ( mode == T_PAIRED ) + pscbox(); - trbox_create(&test_results_box,cmd,mode); - trbox_populate(&test_results_box,cmd); - trbox_finalize(&test_results_box); + trbox_create(&test_results_box,cmd,mode); + trbox_populate(&test_results_box,cmd); + trbox_finalize(&test_results_box); + } - return true; + taint_destroy (taint); } short which_group(const struct group_statistics *g, const struct group_properties *p); -/* Return -1 if the id of a is less than b; +1 if greater than and +/* Return -1 if the id of a is less than b; +1 if greater than and 0 if equal */ -static int -compare_group_binary(const struct group_statistics *a, - const struct group_statistics *b, +static int +compare_group_binary(const struct group_statistics *a, + const struct group_statistics *b, const struct group_properties *p) { short flag_a; short flag_b; - - if ( p->criterion == CMP_LE ) + + if ( p->criterion == CMP_LE ) { - /* less-than-or-equal comparision is not meaningfull for + /* less-than comparision is not meaningfull for alpha variables, so we shouldn't ever arrive here */ assert(p->indep_width == 0 ) ; - + flag_a = ( a->id.f < p->v.critical_value ) ; flag_b = ( b->id.f < p->v.critical_value ) ; } @@ -1944,7 +1883,7 @@ compare_group_binary(const struct group_statistics *a, flag_b = which_group(b, p); } - if (flag_a < flag_b ) + if (flag_a < flag_b ) return -1; return (flag_a > flag_b); @@ -1953,36 +1892,36 @@ compare_group_binary(const struct group_statistics *a, /* This is a degenerate case of a hash, since it can only return three possible values. It's really a comparison, being used as a hash function */ -static unsigned -hash_group_binary(const struct group_statistics *g, +static unsigned +hash_group_binary(const struct group_statistics *g, const struct group_properties *p) { short flag = -1; - if ( p->criterion == CMP_LE ) + if ( p->criterion == CMP_LE ) { /* Not meaningfull to do a less than compare for alpha values ? */ assert(p->indep_width == 0 ) ; - flag = ( g->id.f < p->v.critical_value ) ; + flag = ( g->id.f < p->v.critical_value ) ; } - else if ( p->criterion == CMP_EQ) + else if ( p->criterion == CMP_EQ) { flag = which_group(g,p); } else - assert(0); + NOT_REACHED (); return flag; } -/* return 0 if G belongs to group 0, +/* return 0 if G belongs to group 0, 1 if it belongs to group 1, 2 if it belongs to neither group */ short which_group(const struct group_statistics *g, const struct group_properties *p) { - + if ( 0 == compare_values (&g->id, &p->v.g_value[0], p->indep_width)) return 0; @@ -1991,4 +1930,9 @@ which_group(const struct group_statistics *g, return 2; } - + +/* + Local Variables: + mode: c + End: +*/