1 /* PSPP - computes sample statistics. -*-c-*-
3 Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
4 Written by John Williams <johnr.williams@stonebow.otago.ac.nz>.
5 Almost completly re-written by John Darrington 2004
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 #include <gsl/gsl_cdf.h>
32 #include "dictionary.h"
34 #include "group_proc.h"
44 #include "value-labels.h"
49 #define _(msgid) gettext (msgid)
57 variables=varlist("PV_NO_SCRATCH | PV_NUMERIC");
59 +missing=miss:!analysis/listwise,
60 incl:include/!exclude;
61 format=fmt:!labels/nolabels;
62 criteria=:cin(d:criteria,"%s > 0. && %s < 1.").
70 /* Function to use for testing for missing values */
71 static is_missing_func *value_is_missing;
73 /* Variable for the GROUPS subcommand, if given. */
74 static struct variable *indep_var;
82 struct group_properties
84 /* The comparison criterion */
85 enum comparison criterion;
87 /* The width of the independent variable */
91 /* The value of the independent variable at which groups are determined to
92 belong to one group or the other */
93 double critical_value;
96 /* The values of the independent variable for each group */
97 union value g_value[2];
103 static struct group_properties gp ;
107 /* PAIRS: Number of pairs to be compared ; each pair. */
108 static int n_pairs = 0 ;
111 /* The variables comprising the pair */
112 struct variable *v[2];
114 /* The number of valid variable pairs */
117 /* The sum of the members */
120 /* sum of squares of the members */
123 /* Std deviation of the members */
127 /* Sample Std deviation of the members */
130 /* The means of the members */
133 /* The correlation coefficient between the variables */
136 /* The sum of the differences */
139 /* The sum of the products */
142 /* The mean of the differences */
145 /* The sum of the squares of the differences */
148 /* The std deviation of the differences */
152 static struct pair *pairs=0;
154 static int parse_value (union value * v, int type) ;
156 /* Structures and Functions for the Statistics Summary Box */
158 typedef void populate_ssbox_func(struct ssbox *ssb,
159 struct cmd_t_test *cmd);
160 typedef void finalize_ssbox_func(struct ssbox *ssb);
166 populate_ssbox_func *populate;
167 finalize_ssbox_func *finalize;
172 void ssbox_create(struct ssbox *ssb, struct cmd_t_test *cmd, int mode);
174 /* Populate a ssbox according to cmd */
175 void ssbox_populate(struct ssbox *ssb, struct cmd_t_test *cmd);
177 /* Submit and destroy a ssbox */
178 void ssbox_finalize(struct ssbox *ssb);
180 /* A function to create, populate and submit the Paired Samples Correlation
185 /* Structures and Functions for the Test Results Box */
188 typedef void populate_trbox_func(struct trbox *trb,
189 struct cmd_t_test *cmd);
190 typedef void finalize_trbox_func(struct trbox *trb);
194 populate_trbox_func *populate;
195 finalize_trbox_func *finalize;
199 void trbox_create(struct trbox *trb, struct cmd_t_test *cmd, int mode);
201 /* Populate a ssbox according to cmd */
202 void trbox_populate(struct trbox *trb, struct cmd_t_test *cmd);
204 /* Submit and destroy a ssbox */
205 void trbox_finalize(struct trbox *trb);
207 /* Which mode was T-TEST invoked */
215 static int common_calc (const struct ccase *, void *);
216 static void common_precalc (struct cmd_t_test *);
217 static void common_postcalc (struct cmd_t_test *);
219 static int one_sample_calc (const struct ccase *, void *);
220 static void one_sample_precalc (struct cmd_t_test *);
221 static void one_sample_postcalc (struct cmd_t_test *);
223 static int paired_calc (const struct ccase *, void *);
224 static void paired_precalc (struct cmd_t_test *);
225 static void paired_postcalc (struct cmd_t_test *);
227 static void group_precalc (struct cmd_t_test *);
228 static int group_calc (const struct ccase *, struct cmd_t_test *);
229 static void group_postcalc (struct cmd_t_test *);
232 static void calculate(const struct casefile *cf, void *_mode);
236 static struct cmd_t_test cmd;
238 static int bad_weight_warn;
241 static int compare_group_binary(const struct group_statistics *a,
242 const struct group_statistics *b,
243 const struct group_properties *p);
246 static unsigned hash_group_binary(const struct group_statistics *g,
247 const struct group_properties *p);
255 if ( !parse_t_test(&cmd) )
258 if (! cmd.sbc_criteria)
263 if (cmd.sbc_testval) ++m;
264 if (cmd.sbc_groups) ++m;
265 if (cmd.sbc_pairs) ++m;
270 _("TESTVAL, GROUPS and PAIRS subcommands are mutually exclusive.")
279 else if (cmd.sbc_groups)
284 if ( mode == T_PAIRED)
286 if (cmd.sbc_variables)
288 msg(SE, _("VARIABLES subcommand is not appropriate with PAIRS"));
294 /* Iterate through the pairs and put each variable that is a
295 member of a pair into cmd.v_variables */
298 struct hsh_iterator hi;
299 struct hsh_table *hash;
302 hash = hsh_create (n_pairs, compare_var_names, hash_var_name, 0, 0);
304 for (i=0; i < n_pairs; ++i)
306 hsh_insert(hash,pairs[i].v[0]);
307 hsh_insert(hash,pairs[i].v[1]);
310 assert(cmd.n_variables == 0);
311 cmd.n_variables = hsh_count(hash);
313 cmd.v_variables = xrealloc(cmd.v_variables,
314 sizeof(struct variable) * cmd.n_variables);
315 /* Iterate through the hash */
316 for (i=0,v = (struct variable *) hsh_first(hash,&hi);
318 v=hsh_next(hash,&hi) )
319 cmd.v_variables[i++]=v;
324 else if ( !cmd.sbc_variables)
326 msg(SE, _("One or more VARIABLES must be specified."));
332 /* If /MISSING=INCLUDE is set, then user missing values are ignored */
333 if (cmd.incl == TTS_INCLUDE )
334 value_is_missing = mv_is_value_system_missing;
336 value_is_missing = mv_is_value_missing;
340 multipass_procedure_with_splits (calculate, &cmd);
346 if ( mode == T_IND_SAMPLES)
349 /* Destroy any group statistics we created */
350 for (v = 0 ; v < cmd.n_variables ; ++v )
352 struct group_proc *grpp = group_proc_get (cmd.v_variables[v]);
353 hsh_destroy (grpp->group_hash);
362 tts_custom_groups (struct cmd_t_test *cmd UNUSED)
364 int n_group_values=0;
368 indep_var = parse_variable ();
371 lex_error ("expecting variable name in GROUPS subcommand");
375 if (indep_var->type == T_STRING && indep_var->width > MAX_SHORT_STRING)
377 msg (SE, _("Long string variable %s is not valid here."),
382 if (!lex_match ('('))
384 if (indep_var->type == NUMERIC)
386 gp.v.g_value[0].f = 1;
387 gp.v.g_value[1].f = 2;
389 gp.criterion = CMP_EQ;
397 msg (SE, _("When applying GROUPS to a string variable, two "
398 "values must be specified."));
403 if (!parse_value (&gp.v.g_value[0], indep_var->type))
409 if (indep_var->type != NUMERIC)
412 msg (SE, _("When applying GROUPS to a string variable, two "
413 "values must be specified."));
416 gp.criterion = CMP_LE;
417 gp.v.critical_value = gp.v.g_value[0].f;
423 if (!parse_value (&gp.v.g_value[1], indep_var->type))
427 if (!lex_force_match (')'))
430 if ( n_group_values == 2 )
431 gp.criterion = CMP_EQ ;
433 gp.criterion = CMP_LE ;
441 tts_custom_pairs (struct cmd_t_test *cmd UNUSED)
443 struct variable **vars;
445 size_t n_pairs_local;
447 size_t n_before_WITH;
448 size_t n_after_WITH = SIZE_MAX;
449 int paired ; /* Was the PAIRED keyword given ? */
454 if (!parse_variables (default_dict, &vars, &n_vars,
455 PV_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH))
463 if (lex_match (T_WITH))
465 n_before_WITH = n_vars;
466 if (!parse_variables (default_dict, &vars, &n_vars,
467 PV_DUPLICATE | PV_APPEND
468 | PV_NUMERIC | PV_NO_SCRATCH))
473 n_after_WITH = n_vars - n_before_WITH;
476 paired = (lex_match ('(') && lex_match_id ("PAIRED") && lex_match (')'));
478 /* Determine the number of pairs needed */
481 if (n_before_WITH != n_after_WITH)
484 msg (SE, _("PAIRED was specified but the number of variables "
485 "preceding WITH (%d) did not match the number "
487 n_before_WITH, n_after_WITH );
490 n_pairs_local = n_before_WITH;
492 else if (n_before_WITH > 0) /* WITH keyword given, but not PAIRED keyword */
494 n_pairs_local = n_before_WITH * n_after_WITH ;
496 else /* Neither WITH nor PAIRED keyword given */
501 msg (SE, _("At least two variables must be specified "
506 /* how many ways can you pick 2 from n_vars ? */
507 n_pairs_local = n_vars * (n_vars - 1) / 2;
511 /* Allocate storage for the pairs */
512 pairs = xrealloc(pairs, sizeof(struct pair) * (n_pairs + n_pairs_local) );
514 /* Populate the pairs with the appropriate variables */
519 assert(n_pairs_local == n_vars / 2);
520 for (i = 0; i < n_pairs_local; ++i)
522 pairs[i].v[n_pairs] = vars[i];
523 pairs[i].v[n_pairs + 1] = vars[i + n_pairs_local];
526 else if (n_before_WITH > 0) /* WITH keyword given, but not PAIRED keyword */
531 for(i=0 ; i < n_before_WITH ; ++i )
533 for(j=0 ; j < n_after_WITH ; ++j)
535 pairs[p].v[0] = vars[i];
536 pairs[p].v[1] = vars[j+n_before_WITH];
541 else /* Neither WITH nor PAIRED given */
546 for(i=0 ; i < n_vars ; ++i )
548 for(j=i+1 ; j < n_vars ; ++j)
550 pairs[p].v[0] = vars[i];
551 pairs[p].v[1] = vars[j];
557 n_pairs+=n_pairs_local;
563 /* Parses the current token (numeric or string, depending on type)
564 value v and returns success. */
566 parse_value (union value * v, int type )
570 if (!lex_force_num ())
576 if (!lex_force_string ())
578 strncpy (v->s, ds_c_str (&tokstr), ds_length (&tokstr));
587 /* Implementation of the SSBOX object */
589 void ssbox_base_init(struct ssbox *this, int cols,int rows);
591 void ssbox_base_finalize(struct ssbox *ssb);
593 void ssbox_one_sample_init(struct ssbox *this,
594 struct cmd_t_test *cmd );
596 void ssbox_independent_samples_init(struct ssbox *this,
597 struct cmd_t_test *cmd);
599 void ssbox_paired_init(struct ssbox *this,
600 struct cmd_t_test *cmd);
603 /* Factory to create an ssbox */
605 ssbox_create(struct ssbox *ssb, struct cmd_t_test *cmd, int mode)
610 ssbox_one_sample_init(ssb,cmd);
613 ssbox_independent_samples_init(ssb,cmd);
616 ssbox_paired_init(ssb,cmd);
625 /* Despatcher for the populate method */
627 ssbox_populate(struct ssbox *ssb,struct cmd_t_test *cmd)
629 ssb->populate(ssb,cmd);
633 /* Despatcher for finalize */
635 ssbox_finalize(struct ssbox *ssb)
641 /* Submit the box and clear up */
643 ssbox_base_finalize(struct ssbox *ssb)
650 /* Initialize a ssbox struct */
652 ssbox_base_init(struct ssbox *this, int cols,int rows)
654 this->finalize = ssbox_base_finalize;
655 this->t = tab_create (cols, rows, 0);
657 tab_columns (this->t, SOM_COL_DOWN, 1);
658 tab_headers (this->t,0,0,1,0);
659 tab_box (this->t, TAL_2, TAL_2, TAL_0, TAL_1, 0, 0, cols -1, rows -1 );
660 tab_hline(this->t, TAL_2,0,cols-1,1);
661 tab_dim (this->t, tab_natural_dimensions);
664 void ssbox_one_sample_populate(struct ssbox *ssb,
665 struct cmd_t_test *cmd);
667 /* Initialize the one_sample ssbox */
669 ssbox_one_sample_init(struct ssbox *this,
670 struct cmd_t_test *cmd )
673 const int vsize=cmd->n_variables+1;
675 this->populate = ssbox_one_sample_populate;
677 ssbox_base_init(this, hsize,vsize);
678 tab_title (this->t, 0, _("One-Sample Statistics"));
679 tab_vline(this->t, TAL_2, 1,0,vsize - 1);
680 tab_text (this->t, 1, 0, TAB_CENTER | TAT_TITLE, _("N"));
681 tab_text (this->t, 2, 0, TAB_CENTER | TAT_TITLE, _("Mean"));
682 tab_text (this->t, 3, 0, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
683 tab_text (this->t, 4, 0, TAB_CENTER | TAT_TITLE, _("SE. Mean"));
686 void ssbox_independent_samples_populate(struct ssbox *ssb,
687 struct cmd_t_test *cmd);
689 /* Initialize the independent samples ssbox */
691 ssbox_independent_samples_init(struct ssbox *this,
692 struct cmd_t_test *cmd)
695 int vsize = cmd->n_variables*2 +1;
697 this->populate = ssbox_independent_samples_populate;
699 ssbox_base_init(this, hsize,vsize);
700 tab_title (this->t, 0, _("Group Statistics"));
701 tab_vline(this->t,0,1,0,vsize - 1);
702 tab_text (this->t, 1, 0, TAB_CENTER | TAT_TITLE, indep_var->name);
703 tab_text (this->t, 2, 0, TAB_CENTER | TAT_TITLE, _("N"));
704 tab_text (this->t, 3, 0, TAB_CENTER | TAT_TITLE, _("Mean"));
705 tab_text (this->t, 4, 0, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
706 tab_text (this->t, 5, 0, TAB_CENTER | TAT_TITLE, _("SE. Mean"));
710 /* Populate the ssbox for independent samples */
712 ssbox_independent_samples_populate(struct ssbox *ssb,
713 struct cmd_t_test *cmd)
719 double indep_value[2];
721 char prefix[2][3]={"",""};
723 if ( indep_var->type == NUMERIC )
725 val_lab0 = val_labs_find( indep_var->val_labs,gp.v.g_value[0]);
726 val_lab1 = val_labs_find( indep_var->val_labs,gp.v.g_value[1]);
730 val_lab0 = gp.v.g_value[0].s;
731 val_lab1 = gp.v.g_value[1].s;
734 if (gp.criterion == CMP_LE )
736 strcpy(prefix[0],"< ");
737 strcpy(prefix[1],">=");
738 indep_value[0] = gp.v.critical_value;
739 indep_value[1] = gp.v.critical_value;
743 indep_value[0] = gp.v.g_value[0].f;
744 indep_value[1] = gp.v.g_value[1].f;
749 for (i=0; i < cmd->n_variables; ++i)
751 struct variable *var = cmd->v_variables[i];
752 struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
755 tab_text (ssb->t, 0, i*2+1, TAB_LEFT, cmd->v_variables[i]->name);
758 tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF,
759 "%s%s", prefix[0], val_lab0);
761 tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF,
762 "%s%g", prefix[0], indep_value[0]);
766 tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF,
767 "%s%s", prefix[1], val_lab1);
769 tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF,
770 "%s%g", prefix[1], indep_value[1]);
773 /* Fill in the group statistics */
774 for ( count = 0 ; count < 2 ; ++count )
776 union value search_val;
778 struct group_statistics *gs;
780 if ( gp.criterion == CMP_LE )
784 /* less than ( < ) case */
785 search_val.f = gp.v.critical_value - 1.0;
790 search_val.f = gp.v.critical_value + 1.0;
795 search_val = gp.v.g_value[count];
798 gs = hsh_find(grp_hash, (void *) &search_val);
801 tab_float(ssb->t, 2 ,i*2+count+1, TAB_RIGHT, gs->n, 2, 0);
802 tab_float(ssb->t, 3 ,i*2+count+1, TAB_RIGHT, gs->mean, 8, 2);
803 tab_float(ssb->t, 4 ,i*2+count+1, TAB_RIGHT, gs->std_dev, 8, 3);
804 tab_float(ssb->t, 5 ,i*2+count+1, TAB_RIGHT, gs->se_mean, 8, 3);
810 void ssbox_paired_populate(struct ssbox *ssb,
811 struct cmd_t_test *cmd);
813 /* Initialize the paired values ssbox */
815 ssbox_paired_init(struct ssbox *this, struct cmd_t_test *cmd UNUSED)
819 int vsize = n_pairs*2+1;
821 this->populate = ssbox_paired_populate;
823 ssbox_base_init(this, hsize,vsize);
824 tab_title (this->t, 0, _("Paired Sample Statistics"));
825 tab_vline(this->t,TAL_0,1,0,vsize-1);
826 tab_vline(this->t,TAL_2,2,0,vsize-1);
827 tab_text (this->t, 2, 0, TAB_CENTER | TAT_TITLE, _("Mean"));
828 tab_text (this->t, 3, 0, TAB_CENTER | TAT_TITLE, _("N"));
829 tab_text (this->t, 4, 0, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
830 tab_text (this->t, 5, 0, TAB_CENTER | TAT_TITLE, _("SE. Mean"));
834 /* Populate the ssbox for paired values */
836 ssbox_paired_populate(struct ssbox *ssb,struct cmd_t_test *cmd UNUSED)
842 for (i=0; i < n_pairs; ++i)
846 tab_text (ssb->t, 0, i*2+1, TAB_LEFT | TAT_PRINTF , _("Pair %d"),i);
848 for (j=0 ; j < 2 ; ++j)
850 struct group_statistics *gs;
852 gs = &group_proc_get (pairs[i].v[j])->ugs;
856 tab_text (ssb->t, 1, i*2+j+1, TAB_LEFT, pairs[i].v[j]->name);
859 tab_float (ssb->t,2, i*2+j+1, TAB_RIGHT, pairs[i].mean[j], 8, 2);
860 tab_float (ssb->t,3, i*2+j+1, TAB_RIGHT, pairs[i].n, 2, 0);
861 tab_float (ssb->t,4, i*2+j+1, TAB_RIGHT, pairs[i].std_dev[j], 8, 3);
862 tab_float (ssb->t,5, i*2+j+1, TAB_RIGHT, pairs[i].std_dev[j]/sqrt(pairs[i].n), 8, 3);
868 /* Populate the one sample ssbox */
870 ssbox_one_sample_populate(struct ssbox *ssb, struct cmd_t_test *cmd)
876 for (i=0; i < cmd->n_variables; ++i)
878 struct group_statistics *gs = &group_proc_get (cmd->v_variables[i])->ugs;
880 tab_text (ssb->t, 0, i+1, TAB_LEFT, cmd->v_variables[i]->name);
881 tab_float (ssb->t,1, i+1, TAB_RIGHT, gs->n, 2, 0);
882 tab_float (ssb->t,2, i+1, TAB_RIGHT, gs->mean, 8, 2);
883 tab_float (ssb->t,3, i+1, TAB_RIGHT, gs->std_dev, 8, 2);
884 tab_float (ssb->t,4, i+1, TAB_RIGHT, gs->se_mean, 8, 3);
891 /* Implementation of the Test Results box struct */
893 void trbox_base_init(struct trbox *self,size_t n_vars, int cols);
894 void trbox_base_finalize(struct trbox *trb);
896 void trbox_independent_samples_init(struct trbox *trb,
897 struct cmd_t_test *cmd );
899 void trbox_independent_samples_populate(struct trbox *trb,
900 struct cmd_t_test *cmd);
902 void trbox_one_sample_init(struct trbox *self,
903 struct cmd_t_test *cmd );
905 void trbox_one_sample_populate(struct trbox *trb,
906 struct cmd_t_test *cmd);
908 void trbox_paired_init(struct trbox *self,
909 struct cmd_t_test *cmd );
911 void trbox_paired_populate(struct trbox *trb,
912 struct cmd_t_test *cmd);
916 /* Create a trbox according to mode*/
918 trbox_create(struct trbox *trb,
919 struct cmd_t_test *cmd, int mode)
924 trbox_one_sample_init(trb,cmd);
927 trbox_independent_samples_init(trb,cmd);
930 trbox_paired_init(trb,cmd);
937 /* Populate a trbox according to cmd */
939 trbox_populate(struct trbox *trb, struct cmd_t_test *cmd)
941 trb->populate(trb,cmd);
944 /* Submit and destroy a trbox */
946 trbox_finalize(struct trbox *trb)
951 /* Initialize the independent samples trbox */
953 trbox_independent_samples_init(struct trbox *self,
954 struct cmd_t_test *cmd UNUSED)
957 const int vsize=cmd->n_variables*2+3;
960 self->populate = trbox_independent_samples_populate;
962 trbox_base_init(self,cmd->n_variables*2,hsize);
963 tab_title(self->t,0,_("Independent Samples Test"));
964 tab_hline(self->t,TAL_1,2,hsize-1,1);
965 tab_vline(self->t,TAL_2,2,0,vsize-1);
966 tab_vline(self->t,TAL_1,4,0,vsize-1);
967 tab_box(self->t,-1,-1,-1,TAL_1, 2,1,hsize-2,vsize-1);
968 tab_hline(self->t,TAL_1, hsize-2,hsize-1,2);
969 tab_box(self->t,-1,-1,-1,TAL_1, hsize-2,2,hsize-1,vsize-1);
970 tab_joint_text(self->t, 2, 0, 3, 0,
971 TAB_CENTER,_("Levene's Test for Equality of Variances"));
972 tab_joint_text(self->t, 4,0,hsize-1,0,
973 TAB_CENTER,_("t-test for Equality of Means"));
975 tab_text(self->t,2,2, TAB_CENTER | TAT_TITLE,_("F"));
976 tab_text(self->t,3,2, TAB_CENTER | TAT_TITLE,_("Sig."));
977 tab_text(self->t,4,2, TAB_CENTER | TAT_TITLE,_("t"));
978 tab_text(self->t,5,2, TAB_CENTER | TAT_TITLE,_("df"));
979 tab_text(self->t,6,2, TAB_CENTER | TAT_TITLE,_("Sig. (2-tailed)"));
980 tab_text(self->t,7,2, TAB_CENTER | TAT_TITLE,_("Mean Difference"));
981 tab_text(self->t,8,2, TAB_CENTER | TAT_TITLE,_("Std. Error Difference"));
982 tab_text(self->t,9,2, TAB_CENTER | TAT_TITLE,_("Lower"));
983 tab_text(self->t,10,2, TAB_CENTER | TAT_TITLE,_("Upper"));
985 tab_joint_text(self->t, 9, 1, 10, 1, TAB_CENTER | TAT_PRINTF,
986 _("%g%% Confidence Interval of the Difference"),
987 cmd->criteria*100.0);
991 /* Populate the independent samples trbox */
993 trbox_independent_samples_populate(struct trbox *self,
994 struct cmd_t_test *cmd )
999 for (i=0; i < cmd->n_variables; ++i)
1008 double pooled_variance;
1009 double std_err_diff;
1012 struct variable *var = cmd->v_variables[i];
1013 struct group_proc *grp_data = group_proc_get (var);
1015 struct hsh_table *grp_hash = grp_data->group_hash;
1017 struct group_statistics *gs0 ;
1018 struct group_statistics *gs1 ;
1020 union value search_val;
1022 if ( gp.criterion == CMP_LE )
1023 search_val.f = gp.v.critical_value - 1.0;
1025 search_val = gp.v.g_value[0];
1027 gs0 = hsh_find(grp_hash, (void *) &search_val);
1030 if ( gp.criterion == CMP_LE )
1031 search_val.f = gp.v.critical_value + 1.0;
1033 search_val = gp.v.g_value[1];
1035 gs1 = hsh_find(grp_hash, (void *) &search_val);
1039 tab_text (self->t, 0, i*2+3, TAB_LEFT, cmd->v_variables[i]->name);
1041 tab_text (self->t, 1, i*2+3, TAB_LEFT, _("Equal variances assumed"));
1044 tab_float(self->t, 2, i*2+3, TAB_CENTER, grp_data->levene, 8,3);
1046 /* Now work out the significance of the Levene test */
1047 df1 = 1; df2 = grp_data->ugs.n - 2;
1048 q = gsl_cdf_fdist_Q(grp_data->levene, df1, df2);
1050 tab_float(self->t, 3, i*2+3, TAB_CENTER, q, 8,3 );
1052 df = gs0->n + gs1->n - 2.0 ;
1053 tab_float (self->t, 5, i*2+3, TAB_RIGHT, df, 2, 0);
1055 pooled_variance = ( (gs0->n )*pow2(gs0->s_std_dev)
1057 (gs1->n )*pow2(gs1->s_std_dev)
1060 t = (gs0->mean - gs1->mean) / sqrt(pooled_variance) ;
1061 t /= sqrt((gs0->n + gs1->n)/(gs0->n*gs1->n));
1063 tab_float (self->t, 4, i*2+3, TAB_RIGHT, t, 8, 3);
1065 p = gsl_cdf_tdist_P(t, df);
1066 q = gsl_cdf_tdist_Q(t, df);
1068 tab_float(self->t, 6, i*2+3, TAB_RIGHT, 2.0*(t>0?q:p) , 8, 3);
1070 mean_diff = gs0->mean - gs1->mean;
1071 tab_float(self->t, 7, i*2+3, TAB_RIGHT, mean_diff, 8, 3);
1074 std_err_diff = sqrt( pow2(gs0->se_mean) + pow2(gs1->se_mean));
1075 tab_float(self->t, 8, i*2+3, TAB_RIGHT, std_err_diff, 8, 3);
1078 /* Now work out the confidence interval */
1079 q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
1081 t = gsl_cdf_tdist_Qinv(q,df);
1082 tab_float(self->t, 9, i*2+3, TAB_RIGHT,
1083 mean_diff - t * std_err_diff, 8, 3);
1085 tab_float(self->t, 10, i*2+3, TAB_RIGHT,
1086 mean_diff + t * std_err_diff, 8, 3);
1091 /* Now for the \sigma_1 != \sigma_2 case */
1092 tab_text (self->t, 1, i*2+3+1,
1093 TAB_LEFT, _("Equal variances not assumed"));
1096 se2 = (pow2(gs0->s_std_dev)/(gs0->n -1) ) +
1097 (pow2(gs1->s_std_dev)/(gs1->n -1) );
1099 t = mean_diff / sqrt(se2) ;
1100 tab_float (self->t, 4, i*2+3+1, TAB_RIGHT, t, 8, 3);
1103 (pow2(pow2(gs0->s_std_dev)/(gs0->n - 1 ))
1107 (pow2(pow2(gs1->s_std_dev)/(gs1->n - 1 ))
1111 tab_float (self->t, 5, i*2+3+1, TAB_RIGHT, df, 8, 3);
1113 p = gsl_cdf_tdist_P(t, df);
1114 q = gsl_cdf_tdist_Q(t, df);
1116 tab_float(self->t, 6, i*2+3+1, TAB_RIGHT, 2.0*(t>0?q:p) , 8, 3);
1118 /* Now work out the confidence interval */
1119 q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
1121 t = gsl_cdf_tdist_Qinv(q, df);
1123 tab_float(self->t, 7, i*2+3+1, TAB_RIGHT, mean_diff, 8, 3);
1126 tab_float(self->t, 8, i*2+3+1, TAB_RIGHT, std_err_diff, 8, 3);
1129 tab_float(self->t, 9, i*2+3+1, TAB_RIGHT,
1130 mean_diff - t * std_err_diff, 8, 3);
1132 tab_float(self->t, 10, i*2+3+1, TAB_RIGHT,
1133 mean_diff + t * std_err_diff, 8, 3);
1139 /* Initialize the paired samples trbox */
1141 trbox_paired_init(struct trbox *self,
1142 struct cmd_t_test *cmd UNUSED)
1146 const int vsize=n_pairs+3;
1148 self->populate = trbox_paired_populate;
1150 trbox_base_init(self,n_pairs,hsize);
1151 tab_title (self->t, 0, _("Paired Samples Test"));
1152 tab_hline(self->t,TAL_1,2,6,1);
1153 tab_vline(self->t,TAL_2,2,0,vsize - 1);
1154 tab_joint_text(self->t,2,0,6,0,TAB_CENTER,_("Paired Differences"));
1155 tab_box(self->t,-1,-1,-1,TAL_1, 2,1,6,vsize-1);
1156 tab_box(self->t,-1,-1,-1,TAL_1, 6,0,hsize-1,vsize-1);
1157 tab_hline(self->t,TAL_1,5,6, 2);
1158 tab_vline(self->t,TAL_0,6,0,1);
1160 tab_joint_text(self->t, 5, 1, 6, 1, TAB_CENTER | TAT_PRINTF,
1161 _("%g%% Confidence Interval of the Difference"),
1162 cmd->criteria*100.0);
1164 tab_text (self->t, 2, 2, TAB_CENTER | TAT_TITLE, _("Mean"));
1165 tab_text (self->t, 3, 2, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
1166 tab_text (self->t, 4, 2, TAB_CENTER | TAT_TITLE, _("Std. Error Mean"));
1167 tab_text (self->t, 5, 2, TAB_CENTER | TAT_TITLE, _("Lower"));
1168 tab_text (self->t, 6, 2, TAB_CENTER | TAT_TITLE, _("Upper"));
1169 tab_text (self->t, 7, 2, TAB_CENTER | TAT_TITLE, _("t"));
1170 tab_text (self->t, 8, 2, TAB_CENTER | TAT_TITLE, _("df"));
1171 tab_text (self->t, 9, 2, TAB_CENTER | TAT_TITLE, _("Sig. (2-tailed)"));
1174 /* Populate the paired samples trbox */
1176 trbox_paired_populate(struct trbox *trb,
1177 struct cmd_t_test *cmd UNUSED)
1181 for (i=0; i < n_pairs; ++i)
1186 double n = pairs[i].n;
1190 tab_text (trb->t, 0, i+3, TAB_LEFT | TAT_PRINTF, _("Pair %d"),i);
1192 tab_text (trb->t, 1, i+3, TAB_LEFT | TAT_PRINTF, "%s - %s",
1193 pairs[i].v[0]->name, pairs[i].v[1]->name);
1195 tab_float(trb->t, 2, i+3, TAB_RIGHT, pairs[i].mean_diff, 8, 4);
1197 tab_float(trb->t, 3, i+3, TAB_RIGHT, pairs[i].std_dev_diff, 8, 5);
1200 se_mean = pairs[i].std_dev_diff / sqrt(n) ;
1201 tab_float(trb->t, 4, i+3, TAB_RIGHT, se_mean, 8,5 );
1203 /* Now work out the confidence interval */
1204 q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
1206 t = gsl_cdf_tdist_Qinv(q, df);
1208 tab_float(trb->t, 5, i+3, TAB_RIGHT,
1209 pairs[i].mean_diff - t * se_mean , 8, 4);
1211 tab_float(trb->t, 6, i+3, TAB_RIGHT,
1212 pairs[i].mean_diff + t * se_mean , 8, 4);
1214 t = (pairs[i].mean[0] - pairs[i].mean[1])
1216 ( pow2 (pairs[i].s_std_dev[0]) + pow2 (pairs[i].s_std_dev[1]) -
1217 2 * pairs[i].correlation *
1218 pairs[i].s_std_dev[0] * pairs[i].s_std_dev[1] )
1222 tab_float(trb->t, 7, i+3, TAB_RIGHT, t , 8,3 );
1224 /* Degrees of freedom */
1225 tab_float(trb->t, 8, i+3, TAB_RIGHT, df , 2, 0 );
1227 p = gsl_cdf_tdist_P(t,df);
1228 q = gsl_cdf_tdist_P(t,df);
1230 tab_float(trb->t, 9, i+3, TAB_RIGHT, 2.0*(t>0?q:p) , 8, 3);
1235 /* Initialize the one sample trbox */
1237 trbox_one_sample_init(struct trbox *self, struct cmd_t_test *cmd )
1240 const int vsize=cmd->n_variables+3;
1242 self->populate = trbox_one_sample_populate;
1244 trbox_base_init(self, cmd->n_variables,hsize);
1245 tab_title (self->t, 0, _("One-Sample Test"));
1246 tab_hline(self->t, TAL_1, 1, hsize - 1, 1);
1247 tab_vline(self->t, TAL_2, 1, 0, vsize - 1);
1249 tab_joint_text(self->t, 1, 0, hsize-1,0, TAB_CENTER | TAT_PRINTF,
1250 _("Test Value = %f"), cmd->n_testval[0]);
1252 tab_box(self->t, -1, -1, -1, TAL_1, 1,1,hsize-1,vsize-1);
1255 tab_joint_text(self->t,5,1,6,1,TAB_CENTER | TAT_PRINTF,
1256 _("%g%% Confidence Interval of the Difference"),
1257 cmd->criteria*100.0);
1259 tab_vline(self->t,TAL_0,6,1,1);
1260 tab_hline(self->t,TAL_1,5,6,2);
1261 tab_text (self->t, 1, 2, TAB_CENTER | TAT_TITLE, _("t"));
1262 tab_text (self->t, 2, 2, TAB_CENTER | TAT_TITLE, _("df"));
1263 tab_text (self->t, 3, 2, TAB_CENTER | TAT_TITLE, _("Sig. (2-tailed)"));
1264 tab_text (self->t, 4, 2, TAB_CENTER | TAT_TITLE, _("Mean Difference"));
1265 tab_text (self->t, 5, 2, TAB_CENTER | TAT_TITLE, _("Lower"));
1266 tab_text (self->t, 6, 2, TAB_CENTER | TAT_TITLE, _("Upper"));
1271 /* Populate the one sample trbox */
1273 trbox_one_sample_populate(struct trbox *trb, struct cmd_t_test *cmd)
1279 for (i=0; i < cmd->n_variables; ++i)
1284 struct group_statistics *gs = &group_proc_get (cmd->v_variables[i])->ugs;
1287 tab_text (trb->t, 0, i+3, TAB_LEFT, cmd->v_variables[i]->name);
1289 t = (gs->mean - cmd->n_testval[0] ) * sqrt(gs->n) / gs->std_dev ;
1291 tab_float (trb->t, 1, i+3, TAB_RIGHT, t, 8,3);
1293 /* degrees of freedom */
1296 tab_float (trb->t, 2, i+3, TAB_RIGHT, df, 8,0);
1298 p = gsl_cdf_tdist_P(t, df);
1299 q = gsl_cdf_tdist_Q(t, df);
1301 /* Multiply by 2 to get 2-tailed significance, makeing sure we've got
1303 tab_float (trb->t, 3, i+3, TAB_RIGHT, 2.0*(t>0?q:p), 8,3);
1305 tab_float (trb->t, 4, i+3, TAB_RIGHT, gs->mean_diff, 8,3);
1308 q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
1309 t = gsl_cdf_tdist_Qinv(q, df);
1311 tab_float (trb->t, 5, i+3, TAB_RIGHT,
1312 gs->mean_diff - t * gs->se_mean, 8,4);
1314 tab_float (trb->t, 6, i+3, TAB_RIGHT,
1315 gs->mean_diff + t * gs->se_mean, 8,4);
1319 /* Base initializer for the generalized trbox */
1321 trbox_base_init(struct trbox *self, size_t data_rows, int cols)
1323 const size_t rows = 3 + data_rows;
1325 self->finalize = trbox_base_finalize;
1326 self->t = tab_create (cols, rows, 0);
1327 tab_headers (self->t,0,0,3,0);
1328 tab_box (self->t, TAL_2, TAL_2, TAL_0, TAL_0, 0, 0, cols -1, rows -1);
1329 tab_hline(self->t, TAL_2,0,cols-1,3);
1330 tab_dim (self->t, tab_natural_dimensions);
1334 /* Base finalizer for the trbox */
1336 trbox_base_finalize(struct trbox *trb)
1342 /* Create , populate and submit the Paired Samples Correlation box */
1346 const int rows=1+n_pairs;
1350 struct tab_table *table;
1352 table = tab_create (cols,rows,0);
1354 tab_columns (table, SOM_COL_DOWN, 1);
1355 tab_headers (table,0,0,1,0);
1356 tab_box (table, TAL_2, TAL_2, TAL_0, TAL_1, 0, 0, cols -1, rows -1 );
1357 tab_hline(table, TAL_2, 0, cols - 1, 1);
1358 tab_vline(table, TAL_2, 2, 0, rows - 1);
1359 tab_dim(table, tab_natural_dimensions);
1360 tab_title(table, 0, _("Paired Samples Correlations"));
1362 /* column headings */
1363 tab_text(table, 2,0, TAB_CENTER | TAT_TITLE, _("N"));
1364 tab_text(table, 3,0, TAB_CENTER | TAT_TITLE, _("Correlation"));
1365 tab_text(table, 4,0, TAB_CENTER | TAT_TITLE, _("Sig."));
1367 for (i=0; i < n_pairs; ++i)
1371 double df = pairs[i].n -2;
1373 double correlation_t =
1374 pairs[i].correlation * sqrt(df) /
1375 sqrt(1 - pow2(pairs[i].correlation));
1379 tab_text(table, 0,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF,
1382 tab_text(table, 1,i+1, TAB_LEFT | TAT_TITLE | TAT_PRINTF,
1383 _("%s & %s"), pairs[i].v[0]->name, pairs[i].v[1]->name);
1387 tab_float(table, 2, i+1, TAB_RIGHT, pairs[i].n, 4, 0);
1388 tab_float(table, 3, i+1, TAB_RIGHT, pairs[i].correlation, 8, 3);
1390 p = gsl_cdf_tdist_P(correlation_t, df);
1391 q = gsl_cdf_tdist_Q(correlation_t, df);
1393 tab_float(table, 4, i+1, TAB_RIGHT, 2.0*(correlation_t>0?q:p), 8, 3);
1402 /* Calculation Implementation */
1404 /* Per case calculations common to all variants of the T test */
1406 common_calc (const struct ccase *c, void *_cmd)
1409 struct cmd_t_test *cmd = (struct cmd_t_test *)_cmd;
1411 double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn);
1414 /* Skip the entire case if /MISSING=LISTWISE is set */
1415 if ( cmd->miss == TTS_LISTWISE )
1417 for(i=0; i< cmd->n_variables ; ++i)
1419 struct variable *v = cmd->v_variables[i];
1420 const union value *val = case_data (c, v->fv);
1422 if (value_is_missing(&v->miss, val) )
1429 /* Listwise has to be implicit if the independent variable is missing ?? */
1430 if ( cmd->sbc_groups )
1432 const union value *gv = case_data (c, indep_var->fv);
1433 if ( value_is_missing(&indep_var->miss, gv) )
1440 for(i=0; i< cmd->n_variables ; ++i)
1442 struct group_statistics *gs;
1443 struct variable *v = cmd->v_variables[i];
1444 const union value *val = case_data (c, v->fv);
1446 gs= &group_proc_get (cmd->v_variables[i])->ugs;
1448 if (! value_is_missing(&v->miss, val) )
1451 gs->sum+=weight * val->f;
1452 gs->ssq+=weight * val->f * val->f;
1458 /* Pre calculations common to all variants of the T test */
1460 common_precalc ( struct cmd_t_test *cmd )
1464 for(i=0; i< cmd->n_variables ; ++i)
1466 struct group_statistics *gs;
1467 gs= &group_proc_get (cmd->v_variables[i])->ugs;
1476 /* Post calculations common to all variants of the T test */
1478 common_postcalc ( struct cmd_t_test *cmd )
1483 for(i=0; i< cmd->n_variables ; ++i)
1485 struct group_statistics *gs;
1486 gs= &group_proc_get (cmd->v_variables[i])->ugs;
1488 gs->mean=gs->sum / gs->n;
1489 gs->s_std_dev= sqrt(
1490 ( (gs->ssq / gs->n ) - gs->mean * gs->mean )
1495 ( (gs->ssq / gs->n ) - gs->mean * gs->mean )
1498 gs->se_mean = gs->std_dev / sqrt(gs->n);
1499 gs->mean_diff= gs->sum_diff / gs->n;
1503 /* Per case calculations for one sample t test */
1505 one_sample_calc (const struct ccase *c, void *cmd_)
1508 struct cmd_t_test *cmd = (struct cmd_t_test *)cmd_;
1511 double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn);
1513 /* Skip the entire case if /MISSING=LISTWISE is set */
1514 if ( cmd->miss == TTS_LISTWISE )
1516 for(i=0; i< cmd->n_variables ; ++i)
1518 struct variable *v = cmd->v_variables[i];
1519 const union value *val = case_data (c, v->fv);
1521 if (value_is_missing(&v->miss, val) )
1528 for(i=0; i< cmd->n_variables ; ++i)
1530 struct group_statistics *gs;
1531 struct variable *v = cmd->v_variables[i];
1532 const union value *val = case_data (c, v->fv);
1534 gs= &group_proc_get (cmd->v_variables[i])->ugs;
1536 if ( ! value_is_missing(&v->miss, val))
1537 gs->sum_diff += weight * (val->f - cmd->n_testval[0]);
1543 /* Pre calculations for one sample t test */
1545 one_sample_precalc ( struct cmd_t_test *cmd )
1549 for(i=0; i< cmd->n_variables ; ++i)
1551 struct group_statistics *gs;
1552 gs= &group_proc_get (cmd->v_variables[i])->ugs;
1558 /* Post calculations for one sample t test */
1560 one_sample_postcalc (struct cmd_t_test *cmd)
1564 for(i=0; i< cmd->n_variables ; ++i)
1566 struct group_statistics *gs;
1567 gs= &group_proc_get (cmd->v_variables[i])->ugs;
1569 gs->mean_diff = gs->sum_diff / gs->n ;
1576 paired_precalc (struct cmd_t_test *cmd UNUSED)
1580 for(i=0; i < n_pairs ; ++i )
1583 pairs[i].sum[0] = 0; pairs[i].sum[1] = 0;
1584 pairs[i].ssq[0] = 0; pairs[i].ssq[1] = 0;
1585 pairs[i].sum_of_prod = 0;
1586 pairs[i].correlation = 0;
1587 pairs[i].sum_of_diffs = 0;
1588 pairs[i].ssq_diffs = 0;
1595 paired_calc (const struct ccase *c, void *cmd_)
1599 struct cmd_t_test *cmd = (struct cmd_t_test *) cmd_;
1601 double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn);
1603 /* Skip the entire case if /MISSING=LISTWISE is set ,
1604 AND one member of a pair is missing */
1605 if ( cmd->miss == TTS_LISTWISE )
1607 for(i=0; i < n_pairs ; ++i )
1609 struct variable *v0 = pairs[i].v[0];
1610 struct variable *v1 = pairs[i].v[1];
1612 const union value *val0 = case_data (c, v0->fv);
1613 const union value *val1 = case_data (c, v1->fv);
1615 if ( value_is_missing(&v0->miss, val0) ||
1616 value_is_missing(&v1->miss, val1) )
1623 for(i=0; i < n_pairs ; ++i )
1625 struct variable *v0 = pairs[i].v[0];
1626 struct variable *v1 = pairs[i].v[1];
1628 const union value *val0 = case_data (c, v0->fv);
1629 const union value *val1 = case_data (c, v1->fv);
1631 if ( ( !value_is_missing(&v0->miss, val0)
1632 && !value_is_missing(&v1->miss, val1) ) )
1634 pairs[i].n += weight;
1635 pairs[i].sum[0] += weight * val0->f;
1636 pairs[i].sum[1] += weight * val1->f;
1638 pairs[i].ssq[0] += weight * pow2(val0->f);
1639 pairs[i].ssq[1] += weight * pow2(val1->f);
1641 pairs[i].sum_of_prod += weight * val0->f * val1->f ;
1643 pairs[i].sum_of_diffs += weight * ( val0->f - val1->f ) ;
1644 pairs[i].ssq_diffs += weight * pow2(val0->f - val1->f);
1652 paired_postcalc (struct cmd_t_test *cmd UNUSED)
1656 for(i=0; i < n_pairs ; ++i )
1659 const double n = pairs[i].n;
1661 for (j=0; j < 2 ; ++j)
1663 pairs[i].mean[j] = pairs[i].sum[j] / n ;
1664 pairs[i].s_std_dev[j] = sqrt((pairs[i].ssq[j] / n -
1665 pow2(pairs[i].mean[j]))
1668 pairs[i].std_dev[j] = sqrt(n/(n-1)*(pairs[i].ssq[j] / n -
1669 pow2(pairs[i].mean[j]))
1673 pairs[i].correlation = pairs[i].sum_of_prod / pairs[i].n -
1674 pairs[i].mean[0] * pairs[i].mean[1] ;
1675 /* correlation now actually contains the covariance */
1677 pairs[i].correlation /= pairs[i].std_dev[0] * pairs[i].std_dev[1];
1678 pairs[i].correlation *= pairs[i].n / ( pairs[i].n - 1 );
1680 pairs[i].mean_diff = pairs[i].sum_of_diffs / n ;
1682 pairs[i].std_dev_diff = sqrt ( n / (n - 1) * (
1683 ( pairs[i].ssq_diffs / n )
1685 pow2(pairs[i].mean_diff )
1691 group_precalc (struct cmd_t_test *cmd )
1696 for(i=0; i< cmd->n_variables ; ++i)
1698 struct group_proc *ttpr = group_proc_get (cmd->v_variables[i]);
1700 /* There's always 2 groups for a T - TEST */
1703 gp.indep_width = indep_var->width;
1705 ttpr->group_hash = hsh_create(2,
1706 (hsh_compare_func *) compare_group_binary,
1707 (hsh_hash_func *) hash_group_binary,
1708 (hsh_free_func *) free_group,
1711 for (j=0 ; j < 2 ; ++j)
1714 struct group_statistics *gs = (struct group_statistics *)
1715 xmalloc (sizeof(struct group_statistics));
1721 if ( gp.criterion == CMP_EQ )
1723 gs->id = gp.v.g_value[j];
1728 gs->id.f = gp.v.critical_value - 1.0 ;
1730 gs->id.f = gp.v.critical_value + 1.0 ;
1733 hsh_insert ( ttpr->group_hash, (void *) gs );
1741 group_calc (const struct ccase *c, struct cmd_t_test *cmd)
1745 const union value *gv = case_data (c, indep_var->fv);
1747 const double weight = dict_get_case_weight(default_dict,c,&bad_weight_warn);
1749 if ( value_is_missing(&indep_var->miss, gv) )
1754 if ( cmd->miss == TTS_LISTWISE )
1756 for(i=0; i< cmd->n_variables ; ++i)
1758 struct variable *v = cmd->v_variables[i];
1759 const union value *val = case_data (c, v->fv);
1761 if (value_is_missing(&v->miss, val) )
1768 gv = case_data (c, indep_var->fv);
1770 for(i=0; i< cmd->n_variables ; ++i)
1772 struct variable *var = cmd->v_variables[i];
1773 const union value *val = case_data (c, var->fv);
1774 struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
1775 struct group_statistics *gs;
1777 gs = hsh_find(grp_hash, (void *) gv);
1779 /* If the independent variable doesn't match either of the values
1780 for this case then move on to the next case */
1784 if ( !value_is_missing(&var->miss, val) )
1787 gs->sum+=weight * val->f;
1788 gs->ssq+=weight * pow2(val->f);
1797 group_postcalc ( struct cmd_t_test *cmd )
1801 for(i=0; i< cmd->n_variables ; ++i)
1803 struct variable *var = cmd->v_variables[i];
1804 struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
1805 struct hsh_iterator g;
1806 struct group_statistics *gs;
1809 for (gs = hsh_first (grp_hash,&g);
1811 gs = hsh_next(grp_hash,&g))
1813 gs->mean = gs->sum / gs->n;
1815 gs->s_std_dev= sqrt(
1816 ( (gs->ssq / gs->n ) - gs->mean * gs->mean )
1821 ( (gs->ssq / gs->n ) - gs->mean * gs->mean )
1824 gs->se_mean = gs->std_dev / sqrt(gs->n);
1834 calculate(const struct casefile *cf, void *cmd_)
1836 struct ssbox stat_summary_box;
1837 struct trbox test_results_box;
1839 struct casereader *r;
1842 struct cmd_t_test *cmd = (struct cmd_t_test *) cmd_;
1844 common_precalc(cmd);
1845 for(r = casefile_get_reader (cf);
1846 casereader_read (r, &c) ;
1849 common_calc(&c,cmd);
1851 casereader_destroy (r);
1852 common_postcalc(cmd);
1857 one_sample_precalc(cmd);
1858 for(r = casefile_get_reader (cf);
1859 casereader_read (r, &c) ;
1862 one_sample_calc(&c,cmd);
1864 casereader_destroy (r);
1865 one_sample_postcalc(cmd);
1869 paired_precalc(cmd);
1870 for(r = casefile_get_reader (cf);
1871 casereader_read (r, &c) ;
1874 paired_calc(&c,cmd);
1876 casereader_destroy (r);
1877 paired_postcalc(cmd);
1883 for(r = casefile_get_reader (cf);
1884 casereader_read (r, &c) ;
1889 casereader_destroy (r);
1890 group_postcalc(cmd);
1892 levene(cf, indep_var, cmd->n_variables, cmd->v_variables,
1893 (cmd->miss == TTS_LISTWISE)?LEV_LISTWISE:LEV_ANALYSIS ,
1898 ssbox_create(&stat_summary_box,cmd,mode);
1899 ssbox_populate(&stat_summary_box,cmd);
1900 ssbox_finalize(&stat_summary_box);
1902 if ( mode == T_PAIRED)
1905 trbox_create(&test_results_box,cmd,mode);
1906 trbox_populate(&test_results_box,cmd);
1907 trbox_finalize(&test_results_box);
1911 short which_group(const struct group_statistics *g,
1912 const struct group_properties *p);
1914 /* Return -1 if the id of a is less than b; +1 if greater than and
1917 compare_group_binary(const struct group_statistics *a,
1918 const struct group_statistics *b,
1919 const struct group_properties *p)
1924 if ( p->criterion == CMP_LE )
1926 /* less-than-or-equal comparision is not meaningfull for
1927 alpha variables, so we shouldn't ever arrive here */
1928 assert(p->indep_width == 0 ) ;
1930 flag_a = ( a->id.f < p->v.critical_value ) ;
1931 flag_b = ( b->id.f < p->v.critical_value ) ;
1935 flag_a = which_group(a, p);
1936 flag_b = which_group(b, p);
1939 if (flag_a < flag_b )
1942 return (flag_a > flag_b);
1945 /* This is a degenerate case of a hash, since it can only return three possible
1946 values. It's really a comparison, being used as a hash function */
1949 hash_group_binary(const struct group_statistics *g,
1950 const struct group_properties *p)
1954 if ( p->criterion == CMP_LE )
1956 /* Not meaningfull to do a less than compare for alpha values ? */
1957 assert(p->indep_width == 0 ) ;
1958 flag = ( g->id.f < p->v.critical_value ) ;
1960 else if ( p->criterion == CMP_EQ)
1962 flag = which_group(g,p);
1970 /* return 0 if G belongs to group 0,
1971 1 if it belongs to group 1,
1972 2 if it belongs to neither group */
1974 which_group(const struct group_statistics *g,
1975 const struct group_properties *p)
1978 if ( 0 == compare_values (&g->id, &p->v.g_value[0], p->indep_width))
1981 if ( 0 == compare_values (&g->id, &p->v.g_value[1], p->indep_width))