src/language/stats/reliability.q

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2008 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 "xalloc.h"
  20 #include "xmalloca.h"
  21
  22 #include "gettext.h"
  23 #define _(msgid) gettext (msgid)
  24 #define N_(msgid) msgid
  25
  26 #include <data/variable.h>
  27 #include <data/dictionary.h>
  28 #include <data/procedure.h>
  29 #include <data/casereader.h>
  30 #include <data/casegrouper.h>
  31 #include <math/moments.h>
  32 #include <data/case.h>
  33
  34 #include <language/command.h>
  35
  36 #include <output/manager.h>
  37 #include <output/table.h>
  38
  39 /* (headers) */
  40
  41 /* (specification)
  42    reliability (rel_):
  43      *^variables=varlist("PV_NO_SCRATCH | PV_NUMERIC");
  44      scale=custom;
  45      missing=miss:!exclude/include;
  46      model=custom;
  47      method=covariance;
  48      +summary[sum_]=total.
  49 */
  50 /* (declarations) */
  51 /* (functions) */
  52
  53
  54 static int rel_custom_scale (struct lexer *lexer, struct dataset *ds,
  55                       struct cmd_reliability *p, void *aux);
  56
  57 static int rel_custom_model (struct lexer *, struct dataset *,
  58                              struct cmd_reliability *, void *);
  59
  60 int cmd_reliability (struct lexer *lexer, struct dataset *ds);
  61
  62 struct cronbach
  63 {
  64   const struct variable **items;
  65   size_t n_items;
  66   double alpha;
  67   double sum_of_variances;
  68   double variance_of_sums;
  69   int totals_idx;          /* Casereader index into the totals */
  70
  71   struct moments1 **m ;    /* Moments of the items */
  72   struct moments1 *total ; /* Moments of the totals */
  73 };
  74
  75 #if 0
  76 static void
  77 dump_cronbach (const struct cronbach *s)
  78 {
  79   int i;
  80   printf ("N items %d\n", s->n_items);
  81   for (i = 0 ; i < s->n_items; ++i)
  82     {
  83       printf ("%s\n", var_get_name (s->items[i]));
  84     }
  85
  86   printf ("Totals idx %d\n", s->totals_idx);
  87
  88   printf ("scale variance %g\n", s->variance_of_sums);
  89   printf ("alpha %g\n", s->alpha);
  90   putchar ('\n');
  91 }
  92 #endif
  93
  94 enum model
  95   {
  96     MODEL_ALPHA,
  97     MODEL_SPLIT
  98   };
  99
 100
 101 struct reliability
 102 {
 103   const struct variable **variables;
 104   int n_variables;
 105   enum mv_class exclude;
 106
 107   struct cronbach *sc;
 108   int n_sc;
 109
 110   int total_start;
 111
 112   struct string scale_name;
 113
 114   enum model model;
 115   int split_point;
 116 };
 117
 118
 119 static double
 120 alpha (int k, double sum_of_variances, double variance_of_sums)
 121 {
 122   return k / ( k - 1.0) * ( 1 - sum_of_variances / variance_of_sums);
 123 }
 124
 125 static void reliability_summary_total (const struct reliability *rel);
 126
 127 static void reliability_statistics (const struct reliability *rel);
 128
 129
 130
 131 static void
 132 run_reliability (struct casereader *group, struct dataset *ds,
 133                  struct reliability *rel);
 134
 135
 136 int
 137 cmd_reliability (struct lexer *lexer, struct dataset *ds)
 138 {
 139   int i;
 140   bool ok = false;
 141   struct casegrouper *grouper;
 142   struct casereader *group;
 143   struct cmd_reliability cmd;
 144
 145   struct reliability rel = {
 146     NULL, 0, MV_ANY, NULL, 0, -1,
 147     DS_EMPTY_INITIALIZER,
 148     MODEL_ALPHA, 0};
 149
 150   cmd.v_variables = NULL;
 151
 152   if ( ! parse_reliability (lexer, ds, &cmd, &rel) )
 153     {
 154       goto done;
 155     }
 156
 157   rel.variables = cmd.v_variables;
 158   rel.n_variables = cmd.n_variables;
 159   rel.exclude = MV_ANY;
 160
 161
 162   if (NULL == rel.sc)
 163     {
 164       struct cronbach *c;
 165       /* Create a default Scale */
 166
 167       rel.n_sc = 1;
 168       rel.sc = xzalloc (sizeof (struct cronbach) * rel.n_sc);
 169
 170       ds_init_cstr (&rel.scale_name, "ANY");
 171
 172       c = &rel.sc[0];
 173       c->n_items = cmd.n_variables;
 174       c->items = xzalloc (sizeof (struct variable*) * c->n_items);
 175
 176       for (i = 0 ; i < c->n_items ; ++i)
 177         c->items[i] = cmd.v_variables[i];
 178     }
 179
 180   if ( cmd.miss == REL_INCLUDE)
 181     rel.exclude = MV_SYSTEM;
 182
 183   if ( rel.model == MODEL_SPLIT)
 184     {
 185       int i;
 186       const struct cronbach *s;
 187
 188       rel.n_sc += 2 ;
 189       rel.sc = xrealloc (rel.sc, sizeof (struct cronbach) * rel.n_sc);
 190
 191       s = &rel.sc[0];
 192
 193       rel.sc[1].n_items =
 194         (rel.split_point == -1) ? s->n_items / 2 : rel.split_point;
 195
 196       rel.sc[2].n_items = s->n_items - rel.sc[1].n_items;
 197       rel.sc[1].items = xzalloc (sizeof (struct variable *)
 198                                  * rel.sc[1].n_items);
 199
 200       rel.sc[2].items = xzalloc (sizeof (struct variable *) *
 201                                  rel.sc[2].n_items);
 202
 203       for  (i = 0; i < rel.sc[1].n_items ; ++i)
 204         rel.sc[1].items[i] = s->items[i];
 205
 206       while (i < s->n_items)
 207         {
 208           rel.sc[2].items[i - rel.sc[1].n_items] = s->items[i];
 209           i++;
 210         }
 211     }
 212
 213   if (cmd.a_summary[REL_SUM_TOTAL])
 214     {
 215       int i;
 216       const int base_sc = rel.n_sc;
 217
 218       rel.total_start = base_sc;
 219
 220       rel.n_sc +=  rel.sc[0].n_items ;
 221       rel.sc = xrealloc (rel.sc, sizeof (struct cronbach) * rel.n_sc);
 222
 223       for (i = 0 ; i < rel.sc[0].n_items; ++i )
 224         {
 225           int v_src;
 226           int v_dest = 0;
 227           struct cronbach *s = &rel.sc[i + base_sc];
 228
 229           s->n_items = rel.sc[0].n_items - 1;
 230           s->items = xzalloc (sizeof (struct variable *) * s->n_items);
 231           for (v_src = 0 ; v_src < rel.sc[0].n_items ; ++v_src)
 232             {
 233               if ( v_src != i)
 234                 s->items[v_dest++] = rel.sc[0].items[v_src];
 235             }
 236         }
 237     }
 238
 239   /* Data pass. */
 240   grouper = casegrouper_create_splits (proc_open (ds), dataset_dict (ds));
 241   while (casegrouper_get_next_group (grouper, &group))
 242     {
 243       run_reliability (group, ds, &rel);
 244
 245       reliability_statistics (&rel);
 246
 247       if (cmd.a_summary[REL_SUM_TOTAL])
 248         reliability_summary_total (&rel);
 249     }
 250   ok = casegrouper_destroy (grouper);
 251   ok = proc_commit (ds) && ok;
 252
 253   free_reliability (&cmd);
 254
 255  done:
 256
 257   /* Free all the stuff */
 258   for (i = 0 ; i < rel.n_sc; ++i)
 259     {
 260       int x;
 261       struct cronbach *c = &rel.sc[i];
 262       free (c->items);
 263
 264       moments1_destroy (c->total);
 265
 266       if ( c->m)
 267         for (x = 0 ; x < c->n_items; ++x)
 268           moments1_destroy (c->m[x]);
 269
 270       free (c->m);
 271     }
 272
 273   ds_destroy (&rel.scale_name);
 274   free (rel.sc);
 275
 276   if (ok)
 277     return CMD_SUCCESS;
 278
 279   return CMD_FAILURE;
 280 }
 281
 282 /* Return the sum of all the item variables in S */
 283 static  double
 284 append_sum (const struct ccase *c, casenumber n UNUSED, void *aux)
 285 {
 286   double sum = 0;
 287   const struct cronbach *s = aux;
 288
 289   int v;
 290   for (v = 0 ; v < s->n_items; ++v)
 291     {
 292       sum += case_data (c, s->items[v])->f;
 293     }
 294
 295   return sum;
 296 };
 297
 298
 299 static void case_processing_summary (casenumber n_valid, casenumber n_missing);
 300
 301 static void
 302 run_reliability (struct casereader *input, struct dataset *ds UNUSED,
 303                  struct reliability *rel)
 304 {
 305   int i;
 306   int si;
 307   struct ccase c;
 308   casenumber n_missing ;
 309   casenumber n_valid = 0;
 310
 311
 312   for (si = 0 ; si < rel->n_sc; ++si)
 313     {
 314       struct cronbach *s = &rel->sc[si];
 315
 316       s->m = xzalloc (sizeof (s->m) * s->n_items);
 317       s->total = moments1_create (MOMENT_VARIANCE);
 318
 319       for (i = 0 ; i < s->n_items ; ++i )
 320         s->m[i] = moments1_create (MOMENT_VARIANCE);
 321     }
 322
 323   input = casereader_create_filter_missing (input,
 324                                             rel->variables,
 325                                             rel->n_variables,
 326                                             rel->exclude,
 327                                             &n_missing,
 328                                             NULL);
 329
 330   for (si = 0 ; si < rel->n_sc; ++si)
 331     {
 332       struct cronbach *s = &rel->sc[si];
 333
 334
 335       s->totals_idx = casereader_get_value_cnt (input);
 336       input =
 337         casereader_create_append_numeric (input, append_sum,
 338                                           s, NULL);
 339     }
 340
 341   for (; casereader_read (input, &c); case_destroy (&c))
 342     {
 343       double weight = 1.0;
 344       n_valid ++;
 345
 346       for (si = 0; si < rel->n_sc; ++si)
 347         {
 348           struct cronbach *s = &rel->sc[si];
 349
 350           for (i = 0 ; i < s->n_items ; ++i )
 351             moments1_add (s->m[i], case_data (&c, s->items[i])->f, weight);
 352
 353           moments1_add (s->total, case_data_idx (&c, s->totals_idx)->f, weight);
 354         }
 355     }
 356   casereader_destroy (input);
 357
 358   for (si = 0; si < rel->n_sc; ++si)
 359     {
 360       struct cronbach *s = &rel->sc[si];
 361
 362       s->sum_of_variances = 0;
 363       for (i = 0 ; i < s->n_items ; ++i )
 364         {
 365           double weight, mean, variance;
 366           moments1_calculate (s->m[i], &weight, &mean, &variance, NULL, NULL);
 367
 368           s->sum_of_variances += variance;
 369         }
 370
 371       moments1_calculate (s->total, NULL, NULL, &s->variance_of_sums,
 372                           NULL, NULL);
 373
 374       s->alpha =
 375         alpha (s->n_items, s->sum_of_variances, s->variance_of_sums);
 376     }
 377
 378
 379   {
 380     struct tab_table *tab = tab_create(1, 1, 0);
 381
 382     tab_dim (tab, tab_natural_dimensions);
 383     tab_flags (tab, SOMF_NO_TITLE );
 384
 385     tab_text(tab, 0, 0, TAT_PRINTF, "Scale: %s", ds_cstr (&rel->scale_name));
 386
 387     tab_submit(tab);
 388   }
 389
 390
 391   case_processing_summary (n_valid, n_missing);
 392 }
 393
 394
 395 static void reliability_statistics_model_alpha (struct tab_table *tbl,
 396                                                 const struct reliability *rel);
 397
 398 static void reliability_statistics_model_split (struct tab_table *tbl,
 399                                                 const struct reliability *rel);
 400
 401 struct reliability_output_table
 402 {
 403   int n_cols;
 404   int n_rows;
 405   int heading_cols;
 406   int heading_rows;
 407   void (*populate)(struct tab_table *, const struct reliability *);
 408 };
 409
 410 static struct reliability_output_table rol[2] =
 411   {
 412     { 2, 2, 1, 1, reliability_statistics_model_alpha},
 413     { 4, 9, 3, 0, reliability_statistics_model_split}
 414   };
 415
 416 static void
 417 reliability_statistics (const struct reliability *rel)
 418 {
 419   int n_cols = rol[rel->model].n_cols;
 420   int n_rows = rol[rel->model].n_rows;
 421   int heading_columns = rol[rel->model].heading_cols;
 422   int heading_rows = rol[rel->model].heading_rows;
 423
 424   struct tab_table *tbl = tab_create (n_cols, n_rows, 0);
 425   tab_headers (tbl, heading_columns, 0, heading_rows, 0);
 426
 427   tab_dim (tbl, tab_natural_dimensions);
 428
 429   tab_title (tbl, _("Reliability Statistics"));
 430
 431   /* Vertical lines for the data only */
 432   tab_box (tbl,
 433            -1, -1,
 434            -1, TAL_1,
 435            heading_columns, 0,
 436            n_cols - 1, n_rows - 1);
 437
 438   /* Box around table */
 439   tab_box (tbl,
 440            TAL_2, TAL_2,
 441            -1, -1,
 442            0, 0,
 443            n_cols - 1, n_rows - 1);
 444
 445
 446   tab_hline (tbl, TAL_2, 0, n_cols - 1, heading_rows);
 447
 448   tab_vline (tbl, TAL_2, heading_columns, 0, n_rows - 1);
 449
 450   if ( rel->model == MODEL_ALPHA )
 451     reliability_statistics_model_alpha (tbl, rel);
 452   else if (rel->model == MODEL_SPLIT )
 453     reliability_statistics_model_split (tbl, rel);
 454
 455   tab_submit (tbl);
 456 }
 457
 458 static void
 459 reliability_summary_total (const struct reliability *rel)
 460 {
 461   int i;
 462   const int n_cols = 5;
 463   const int heading_columns = 1;
 464   const int heading_rows = 1;
 465   const int n_rows = rel->sc[0].n_items + heading_rows ;
 466
 467   struct tab_table *tbl = tab_create (n_cols, n_rows, 0);
 468   tab_headers (tbl, heading_columns, 0, heading_rows, 0);
 469
 470   tab_dim (tbl, tab_natural_dimensions);
 471
 472   tab_title (tbl, _("Item-Total Statistics"));
 473
 474   /* Vertical lines for the data only */
 475   tab_box (tbl,
 476            -1, -1,
 477            -1, TAL_1,
 478            heading_columns, 0,
 479            n_cols - 1, n_rows - 1);
 480
 481   /* Box around table */
 482   tab_box (tbl,
 483            TAL_2, TAL_2,
 484            -1, -1,
 485            0, 0,
 486            n_cols - 1, n_rows - 1);
 487
 488
 489   tab_hline (tbl, TAL_2, 0, n_cols - 1, heading_rows);
 490
 491   tab_vline (tbl, TAL_2, heading_columns, 0, n_rows - 1);
 492
 493   tab_text (tbl, 1, 0, TAB_CENTER | TAT_TITLE,
 494             _("Scale Mean if Item Deleted"));
 495
 496   tab_text (tbl, 2, 0, TAB_CENTER | TAT_TITLE,
 497             _("Scale Variance if Item Deleted"));
 498
 499   tab_text (tbl, 3, 0, TAB_CENTER | TAT_TITLE,
 500             _("Corrected Item-Total Correlation"));
 501
 502   tab_text (tbl, 4, 0, TAB_CENTER | TAT_TITLE,
 503             _("Cronbach's Alpha if Item Deleted"));
 504
 505
 506   for (i = 0 ; i < rel->sc[0].n_items; ++i)
 507     {
 508       double cov, item_to_total_r;
 509       double mean, weight, var;
 510
 511       const struct cronbach *s = &rel->sc[rel->total_start + i];
 512       tab_text (tbl, 0, heading_rows + i, TAB_LEFT| TAT_TITLE,
 513                 var_to_string (rel->sc[0].items[i]));
 514
 515       moments1_calculate (s->total, &weight, &mean, &var, 0, 0);
 516
 517       tab_float (tbl, 1, heading_rows + i, TAB_RIGHT,
 518                  mean, 8, 3);
 519
 520       tab_float (tbl, 2, heading_rows + i, TAB_RIGHT,
 521                  s->variance_of_sums, 8, 3);
 522
 523       tab_float (tbl, 4, heading_rows + i, TAB_RIGHT,
 524                  s->alpha, 8, 3);
 525
 526
 527       moments1_calculate (rel->sc[0].m[i], &weight, &mean, &var, 0,0);
 528       cov = rel->sc[0].variance_of_sums + var - s->variance_of_sums;
 529       cov /= 2.0;
 530
 531       item_to_total_r = (cov - var) / (sqrt(var) * sqrt (s->variance_of_sums));
 532
 533
 534       tab_float (tbl, 3, heading_rows + i, TAB_RIGHT,
 535                  item_to_total_r, 8, 3);
 536     }
 537
 538
 539   tab_submit (tbl);
 540 }
 541
 542
 543 static void
 544 reliability_statistics_model_alpha (struct tab_table *tbl,
 545                                     const struct reliability *rel)
 546 {
 547   const struct cronbach *s = &rel->sc[0];
 548
 549   tab_text (tbl, 0, 0, TAB_CENTER | TAT_TITLE,
 550                 _("Cronbach's Alpha"));
 551
 552   tab_text (tbl, 1, 0, TAB_CENTER | TAT_TITLE,
 553                 _("N of items"));
 554
 555   tab_float (tbl, 0, 1, TAB_RIGHT, s->alpha, 8, 3);
 556
 557   tab_float (tbl, 1, 1, TAB_RIGHT, s->n_items, 8, 0);
 558 }
 559
 560
 561 static void
 562 reliability_statistics_model_split (struct tab_table *tbl,
 563                                     const struct reliability *rel)
 564 {
 565   tab_text (tbl, 0, 0, TAB_LEFT,
 566             _("Cronbach's Alpha"));
 567
 568   tab_text (tbl, 1, 0, TAB_LEFT,
 569             _("Part 1"));
 570
 571   tab_text (tbl, 2, 0, TAB_LEFT,
 572             _("Value"));
 573
 574   tab_text (tbl, 2, 1, TAB_LEFT,
 575             _("N of Items"));
 576
 577
 578
 579   tab_text (tbl, 1, 2, TAB_LEFT,
 580             _("Part 2"));
 581
 582   tab_text (tbl, 2, 2, TAB_LEFT,
 583             _("Value"));
 584
 585   tab_text (tbl, 2, 3, TAB_LEFT,
 586             _("N of Items"));
 587
 588
 589
 590   tab_text (tbl, 1, 4, TAB_LEFT,
 591             _("Total N of Items"));
 592
 593   tab_text (tbl, 0, 5, TAB_LEFT,
 594             _("Correlation Between Forms"));
 595
 596
 597   tab_text (tbl, 0, 6, TAB_LEFT,
 598             _("Spearman-Brown Coefficient"));
 599
 600   tab_text (tbl, 1, 6, TAB_LEFT,
 601             _("Equal Length"));
 602
 603   tab_text (tbl, 1, 7, TAB_LEFT,
 604             _("Unequal Length"));
 605
 606
 607   tab_text (tbl, 0, 8, TAB_LEFT,
 608             _("Guttman Split-Half Coefficient"));
 609
 610
 611
 612   tab_float (tbl, 3, 0, TAB_RIGHT, rel->sc[1].alpha, 8, 3);
 613   tab_float (tbl, 3, 2, TAB_RIGHT, rel->sc[2].alpha, 8, 3);
 614
 615   tab_float (tbl, 3, 1, TAB_RIGHT, rel->sc[1].n_items, 8, 0);
 616   tab_float (tbl, 3, 3, TAB_RIGHT, rel->sc[2].n_items, 8, 0);
 617
 618   tab_float (tbl, 3, 4, TAB_RIGHT,
 619              rel->sc[1].n_items + rel->sc[2].n_items, 8, 0);
 620
 621   {
 622     /* R is the correlation between the two parts */
 623     double r = rel->sc[0].variance_of_sums -
 624       rel->sc[1].variance_of_sums -
 625       rel->sc[2].variance_of_sums ;
 626
 627     /* Guttman Split Half Coefficient */
 628     double g = 2 * r / rel->sc[0].variance_of_sums;
 629
 630     /* Unequal Length Spearman Brown Coefficient, and
 631      intermediate value used in the computation thereof */
 632     double uly, tmp;
 633
 634     r /= sqrt (rel->sc[1].variance_of_sums);
 635     r /= sqrt (rel->sc[2].variance_of_sums);
 636     r /= 2.0;
 637
 638     tab_float (tbl, 3, 5, TAB_RIGHT, r, 8, 3);
 639
 640     /* Equal length Spearman-Brown Coefficient */
 641     tab_float (tbl, 3, 6, TAB_RIGHT, 2 * r / (1.0 + r), 8, 3);
 642
 643     tab_float (tbl, 3, 8, TAB_RIGHT, g, 8, 3);
 644
 645     tmp = (1.0 - r*r) * rel->sc[1].n_items * rel->sc[2].n_items /
 646       pow2 (rel->sc[0].n_items);
 647
 648     uly = sqrt( pow4 (r) + 4 * pow2 (r) * tmp);
 649     uly -= pow2 (r);
 650     uly /= 2 * tmp;
 651
 652     tab_float (tbl, 3, 7, TAB_RIGHT, uly, 8, 3);
 653
 654   }
 655 }
 656
 657
 658
 659 static void
 660 case_processing_summary (casenumber n_valid, casenumber n_missing)
 661 {
 662   casenumber total;
 663   int n_cols = 4;
 664   int n_rows = 4;
 665   int heading_columns = 2;
 666   int heading_rows = 1;
 667   struct tab_table *tbl;
 668   tbl = tab_create (n_cols, n_rows, 0);
 669   tab_headers (tbl, heading_columns, 0, heading_rows, 0);
 670
 671   tab_dim (tbl, tab_natural_dimensions);
 672
 673   tab_title (tbl, _("Case Processing Summary"));
 674
 675   /* Vertical lines for the data only */
 676   tab_box (tbl,
 677            -1, -1,
 678            -1, TAL_1,
 679            heading_columns, 0,
 680            n_cols - 1, n_rows - 1);
 681
 682   /* Box around table */
 683   tab_box (tbl,
 684            TAL_2, TAL_2,
 685            -1, -1,
 686            0, 0,
 687            n_cols - 1, n_rows - 1);
 688
 689
 690   tab_hline (tbl, TAL_2, 0, n_cols - 1, heading_rows);
 691
 692   tab_vline (tbl, TAL_2, heading_columns, 0, n_rows - 1);
 693
 694
 695   tab_text (tbl, 0, heading_rows, TAB_LEFT | TAT_TITLE,
 696                 _("Cases"));
 697
 698   tab_text (tbl, 1, heading_rows, TAB_LEFT | TAT_TITLE,
 699                 _("Valid"));
 700
 701   tab_text (tbl, 1, heading_rows + 1, TAB_LEFT | TAT_TITLE,
 702                 _("Excluded"));
 703
 704   tab_text (tbl, 1, heading_rows + 2, TAB_LEFT | TAT_TITLE,
 705                 _("Total"));
 706
 707   tab_text (tbl, heading_columns, 0, TAB_CENTER | TAT_TITLE,
 708                 _("N"));
 709
 710   tab_text (tbl, heading_columns + 1, 0, TAB_CENTER | TAT_TITLE | TAT_PRINTF,
 711                 _("%%"));
 712
 713   total = n_missing + n_valid;
 714
 715   tab_float (tbl, 2, heading_rows, TAB_RIGHT,
 716              n_valid, 8, 0);
 717
 718
 719   tab_float (tbl, 2, heading_rows + 1, TAB_RIGHT,
 720              n_missing, 8, 0);
 721
 722
 723   tab_float (tbl, 2, heading_rows + 2, TAB_RIGHT,
 724              total, 8, 0);
 725
 726
 727   tab_float (tbl, 3, heading_rows, TAB_RIGHT,
 728              100 * n_valid / (double) total, 8, 1);
 729
 730
 731   tab_float (tbl, 3, heading_rows + 1, TAB_RIGHT,
 732              100 * n_missing / (double) total, 8, 1);
 733
 734
 735   tab_float (tbl, 3, heading_rows + 2, TAB_RIGHT,
 736              100 * total / (double) total, 8, 1);
 737
 738
 739   tab_submit (tbl);
 740 }
 741
 742 static int
 743 rel_custom_model (struct lexer *lexer, struct dataset *ds UNUSED,
 744                   struct cmd_reliability *cmd UNUSED, void *aux)
 745 {
 746   struct reliability *rel = aux;
 747
 748   if (lex_match_id (lexer, "ALPHA"))
 749     {
 750       rel->model = MODEL_ALPHA;
 751     }
 752   else if (lex_match_id (lexer, "SPLIT"))
 753     {
 754       rel->model = MODEL_SPLIT;
 755       rel->split_point = -1;
 756       if ( lex_match (lexer, '('))
 757         {
 758           lex_force_num (lexer);
 759           rel->split_point = lex_number (lexer);
 760           lex_get (lexer);
 761           lex_force_match (lexer, ')');
 762         }
 763     }
 764   else
 765     return 0;
 766
 767   return 1;
 768 }
 769
 770
 771
 772 static int
 773 rel_custom_scale (struct lexer *lexer, struct dataset *ds UNUSED,
 774                   struct cmd_reliability *p, void *aux)
 775 {
 776   struct const_var_set *vs;
 777   struct reliability *rel = aux;
 778   struct cronbach *scale;
 779
 780   rel->n_sc = 1;
 781   rel->sc = xzalloc (sizeof (struct cronbach) * rel->n_sc);
 782   scale = &rel->sc[0];
 783
 784   if ( ! lex_force_match (lexer, '(')) return 0;
 785
 786   if ( ! lex_force_string (lexer) ) return 0;
 787
 788   ds_init_string (&rel->scale_name, lex_tokstr (lexer));
 789
 790   lex_get (lexer);
 791
 792   if ( ! lex_force_match (lexer, ')')) return 0;
 793
 794   lex_match (lexer, '=');
 795
 796   vs = const_var_set_create_from_array (p->v_variables, p->n_variables);
 797
 798   if (!parse_const_var_set_vars (lexer, vs, &scale->items, &scale->n_items, 0))
 799     {
 800       const_var_set_destroy (vs);
 801       return 2;
 802     }
 803
 804   const_var_set_destroy (vs);
 805   return 1;
 806 }
 807
 808 /*
 809    Local Variables:
 810    mode: c
 811    End:
 812 */