839d0dc8fa323abd6acbfbb99258a2bd7ce8c96c
[pspp] / src / t-test.q
1 /* PSPP - computes sample statistics. -*-c-*-
2
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
6
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.
11
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.
16
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., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA. */
21
22 #include <config.h>
23 #include <assert.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <math.h>
27 #include "alloc.h"
28 #include "str.h"
29 #include "dcdflib/cdflib.h"
30 #include "command.h"
31 #include "lexer.h"
32 #include "error.h"
33 #include "magic.h"
34 #include "tab.h"
35 #include "som.h"
36 #include "value-labels.h"
37 #include "var.h"
38 #include "vfm.h"
39 #include "pool.h"
40
41 /* (specification)
42    "T-TEST" (tts_):
43      groups=custom;
44      testval=double;
45      variables=varlist("PV_NO_SCRATCH | PV_NUMERIC");
46      pairs=custom;
47      +missing=miss:!analysis/listwise,
48              incl:include/!exclude;
49      format=fmt:!labels/nolabels;
50      criteria=:cin(d:criteria,"%s > 0. && %s < 1.").
51 */
52 /* (declarations) */
53 /* (functions) */
54
55 static struct cmd_t_test cmd;
56
57
58 static struct pool *t_test_pool ;
59
60 /* Variable for the GROUPS subcommand, if given. */
61 static struct variable *groups;
62
63 /* GROUPS: Number of values specified by the user; the values
64    specified if any. */
65 static int n_groups_values;
66 static union value groups_values[2];
67
68 /* PAIRS: Number of pairs to be compared ; each pair. */
69 static int n_pairs ;
70 typedef struct variable *pair_t[2] ;
71 static pair_t *pairs;
72
73
74 static int parse_value (union value * v, int type) ;
75
76
77 /* Structures and Functions for the Statistics Summary Box */
78 struct ssbox;
79 typedef void populate_ssbox_func(struct ssbox *ssb,
80                                             struct cmd_t_test *cmd);
81 typedef void finalize_ssbox_func(struct ssbox *ssb);
82
83 struct ssbox
84 {
85   struct tab_table *t;
86
87   populate_ssbox_func *populate;
88   finalize_ssbox_func *finalize;
89
90 };
91
92 /* Create a ssbox */
93 void ssbox_create(struct ssbox *ssb,   struct cmd_t_test *cmd, int mode);
94
95 /* Populate a ssbox according to cmd */
96 void ssbox_populate(struct ssbox *ssb, struct cmd_t_test *cmd);
97
98 /* Submit and destroy a ssbox */
99 void ssbox_finalize(struct ssbox *ssb);
100
101
102
103 /* Structures and Functions for the Test Results Box */
104 struct trbox;
105
106 typedef void populate_trbox_func(struct trbox *trb,
107                                  struct cmd_t_test *cmd);
108 typedef void finalize_trbox_func(struct trbox *trb);
109
110 struct trbox {
111   struct tab_table *t;
112   populate_trbox_func *populate;
113   finalize_trbox_func *finalize;
114 };
115
116 /* Create a trbox */
117 void trbox_create(struct trbox *trb,   struct cmd_t_test *cmd, int mode);
118
119 /* Populate a ssbox according to cmd */
120 void trbox_populate(struct trbox *trb, struct cmd_t_test *cmd);
121
122 /* Submit and destroy a ssbox */
123 void trbox_finalize(struct trbox *trb);
124
125 /* Which mode was T-TEST invoked */
126 enum {
127   T_1_SAMPLE = 0 ,
128   T_IND_SAMPLES, 
129   T_PAIRED
130 };
131
132 int
133 cmd_t_test(void)
134 {
135   int mode;
136
137   struct ssbox stat_summary_box;
138   struct trbox test_results_box;
139
140   
141   if (!lex_force_match_id ("T"))
142     return CMD_FAILURE;
143
144   lex_match ('-');
145   lex_match_id ("TEST");
146
147   if ( !parse_t_test(&cmd) )
148     return CMD_FAILURE;
149
150
151   if (! cmd.sbc_criteria)
152     cmd.criteria=0.95;
153
154
155   if ( cmd.sbc_testval + cmd.sbc_groups + cmd.sbc_pairs != 1 ) 
156     {
157       msg(SE, 
158           _("Exactly one of TESTVAL, GROUPS or PAIRS subcommands is required")
159           );
160       return CMD_FAILURE;
161     }
162
163   if (cmd.sbc_testval) 
164     mode=T_1_SAMPLE;
165   else if (cmd.sbc_groups)
166     mode=T_IND_SAMPLES;
167   else
168     mode=T_PAIRED;
169
170   if ( mode == T_PAIRED && cmd.sbc_variables) 
171     {
172       msg(SE, _("VARIABLES subcommand is not appropriate with PAIRS"));
173       return CMD_FAILURE;
174     }
175
176
177
178   t_test_pool = pool_create ();
179
180   ssbox_create(&stat_summary_box,&cmd,mode);
181   trbox_create(&test_results_box,&cmd,mode);
182
183   ssbox_populate(&stat_summary_box,&cmd);
184   trbox_populate(&test_results_box,&cmd);
185
186   ssbox_finalize(&stat_summary_box);
187   trbox_finalize(&test_results_box);
188
189   pool_destroy (t_test_pool);
190
191   t_test_pool=0;
192
193     
194   return CMD_SUCCESS;
195 }
196
197
198 static int
199 tts_custom_groups (struct cmd_t_test *cmd unused)
200 {
201   lex_match('=');
202
203   if (token != T_ALL && 
204       (token != T_ID || dict_lookup_var (default_dict, tokid) == NULL)
205      ) 
206   {
207     msg(SE,_("`%s' is not a variable name"),tokid);
208     return 0;
209   }
210
211   groups = parse_variable ();
212   if (!groups)
213     {
214       lex_error ("expecting variable name in GROUPS subcommand");
215       return 0;
216     }
217
218   if (groups->type == T_STRING && groups->width > MAX_SHORT_STRING)
219     {
220       msg (SE, _("Long string variable %s is not valid here."),
221            groups->name);
222       return 0;
223     }
224
225   if (!lex_match ('('))
226     {
227
228       if (groups->type == NUMERIC)
229         {
230           n_groups_values = 2;
231           groups_values[0].f = 1;
232           groups_values[1].f = 2;
233           return 1;
234         }
235       else
236         {
237           msg (SE, _("When applying GROUPS to a string variable, at "
238                      "least one value must be specified."));
239           return 0;
240         }
241     }
242
243   if (!parse_value (&groups_values[0],groups->type))
244     return 0;
245   n_groups_values = 1;
246
247   lex_match (',');
248
249   if (lex_match (')'))
250     return 1;
251
252   if (!parse_value (&groups_values[1],groups->type))
253     return 0;
254   n_groups_values = 2;
255
256   if (!lex_force_match (')'))
257     return 0;
258
259   return 1;
260 }
261
262 static int
263 tts_custom_pairs (struct cmd_t_test *cmd unused)
264 {
265   struct variable **vars;
266   int n_vars;
267   int n_before_WITH ;
268   int n_after_WITH =-1;
269   int paired ; /* Was the PAIRED keyword given ? */
270
271   lex_match('=');
272
273   if ((token != T_ID || dict_lookup_var (default_dict, tokid) == NULL)
274       && token != T_ALL)
275     {
276       msg(SE,_("`%s' is not a variable name"),tokid);
277       return 0;
278     }
279
280   n_vars=0;
281   if (!parse_variables (default_dict, &vars, &n_vars,
282                         PV_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH))
283     {
284       free (vars);
285       return 0;
286     }
287   
288   
289   assert (n_vars);
290
291   n_before_WITH=0;
292   if (lex_match (T_WITH))
293     {
294       n_before_WITH = n_vars;
295
296       if (!parse_variables (default_dict, &vars, &n_vars,
297                             PV_DUPLICATE | PV_APPEND
298                             | PV_NUMERIC | PV_NO_SCRATCH))
299         {
300           free (vars);
301           return 0;
302         }
303
304       n_after_WITH = n_vars - n_before_WITH;
305     }
306
307
308   paired = (lex_match ('(') && lex_match_id ("PAIRED") && lex_match (')'));
309
310   
311   /* Determine the number of pairs needed */
312
313   if (paired)
314     {
315       if (n_before_WITH != n_after_WITH)
316         {
317           free (vars);
318           msg (SE, _("PAIRED was specified but the number of variables "
319                      "preceding WITH (%d) did not match the number "
320                      "following (%d)."),
321                n_before_WITH, n_after_WITH );
322           return 0;
323         }
324
325       n_pairs=n_before_WITH;
326
327     }
328   else if (n_before_WITH > 0) /* WITH keyword given, but not PAIRED keyword */
329     {
330       n_pairs=n_before_WITH * n_after_WITH ;
331     }
332   else /* Neither WITH nor PAIRED keyword given */
333     {
334       if (n_vars < 2)
335         {
336           free (vars);
337           msg (SE, _("At least two variables must be specified "
338                      "on PAIRS."));
339           return 0;
340         }
341
342       /* how many ways can you pick 2 from n_vars ? */
343       n_pairs = n_vars * (n_vars -1 ) /2 ;
344     }
345
346   /* Allocate storage for the pairs */
347
348   pairs = xrealloc(pairs,sizeof(pair_t) *n_pairs);
349
350
351   /* Populate the pairs with the appropriate variables */
352   
353   if ( paired ) 
354     {
355       int i;
356
357       assert(n_pairs == n_vars/2);
358       for (i = 0; i < n_pairs ; ++i)
359         {
360           pairs[i][0] = vars[i];
361           pairs[i][1] = vars[i+n_pairs];
362         }
363     }
364   else if (n_before_WITH > 0) /* WITH keyword given, but not PAIRED keyword */
365     {
366       int i,j;
367       int p=0;
368
369       for(i=0 ; i < n_before_WITH ; ++i ) 
370         {
371           for(j=0 ; j < n_after_WITH ; ++j)
372             {
373               pairs[p][0] = vars[i];
374               pairs[p][1] = vars[j+n_before_WITH];
375               ++p;
376             }
377         }
378     }
379   else /* Neither WITH nor PAIRED given */
380     {
381       int i,j;
382       int p=0;
383       
384       for(i=0 ; i < n_vars ; ++i ) 
385         {
386           for(j=i+1 ; j < n_vars ; ++j)
387             {
388               pairs[p][0] = vars[i];
389               pairs[p][1] = vars[j];
390               ++p;
391             }
392         }
393     }
394
395   return 1;
396 }
397
398
399 /* Parses the current token (numeric or string, depending on type)
400     value v and returns success. */
401 static int
402 parse_value (union value * v, int type )
403 {
404   if (type == NUMERIC)
405     {
406       if (!lex_force_num ())
407         return 0;
408       v->f = tokval;
409     }
410   else
411     {
412       if (!lex_force_string ())
413         return 0;
414       strncpy (v->s, ds_value (&tokstr), ds_length (&tokstr));
415     }
416
417   lex_get ();
418
419   return 1;
420 }
421
422
423 /* *******************************************************************
424                               SSBOX Implementation
425
426    ***************************************************************** */
427
428
429
430 void ssbox_base_init(struct ssbox *this, int cols,int rows);
431
432 void ssbox_base_finalize(struct ssbox *ssb);
433
434 void ssbox_one_sample_init(struct ssbox *this, 
435                            struct cmd_t_test *cmd );
436
437 void ssbox_independent_samples_init(struct ssbox *this,
438                                     struct cmd_t_test *cmd);
439
440 void ssbox_paired_init(struct ssbox *this,
441                            struct cmd_t_test *cmd);
442
443 /* Factory to create an ssbox */
444 void 
445 ssbox_create(struct ssbox *ssb, struct cmd_t_test *cmd, int mode)
446 {
447
448     switch (mode) 
449       {
450       case T_1_SAMPLE:
451         ssbox_one_sample_init(ssb,cmd);
452         break;
453       case T_IND_SAMPLES:
454         ssbox_independent_samples_init(ssb,cmd);
455         break;
456       case T_PAIRED:
457         ssbox_paired_init(ssb,cmd);
458         break;
459       default:
460         assert(0);
461       }
462
463 }
464
465
466 void
467 ssbox_populate(struct ssbox *ssb,struct cmd_t_test *cmd)
468 {
469   ssb->populate(ssb,cmd);
470 }
471
472
473 void
474 ssbox_finalize(struct ssbox *ssb)
475 {
476   ssb->finalize(ssb);
477 }
478
479
480
481 void 
482 ssbox_base_finalize(struct ssbox *ssb)
483 {
484   tab_submit(ssb->t);
485 }
486
487
488 void 
489 ssbox_base_init(struct ssbox *this, int cols,int rows)
490 {
491   this->finalize = ssbox_base_finalize;
492   this->t = tab_create (cols, rows, 0);
493
494   tab_columns (this->t, SOM_COL_DOWN, 1);
495
496   tab_headers (this->t,0,0,1,0); 
497
498   tab_box (this->t, TAL_2, TAL_2, TAL_0, TAL_1, 0, 0, cols -1, rows -1 );
499
500   tab_hline(this->t, TAL_2,0,cols-1,1);
501
502   tab_dim (this->t, tab_natural_dimensions);
503
504 }
505
506
507
508 void  ssbox_one_sample_populate(struct ssbox *ssb,
509                               struct cmd_t_test *cmd);
510
511
512
513 void 
514 ssbox_one_sample_init(struct ssbox *this, 
515                            struct cmd_t_test *cmd )
516 {
517   const int hsize=5;
518   const int vsize=cmd->n_variables+1;
519
520   this->populate = ssbox_one_sample_populate;
521
522   ssbox_base_init(this, hsize,vsize);
523
524
525   tab_title (this->t, 0, _("One-Sample Statistics"));
526
527   tab_vline(this->t, TAL_2, 1,0,vsize);
528
529   tab_text (this->t, 1, 0, TAB_CENTER | TAT_TITLE, _("N"));
530   tab_text (this->t, 2, 0, TAB_CENTER | TAT_TITLE, _("Mean"));
531   tab_text (this->t, 3, 0, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
532   tab_text (this->t, 4, 0, TAB_CENTER | TAT_TITLE, _("SE. Mean"));
533
534
535 }
536
537
538 void ssbox_independent_samples_populate(struct ssbox *ssb,
539                                         struct cmd_t_test *cmd);
540
541
542 void 
543 ssbox_independent_samples_init(struct ssbox *this, 
544         struct cmd_t_test *cmd)
545
546 {
547   int hsize=6;
548   int vsize = cmd->n_variables*2 +1;
549
550   this->populate = ssbox_independent_samples_populate;
551
552   ssbox_base_init(this, hsize,vsize);
553
554   tab_title (this->t, 0, _("Group Statistics"));
555
556   tab_vline(this->t,0,1,0,vsize);
557
558   tab_text (this->t, 1, 0, TAB_CENTER | TAT_TITLE, groups->name);
559
560   tab_text (this->t, 2, 0, TAB_CENTER | TAT_TITLE, _("N"));
561   tab_text (this->t, 3, 0, TAB_CENTER | TAT_TITLE, _("Mean"));
562   tab_text (this->t, 4, 0, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
563   tab_text (this->t, 5, 0, TAB_CENTER | TAT_TITLE, _("SE. Mean"));
564
565
566 }
567
568
569 void 
570 ssbox_independent_samples_populate(struct ssbox *ssb,
571                               struct cmd_t_test *cmd)
572 {
573   int i;
574
575   char *val_lab1=0;
576   char *val_lab2=0;
577
578   if ( groups->type == NUMERIC ) 
579     {
580       val_lab1 = val_labs_find( groups->val_labs,groups_values[0]); 
581       val_lab2 = val_labs_find( groups->val_labs,groups_values[1]);
582     }
583   else
584     {
585       val_lab1 = groups_values[0].s;
586       val_lab2 = groups_values[1].s;
587     }
588
589
590   assert(ssb->t);
591
592   for (i=0; i < cmd->n_variables; ++i)
593     {
594       tab_text (ssb->t, 0, i*2+1, 
595                 TAB_LEFT, cmd->v_variables[i]->name);
596
597       if (val_lab1)
598         tab_text (ssb->t, 1, i*2+1,
599                 TAB_LEFT, val_lab1);
600       else
601         tab_float(ssb->t, 1 ,i*2+1,
602                   TAB_LEFT, groups_values[0].f, 2,0);
603
604
605       if (val_lab2)
606         tab_text (ssb->t, 1, i*2+1+1,
607                   TAB_LEFT, val_lab2);
608       else
609         tab_float(ssb->t, 1 ,i*2+1+1,
610                   TAB_LEFT, groups_values[1].f,2,0);
611
612
613     }
614
615 }
616
617
618 void ssbox_paired_populate(struct ssbox *ssb,
619                            struct cmd_t_test *cmd);
620
621
622 void 
623 ssbox_paired_init(struct ssbox *this, 
624                            struct cmd_t_test *cmd unused)
625 {
626   int hsize=6;
627
628   int vsize = n_pairs*2+1;
629
630   this->populate = ssbox_paired_populate;
631
632   ssbox_base_init(this, hsize,vsize);
633
634   tab_title (this->t, 0, _("Paired Sample Statistics"));
635
636   tab_vline(this->t,TAL_0,1,0,vsize-1);
637   tab_vline(this->t,TAL_2,2,0,vsize-1);
638
639   tab_text (this->t, 2, 0, TAB_CENTER | TAT_TITLE, _("Mean"));
640   tab_text (this->t, 3, 0, TAB_CENTER | TAT_TITLE, _("N"));
641   tab_text (this->t, 4, 0, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
642   tab_text (this->t, 5, 0, TAB_CENTER | TAT_TITLE, _("SE. Mean"));
643
644
645 }
646
647
648 void 
649 ssbox_paired_populate(struct ssbox *ssb,
650                               struct cmd_t_test *cmd unused)
651 {
652   int i;
653   struct string ds;
654
655   assert(ssb->t);
656
657   ds_init(t_test_pool,&ds,15);
658
659
660   for (i=0; i < n_pairs; ++i)
661     {
662
663       ds_clear(&ds);
664
665       ds_printf(&ds,_("Pair %d"),i);
666
667       tab_text (ssb->t, 0, i*2+1, TAB_LEFT, ds.string);
668
669       tab_text (ssb->t, 1, i*2+1, TAB_LEFT, pairs[i][0]->name);
670       tab_text (ssb->t, 1, i*2+2, TAB_LEFT, pairs[i][1]->name);
671     }
672
673   ds_destroy(&ds);
674 }
675
676
677 void 
678 ssbox_one_sample_populate(struct ssbox *ssb,
679                               struct cmd_t_test *cmd)
680 {
681   int i;
682
683   assert(ssb->t);
684
685   for (i=0; i < cmd->n_variables; ++i)
686     {
687       tab_text (ssb->t, 0, i+1, 
688                 TAB_LEFT, cmd->v_variables[i]->name);
689     }
690   
691 }
692
693
694 /* ****************************************************************
695
696       TEST RESULT BOX Implementation
697
698    *****************************************************************/   
699
700 void trbox_base_init(struct trbox *self,int n_vars, int cols);
701 void trbox_base_finalize(struct trbox *trb);
702
703 void trbox_independent_samples_init(struct trbox *trb,
704                                     struct cmd_t_test *cmd );
705
706 void trbox_independent_samples_populate(struct trbox *trb,
707                                         struct cmd_t_test *cmd);
708
709 void trbox_one_sample_init(struct trbox *self,
710                       struct cmd_t_test *cmd );
711
712 void trbox_one_sample_populate(struct trbox *trb,
713                                struct cmd_t_test *cmd);
714
715 void trbox_paired_init(struct trbox *self,
716                        struct cmd_t_test *cmd );
717
718 void trbox_paired_populate(struct trbox *trb,
719                       struct cmd_t_test *cmd);
720
721
722
723 /* Create a trbox */
724 void 
725 trbox_create(struct trbox *trb,   
726              struct cmd_t_test *cmd, int mode)
727 {
728
729     switch (mode) 
730       {
731       case T_1_SAMPLE:
732         trbox_one_sample_init(trb,cmd);
733         break;
734
735
736       case T_IND_SAMPLES:
737         trbox_independent_samples_init(trb,cmd);
738         break;
739
740
741       case T_PAIRED:
742         trbox_paired_init(trb,cmd);
743         break;
744         
745       default:
746         assert(0);
747       }
748
749 }
750
751 /* Populate a trbox according to cmd */
752 void 
753 trbox_populate(struct trbox *trb, struct cmd_t_test *cmd)
754 {
755   trb->populate(trb,cmd);
756 }
757
758 /* Submit and destroy a trbox */
759 void 
760 trbox_finalize(struct trbox *trb)
761 {
762   trb->finalize(trb);
763 }
764
765
766 void 
767 trbox_independent_samples_init(struct trbox *self,
768                            struct cmd_t_test *cmd unused)
769 {
770   const int hsize=11;
771   const int vsize=cmd->n_variables*2+3;
772
773   struct string ds;
774
775   assert(self);
776
777   self->populate = trbox_independent_samples_populate;
778
779   trbox_base_init(self,cmd->n_variables*2,hsize);
780
781   tab_title(self->t,0,_("Independent Samples Test"));
782
783   tab_hline(self->t,TAL_1,2,hsize-1,1);
784   tab_vline(self->t,TAL_2,2,0,vsize-1);
785
786   tab_vline(self->t,TAL_1,4,0,vsize-1);
787
788   tab_box(self->t,-1,-1,-1,TAL_1,
789           2,1,hsize-2,vsize-1);
790
791
792   tab_hline(self->t,TAL_1,
793             hsize-2,hsize-1,2);
794
795   tab_box(self->t,-1,-1,-1,TAL_1,
796           hsize-2,2,hsize-1,vsize-1);
797
798
799   tab_joint_text(self->t, 2,0,3,0,
800                  TAB_CENTER,_("Levine's Test for Equality of Variances"));
801
802   tab_joint_text(self->t, 4,0,hsize-1,0,
803                  TAB_CENTER,_("t-test for Equality of Means"));
804
805
806   tab_text(self->t,2,2, TAB_CENTER | TAT_TITLE,_("F"));
807   tab_text(self->t,3,2, TAB_CENTER | TAT_TITLE,_("Sig."));
808   tab_text(self->t,4,2, TAB_CENTER | TAT_TITLE,_("t"));
809   tab_text(self->t,5,2, TAB_CENTER | TAT_TITLE,_("df"));
810   tab_text(self->t,6,2, TAB_CENTER | TAT_TITLE,_("Sig. (2-tailed)"));
811   tab_text(self->t,7,2, TAB_CENTER | TAT_TITLE,_("Mean Difference"));
812   tab_text(self->t,8,2, TAB_CENTER | TAT_TITLE,_("Std. Error Difference"));
813   tab_text(self->t,9,2, TAB_CENTER | TAT_TITLE,_("Lower"));
814   tab_text(self->t,10,2, TAB_CENTER | TAT_TITLE,_("Upper"));
815
816
817   ds_init(t_test_pool,&ds,80);
818                 
819   ds_printf(&ds,_("%d%% Confidence Interval of the Difference"),
820             (int)round(cmd->criteria*100.0));
821
822   tab_joint_text(self->t,9,1,10,1,TAB_CENTER,
823                  ds.string);
824
825
826   ds_destroy(&ds);
827
828
829
830 }
831
832 void 
833 trbox_independent_samples_populate(struct trbox *self,
834                            struct cmd_t_test *cmd )
835 {
836   int i;
837
838   assert(self);
839
840   for (i=0; i < cmd->n_variables; ++i)
841     {
842       tab_text (self->t, 0, i*2+3, 
843                 TAB_LEFT, cmd->v_variables[i]->name);
844
845       tab_text (self->t, 1, i*2+3, 
846                 TAB_LEFT, _("Equal variances assumed"));
847
848       tab_text (self->t, 1, i*2+3+1, 
849                 TAB_LEFT, _("Equal variances not assumed"));
850
851
852     }
853
854 }
855
856
857 void 
858 trbox_paired_init(struct trbox *self,
859                            struct cmd_t_test *cmd unused)
860 {
861
862   const int hsize=10;
863   const int vsize=n_pairs*2+3;
864
865   struct string ds;
866
867   self->populate = trbox_paired_populate;
868
869   trbox_base_init(self,n_pairs*2,hsize);
870
871
872   tab_title (self->t, 0, _("Paired Samples Test"));
873
874
875   tab_hline(self->t,TAL_1,2,6,1);
876   tab_vline(self->t,TAL_2,2,0,vsize);
877
878
879
880   tab_joint_text(self->t,2,0,6,0,TAB_CENTER,_("Paired Differences"));
881
882
883   tab_box(self->t,-1,-1,-1,TAL_1,
884           2,1,6,vsize-1);
885
886
887   tab_box(self->t,-1,-1,-1,TAL_1,
888           6,0,hsize-1,vsize-1);
889
890
891
892   tab_hline(self->t,TAL_1,5,6, 2);
893   tab_vline(self->t,TAL_0,6,0,1);
894
895
896   ds_init(t_test_pool,&ds,80);
897                 
898   ds_printf(&ds,_("%d%% Confidence Interval of the Difference"),
899             (int)round(cmd->criteria*100.0));
900
901   tab_joint_text(self->t,5,1,6,1,TAB_CENTER,
902                  ds.string);
903
904
905   ds_destroy(&ds);
906
907   tab_text (self->t, 2, 2, TAB_CENTER | TAT_TITLE, _("Mean"));
908   tab_text (self->t, 3, 2, TAB_CENTER | TAT_TITLE, _("Std. Deviation"));
909   tab_text (self->t, 4, 2, TAB_CENTER | TAT_TITLE, _("Std. Error Mean"));
910   tab_text (self->t, 5, 2, TAB_CENTER | TAT_TITLE, _("Lower"));
911   tab_text (self->t, 6, 2, TAB_CENTER | TAT_TITLE, _("Upper"));
912   tab_text (self->t, 7, 2, TAB_CENTER | TAT_TITLE, _("t"));
913   tab_text (self->t, 8, 2, TAB_CENTER | TAT_TITLE, _("df"));
914   tab_text (self->t, 9, 2, TAB_CENTER | TAT_TITLE, _("Sig. (2-tailed)"));
915
916
917
918
919   
920
921
922 }
923
924
925 void 
926 trbox_paired_populate(struct trbox *trb,
927                               struct cmd_t_test *cmd unused)
928 {
929   int i;
930   struct string ds;
931
932
933   ds_init(t_test_pool,&ds,15);  
934
935   for (i=0; i < n_pairs; ++i)
936     {
937
938       ds_clear(&ds);
939
940       ds_printf(&ds,_("Pair %d"),i);
941
942       tab_text (trb->t, 0, i*2+3, TAB_LEFT, ds.string);
943
944       tab_text (trb->t, 1, i*2+3, TAB_LEFT, pairs[i][0]->name);
945       tab_text (trb->t, 1, i*2+4, TAB_LEFT, pairs[i][1]->name);
946     }
947
948
949   ds_destroy(&ds);
950
951 }
952
953
954 void 
955 trbox_one_sample_init(struct trbox *self,
956                            struct cmd_t_test *cmd )
957 {
958   const int hsize=7;
959   const int vsize=cmd->n_variables+3;
960
961   struct string ds;
962   
963   self->populate = trbox_one_sample_populate;
964
965   trbox_base_init(self,cmd->n_variables,hsize);
966
967
968   tab_title (self->t, 0, _("One-Sample Test"));
969
970   tab_hline(self->t,TAL_1,1,hsize-1,1);
971   tab_vline(self->t,TAL_2,1,0,vsize);
972
973   ds_init(t_test_pool,&ds,80);
974
975   ds_printf(&ds,_("Test Value = %f"),cmd->n_testval);
976
977   tab_joint_text(self->t,1,0,hsize-1,0,TAB_CENTER,ds.string);
978   
979   tab_box(self->t,-1,-1,-1,TAL_1,
980           1,1,hsize-1,vsize-1);
981
982
983   ds_clear(&ds);
984                 
985   ds_printf(&ds,_("%d%% Confidence Interval of the Difference"),
986             (int)round(cmd->criteria*100.0));
987
988   tab_joint_text(self->t,5,1,6,1,TAB_CENTER,
989                  ds.string);
990
991   ds_destroy(&ds);
992
993   tab_vline(self->t,TAL_0,6,1,1);
994   tab_hline(self->t,TAL_1,5,6,2);
995
996
997   tab_text (self->t, 1, 2, TAB_CENTER | TAT_TITLE, _("t"));
998   tab_text (self->t, 2, 2, TAB_CENTER | TAT_TITLE, _("df"));
999   tab_text (self->t, 3, 2, TAB_CENTER | TAT_TITLE, _("Sig. (2-tailed)"));
1000   tab_text (self->t, 4, 2, TAB_CENTER | TAT_TITLE, _("Mean Difference"));
1001   tab_text (self->t, 5, 2, TAB_CENTER | TAT_TITLE, _("Lower"));
1002   tab_text (self->t, 6, 2, TAB_CENTER | TAT_TITLE, _("Upper"));
1003
1004
1005 }
1006
1007
1008
1009 void 
1010 trbox_one_sample_populate(struct trbox *trb,
1011                               struct cmd_t_test *cmd)
1012 {
1013   int i;
1014
1015   assert(trb->t);
1016
1017   for (i=0; i < cmd->n_variables; ++i)
1018     {
1019       tab_text (trb->t, 0, i+3, 
1020                 TAB_LEFT, cmd->v_variables[i]->name);
1021     }
1022   
1023 }
1024
1025
1026 void 
1027 trbox_base_init(struct trbox *self, int data_rows,int cols)
1028 {
1029   const int rows=3+data_rows;
1030
1031   self->finalize = trbox_base_finalize;
1032   self->t = tab_create (cols, rows, 0);
1033
1034
1035   tab_headers (self->t,0,0,3,0); 
1036
1037
1038   tab_box (self->t, TAL_2, TAL_2, TAL_0, TAL_0, 0, 0, cols -1, rows -1);
1039
1040   tab_hline(self->t, TAL_2,0,cols-1,3);
1041
1042   tab_dim (self->t, tab_natural_dimensions);
1043
1044 }
1045
1046
1047 void 
1048 trbox_base_finalize(struct trbox *trb)
1049 {
1050   tab_submit(trb->t);
1051 }