X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fnpar.c;h=eada5d16496db6195b78eb6463db9f03a5c4ec30;hb=c5d4a219c4f28f2a0adb223be62fe4bb8df02f8f;hp=737c94e3d2a296dfd4f999dac4e822c5c08e5ea3;hpb=c79b359c221a3bb046492c589a8c82af06f09cc0;p=pspp diff --git a/src/language/stats/npar.c b/src/language/stats/npar.c index 737c94e3d2..eada5d1649 100644 --- a/src/language/stats/npar.c +++ b/src/language/stats/npar.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. -*-c-*- - Copyright (C) 2006, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 2006, 2008, 2009, 2010, 2011, 2016 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -149,7 +149,7 @@ static int npar_method (struct lexer *, struct npar_specs *); /* Command parsing functions. */ static int parse_npar_tests (struct lexer *lexer, struct dataset *ds, struct cmd_npar_tests *p, - struct npar_specs *npar_specs ); + struct npar_specs *npar_specs); static int parse_npar_tests (struct lexer *lexer, struct dataset *ds, struct cmd_npar_tests *npt, @@ -487,7 +487,7 @@ parse_npar_tests (struct lexer *lexer, struct dataset *ds, struct cmd_npar_tests lex_match (lexer, T_COMMA); } } - else if ( settings_get_syntax () != COMPATIBLE && lex_match_id (lexer, "ALGORITHM")) + else if (settings_get_syntax () != COMPATIBLE && lex_match_id (lexer, "ALGORITHM")) { lex_match (lexer, T_EQUALS); if (lex_match_id (lexer, "COMPATIBLE")) @@ -498,7 +498,6 @@ parse_npar_tests (struct lexer *lexer, struct dataset *ds, struct cmd_npar_tests if (!lex_match (lexer, T_SLASH)) break; } - if (lex_token (lexer) != T_ENDCMD) { lex_error (lexer, _("expecting end of command")); @@ -529,18 +528,18 @@ npar_execute (struct casereader *input, int t; struct descriptives *summary_descriptives = NULL; - for ( t = 0 ; t < specs->n_tests; ++t ) + for (t = 0 ; t < specs->n_tests; ++t) { const struct npar_test *test = specs->test[t]; - if ( NULL == test->execute ) + if (NULL == test->execute) { - msg (SW, _("NPAR subcommand not currently implemented.")); + msg (SW, _("%s subcommand not currently implemented."), "NPAR"); continue; } test->execute (ds, casereader_clone (input), specs->filter, test, specs->exact, specs->timer); } - if ( specs->descriptives ) + if (specs->descriptives && specs->n_vars > 0) { summary_descriptives = xnmalloc (sizeof (*summary_descriptives), specs->n_vars); @@ -552,9 +551,10 @@ npar_execute (struct casereader *input, specs->filter); } - if ( (specs->descriptives || specs->quartiles) - && !taint_has_tainted_successor (casereader_get_taint (input)) ) - do_summary_box (summary_descriptives, specs->vv, specs->n_vars ); + if ((specs->descriptives || specs->quartiles) + && !taint_has_tainted_successor (casereader_get_taint (input))) + do_summary_box (summary_descriptives, specs->vv, specs->n_vars, + dict_get_weight_format (dataset_dict (ds))); free (summary_descriptives); casereader_destroy (input); @@ -577,13 +577,13 @@ cmd_npar_tests (struct lexer *lexer, struct dataset *ds) npar_specs.n_vars = -1; npar_specs.vv = NULL; - if ( ! parse_npar_tests (lexer, ds, &cmd, &npar_specs) ) + if (! parse_npar_tests (lexer, ds, &cmd, &npar_specs)) { pool_destroy (npar_specs.pool); return CMD_FAILURE; } - for (i = 0; i < npar_specs.n_tests; ++i ) + for (i = 0; i < npar_specs.n_tests; ++i) { const struct npar_test *test = npar_specs.test[i]; test->insert_variables (test, &var_map); @@ -602,18 +602,18 @@ cmd_npar_tests (struct lexer *lexer, struct dataset *ds) } } - sort (npar_specs.vv, npar_specs.n_vars, sizeof (*npar_specs.vv), + sort (npar_specs.vv, npar_specs.n_vars, sizeof (*npar_specs.vv), compare_var_ptrs_by_name, NULL); - if ( cmd.statistics ) + if (cmd.statistics) { int i; - for ( i = 0 ; i < NPAR_ST_count; ++i ) + for (i = 0 ; i < NPAR_ST_count; ++i) { - if ( cmd.a_statistics[i] ) + if (cmd.a_statistics[i]) { - switch ( i ) + switch (i) { case NPAR_ST_DESCRIPTIVES: npar_specs.descriptives = true; @@ -633,7 +633,7 @@ cmd_npar_tests (struct lexer *lexer, struct dataset *ds) } input = proc_open (ds); - if ( cmd.miss == MISS_LISTWISE ) + if (cmd.miss == MISS_LISTWISE) { input = casereader_create_filter_missing (input, npar_specs.vv, @@ -666,9 +666,9 @@ npar_runs (struct lexer *lexer, struct dataset *ds, nt->execute = runs_execute; nt->insert_variables = one_sample_insert_variables; - if ( lex_force_match (lexer, T_LPAREN) ) + if (lex_force_match (lexer, T_LPAREN)) { - if ( lex_match_id (lexer, "MEAN")) + if (lex_match_id (lexer, "MEAN")) { rt->cp_mode = CP_MEAN; } @@ -688,12 +688,16 @@ npar_runs (struct lexer *lexer, struct dataset *ds, } else { - lex_error (lexer, _("Expecting MEAN, MEDIAN, MODE or number")); + lex_error (lexer, _("Expecting %s, %s, %s or a number."), "MEAN", "MEDIAN", "MODE"); return 0; } - - lex_force_match (lexer, T_RPAREN); - lex_force_match (lexer, T_EQUALS); + + if (! lex_force_match (lexer, T_RPAREN)) + return 2; + + if (! lex_force_match (lexer, T_EQUALS)) + return 2; + if (!parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds), &tp->vars, &tp->n_vars, PV_NO_SCRATCH | PV_NO_DUPLICATE | PV_NUMERIC)) @@ -716,7 +720,7 @@ static int npar_friedman (struct lexer *lexer, struct dataset *ds, struct npar_specs *specs) { - struct friedman_test *ft = pool_alloc (specs->pool, sizeof (*ft)); + struct friedman_test *ft = pool_alloc (specs->pool, sizeof (*ft)); struct one_sample_test *ost = &ft->parent; struct npar_test *nt = &ost->parent; @@ -747,7 +751,7 @@ static int npar_kendall (struct lexer *lexer, struct dataset *ds, struct npar_specs *specs) { - struct friedman_test *kt = pool_alloc (specs->pool, sizeof (*kt)); + struct friedman_test *kt = pool_alloc (specs->pool, sizeof (*kt)); struct one_sample_test *ost = &kt->parent; struct npar_test *nt = &ost->parent; @@ -779,7 +783,7 @@ static int npar_cochran (struct lexer *lexer, struct dataset *ds, struct npar_specs *specs) { - struct one_sample_test *ft = pool_alloc (specs->pool, sizeof (*ft)); + struct one_sample_test *ft = pool_alloc (specs->pool, sizeof (*ft)); struct npar_test *nt = &ft->parent; nt->execute = cochran_execute; @@ -826,16 +830,16 @@ npar_chisquare (struct lexer *lexer, struct dataset *ds, cstp->ranged = false; - if ( lex_match (lexer, T_LPAREN)) + if (lex_match (lexer, T_LPAREN)) { cstp->ranged = true; - if ( ! lex_force_num (lexer)) return 0; - cstp->lo = lex_integer (lexer); + if (! lex_force_num (lexer)) return 0; + cstp->lo = lex_number (lexer); lex_get (lexer); - lex_force_match (lexer, T_COMMA); - if (! lex_force_num (lexer) ) return 0; - cstp->hi = lex_integer (lexer); - if ( cstp->lo >= cstp->hi ) + if (! lex_force_match (lexer, T_COMMA)) return 0; + if (! lex_force_num (lexer)) return 0; + cstp->hi = lex_number (lexer); + if (cstp->lo >= cstp->hi) { msg (ME, _("The specified value of HI (%d) is " @@ -851,20 +855,22 @@ npar_chisquare (struct lexer *lexer, struct dataset *ds, cstp->expected = NULL; if (lex_match_phrase (lexer, "/EXPECTED")) { - lex_force_match (lexer, T_EQUALS); - if ( ! lex_match_id (lexer, "EQUAL") ) + if (! lex_force_match (lexer, T_EQUALS)) return 0; + if (! lex_match_id (lexer, "EQUAL")) { double f; int n; - while ( lex_is_number (lexer) ) + while (lex_is_number (lexer)) { int i; n = 1; f = lex_number (lexer); lex_get (lexer); - if ( lex_match (lexer, T_ASTERISK)) + if (lex_match (lexer, T_ASTERISK)) { n = f; + if (!lex_force_num (lexer)) + return 0; f = lex_number (lexer); lex_get (lexer); } @@ -875,17 +881,17 @@ npar_chisquare (struct lexer *lexer, struct dataset *ds, cstp->expected, sizeof (double) * cstp->n_expected); - for ( i = cstp->n_expected - n ; + for (i = cstp->n_expected - n ; i < cstp->n_expected; - ++i ) + ++i) cstp->expected[i] = f; } } } - if ( cstp->ranged && cstp->n_expected > 0 && - cstp->n_expected != cstp->hi - cstp->lo + 1 ) + if (cstp->ranged && cstp->n_expected > 0 && + cstp->n_expected != cstp->hi - cstp->lo + 1) { msg (ME, _("%d expected values were given, but the specified " @@ -922,14 +928,15 @@ npar_binomial (struct lexer *lexer, struct dataset *ds, btp->p = 0.5; - if ( lex_match (lexer, T_LPAREN) ) + if (lex_match (lexer, T_LPAREN)) { equals = false; - if ( lex_force_num (lexer) ) + if (lex_force_num (lexer)) { btp->p = lex_number (lexer); lex_get (lexer); - lex_force_match (lexer, T_RPAREN); + if (!lex_force_match (lexer, T_RPAREN)) + return 0; } else return 0; @@ -937,36 +944,41 @@ npar_binomial (struct lexer *lexer, struct dataset *ds, else equals = true; - if (equals || lex_match (lexer, T_EQUALS) ) - { - if (parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds), - &tp->vars, &tp->n_vars, - PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE) ) - { - if (lex_match (lexer, T_LPAREN)) - { - if (! lex_force_num (lexer)) - return 2; - btp->category1 = lex_number (lexer); - lex_get (lexer); - if ( lex_match (lexer, T_COMMA)) - { - if ( ! lex_force_num (lexer) ) return 2; - btp->category2 = lex_number (lexer); - lex_get (lexer); - } - else - { - btp->cutpoint = btp->category1; - } - - lex_force_match (lexer, T_RPAREN); - } - } - else - return 2; + if (!equals) + if (!lex_force_match (lexer, T_EQUALS)) + return 0; - } + { + if (parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds), + &tp->vars, &tp->n_vars, + PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE)) + { + if (lex_match (lexer, T_LPAREN)) + { + if (! lex_force_num (lexer)) + return 2; + btp->category1 = lex_number (lexer); + lex_get (lexer); + if (lex_match (lexer, T_COMMA)) + { + if (! lex_force_num (lexer)) return 2; + btp->category2 = lex_number (lexer); + lex_get (lexer); + } + else + { + btp->cutpoint = btp->category1; + } + + if (! lex_force_match (lexer, T_RPAREN)) + return 0; + } + } + else + { + return 2; + } + } specs->n_tests++; specs->test = pool_realloc (specs->pool, @@ -990,7 +1002,7 @@ ks_one_sample_parse_params (struct lexer *lexer, struct ks_one_sample_test *kst, kst->p[0] = lex_number (lexer); lex_get (lexer); - if ( params == 2) + if (params == 2) { lex_match (lexer, T_COMMA); if (lex_force_num (lexer)) @@ -1047,7 +1059,7 @@ npar_ks_one_sample (struct lexer *lexer, struct dataset *ds, struct npar_specs * if (! parse_variables_const_pool (lexer, specs->pool, dataset_dict (ds), &tp->vars, &tp->n_vars, - PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE) ) + PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE)) return 2; specs->n_tests++; @@ -1081,15 +1093,15 @@ parse_two_sample_related_test (struct lexer *lexer, if (!parse_variables_const_pool (lexer, pool, dict, &vlist1, &n_vlist1, - PV_NUMERIC | PV_NO_SCRATCH | PV_DUPLICATE) ) + PV_NUMERIC | PV_NO_SCRATCH | PV_DUPLICATE)) return false; - if ( lex_match (lexer, T_WITH)) + if (lex_match (lexer, T_WITH)) { with = true; - if ( !parse_variables_const_pool (lexer, pool, dict, + if (!parse_variables_const_pool (lexer, pool, dict, &vlist2, &n_vlist2, - PV_NUMERIC | PV_NO_SCRATCH | PV_DUPLICATE) ) + PV_NUMERIC | PV_NO_SCRATCH | PV_DUPLICATE)) return false; paired = (lex_match (lexer, T_LPAREN) && @@ -1097,11 +1109,11 @@ parse_two_sample_related_test (struct lexer *lexer, } - if ( with ) + if (with) { if (paired) { - if ( n_vlist1 != n_vlist2) + if (n_vlist1 != n_vlist2) { msg (SE, _("PAIRED was specified but the number of variables " "preceding WITH (%zu) did not match the number " @@ -1122,15 +1134,15 @@ parse_two_sample_related_test (struct lexer *lexer, } test_parameters->pairs = - pool_alloc (pool, sizeof ( variable_pair) * test_parameters->n_pairs); + pool_alloc (pool, sizeof (variable_pair) * test_parameters->n_pairs); - if ( with ) + if (with) { if (paired) { int i; assert (n_vlist1 == n_vlist2); - for ( i = 0 ; i < n_vlist1; ++i ) + for (i = 0 ; i < n_vlist1; ++i) { test_parameters->pairs[n][0] = vlist1[i]; test_parameters->pairs[n][1] = vlist2[i]; @@ -1140,9 +1152,9 @@ parse_two_sample_related_test (struct lexer *lexer, else { int i,j; - for ( i = 0 ; i < n_vlist1; ++i ) + for (i = 0 ; i < n_vlist1; ++i) { - for ( j = 0 ; j < n_vlist2; ++j ) + for (j = 0 ; j < n_vlist2; ++j) { test_parameters->pairs[n][0] = vlist1[i]; test_parameters->pairs[n][1] = vlist2[j]; @@ -1154,11 +1166,11 @@ parse_two_sample_related_test (struct lexer *lexer, else { int i,j; - for ( i = 0 ; i < n_vlist1 - 1; ++i ) + for (i = 0 ; i < n_vlist1 - 1; ++i) { - for ( j = i + 1 ; j < n_vlist1; ++j ) + for (j = i + 1 ; j < n_vlist1; ++j) { - assert ( n < test_parameters->n_pairs); + assert (n < test_parameters->n_pairs); test_parameters->pairs[n][0] = vlist1[i]; test_parameters->pairs[n][1] = vlist1[j]; n++; @@ -1166,7 +1178,7 @@ parse_two_sample_related_test (struct lexer *lexer, } } - assert ( n == test_parameters->n_pairs); + assert (n == test_parameters->n_pairs); return true; } @@ -1177,24 +1189,26 @@ parse_n_sample_related_test (struct lexer *lexer, const struct dictionary *dict, struct n_sample_test *nst, struct pool *pool - ) + ) { if (!parse_variables_const_pool (lexer, pool, dict, &nst->vars, &nst->n_vars, - PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE) ) + PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE)) return false; - if ( ! lex_force_match (lexer, T_BY)) + if (! lex_force_match (lexer, T_BY)) return false; nst->indep_var = parse_variable_const (lexer, dict); + if (!nst->indep_var) + return false; - if ( ! lex_force_match (lexer, T_LPAREN)) + if (! lex_force_match (lexer, T_LPAREN)) return false; value_init (&nst->val1, var_get_width (nst->indep_var)); - if ( ! parse_value (lexer, &nst->val1, nst->indep_var)) + if (! parse_value (lexer, &nst->val1, nst->indep_var)) { value_destroy (&nst->val1, var_get_width (nst->indep_var)); return false; @@ -1203,13 +1217,13 @@ parse_n_sample_related_test (struct lexer *lexer, lex_match (lexer, T_COMMA); value_init (&nst->val2, var_get_width (nst->indep_var)); - if ( ! parse_value (lexer, &nst->val2, nst->indep_var)) + if (! parse_value (lexer, &nst->val2, nst->indep_var)) { value_destroy (&nst->val2, var_get_width (nst->indep_var)); return false; } - if ( ! lex_force_match (lexer, T_RPAREN)) + if (! lex_force_match (lexer, T_RPAREN)) return false; return true; @@ -1218,14 +1232,14 @@ parse_n_sample_related_test (struct lexer *lexer, static int npar_wilcoxon (struct lexer *lexer, struct dataset *ds, - struct npar_specs *specs ) + struct npar_specs *specs) { struct two_sample_test *tp = pool_alloc (specs->pool, sizeof (*tp)); struct npar_test *nt = &tp->parent; nt->execute = wilcoxon_execute; if (!parse_two_sample_related_test (lexer, dataset_dict (ds), - tp, specs->pool) ) + tp, specs->pool)) return 0; specs->n_tests++; @@ -1241,7 +1255,7 @@ npar_wilcoxon (struct lexer *lexer, static int npar_mann_whitney (struct lexer *lexer, struct dataset *ds, - struct npar_specs *specs ) + struct npar_specs *specs) { struct n_sample_test *tp = pool_alloc (specs->pool, sizeof (*tp)); struct npar_test *nt = &tp->parent; @@ -1250,7 +1264,7 @@ npar_mann_whitney (struct lexer *lexer, nt->execute = mann_whitney_execute; if (!parse_n_sample_related_test (lexer, dataset_dict (ds), - tp, specs->pool) ) + tp, specs->pool)) return 0; specs->n_tests++; @@ -1274,12 +1288,12 @@ npar_median (struct lexer *lexer, mt->median = SYSMIS; - if ( lex_match (lexer, T_LPAREN)) + if (lex_match (lexer, T_LPAREN) && lex_force_num (lexer)) { - lex_force_num (lexer); mt->median = lex_number (lexer); lex_get (lexer); - lex_force_match (lexer, T_RPAREN); + if (! lex_force_match (lexer, T_RPAREN)) + return 0; } lex_match (lexer, T_EQUALS); @@ -1288,7 +1302,7 @@ npar_median (struct lexer *lexer, nt->execute = median_execute; if (!parse_n_sample_related_test (lexer, dataset_dict (ds), - tp, specs->pool) ) + tp, specs->pool)) return 0; specs->n_tests++; @@ -1311,7 +1325,7 @@ npar_sign (struct lexer *lexer, struct dataset *ds, nt->execute = sign_execute; if (!parse_two_sample_related_test (lexer, dataset_dict (ds), - tp, specs->pool) ) + tp, specs->pool)) return 0; specs->n_tests++; @@ -1334,7 +1348,7 @@ npar_mcnemar (struct lexer *lexer, struct dataset *ds, nt->execute = mcnemar_execute; if (!parse_two_sample_related_test (lexer, dataset_dict (ds), - tp, specs->pool) ) + tp, specs->pool)) return 0; specs->n_tests++; @@ -1359,7 +1373,7 @@ npar_jonckheere_terpstra (struct lexer *lexer, struct dataset *ds, nt->execute = jonckheere_terpstra_execute; if (!parse_n_sample_related_test (lexer, dataset_dict (ds), - tp, specs->pool) ) + tp, specs->pool)) return 0; specs->n_tests++; @@ -1383,7 +1397,7 @@ npar_kruskal_wallis (struct lexer *lexer, struct dataset *ds, nt->execute = kruskal_wallis_execute; if (!parse_n_sample_related_test (lexer, dataset_dict (ds), - tp, specs->pool) ) + tp, specs->pool)) return 0; specs->n_tests++; @@ -1401,10 +1415,10 @@ insert_variable_into_map (struct hmapx *var_map, const struct variable *var) size_t hash = hash_pointer (var, 0); struct hmapx_node *node; const struct variable *v = NULL; - + HMAPX_FOR_EACH_WITH_HASH (v, node, hash, var_map) { - if ( v == var) + if (v == var) return ; } @@ -1419,7 +1433,7 @@ one_sample_insert_variables (const struct npar_test *test, int i; const struct one_sample_test *ost = UP_CAST (test, const struct one_sample_test, parent); - for ( i = 0 ; i < ost->n_vars ; ++i ) + for (i = 0 ; i < ost->n_vars ; ++i) insert_variable_into_map (var_map, ost->vars[i]); } @@ -1431,7 +1445,7 @@ two_sample_insert_variables (const struct npar_test *test, int i; const struct two_sample_test *tst = UP_CAST (test, const struct two_sample_test, parent); - for ( i = 0 ; i < tst->n_pairs ; ++i ) + for (i = 0 ; i < tst->n_pairs ; ++i) { variable_pair *pair = &tst->pairs[i]; @@ -1440,14 +1454,14 @@ two_sample_insert_variables (const struct npar_test *test, } } -static void +static void n_sample_insert_variables (const struct npar_test *test, struct hmapx *var_map) { int i; const struct n_sample_test *tst = UP_CAST (test, const struct n_sample_test, parent); - for ( i = 0 ; i < tst->n_vars ; ++i ) + for (i = 0 ; i < tst->n_vars ; ++i) insert_variable_into_map (var_map, tst->vars[i]); insert_variable_into_map (var_map, tst->indep_var); @@ -1457,7 +1471,7 @@ n_sample_insert_variables (const struct npar_test *test, static int npar_method (struct lexer *lexer, struct npar_specs *specs) { - if ( lex_match_id (lexer, "EXACT") ) + if (lex_match_id (lexer, "EXACT")) { specs->exact = true; specs->timer = 0.0; @@ -1465,14 +1479,15 @@ npar_method (struct lexer *lexer, struct npar_specs *specs) { specs->timer = 5.0; - if ( lex_match (lexer, T_LPAREN)) + if (lex_match (lexer, T_LPAREN)) { - if ( lex_force_num (lexer) ) + if (lex_force_num (lexer)) { specs->timer = lex_number (lexer); lex_get (lexer); } - lex_force_match (lexer, T_RPAREN); + if (lex_force_match (lexer, T_RPAREN)) + return 0; } } }