1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 2009, 2010, 2011, 2013, 2015, 2016 Free Software Foundation, Inc.
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.
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.
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/>. */
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"
38 #define _(msgid) gettext (msgid)
39 #define N_(msgid) msgid
43 const struct variable **items;
46 double sum_of_variances;
47 double variance_of_sums;
48 int totals_idx; /* Casereader index into the totals */
50 struct moments1 **m ; /* Moments of the items */
51 struct moments1 *total ; /* Moments of the totals */
56 dump_cronbach (const struct cronbach *s)
59 printf ("N items %d\n", s->n_items);
60 for (i = 0 ; i < s->n_items; ++i)
62 printf ("%s\n", var_get_name (s->items[i]));
65 printf ("Totals idx %d\n", s->totals_idx);
67 printf ("scale variance %g\n", s->variance_of_sums);
68 printf ("alpha %g\n", s->alpha);
82 SUMMARY_TOTAL = 0x0001,
88 const struct variable **variables;
90 enum mv_class exclude;
97 struct string scale_name;
103 enum summary_opts summary;
105 const struct variable *wv;
109 static bool run_reliability (struct dataset *ds, const struct reliability *reliability);
112 reliability_destroy (struct reliability *rel)
115 ds_destroy (&rel->scale_name);
117 for (j = 0; j < rel->n_sc ; ++j)
120 free (rel->sc[j].items);
121 moments1_destroy (rel->sc[j].total);
123 for (x = 0; x < rel->sc[j].n_items; ++x)
124 free (rel->sc[j].m[x]);
129 free (rel->variables);
133 cmd_reliability (struct lexer *lexer, struct dataset *ds)
135 const struct dictionary *dict = dataset_dict (ds);
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);
150 lex_match (lexer, T_SLASH);
152 if (!lex_force_match_id (lexer, "VARIABLES"))
157 lex_match (lexer, T_EQUALS);
159 if (!parse_variables_const (lexer, dict, &reliability.variables, &reliability.n_variables,
160 PV_NO_DUPLICATE | PV_NUMERIC))
163 if (reliability.n_variables < 2)
164 msg (MW, _("Reliability on a single variable is not useful."));
170 /* Create a default Scale */
172 reliability.n_sc = 1;
173 reliability.sc = xcalloc (reliability.n_sc, sizeof (struct cronbach));
175 ds_assign_cstr (&reliability.scale_name, "ANY");
177 c = &reliability.sc[0];
178 c->n_items = reliability.n_variables;
179 c->items = xcalloc (c->n_items, sizeof (struct variable*));
181 for (i = 0 ; i < c->n_items ; ++i)
182 c->items[i] = reliability.variables[i];
187 while (lex_token (lexer) != T_ENDCMD)
189 lex_match (lexer, T_SLASH);
191 if (lex_match_id (lexer, "SCALE"))
193 struct const_var_set *vs;
194 if (! lex_force_match (lexer, T_LPAREN))
197 if (! lex_force_string (lexer))
200 ds_assign_substring (&reliability.scale_name, lex_tokss (lexer));
204 if (! lex_force_match (lexer, T_RPAREN))
207 lex_match (lexer, T_EQUALS);
209 vs = const_var_set_create_from_array (reliability.variables, reliability.n_variables);
211 free (reliability.sc->items);
212 if (!parse_const_var_set_vars (lexer, vs, &reliability.sc->items, &reliability.sc->n_items, 0))
214 const_var_set_destroy (vs);
218 const_var_set_destroy (vs);
220 else if (lex_match_id (lexer, "MODEL"))
222 lex_match (lexer, T_EQUALS);
223 if (lex_match_id (lexer, "ALPHA"))
225 reliability.model = MODEL_ALPHA;
227 else if (lex_match_id (lexer, "SPLIT"))
229 reliability.model = MODEL_SPLIT;
230 reliability.split_point = -1;
232 if (lex_match (lexer, T_LPAREN)
233 && lex_force_num (lexer))
235 reliability.split_point = lex_number (lexer);
237 if (! lex_force_match (lexer, T_RPAREN))
244 else if (lex_match_id (lexer, "SUMMARY"))
246 lex_match (lexer, T_EQUALS);
247 if (lex_match_id (lexer, "TOTAL"))
249 reliability.summary |= SUMMARY_TOTAL;
251 else if (lex_match (lexer, T_ALL))
253 reliability.summary = 0xFFFF;
258 else if (lex_match_id (lexer, "MISSING"))
260 lex_match (lexer, T_EQUALS);
261 while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
263 if (lex_match_id (lexer, "INCLUDE"))
265 reliability.exclude = MV_SYSTEM;
267 else if (lex_match_id (lexer, "EXCLUDE"))
269 reliability.exclude = MV_ANY;
273 lex_error (lexer, NULL);
278 else if (lex_match_id (lexer, "STATISTICS"))
280 int statistics_start = lex_ofs (lexer) - 1;
281 lex_match (lexer, T_EQUALS);
282 while (lex_match (lexer, T_ID))
284 int statistics_end = lex_ofs (lexer) - 1;
286 lex_ofs_msg (lexer, SW, statistics_start, statistics_end,
287 _("The STATISTICS subcommand is not yet implemented. "
288 "No statistics will be produced."));
292 lex_error (lexer, NULL);
297 if (reliability.model == MODEL_SPLIT)
300 const struct cronbach *s;
302 if (reliability.split_point >= reliability.n_variables)
304 msg (ME, _("The split point must be less than the number of variables"));
308 reliability.n_sc += 2 ;
309 reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
311 s = &reliability.sc[0];
313 reliability.sc[1].n_items =
314 (reliability.split_point == -1) ? s->n_items / 2 : reliability.split_point;
316 reliability.sc[2].n_items = s->n_items - reliability.sc[1].n_items;
317 reliability.sc[1].items = XCALLOC (reliability.sc[1].n_items, const struct variable *);
318 reliability.sc[2].items = XCALLOC (reliability.sc[2].n_items, const struct variable *);
320 for (i = 0; i < reliability.sc[1].n_items ; ++i)
321 reliability.sc[1].items[i] = s->items[i];
323 while (i < s->n_items)
325 reliability.sc[2].items[i - reliability.sc[1].n_items] = s->items[i];
330 if (reliability.summary & SUMMARY_TOTAL)
333 const int base_sc = reliability.n_sc;
335 reliability.total_start = base_sc;
337 reliability.n_sc += reliability.sc[0].n_items ;
338 reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
341 for (i = 0 ; i < reliability.sc[0].n_items; ++i)
345 struct cronbach *s = &reliability.sc[i + base_sc];
347 s->n_items = reliability.sc[0].n_items - 1;
348 s->items = xcalloc (s->n_items, sizeof (struct variable *));
349 for (v_src = 0 ; v_src < reliability.sc[0].n_items ; ++v_src)
352 s->items[v_dest++] = reliability.sc[0].items[v_src];
358 if (! run_reliability (ds, &reliability))
361 reliability_destroy (&reliability);
365 reliability_destroy (&reliability);
371 do_reliability (struct casereader *group, struct dataset *ds,
372 const struct reliability *rel);
375 static void reliability_summary_total (const struct reliability *rel);
377 static void reliability_statistics (const struct reliability *rel);
381 run_reliability (struct dataset *ds, const struct reliability *reliability)
383 struct dictionary *dict = dataset_dict (ds);
385 struct casereader *group;
387 struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), dict);
390 for (si = 0 ; si < reliability->n_sc; ++si)
392 struct cronbach *s = &reliability->sc[si];
395 s->m = xcalloc (s->n_items, sizeof *s->m);
396 s->total = moments1_create (MOMENT_VARIANCE);
398 for (i = 0 ; i < s->n_items ; ++i)
399 s->m[i] = moments1_create (MOMENT_VARIANCE);
403 while (casegrouper_get_next_group (grouper, &group))
405 do_reliability (group, ds, reliability);
407 reliability_statistics (reliability);
409 if (reliability->summary & SUMMARY_TOTAL)
410 reliability_summary_total (reliability);
413 ok = casegrouper_destroy (grouper);
414 ok = proc_commit (ds) && ok;
423 /* Return the sum of all the item variables in S */
425 append_sum (const struct ccase *c, casenumber n UNUSED, void *aux)
428 const struct cronbach *s = aux;
430 for (int v = 0 ; v < s->n_items; ++v)
431 sum += case_num (c, s->items[v]);
437 case_processing_summary (casenumber n_valid, casenumber n_missing,
438 const struct dictionary *dict);
442 alpha (int k, double sum_of_variances, double variance_of_sums)
444 return k / (k - 1.0) * (1 - sum_of_variances / variance_of_sums);
448 do_reliability (struct casereader *input, struct dataset *ds,
449 const struct reliability *rel)
454 casenumber n_missing ;
455 casenumber n_valid = 0;
458 for (si = 0 ; si < rel->n_sc; ++si)
460 struct cronbach *s = &rel->sc[si];
462 moments1_clear (s->total);
464 for (i = 0 ; i < s->n_items ; ++i)
465 moments1_clear (s->m[i]);
468 input = casereader_create_filter_missing (input,
475 for (si = 0 ; si < rel->n_sc; ++si)
477 struct cronbach *s = &rel->sc[si];
480 s->totals_idx = caseproto_get_n_widths (casereader_get_proto (input));
482 casereader_create_append_numeric (input, append_sum,
486 for (; (c = casereader_read (input)) != NULL; case_unref (c))
491 for (si = 0; si < rel->n_sc; ++si)
493 struct cronbach *s = &rel->sc[si];
495 for (i = 0 ; i < s->n_items ; ++i)
496 moments1_add (s->m[i], case_num (c, s->items[i]), weight);
498 moments1_add (s->total, case_num_idx (c, s->totals_idx), weight);
501 casereader_destroy (input);
503 for (si = 0; si < rel->n_sc; ++si)
505 struct cronbach *s = &rel->sc[si];
507 s->sum_of_variances = 0;
508 for (i = 0 ; i < s->n_items ; ++i)
510 double weight, mean, variance;
511 moments1_calculate (s->m[i], &weight, &mean, &variance, NULL, NULL);
513 s->sum_of_variances += variance;
516 moments1_calculate (s->total, NULL, NULL, &s->variance_of_sums,
520 alpha (s->n_items, s->sum_of_variances, s->variance_of_sums);
523 output_item_submit (text_item_create_nocopy (
525 xasprintf (_("Scale: %s"), ds_cstr (&rel->scale_name)),
528 case_processing_summary (n_valid, n_missing, dataset_dict (ds));
536 case_processing_summary (casenumber n_valid, casenumber n_missing,
537 const struct dictionary *dict)
539 struct pivot_table *table = pivot_table_create (
540 N_("Case Processing Summary"));
541 pivot_table_set_weight_var (table, dict_get_weight (dict));
543 pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
544 N_("N"), PIVOT_RC_COUNT,
545 N_("Percent"), PIVOT_RC_PERCENT);
547 struct pivot_dimension *cases = pivot_dimension_create (
548 table, PIVOT_AXIS_ROW, N_("Cases"), N_("Valid"), N_("Excluded"),
550 cases->root->show_label = true;
552 casenumber total = n_missing + n_valid;
564 { 1, 0, 100.0 * n_valid / total },
565 { 1, 1, 100.0 * n_missing / total },
569 for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
571 const struct entry *e = &entries[i];
572 pivot_table_put2 (table, e->stat_idx, e->case_idx,
573 pivot_value_new_number (e->x));
576 pivot_table_submit (table);
580 reliability_summary_total (const struct reliability *rel)
582 struct pivot_table *table = pivot_table_create (N_("Item-Total Statistics"));
584 pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
585 N_("Scale Mean if Item Deleted"),
586 N_("Scale Variance if Item Deleted"),
587 N_("Corrected Item-Total Correlation"),
588 N_("Cronbach's Alpha if Item Deleted"));
590 struct pivot_dimension *variables = pivot_dimension_create (
591 table, PIVOT_AXIS_ROW, N_("Variables"));
593 for (size_t i = 0 ; i < rel->sc[0].n_items; ++i)
595 const struct cronbach *s = &rel->sc[rel->total_start + i];
597 int var_idx = pivot_category_create_leaf (
598 variables->root, pivot_value_new_variable (rel->sc[0].items[i]));
601 moments1_calculate (s->total, NULL, &mean, NULL, NULL, NULL);
604 moments1_calculate (rel->sc[0].m[i], NULL, NULL, &var, NULL, NULL);
606 = (rel->sc[0].variance_of_sums + var - s->variance_of_sums) / 2.0;
611 (cov - var) / sqrt (var * s->variance_of_sums),
614 for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
615 pivot_table_put2 (table, i, var_idx,
616 pivot_value_new_number (entries[i]));
619 pivot_table_submit (table);
624 reliability_statistics (const struct reliability *rel)
626 struct pivot_table *table = pivot_table_create (
627 N_("Reliability Statistics"));
628 pivot_table_set_weight_var (table, rel->wv);
630 if (rel->model == MODEL_ALPHA)
632 pivot_dimension_create (table, PIVOT_AXIS_COLUMN,
634 N_("Cronbach's Alpha"), PIVOT_RC_OTHER,
635 N_("N of Items"), PIVOT_RC_COUNT);
637 const struct cronbach *s = &rel->sc[0];
638 pivot_table_put1 (table, 0, pivot_value_new_number (s->alpha));
639 pivot_table_put1 (table, 1, pivot_value_new_number (s->n_items));
643 struct pivot_dimension *statistics = pivot_dimension_create (
644 table, PIVOT_AXIS_ROW, N_("Statistics"));
645 struct pivot_category *alpha = pivot_category_create_group (
646 statistics->root, N_("Cronbach's Alpha"));
647 pivot_category_create_group (alpha, N_("Part 1"),
648 N_("Value"), PIVOT_RC_OTHER,
649 N_("N of Items"), PIVOT_RC_COUNT);
650 pivot_category_create_group (alpha, N_("Part 2"),
651 N_("Value"), PIVOT_RC_OTHER,
652 N_("N of Items"), PIVOT_RC_COUNT);
653 pivot_category_create_leaves (alpha,
654 N_("Total N of Items"), PIVOT_RC_COUNT);
655 pivot_category_create_leaves (statistics->root,
656 N_("Correlation Between Forms"),
658 pivot_category_create_group (statistics->root,
659 N_("Spearman-Brown Coefficient"),
660 N_("Equal Length"), PIVOT_RC_OTHER,
661 N_("Unequal Length"), PIVOT_RC_OTHER);
662 pivot_category_create_leaves (statistics->root,
663 N_("Guttman Split-Half Coefficient"),
666 /* R is the correlation between the two parts */
667 double r0 = rel->sc[0].variance_of_sums -
668 rel->sc[1].variance_of_sums -
669 rel->sc[2].variance_of_sums ;
670 double r1 = (r0 / sqrt (rel->sc[1].variance_of_sums)
671 / sqrt (rel->sc[2].variance_of_sums)
674 /* Guttman Split Half Coefficient */
675 double g = 2 * r0 / rel->sc[0].variance_of_sums;
677 double tmp = (1.0 - r1*r1) * rel->sc[1].n_items * rel->sc[2].n_items /
678 pow2 (rel->sc[0].n_items);
685 rel->sc[1].n_items + rel->sc[2].n_items,
688 (sqrt (pow4 (r1) + 4 * pow2 (r1) * tmp) - pow2 (r1)) / (2 * tmp),
691 for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)
692 pivot_table_put1 (table, i, pivot_value_new_number (entries[i]));
695 pivot_table_submit (table);