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, 2016 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/pivot-table.h"
  35 #include "output/output-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 = xcalloc (reliability.n_sc, sizeof (struct cronbach));
 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 = xcalloc (c->n_items, sizeof (struct variable*));
 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                    && lex_force_num (lexer))
 234                 {
 235                   reliability.split_point = lex_number (lexer);
 236                   lex_get (lexer);
 237                   if (! lex_force_match (lexer, T_RPAREN))
 238                     goto error;
 239                 }
 240             }
 241           else
 242             goto error;
 243         }
 244       else if (lex_match_id (lexer, "SUMMARY"))
 245         {
 246           lex_match (lexer, T_EQUALS);
 247           if (lex_match_id (lexer, "TOTAL"))
 248             {
 249               reliability.summary |= SUMMARY_TOTAL;
 250             }
 251           else if (lex_match (lexer, T_ALL))
 252             {
 253               reliability.summary = 0xFFFF;
 254             }
 255           else
 256             goto error;
 257         }
 258       else if (lex_match_id (lexer, "MISSING"))
 259         {
 260           lex_match (lexer, T_EQUALS);
 261           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
 262             {
 263               if (lex_match_id (lexer, "INCLUDE"))
 264                 {
 265                   reliability.exclude = MV_SYSTEM;
 266                 }
 267               else if (lex_match_id (lexer, "EXCLUDE"))
 268                 {
 269                   reliability.exclude = MV_ANY;
 270                 }
 271               else
 272                 {
 273                   lex_error (lexer, NULL);
 274                   goto error;
 275                 }
 276             }
 277         }
 278       else if (lex_match_id (lexer, "STATISTICS"))
 279         {
 280           lex_match (lexer, T_EQUALS);
 281           msg (SW, _("The STATISTICS subcommand is not yet implemented.  "
 282                      "No statistics will be produced."));
 283           while (lex_match (lexer, T_ID))
 284             continue;
 285         }
 286       else
 287         {
 288           lex_error (lexer, NULL);
 289           goto error;
 290         }
 291     }
 292
 293   if (reliability.model == MODEL_SPLIT)
 294     {
 295       int i;
 296       const struct cronbach *s;
 297
 298       if (reliability.split_point >= reliability.n_variables)
 299         {
 300           msg (ME, _("The split point must be less than the number of variables"));
 301           goto error;
 302         }
 303
 304       reliability.n_sc += 2 ;
 305       reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
 306
 307       s = &reliability.sc[0];
 308
 309       reliability.sc[1].n_items =
 310         (reliability.split_point == -1) ? s->n_items / 2 : reliability.split_point;
 311
 312       reliability.sc[2].n_items = s->n_items - reliability.sc[1].n_items;
 313       reliability.sc[1].items = XCALLOC (reliability.sc[1].n_items, const struct variable *);
 314       reliability.sc[2].items = XCALLOC (reliability.sc[2].n_items, const struct variable *);
 315
 316       for  (i = 0; i < reliability.sc[1].n_items ; ++i)
 317         reliability.sc[1].items[i] = s->items[i];
 318
 319       while (i < s->n_items)
 320         {
 321           reliability.sc[2].items[i - reliability.sc[1].n_items] = s->items[i];
 322           i++;
 323         }
 324     }
 325
 326   if (reliability.summary & SUMMARY_TOTAL)
 327     {
 328       int i;
 329       const int base_sc = reliability.n_sc;
 330
 331       reliability.total_start = base_sc;
 332
 333       reliability.n_sc +=  reliability.sc[0].n_items ;
 334       reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
 335
 336
 337       for (i = 0 ; i < reliability.sc[0].n_items; ++i)
 338         {
 339           int v_src;
 340           int v_dest = 0;
 341           struct cronbach *s = &reliability.sc[i + base_sc];
 342
 343           s->n_items = reliability.sc[0].n_items - 1;
 344           s->items = xcalloc (s->n_items, sizeof (struct variable *));
 345           for (v_src = 0 ; v_src < reliability.sc[0].n_items ; ++v_src)
 346             {
 347               if (v_src != i)
 348                 s->items[v_dest++] = reliability.sc[0].items[v_src];
 349             }
 350         }
 351     }
 352
 353
 354   if (! run_reliability (ds, &reliability))
 355     goto error;
 356
 357   reliability_destroy (&reliability);
 358   return CMD_SUCCESS;
 359
 360  error:
 361   reliability_destroy (&reliability);
 362   return CMD_FAILURE;
 363 }
 364
 365
 366 static void
 367 do_reliability (struct casereader *group, struct dataset *ds,
 368                 const struct reliability *rel);
 369
 370
 371 static void reliability_summary_total (const struct reliability *rel);
 372
 373 static void reliability_statistics (const struct reliability *rel);
 374
 375
 376 static bool
 377 run_reliability (struct dataset *ds, const struct reliability *reliability)
 378 {
 379   struct dictionary *dict = dataset_dict (ds);
 380   bool ok;
 381   struct casereader *group;
 382
 383   struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), dict);
 384   int si;
 385
 386   for (si = 0 ; si < reliability->n_sc; ++si)
 387     {
 388       struct cronbach *s = &reliability->sc[si];
 389       int i;
 390
 391       s->m = xcalloc (s->n_items, sizeof *s->m);
 392       s->total = moments1_create (MOMENT_VARIANCE);
 393
 394       for (i = 0 ; i < s->n_items ; ++i)
 395         s->m[i] = moments1_create (MOMENT_VARIANCE);
 396     }
 397
 398
 399   while (casegrouper_get_next_group (grouper, &group))
 400     {
 401       do_reliability (group, ds, reliability);
 402
 403       reliability_statistics (reliability);
 404
 405       if (reliability->summary & SUMMARY_TOTAL)
 406         reliability_summary_total (reliability);
 407     }
 408
 409   ok = casegrouper_destroy (grouper);
 410   ok = proc_commit (ds) && ok;
 411
 412   return ok;
 413 }
 414
 415
 416 \f
 417
 418
 419 /* Return the sum of all the item variables in S */
 420 static  double
 421 append_sum (const struct ccase *c, casenumber n UNUSED, void *aux)
 422 {
 423   double sum = 0;
 424   const struct cronbach *s = aux;
 425
 426   for (int v = 0 ; v < s->n_items; ++v)
 427     sum += case_num (c, s->items[v]);
 428
 429   return sum;
 430 };
 431
 432 static void
 433 case_processing_summary (casenumber n_valid, casenumber n_missing,
 434                          const struct dictionary *dict);
 435
 436
 437 static double
 438 alpha (int k, double sum_of_variances, double variance_of_sums)
 439 {
 440   return k / (k - 1.0) * (1 - sum_of_variances / variance_of_sums);
 441 }
 442
 443 static void
 444 do_reliability (struct casereader *input, struct dataset *ds,
 445                 const struct reliability *rel)
 446 {
 447   int i;
 448   int si;
 449   struct ccase *c;
 450   casenumber n_missing ;
 451   casenumber n_valid = 0;
 452
 453
 454   for (si = 0 ; si < rel->n_sc; ++si)
 455     {
 456       struct cronbach *s = &rel->sc[si];
 457
 458       moments1_clear (s->total);
 459
 460       for (i = 0 ; i < s->n_items ; ++i)
 461         moments1_clear (s->m[i]);
 462     }
 463
 464   input = casereader_create_filter_missing (input,
 465                                             rel->variables,
 466                                             rel->n_variables,
 467                                             rel->exclude,
 468                                             &n_missing,
 469                                             NULL);
 470
 471   for (si = 0 ; si < rel->n_sc; ++si)
 472     {
 473       struct cronbach *s = &rel->sc[si];
 474
 475
 476       s->totals_idx = caseproto_get_n_widths (casereader_get_proto (input));
 477       input =
 478         casereader_create_append_numeric (input, append_sum,
 479                                           s, NULL);
 480     }
 481
 482   for (; (c = casereader_read (input)) != NULL; case_unref (c))
 483     {
 484       double weight = 1.0;
 485       n_valid ++;
 486
 487       for (si = 0; si < rel->n_sc; ++si)
 488         {
 489           struct cronbach *s = &rel->sc[si];
 490
 491           for (i = 0 ; i < s->n_items ; ++i)
 492             moments1_add (s->m[i], case_num (c, s->items[i]), weight);
 493
 494           moments1_add (s->total, case_num_idx (c, s->totals_idx), weight);
 495         }
 496     }
 497   casereader_destroy (input);
 498
 499   for (si = 0; si < rel->n_sc; ++si)
 500     {
 501       struct cronbach *s = &rel->sc[si];
 502
 503       s->sum_of_variances = 0;
 504       for (i = 0 ; i < s->n_items ; ++i)
 505         {
 506           double weight, mean, variance;
 507           moments1_calculate (s->m[i], &weight, &mean, &variance, NULL, NULL);
 508
 509           s->sum_of_variances += variance;
 510         }
 511
 512       moments1_calculate (s->total, NULL, NULL, &s->variance_of_sums,
 513                           NULL, NULL);
 514
 515       s->alpha =
 516         alpha (s->n_items, s->sum_of_variances, s->variance_of_sums);
 517     }
 518
 519   output_item_submit (text_item_create_nocopy (
 520                         TEXT_ITEM_TITLE,
 521                         xasprintf (_("Scale: %s"), ds_cstr (&rel->scale_name)),
 522                         NULL));
 523
 524   case_processing_summary (n_valid, n_missing, dataset_dict (ds));
 525 }
 526
 527
 528
 529
 530
 531 static void
 532 case_processing_summary (casenumber n_valid, casenumber n_missing,
 533                          const struct dictionary *dict)
 534 {
 535   struct pivot_table *table = pivot_table_create (
 536     N_("Case Processing Summary"));
 537   pivot_table_set_weight_var (table, dict_get_weight (dict));
 538
 539   pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
 540                           N_("N"), PIVOT_RC_COUNT,
 541                           N_("Percent"), PIVOT_RC_PERCENT);
 542
 543   struct pivot_dimension *cases = pivot_dimension_create (
 544     table, PIVOT_AXIS_ROW, N_("Cases"), N_("Valid"), N_("Excluded"),
 545     N_("Total"));
 546   cases->root->show_label = true;
 547
 548   casenumber total = n_missing + n_valid;
 549
 550   struct entry
 551     {
 552       int stat_idx;
 553       int case_idx;
 554       double x;
 555     }
 556   entries[] = {
 557     { 0, 0, n_valid },
 558     { 0, 1, n_missing },
 559     { 0, 2, total },
 560     { 1, 0, 100.0 * n_valid / total },
 561     { 1, 1, 100.0 * n_missing / total },
 562     { 1, 2, 100.0 }
 563   };
 564
 565   for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
 566     {
 567       const struct entry *e = &entries[i];
 568       pivot_table_put2 (table, e->stat_idx, e->case_idx,
 569                         pivot_value_new_number (e->x));
 570     }
 571
 572   pivot_table_submit (table);
 573 }
 574
 575 static void
 576 reliability_summary_total (const struct reliability *rel)
 577 {
 578   struct pivot_table *table = pivot_table_create (N_("Item-Total Statistics"));
 579
 580   pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
 581                           N_("Scale Mean if Item Deleted"),
 582                           N_("Scale Variance if Item Deleted"),
 583                           N_("Corrected Item-Total Correlation"),
 584                           N_("Cronbach's Alpha if Item Deleted"));
 585
 586   struct pivot_dimension *variables = pivot_dimension_create (
 587     table, PIVOT_AXIS_ROW, N_("Variables"));
 588
 589   for (size_t i = 0 ; i < rel->sc[0].n_items; ++i)
 590     {
 591       const struct cronbach *s = &rel->sc[rel->total_start + i];
 592
 593       int var_idx = pivot_category_create_leaf (
 594         variables->root, pivot_value_new_variable (rel->sc[0].items[i]));
 595
 596       double mean;
 597       moments1_calculate (s->total, NULL, &mean, NULL, NULL, NULL);
 598
 599       double var;
 600       moments1_calculate (rel->sc[0].m[i], NULL, NULL, &var, NULL, NULL);
 601       double cov
 602         = (rel->sc[0].variance_of_sums + var - s->variance_of_sums) / 2.0;
 603
 604       double entries[] = {
 605         mean,
 606         s->variance_of_sums,
 607         (cov - var) / sqrt (var * s->variance_of_sums),
 608         s->alpha,
 609       };
 610       for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
 611         pivot_table_put2 (table, i, var_idx,
 612                           pivot_value_new_number (entries[i]));
 613     }
 614
 615   pivot_table_submit (table);
 616 }
 617
 618
 619 static void
 620 reliability_statistics (const struct reliability *rel)
 621 {
 622   struct pivot_table *table = pivot_table_create (
 623     N_("Reliability Statistics"));
 624   pivot_table_set_weight_var (table, rel->wv);
 625
 626   if (rel->model == MODEL_ALPHA)
 627     {
 628       pivot_dimension_create (table, PIVOT_AXIS_COLUMN,
 629                               N_("Statistics"),
 630                               N_("Cronbach's Alpha"), PIVOT_RC_OTHER,
 631                               N_("N of Items"), PIVOT_RC_COUNT);
 632
 633       const struct cronbach *s = &rel->sc[0];
 634       pivot_table_put1 (table, 0, pivot_value_new_number (s->alpha));
 635       pivot_table_put1 (table, 1, pivot_value_new_number (s->n_items));
 636     }
 637   else
 638     {
 639       struct pivot_dimension *statistics = pivot_dimension_create (
 640         table, PIVOT_AXIS_ROW, N_("Statistics"));
 641       struct pivot_category *alpha = pivot_category_create_group (
 642         statistics->root, N_("Cronbach's Alpha"));
 643       pivot_category_create_group (alpha, N_("Part 1"),
 644                                    N_("Value"), PIVOT_RC_OTHER,
 645                                    N_("N of Items"), PIVOT_RC_COUNT);
 646       pivot_category_create_group (alpha, N_("Part 2"),
 647                                    N_("Value"), PIVOT_RC_OTHER,
 648                                    N_("N of Items"), PIVOT_RC_COUNT);
 649       pivot_category_create_leaves (alpha,
 650                                     N_("Total N of Items"), PIVOT_RC_COUNT);
 651       pivot_category_create_leaves (statistics->root,
 652                                     N_("Correlation Between Forms"),
 653                                     PIVOT_RC_OTHER);
 654       pivot_category_create_group (statistics->root,
 655                                    N_("Spearman-Brown Coefficient"),
 656                                    N_("Equal Length"), PIVOT_RC_OTHER,
 657                                    N_("Unequal Length"), PIVOT_RC_OTHER);
 658       pivot_category_create_leaves (statistics->root,
 659                                     N_("Guttman Split-Half Coefficient"),
 660                                     PIVOT_RC_OTHER);
 661
 662       /* R is the correlation between the two parts */
 663       double r0 = rel->sc[0].variance_of_sums -
 664         rel->sc[1].variance_of_sums -
 665         rel->sc[2].variance_of_sums ;
 666       double r1 = (r0 / sqrt (rel->sc[1].variance_of_sums)
 667                    / sqrt (rel->sc[2].variance_of_sums)
 668                    / 2.0);
 669
 670       /* Guttman Split Half Coefficient */
 671       double g = 2 * r0 / rel->sc[0].variance_of_sums;
 672
 673       double tmp = (1.0 - r1*r1) * rel->sc[1].n_items * rel->sc[2].n_items /
 674         pow2 (rel->sc[0].n_items);
 675
 676       double entries[] = {
 677         rel->sc[1].alpha,
 678         rel->sc[1].n_items,
 679         rel->sc[2].alpha,
 680         rel->sc[2].n_items,
 681         rel->sc[1].n_items + rel->sc[2].n_items,
 682         r1,
 683         2 * r1 / (1.0 + r1),
 684         (sqrt (pow4 (r1) + 4 * pow2 (r1) * tmp) - pow2 (r1)) / (2 * tmp),
 685         g,
 686       };
 687       for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
 688         pivot_table_put1 (table, i, pivot_value_new_number (entries[i]));
 689     }
 690
 691   pivot_table_submit (table);
 692 }