pintos-os.org Git - pspp/blob - src/language/stats/reliability.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2009, 2010, 2011, 2013, 2015 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include <math.h>
  20
  21 #include "data/casegrouper.h"
  22 #include "data/casereader.h"
  23 #include "data/dataset.h"
  24 #include "data/dictionary.h"
  25 #include "data/format.h"
  26 #include "data/missing-values.h"
  27 #include "language/command.h"
  28 #include "language/lexer/lexer.h"
  29 #include "language/lexer/variable-parser.h"
  30 #include "libpspp/message.h"
  31 #include "libpspp/misc.h"
  32 #include "libpspp/str.h"
  33 #include "math/moments.h"
  34 #include "output/tab.h"
  35 #include "output/text-item.h"
  36
  37 #include "gettext.h"
  38 #define _(msgid) gettext (msgid)
  39 #define N_(msgid) msgid
  40
  41 struct cronbach
  42 {
  43   const struct variable **items;
  44   size_t n_items;
  45   double alpha;
  46   double sum_of_variances;
  47   double variance_of_sums;
  48   int totals_idx;          /* Casereader index into the totals */
  49
  50   struct moments1 **m ;    /* Moments of the items */
  51   struct moments1 *total ; /* Moments of the totals */
  52 };
  53
  54 #if 0
  55 static void
  56 dump_cronbach (const struct cronbach *s)
  57 {
  58   int i;
  59   printf ("N items %d\n", s->n_items);
  60   for (i = 0 ; i < s->n_items; ++i)
  61     {
  62       printf ("%s\n", var_get_name (s->items[i]));
  63     }
  64
  65   printf ("Totals idx %d\n", s->totals_idx);
  66
  67   printf ("scale variance %g\n", s->variance_of_sums);
  68   printf ("alpha %g\n", s->alpha);
  69   putchar ('\n');
  70 }
  71 #endif
  72
  73 enum model
  74   {
  75     MODEL_ALPHA,
  76     MODEL_SPLIT
  77   };
  78
  79
  80 enum summary_opts
  81   {
  82     SUMMARY_TOTAL = 0x0001,
  83   };
  84
  85
  86 struct reliability
  87 {
  88   const struct variable **variables;
  89   size_t n_variables;
  90   enum mv_class exclude;
  91
  92   struct cronbach *sc;
  93   int n_sc;
  94
  95   int total_start;
  96
  97   struct string scale_name;
  98
  99   enum model model;
 100   int split_point;
 101
 102
 103   enum summary_opts summary;
 104
 105   const struct variable *wv;
 106 };
 107
 108
 109 static bool run_reliability (struct dataset *ds, const struct reliability *reliability);
 110
 111 static void
 112 reliability_destroy (struct reliability *rel)
 113 {
 114   int j;
 115   ds_destroy (&rel->scale_name);
 116   if (rel->sc)
 117     for (j = 0; j < rel->n_sc ; ++j)
 118       {
 119         int x;
 120         free (rel->sc[j].items);
 121         moments1_destroy (rel->sc[j].total);
 122         if (rel->sc[j].m)
 123           for (x = 0; x < rel->sc[j].n_items; ++x)
 124             free (rel->sc[j].m[x]);
 125         free (rel->sc[j].m);
 126       }
 127
 128   free (rel->sc);
 129   free (rel->variables);
 130 }
 131
 132 int
 133 cmd_reliability (struct lexer *lexer, struct dataset *ds)
 134 {
 135   const struct dictionary *dict = dataset_dict (ds);
 136
 137   struct reliability reliability;
 138   reliability.n_variables = 0;
 139   reliability.variables = NULL;
 140   reliability.model = MODEL_ALPHA;
 141   reliability.exclude = MV_ANY;
 142   reliability.summary = 0;
 143   reliability.n_sc = 0;
 144   reliability.sc = NULL;
 145   reliability.wv = dict_get_weight (dict);
 146   reliability.total_start = 0;
 147   ds_init_empty (&reliability.scale_name);
 148
 149
 150   lex_match (lexer, T_SLASH);
 151
 152   if (!lex_force_match_id (lexer, "VARIABLES"))
 153     {
 154       goto error;
 155     }
 156
 157   lex_match (lexer, T_EQUALS);
 158
 159   if (!parse_variables_const (lexer, dict, &reliability.variables, &reliability.n_variables,
 160                               PV_NO_DUPLICATE | PV_NUMERIC))
 161     goto error;
 162
 163   if (reliability.n_variables < 2)
 164     msg (MW, _("Reliability on a single variable is not useful."));
 165
 166
 167     {
 168       int i;
 169       struct cronbach *c;
 170       /* Create a default Scale */
 171
 172       reliability.n_sc = 1;
 173       reliability.sc = xzalloc (sizeof (struct cronbach) * reliability.n_sc);
 174
 175       ds_assign_cstr (&reliability.scale_name, "ANY");
 176
 177       c = &reliability.sc[0];
 178       c->n_items = reliability.n_variables;
 179       c->items = xzalloc (sizeof (struct variable*) * c->n_items);
 180
 181       for (i = 0 ; i < c->n_items ; ++i)
 182         c->items[i] = reliability.variables[i];
 183     }
 184
 185
 186
 187   while (lex_token (lexer) != T_ENDCMD)
 188     {
 189       lex_match (lexer, T_SLASH);
 190
 191       if (lex_match_id (lexer, "SCALE"))
 192         {
 193           struct const_var_set *vs;
 194           if ( ! lex_force_match (lexer, T_LPAREN))
 195             goto error;
 196
 197           if ( ! lex_force_string (lexer) )
 198             goto error;
 199
 200           ds_assign_substring (&reliability.scale_name, lex_tokss (lexer));
 201
 202           lex_get (lexer);
 203
 204           if ( ! lex_force_match (lexer, T_RPAREN))
 205             goto error;
 206
 207           lex_match (lexer, T_EQUALS);
 208
 209           vs = const_var_set_create_from_array (reliability.variables, reliability.n_variables);
 210
 211           free (reliability.sc->items);
 212           if (!parse_const_var_set_vars (lexer, vs, &reliability.sc->items, &reliability.sc->n_items, 0))
 213             {
 214               const_var_set_destroy (vs);
 215               goto error;
 216             }
 217
 218           const_var_set_destroy (vs);
 219         }
 220       else if (lex_match_id (lexer, "MODEL"))
 221         {
 222           lex_match (lexer, T_EQUALS);
 223           if (lex_match_id (lexer, "ALPHA"))
 224             {
 225               reliability.model = MODEL_ALPHA;
 226             }
 227           else if (lex_match_id (lexer, "SPLIT"))
 228             {
 229               reliability.model = MODEL_SPLIT;
 230               reliability.split_point = -1;
 231
 232               if ( lex_match (lexer, T_LPAREN))
 233                 {
 234                   lex_force_num (lexer);
 235                   reliability.split_point = lex_number (lexer);
 236                   lex_get (lexer);
 237                   lex_force_match (lexer, T_RPAREN);
 238                 }
 239             }
 240           else
 241             goto error;
 242         }
 243       else if (lex_match_id (lexer, "SUMMARY"))
 244         {
 245           lex_match (lexer, T_EQUALS);
 246           if (lex_match_id (lexer, "TOTAL"))
 247             {
 248               reliability.summary |= SUMMARY_TOTAL;
 249             }
 250           else if (lex_match (lexer, T_ALL))
 251             {
 252               reliability.summary = 0xFFFF;
 253             }
 254           else
 255             goto error;
 256         }
 257       else if (lex_match_id (lexer, "MISSING"))
 258         {
 259           lex_match (lexer, T_EQUALS);
 260           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
 261             {
 262               if (lex_match_id (lexer, "INCLUDE"))
 263                 {
 264                   reliability.exclude = MV_SYSTEM;
 265                 }
 266               else if (lex_match_id (lexer, "EXCLUDE"))
 267                 {
 268                   reliability.exclude = MV_ANY;
 269                 }
 270               else
 271                 {
 272                   lex_error (lexer, NULL);
 273                   goto error;
 274                 }
 275             }
 276         }
 277       else if (lex_match_id (lexer, "STATISTICS"))
 278         {
 279           lex_match (lexer, T_EQUALS);
 280           msg (SW, _("The STATISTICS subcommand is not yet implemented.  "
 281                      "No statistics will be produced."));
 282           while (lex_match (lexer, T_ID))
 283             continue;
 284         }
 285       else
 286         {
 287           lex_error (lexer, NULL);
 288           goto error;
 289         }
 290     }
 291
 292   if ( reliability.model == MODEL_SPLIT)
 293     {
 294       int i;
 295       const struct cronbach *s;
 296
 297       if ( reliability.split_point >= reliability.n_variables)
 298         {
 299           msg (ME, _("The split point must be less than the number of variables"));
 300           goto error;
 301         }
 302
 303       reliability.n_sc += 2 ;
 304       reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
 305
 306       s = &reliability.sc[0];
 307
 308       reliability.sc[1].n_items =
 309         (reliability.split_point == -1) ? s->n_items / 2 : reliability.split_point;
 310
 311       reliability.sc[2].n_items = s->n_items - reliability.sc[1].n_items;
 312       reliability.sc[1].items = xzalloc (sizeof (struct variable *)
 313                                  * reliability.sc[1].n_items);
 314
 315       reliability.sc[2].items = xzalloc (sizeof (struct variable *) *
 316                                  reliability.sc[2].n_items);
 317
 318       for  (i = 0; i < reliability.sc[1].n_items ; ++i)
 319         reliability.sc[1].items[i] = s->items[i];
 320
 321       while (i < s->n_items)
 322         {
 323           reliability.sc[2].items[i - reliability.sc[1].n_items] = s->items[i];
 324           i++;
 325         }
 326     }
 327
 328   if ( reliability.summary & SUMMARY_TOTAL)
 329     {
 330       int i;
 331       const int base_sc = reliability.n_sc;
 332
 333       reliability.total_start = base_sc;
 334
 335       reliability.n_sc +=  reliability.sc[0].n_items ;
 336       reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
 337
 338
 339       for (i = 0 ; i < reliability.sc[0].n_items; ++i )
 340         {
 341           int v_src;
 342           int v_dest = 0;
 343           struct cronbach *s = &reliability.sc[i + base_sc];
 344
 345           s->n_items = reliability.sc[0].n_items - 1;
 346           s->items = xzalloc (sizeof (struct variable *) * s->n_items);
 347           for (v_src = 0 ; v_src < reliability.sc[0].n_items ; ++v_src)
 348             {
 349               if ( v_src != i)
 350                 s->items[v_dest++] = reliability.sc[0].items[v_src];
 351             }
 352         }
 353     }
 354
 355
 356   if ( ! run_reliability (ds, &reliability))
 357     goto error;
 358
 359   reliability_destroy (&reliability);
 360   return CMD_SUCCESS;
 361
 362  error:
 363   reliability_destroy (&reliability);
 364   return CMD_FAILURE;
 365 }
 366
 367
 368 static void
 369 do_reliability (struct casereader *group, struct dataset *ds,
 370                 const struct reliability *rel);
 371
 372
 373 static void reliability_summary_total (const struct reliability *rel);
 374
 375 static void reliability_statistics (const struct reliability *rel);
 376
 377
 378 static bool
 379 run_reliability (struct dataset *ds, const struct reliability *reliability)
 380 {
 381   struct dictionary *dict = dataset_dict (ds);
 382   bool ok;
 383   struct casereader *group;
 384
 385   struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), dict);
 386   int si;
 387
 388   for (si = 0 ; si < reliability->n_sc; ++si)
 389     {
 390       struct cronbach *s = &reliability->sc[si];
 391       int i;
 392
 393       s->m = xzalloc (sizeof *s->m * s->n_items);
 394       s->total = moments1_create (MOMENT_VARIANCE);
 395
 396       for (i = 0 ; i < s->n_items ; ++i )
 397         s->m[i] = moments1_create (MOMENT_VARIANCE);
 398     }
 399
 400
 401   while (casegrouper_get_next_group (grouper, &group))
 402     {
 403       do_reliability (group, ds, reliability);
 404
 405       reliability_statistics (reliability);
 406
 407       if (reliability->summary & SUMMARY_TOTAL )
 408         reliability_summary_total (reliability);
 409     }
 410
 411   ok = casegrouper_destroy (grouper);
 412   ok = proc_commit (ds) && ok;
 413
 414   return ok;
 415 }
 416
 417
 418 \f
 419
 420
 421 /* Return the sum of all the item variables in S */
 422 static  double
 423 append_sum (const struct ccase *c, casenumber n UNUSED, void *aux)
 424 {
 425   double sum = 0;
 426   const struct cronbach *s = aux;
 427
 428   int v;
 429   for (v = 0 ; v < s->n_items; ++v)
 430     {
 431       sum += case_data (c, s->items[v])->f;
 432     }
 433
 434   return sum;
 435 };
 436
 437 static void
 438 case_processing_summary (casenumber n_valid, casenumber n_missing,
 439                          const struct dictionary *dict);
 440
 441
 442 static double
 443 alpha (int k, double sum_of_variances, double variance_of_sums)
 444 {
 445   return k / ( k - 1.0) * ( 1 - sum_of_variances / variance_of_sums);
 446 }
 447
 448 static void
 449 do_reliability (struct casereader *input, struct dataset *ds,
 450                 const struct reliability *rel)
 451 {
 452   int i;
 453   int si;
 454   struct ccase *c;
 455   casenumber n_missing ;
 456   casenumber n_valid = 0;
 457
 458
 459   for (si = 0 ; si < rel->n_sc; ++si)
 460     {
 461       struct cronbach *s = &rel->sc[si];
 462
 463       moments1_clear (s->total);
 464
 465       for (i = 0 ; i < s->n_items ; ++i )
 466         moments1_clear (s->m[i]);
 467     }
 468
 469   input = casereader_create_filter_missing (input,
 470                                             rel->variables,
 471                                             rel->n_variables,
 472                                             rel->exclude,
 473                                             &n_missing,
 474                                             NULL);
 475
 476   for (si = 0 ; si < rel->n_sc; ++si)
 477     {
 478       struct cronbach *s = &rel->sc[si];
 479
 480
 481       s->totals_idx = caseproto_get_n_widths (casereader_get_proto (input));
 482       input =
 483         casereader_create_append_numeric (input, append_sum,
 484                                           s, NULL);
 485     }
 486
 487   for (; (c = casereader_read (input)) != NULL; case_unref (c))
 488     {
 489       double weight = 1.0;
 490       n_valid ++;
 491
 492       for (si = 0; si < rel->n_sc; ++si)
 493         {
 494           struct cronbach *s = &rel->sc[si];
 495
 496           for (i = 0 ; i < s->n_items ; ++i )
 497             moments1_add (s->m[i], case_data (c, s->items[i])->f, weight);
 498
 499           moments1_add (s->total, case_data_idx (c, s->totals_idx)->f, weight);
 500         }
 501     }
 502   casereader_destroy (input);
 503
 504   for (si = 0; si < rel->n_sc; ++si)
 505     {
 506       struct cronbach *s = &rel->sc[si];
 507
 508       s->sum_of_variances = 0;
 509       for (i = 0 ; i < s->n_items ; ++i )
 510         {
 511           double weight, mean, variance;
 512           moments1_calculate (s->m[i], &weight, &mean, &variance, NULL, NULL);
 513
 514           s->sum_of_variances += variance;
 515         }
 516
 517       moments1_calculate (s->total, NULL, NULL, &s->variance_of_sums,
 518                           NULL, NULL);
 519
 520       s->alpha =
 521         alpha (s->n_items, s->sum_of_variances, s->variance_of_sums);
 522     }
 523
 524   text_item_submit (text_item_create_format (TEXT_ITEM_PARAGRAPH, _("Scale: %s"),
 525                                              ds_cstr (&rel->scale_name)));
 526
 527   case_processing_summary (n_valid, n_missing, dataset_dict (ds));
 528 }
 529
 530
 531
 532
 533
 534 static void
 535 case_processing_summary (casenumber n_valid, casenumber n_missing,
 536                          const struct dictionary *dict)
 537 {
 538   const struct variable *wv = dict_get_weight (dict);
 539   const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : & F_8_0;
 540
 541   casenumber total;
 542   int n_cols = 4;
 543   int n_rows = 4;
 544   int heading_columns = 2;
 545   int heading_rows = 1;
 546   struct tab_table *tbl;
 547   tbl = tab_create (n_cols, n_rows);
 548   tab_set_format (tbl, RC_WEIGHT, wfmt);
 549   tab_headers (tbl, heading_columns, 0, heading_rows, 0);
 550
 551   tab_title (tbl, _("Case Processing Summary"));
 552
 553   /* Vertical lines for the data only */
 554   tab_box (tbl,
 555            -1, -1,
 556            -1, TAL_1,
 557            heading_columns, 0,
 558            n_cols - 1, n_rows - 1);
 559
 560   /* Box around table */
 561   tab_box (tbl,
 562            TAL_2, TAL_2,
 563            -1, -1,
 564            0, 0,
 565            n_cols - 1, n_rows - 1);
 566
 567
 568   tab_hline (tbl, TAL_2, 0, n_cols - 1, heading_rows);
 569
 570   tab_vline (tbl, TAL_2, heading_columns, 0, n_rows - 1);
 571
 572
 573   tab_text (tbl, 0, heading_rows, TAB_LEFT | TAT_TITLE,
 574                 _("Cases"));
 575
 576   tab_text (tbl, 1, heading_rows, TAB_LEFT | TAT_TITLE,
 577                 _("Valid"));
 578
 579   tab_text (tbl, 1, heading_rows + 1, TAB_LEFT | TAT_TITLE,
 580                 _("Excluded"));
 581
 582   tab_text (tbl, 1, heading_rows + 2, TAB_LEFT | TAT_TITLE,
 583                 _("Total"));
 584
 585   tab_text (tbl, heading_columns, 0, TAB_CENTER | TAT_TITLE,
 586                 _("N"));
 587
 588   tab_text (tbl, heading_columns + 1, 0, TAB_CENTER | TAT_TITLE, _("%"));
 589
 590   total = n_missing + n_valid;
 591
 592   tab_double (tbl, 2, heading_rows, TAB_RIGHT,
 593              n_valid, NULL, RC_WEIGHT);
 594
 595
 596   tab_double (tbl, 2, heading_rows + 1, TAB_RIGHT,
 597              n_missing, NULL, RC_WEIGHT);
 598
 599
 600   tab_double (tbl, 2, heading_rows + 2, TAB_RIGHT,
 601              total, NULL, RC_WEIGHT);
 602
 603
 604   tab_double (tbl, 3, heading_rows, TAB_RIGHT,
 605               100 * n_valid / (double) total, NULL, RC_OTHER);
 606
 607
 608   tab_double (tbl, 3, heading_rows + 1, TAB_RIGHT,
 609               100 * n_missing / (double) total, NULL, RC_OTHER);
 610
 611
 612   tab_double (tbl, 3, heading_rows + 2, TAB_RIGHT,
 613               100 * total / (double) total, NULL, RC_OTHER);
 614
 615
 616   tab_submit (tbl);
 617 }
 618
 619
 620
 621 static void
 622 reliability_summary_total (const struct reliability *rel)
 623 {
 624   int i;
 625   const int n_cols = 5;
 626   const int heading_columns = 1;
 627   const int heading_rows = 1;
 628   const int n_rows = rel->sc[0].n_items + heading_rows ;
 629   const struct variable *wv = rel->wv;
 630   const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : & F_8_0;
 631   struct tab_table *tbl = tab_create (n_cols, n_rows);
 632   tab_set_format (tbl, RC_WEIGHT, wfmt);
 633   tab_headers (tbl, heading_columns, 0, heading_rows, 0);
 634
 635   tab_title (tbl, _("Item-Total Statistics"));
 636
 637   /* Vertical lines for the data only */
 638   tab_box (tbl,
 639            -1, -1,
 640            -1, TAL_1,
 641            heading_columns, 0,
 642            n_cols - 1, n_rows - 1);
 643
 644   /* Box around table */
 645   tab_box (tbl,
 646            TAL_2, TAL_2,
 647            -1, -1,
 648            0, 0,
 649            n_cols - 1, n_rows - 1);
 650
 651
 652   tab_hline (tbl, TAL_2, 0, n_cols - 1, heading_rows);
 653
 654   tab_vline (tbl, TAL_2, heading_columns, 0, n_rows - 1);
 655
 656   tab_text (tbl, 1, 0, TAB_CENTER | TAT_TITLE,
 657             _("Scale Mean if Item Deleted"));
 658
 659   tab_text (tbl, 2, 0, TAB_CENTER | TAT_TITLE,
 660             _("Scale Variance if Item Deleted"));
 661
 662   tab_text (tbl, 3, 0, TAB_CENTER | TAT_TITLE,
 663             _("Corrected Item-Total Correlation"));
 664
 665   tab_text (tbl, 4, 0, TAB_CENTER | TAT_TITLE,
 666             _("Cronbach's Alpha if Item Deleted"));
 667
 668
 669   for (i = 0 ; i < rel->sc[0].n_items; ++i)
 670     {
 671       double cov, item_to_total_r;
 672       double mean, weight, var;
 673
 674       const struct cronbach *s = &rel->sc[rel->total_start + i];
 675       tab_text (tbl, 0, heading_rows + i, TAB_LEFT| TAT_TITLE,
 676                 var_to_string (rel->sc[0].items[i]));
 677
 678       moments1_calculate (s->total, &weight, &mean, &var, 0, 0);
 679
 680       tab_double (tbl, 1, heading_rows + i, TAB_RIGHT,
 681                   mean, NULL, RC_OTHER);
 682
 683       tab_double (tbl, 2, heading_rows + i, TAB_RIGHT,
 684                   s->variance_of_sums, NULL, RC_OTHER);
 685
 686       tab_double (tbl, 4, heading_rows + i, TAB_RIGHT,
 687                   s->alpha, NULL, RC_OTHER);
 688
 689
 690       moments1_calculate (rel->sc[0].m[i], &weight, &mean, &var, 0,0);
 691       cov = rel->sc[0].variance_of_sums + var - s->variance_of_sums;
 692       cov /= 2.0;
 693
 694       item_to_total_r = (cov - var) / (sqrt(var) * sqrt (s->variance_of_sums));
 695
 696
 697       tab_double (tbl, 3, heading_rows + i, TAB_RIGHT,
 698                   item_to_total_r, NULL, RC_OTHER);
 699     }
 700
 701
 702   tab_submit (tbl);
 703 }
 704
 705
 706 static void reliability_statistics_model_alpha (struct tab_table *tbl,
 707                                                 const struct reliability *rel);
 708
 709 static void reliability_statistics_model_split (struct tab_table *tbl,
 710                                                 const struct reliability *rel);
 711
 712
 713 struct reliability_output_table
 714 {
 715   int n_cols;
 716   int n_rows;
 717   int heading_cols;
 718   int heading_rows;
 719   void (*populate) (struct tab_table *, const struct reliability *);
 720 };
 721
 722
 723 static struct reliability_output_table rol[2] =
 724   {
 725     { 2, 2, 1, 1, reliability_statistics_model_alpha},
 726     { 4, 9, 3, 0, reliability_statistics_model_split}
 727   };
 728
 729 static void
 730 reliability_statistics (const struct reliability *rel)
 731 {
 732   int n_cols = rol[rel->model].n_cols;
 733   int n_rows = rol[rel->model].n_rows;
 734   int heading_columns = rol[rel->model].heading_cols;
 735   int heading_rows = rol[rel->model].heading_rows;
 736   const struct variable *wv = rel->wv;
 737   const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : & F_8_0;
 738   struct tab_table *tbl = tab_create (n_cols, n_rows);
 739   tab_set_format (tbl, RC_WEIGHT, wfmt);
 740
 741   tab_headers (tbl, heading_columns, 0, heading_rows, 0);
 742
 743   tab_title (tbl, _("Reliability Statistics"));
 744
 745   /* Vertical lines for the data only */
 746   tab_box (tbl,
 747            -1, -1,
 748            -1, TAL_1,
 749            heading_columns, 0,
 750            n_cols - 1, n_rows - 1);
 751
 752   /* Box around table */
 753   tab_box (tbl,
 754            TAL_2, TAL_2,
 755            -1, -1,
 756            0, 0,
 757            n_cols - 1, n_rows - 1);
 758
 759
 760   tab_hline (tbl, TAL_2, 0, n_cols - 1, heading_rows);
 761
 762   tab_vline (tbl, TAL_2, heading_columns, 0, n_rows - 1);
 763
 764   if ( rel->model == MODEL_ALPHA )
 765     reliability_statistics_model_alpha (tbl, rel);
 766   else if (rel->model == MODEL_SPLIT )
 767     reliability_statistics_model_split (tbl, rel);
 768
 769   tab_submit (tbl);
 770 }
 771
 772
 773 static void
 774 reliability_statistics_model_alpha (struct tab_table *tbl,
 775                                     const struct reliability *rel)
 776 {
 777   const struct cronbach *s = &rel->sc[0];
 778
 779   tab_text (tbl, 0, 0, TAB_CENTER | TAT_TITLE,
 780                 _("Cronbach's Alpha"));
 781
 782   tab_text (tbl, 1, 0, TAB_CENTER | TAT_TITLE,
 783                 _("N of Items"));
 784
 785   tab_double (tbl, 0, 1, TAB_RIGHT, s->alpha, NULL, RC_OTHER);
 786
 787   tab_double (tbl, 1, 1, TAB_RIGHT, s->n_items, NULL, RC_WEIGHT);
 788 }
 789
 790
 791 static void
 792 reliability_statistics_model_split (struct tab_table *tbl,
 793                                     const struct reliability *rel)
 794 {
 795   tab_text (tbl, 0, 0, TAB_LEFT,
 796             _("Cronbach's Alpha"));
 797
 798   tab_text (tbl, 1, 0, TAB_LEFT,
 799             _("Part 1"));
 800
 801   tab_text (tbl, 2, 0, TAB_LEFT,
 802             _("Value"));
 803
 804   tab_text (tbl, 2, 1, TAB_LEFT,
 805             _("N of Items"));
 806
 807   tab_text (tbl, 1, 2, TAB_LEFT,
 808             _("Part 2"));
 809
 810   tab_text (tbl, 2, 2, TAB_LEFT,
 811             _("Value"));
 812
 813   tab_text (tbl, 2, 3, TAB_LEFT,
 814             _("N of Items"));
 815
 816   tab_text (tbl, 1, 4, TAB_LEFT,
 817             _("Total N of Items"));
 818
 819   tab_text (tbl, 0, 5, TAB_LEFT,
 820             _("Correlation Between Forms"));
 821
 822   tab_text (tbl, 0, 6, TAB_LEFT,
 823             _("Spearman-Brown Coefficient"));
 824
 825   tab_text (tbl, 1, 6, TAB_LEFT,
 826             _("Equal Length"));
 827
 828   tab_text (tbl, 1, 7, TAB_LEFT,
 829             _("Unequal Length"));
 830
 831
 832   tab_text (tbl, 0, 8, TAB_LEFT,
 833             _("Guttman Split-Half Coefficient"));
 834
 835
 836
 837   tab_double (tbl, 3, 0, TAB_RIGHT, rel->sc[1].alpha, NULL, RC_OTHER);
 838   tab_double (tbl, 3, 2, TAB_RIGHT, rel->sc[2].alpha, NULL, RC_OTHER);
 839
 840   tab_double (tbl, 3, 1, TAB_RIGHT, rel->sc[1].n_items, NULL, RC_WEIGHT);
 841   tab_double (tbl, 3, 3, TAB_RIGHT, rel->sc[2].n_items, NULL, RC_WEIGHT);
 842
 843   tab_double (tbl, 3, 4, TAB_RIGHT,
 844              rel->sc[1].n_items + rel->sc[2].n_items, NULL, RC_WEIGHT);
 845
 846   {
 847     /* R is the correlation between the two parts */
 848     double r = rel->sc[0].variance_of_sums -
 849       rel->sc[1].variance_of_sums -
 850       rel->sc[2].variance_of_sums ;
 851
 852     /* Guttman Split Half Coefficient */
 853     double g = 2 * r / rel->sc[0].variance_of_sums;
 854
 855     /* Unequal Length Spearman Brown Coefficient, and
 856      intermediate value used in the computation thereof */
 857     double uly, tmp;
 858
 859     r /= sqrt (rel->sc[1].variance_of_sums);
 860     r /= sqrt (rel->sc[2].variance_of_sums);
 861     r /= 2.0;
 862
 863     tab_double (tbl, 3, 5, TAB_RIGHT, r, NULL, RC_OTHER);
 864
 865     /* Equal length Spearman-Brown Coefficient */
 866     tab_double (tbl, 3, 6, TAB_RIGHT, 2 * r / (1.0 + r), NULL, RC_OTHER);
 867
 868     tab_double (tbl, 3, 8, TAB_RIGHT, g, NULL, RC_OTHER);
 869
 870     tmp = (1.0 - r*r) * rel->sc[1].n_items * rel->sc[2].n_items /
 871       pow2 (rel->sc[0].n_items);
 872
 873     uly = sqrt( pow4 (r) + 4 * pow2 (r) * tmp);
 874     uly -= pow2 (r);
 875     uly /= 2 * tmp;
 876
 877     tab_double (tbl, 3, 7, TAB_RIGHT, uly, NULL, RC_OTHER);
 878   }
 879 }
 880