X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Ft-test.q;h=fa33a4461db3d8a8a9d2b6413d4733640846e137;hb=9f087e7aa4cdff1d5d46d5e188c0017a9d2d0029;hp=7748676ab0c338663f9995bcd50d7845352b9f20;hpb=888d0f91d57e0c3c5a4206c30ac71eb87bf44227;p=pspp-builds.git diff --git a/src/language/stats/t-test.q b/src/language/stats/t-test.q index 7748676a..fa33a446 100644 --- a/src/language/stats/t-test.q +++ b/src/language/stats/t-test.q @@ -1,23 +1,18 @@ -/* 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 @@ -27,31 +22,29 @@ #include #include -#include +#include +#include #include #include #include #include -#include - #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) @@ -88,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]; @@ -109,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; @@ -154,7 +147,7 @@ struct pair static struct pair *pairs=0; -static int parse_value (struct lexer *lexer, 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; @@ -180,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); @@ -210,35 +203,35 @@ 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 dictionary *dict, - const struct ccase *, void *, - const struct casefilter *filter); +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 dictionary *dict, const struct ccase *, void *, const struct casefilter *); +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 dictionary *dict, const struct ccase *, - struct cmd_t_test*, const struct casefilter *); +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 dictionary *dict, const struct ccase *, - struct cmd_t_test *, const struct casefilter *); +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, - const struct dataset *ds); +static void calculate(struct cmd_t_test *, + struct casereader *, + const struct dataset *); static int mode; @@ -247,12 +240,12 @@ static struct cmd_t_test cmd; 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); @@ -260,8 +253,10 @@ static unsigned hash_group_binary(const struct group_statistics *g, int cmd_t_test (struct lexer *lexer, struct dataset *ds) { + struct casegrouper *grouper; + struct casereader *group; bool ok; - + if ( !parse_t_test (lexer, ds, &cmd, NULL) ) return CMD_FAILURE; @@ -276,7 +271,7 @@ cmd_t_test (struct lexer *lexer, struct dataset *ds) if ( m != 1) { - msg(SE, + msg(SE, _("TESTVAL, GROUPS and PAIRS subcommands are mutually exclusive.") ); free_t_test(&cmd); @@ -284,16 +279,16 @@ cmd_t_test (struct lexer *lexer, struct dataset *ds) } } - 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); @@ -301,37 +296,37 @@ cmd_t_test (struct lexer *lexer, struct dataset *ds) } 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); @@ -340,23 +335,28 @@ cmd_t_test (struct lexer *lexer, struct dataset *ds) bad_weight_warn = true; - ok = multipass_procedure_with_splits (ds, 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; } @@ -390,7 +390,7 @@ tts_custom_groups (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *c gp.v.g_value[1].f = 2; gp.criterion = CMP_EQ; - + n_group_values = 2; return 1; @@ -429,7 +429,7 @@ tts_custom_groups (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *c 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 ; @@ -442,7 +442,7 @@ tts_custom_groups (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *c static int 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; @@ -453,7 +453,7 @@ tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cm lex_match (lexer, '='); n_vars=0; - if (!parse_variables (lexer, dataset_dict (ds), &vars, &n_vars, + if (!parse_variables_const (lexer, dataset_dict (ds), &vars, &n_vars, PV_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH)) { free (vars); @@ -465,7 +465,7 @@ tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cm if (lex_match (lexer, T_WITH)) { n_before_WITH = n_vars; - if (!parse_variables (lexer, dataset_dict (ds), &vars, &n_vars, + if (!parse_variables_const (lexer, dataset_dict (ds), &vars, &n_vars, PV_DUPLICATE | PV_APPEND | PV_NUMERIC | PV_NO_SCRATCH)) { @@ -486,7 +486,7 @@ tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cm 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; @@ -514,7 +514,7 @@ tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cm pairs = xnrealloc (pairs, n_pairs + n_pairs_local, sizeof *pairs); /* Populate the pairs with the appropriate variables */ - if ( paired ) + if ( paired ) { int i; @@ -530,7 +530,7 @@ tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cm 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) { @@ -544,8 +544,8 @@ tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cm { 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) { @@ -565,9 +565,9 @@ tts_custom_pairs (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cm /* Parses the current token (numeric or string, depending on type) value v and returns success. */ static int -parse_value (struct lexer *lexer, 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 (lexer)) return 0; @@ -592,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, @@ -603,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); @@ -641,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); @@ -650,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); @@ -667,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; @@ -689,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; @@ -710,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 ( var_is_numeric (indep_var) ) + 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 { @@ -733,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; } @@ -750,7 +750,7 @@ 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; @@ -758,39 +758,39 @@ ssbox_independent_samples_populate(struct ssbox *ssb, 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 @@ -801,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); @@ -814,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; @@ -835,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; @@ -848,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; @@ -861,7 +861,7 @@ ssbox_paired_populate(struct ssbox *ssb,struct cmd_t_test *cmd UNUSED) /* 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); @@ -870,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; @@ -882,12 +882,12 @@ 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, var_get_name (cmd->v_variables[i])); - tab_float (ssb->t,1, i+1, TAB_RIGHT, gs->n, 2, 0); + 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); } - + } @@ -918,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); @@ -939,21 +939,21 @@ trbox_create(struct trbox *trb, } /* 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) { @@ -971,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")); @@ -986,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 ) { @@ -1013,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]; @@ -1031,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]; @@ -1039,7 +1039,7 @@ 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, var_get_name (cmd->v_variables[i])); tab_text (self->t, 1, i*2+3, TAB_LEFT, _("Equal variances assumed")); @@ -1054,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); @@ -1083,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")); @@ -1102,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 ) ) @@ -1130,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) { @@ -1161,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); @@ -1176,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) { @@ -1190,8 +1190,8 @@ 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", var_get_name (pairs[i].v[0]), @@ -1210,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) ); @@ -1227,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); @@ -1238,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; @@ -1251,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); @@ -1274,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; @@ -1303,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); @@ -1322,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); @@ -1337,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); @@ -1351,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); @@ -1375,16 +1375,16 @@ 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, + + 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])); @@ -1409,34 +1409,34 @@ pscbox(void) /* Calculation Implementation */ /* 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, - const struct casefilter *filter) +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; + 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 (dict, c, NULL); /* Listwise has to be implicit if the independent variable is missing ?? */ if ( cmd->sbc_groups ) { - if ( casefilter_variable_missing (filter, c, indep_var) ) + 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 variable *v = cmd->v_variables[i]; + const struct variable *v = cmd->v_variables[i]; + const union value *val = case_data (c, v); - if (! casefilter_variable_missing (filter, c, v) ) + if (!var_is_value_missing (v, val, exclude)) { struct group_statistics *gs; - const union value *val = case_data (c, v->fv); - gs = &group_proc_get (cmd->v_variables[i])->ugs; + gs = &group_proc_get (v)->ugs; gs->n += weight; gs->sum += weight * val->f; @@ -1447,16 +1447,16 @@ common_calc (const struct dictionary *dict, } /* 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; @@ -1465,16 +1465,16 @@ common_precalc ( struct cmd_t_test *cmd ) } /* Post calculations common to all variants of the T test */ -void +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 ) @@ -1491,27 +1491,27 @@ common_postcalc (struct cmd_t_test *cmd) } /* 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 casefilter *filter) +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_; - double weight = dict_get_case_weight (dict, c, &bad_weight_warn); + double weight = dict_get_case_weight (dict, c, NULL); - 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 ( ! casefilter_variable_missing (filter, c, v)) + if (!var_is_value_missing (v, val, exclude)) gs->sum_diff += weight * (val->f - cmd->n_testval[0]); } @@ -1519,27 +1519,27 @@ one_sample_calc (const struct dictionary *dict, } /* 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; @@ -1550,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; @@ -1569,24 +1569,24 @@ paired_precalc (struct cmd_t_test *cmd UNUSED) } -static int -paired_calc (const struct dictionary *dict, const struct ccase *c, - struct cmd_t_test *cmd UNUSED, const struct casefilter *filter) +static int +paired_calc (const struct dictionary *dict, const struct ccase *c, + struct cmd_t_test *cmd UNUSED, enum mv_class exclude) { int i; - double weight = dict_get_case_weight (dict, c, &bad_weight_warn); + 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 ( ! casefilter_variable_missing (filter, c, v0) && - ! casefilter_variable_missing (filter, c, v1) ) + 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; @@ -1605,7 +1605,7 @@ paired_calc (const struct dictionary *dict, const struct ccase *c, return 0; } -static void +static void paired_postcalc (struct cmd_t_test *cmd UNUSED) { int i; @@ -1615,42 +1615,42 @@ 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]); @@ -1658,8 +1658,8 @@ group_precalc (struct cmd_t_test *cmd ) ttpr->n_groups = 2; gp.indep_width = var_get_width (indep_var); - - ttpr->group_hash = hsh_create(2, + + ttpr->group_hash = hsh_create(2, (hsh_compare_func *) compare_group_binary, (hsh_hash_func *) hash_group_binary, (hsh_free_func *) free_group, @@ -1673,58 +1673,56 @@ 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 dictionary *dict, - const struct ccase *c, struct cmd_t_test *cmd, - const struct casefilter *filter) +static int +group_calc (const struct dictionary *dict, + const struct ccase *c, struct cmd_t_test *cmd, + enum mv_class exclude) { int i; - const double weight = - dict_get_case_weight (dict, c, &bad_weight_warn); + const double weight = dict_get_case_weight (dict, c, NULL); const union value *gv; - if ( casefilter_variable_missing (filter, c, indep_var)) + 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 ( ! casefilter_variable_missing (filter, c, var) ) + if (!var_is_value_missing (var, val, exclude)) { gs->n += weight; gs->sum += weight * val->f; @@ -1736,25 +1734,25 @@ group_calc (const struct dictionary *dict, } -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 ) ) ; @@ -1763,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 ++; } @@ -1773,115 +1771,109 @@ group_postcalc ( struct cmd_t_test *cmd ) -static bool -calculate(const struct ccase *first, const struct casefile *cf, - void *cmd_, const struct dataset *ds) +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; - 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)) + if (!casereader_peek (input, 0, &c)) { - common_calc (dict, &c, cmd, filter); + casereader_destroy (input); + return; } + 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); - casereader_destroy (r); + 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, filter); - casereader_read (r, &c) ; - case_destroy (&c)) - { - one_sample_calc (dict, &c, cmd, filter); - } - casereader_destroy (r); + 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, filter); - casereader_read (r, &c) ; - case_destroy (&c)) - { - paired_calc (dict, &c, cmd, filter); - } - casereader_destroy (r); + 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, filter); - casereader_read (r, &c) ; - case_destroy (&c)) - { - group_calc (dict, &c, cmd, filter); - } - casereader_destroy (r); + for(; casereader_read (pass2, &c); case_destroy (&c)) + group_calc (dict, &c, cmd, exclude); group_postcalc(cmd); - levene (dict, cf, indep_var, cmd->n_variables, cmd->v_variables, - filter); + levene (dict, pass3, indep_var, cmd->n_variables, cmd->v_variables, + exclude); break; } + casereader_destroy (pass2); - casefilter_destroy (filter); - - 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 ) ; } @@ -1891,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); @@ -1900,19 +1892,19 @@ 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); } @@ -1922,14 +1914,14 @@ hash_group_binary(const struct group_statistics *g, 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; @@ -1938,4 +1930,9 @@ which_group(const struct group_statistics *g, return 2; } - + +/* + Local Variables: + mode: c + End: +*/