pintos-os.org Git - pspp/blob - src/language/stats/t-test-parser.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2011 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 "libpspp/message.h"
  20
  21 #include "data/casegrouper.h"
  22 #include "data/casereader.h"
  23 #include "data/dictionary.h"
  24 #include "data/dataset.h"
  25 #include "data/missing-values.h"
  26
  27 #include "language/lexer/lexer.h"
  28 #include "language/command.h"
  29 #include "language/lexer/variable-parser.h"
  30 #include "language/lexer/value-parser.h"
  31
  32 #include "gettext.h"
  33 #define _(msgid) gettext (msgid)
  34
  35 #include "t-test.h"
  36
  37 int
  38 cmd_t_test (struct lexer *lexer, struct dataset *ds)
  39 {
  40   bool ok;
  41   const struct dictionary *dict = dataset_dict (ds);
  42   struct tt tt;
  43   int mode_count = 0;
  44
  45   /* Variables pertaining to the paired mode */
  46   const struct variable **v1 = NULL;
  47   size_t n_v1;
  48   const struct variable **v2 = NULL;
  49   size_t n_v2;
  50
  51   size_t n_pairs = 0;
  52   vp *pairs = NULL;
  53
  54
  55   /* One sample mode */
  56   double testval = SYSMIS;
  57
  58   /* Independent samples mode */
  59   const struct variable *gvar;
  60   union value gval0;
  61   union value gval1;
  62   bool cut = false;
  63
  64   tt.wv = dict_get_weight (dict);
  65   tt.dict = dict;
  66   tt.confidence = 0.95;
  67   tt.exclude = MV_ANY;
  68   tt.missing_type = MISS_ANALYSIS;
  69   tt.n_vars = 0;
  70   tt.vars = NULL;
  71   tt.mode = MODE_undef;
  72
  73   lex_match (lexer, T_EQUALS);
  74
  75   for (; lex_token (lexer) != T_ENDCMD; )
  76     {
  77       lex_match (lexer, T_SLASH);
  78       if (lex_match_id (lexer, "TESTVAL"))
  79         {
  80           mode_count++;
  81           tt.mode = MODE_SINGLE;
  82           lex_match (lexer, T_EQUALS);
  83           lex_force_num (lexer);
  84           testval = lex_number (lexer);
  85           lex_get (lexer);
  86         }
  87       else if (lex_match_id (lexer, "GROUPS"))
  88         {
  89           mode_count++;
  90           cut = false;
  91           tt.mode = MODE_INDEP;
  92           lex_match (lexer, T_EQUALS);
  93
  94           if (NULL == (gvar = parse_variable (lexer, dict)))
  95             goto parse_failed;
  96
  97           if (lex_match (lexer, T_LPAREN))
  98             {
  99
 100               value_init (&gval0, var_get_width (gvar));
 101               parse_value (lexer, &gval0, gvar);
 102               cut = true;
 103               if (lex_match (lexer, T_COMMA))
 104                 {
 105                   value_init (&gval1, var_get_width (gvar));
 106                   parse_value (lexer, &gval1, gvar);
 107                   cut = false;
 108                 }
 109
 110               lex_force_match (lexer, T_RPAREN);
 111             }
 112           else
 113             {
 114               value_init (&gval0, 0);
 115               value_init (&gval1, 0);
 116               gval0.f = 1.0;
 117               gval1.f = 2.0;
 118               cut = false;
 119             }
 120
 121           if ( cut == true && var_is_alpha (gvar))
 122             {
 123               msg (SE, _("When applying GROUPS to a string variable, two "
 124                          "values must be specified."));
 125               goto parse_failed;
 126             }
 127         }
 128       else if (lex_match_id (lexer, "PAIRS"))
 129         {
 130           bool with = false;
 131           bool paired = false;
 132
 133           if (tt.n_vars > 0)
 134             {
 135               msg (SE, _("VARIABLES subcommand may not be used with PAIRS."));
 136               goto parse_failed;
 137             }
 138
 139           mode_count++;
 140           tt.mode = MODE_PAIRED;
 141           lex_match (lexer, T_EQUALS);
 142
 143           if (!parse_variables_const (lexer, dict,
 144                                       &v1, &n_v1,
 145                                       PV_NO_DUPLICATE | PV_NUMERIC))
 146             goto parse_failed;
 147
 148           if ( lex_match (lexer, T_WITH))
 149             {
 150               with = true;
 151               if (!parse_variables_const (lexer, dict,
 152                                           &v2, &n_v2,
 153                                           PV_NO_DUPLICATE | PV_NUMERIC))
 154                 goto parse_failed;
 155
 156               if (lex_match (lexer, T_LPAREN)
 157                   && lex_match_id (lexer, "PAIRED")
 158                   && lex_match (lexer, T_RPAREN))
 159                 {
 160                   paired = true;
 161                   if (n_v1 != n_v2)
 162                     {
 163                       msg (SE, _("PAIRED was specified but the number of variables "
 164                                  "preceding WITH (%zu) did not match the number "
 165                                  "following (%zu)."),
 166                            n_v1, n_v2);
 167                       goto parse_failed;
 168                     }
 169                 }
 170             }
 171           {
 172             int i;
 173
 174             if ( !with )
 175               n_pairs = (n_v1 * (n_v1 - 1)) / 2.0;
 176             else if ( paired )
 177               n_pairs = n_v1;
 178             else
 179               n_pairs = n_v1 * n_v2;
 180
 181             pairs = xcalloc (sizeof *pairs, n_pairs);
 182
 183
 184             if ( with)
 185               {
 186                 int x = 0;
 187                 if (paired)
 188                   {
 189                     for (i = 0 ; i < n_v1; ++i)
 190                       {
 191                         vp *pair = &pairs[i];
 192                         (*pair)[0] = v1[i];
 193                         (*pair)[1] = v2[i];
 194                       }
 195                   }
 196                 else
 197                   {
 198                     for (i = 0 ; i < n_v1; ++i)
 199                       {
 200                         int j;
 201                         for (j = 0 ; j < n_v2; ++j)
 202                           {
 203                             vp *pair = &pairs[x++];
 204                             (*pair)[0] = v1[i];
 205                             (*pair)[1] = v2[j];
 206                           }
 207                       }
 208                   }
 209               }
 210             else
 211               {
 212                 int x = 0;
 213                 for (i = 0 ; i < n_v1; ++i)
 214                   {
 215                     int j;
 216
 217                     for (j = i + 1 ; j < n_v1; ++j)
 218                       {
 219                         vp *pair = &pairs[x++];
 220                         (*pair)[0] = v1[i];
 221                         (*pair)[1] = v1[j];
 222                       }
 223                   }
 224               }
 225
 226           }
 227         }
 228       else if (lex_match_id (lexer, "VARIABLES"))
 229         {
 230           if ( tt.mode == MODE_PAIRED)
 231             {
 232               msg (SE, _("VARIABLES subcommand may not be used with PAIRS."));
 233               goto parse_failed;
 234             }
 235
 236           lex_match (lexer, T_EQUALS);
 237
 238           if (!parse_variables_const (lexer, dict,
 239                                       &tt.vars,
 240                                       &tt.n_vars,
 241                                       PV_NO_DUPLICATE | PV_NUMERIC))
 242             goto parse_failed;
 243         }
 244       else if ( lex_match_id (lexer, "MISSING"))
 245         {
 246           lex_match (lexer, T_EQUALS);
 247           while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
 248             {
 249               if (lex_match_id (lexer, "INCLUDE"))
 250                 {
 251                   tt.exclude = MV_SYSTEM;
 252                 }
 253               else if (lex_match_id (lexer, "EXCLUDE"))
 254                 {
 255                   tt.exclude = MV_ANY;
 256                 }
 257               else if (lex_match_id (lexer, "LISTWISE"))
 258                 {
 259                   tt.missing_type = MISS_LISTWISE;
 260                 }
 261               else if (lex_match_id (lexer, "ANALYSIS"))
 262                 {
 263                   tt.missing_type = MISS_ANALYSIS;
 264                 }
 265               else
 266                 {
 267                   lex_error (lexer, NULL);
 268                   goto parse_failed;
 269                 }
 270               lex_match (lexer, T_COMMA);
 271             }
 272         }
 273       else if (lex_match_id (lexer, "CRITERIA"))
 274         {
 275           lex_match (lexer, T_EQUALS);
 276           if ( lex_force_match_id (lexer, "CIN"))
 277             if ( lex_force_match (lexer, T_LPAREN))
 278               {
 279                 lex_force_num (lexer);
 280                 tt.confidence = lex_number (lexer);
 281                 lex_get (lexer);
 282                 lex_force_match (lexer, T_RPAREN);
 283               }
 284         }
 285       else
 286         {
 287           lex_error (lexer, NULL);
 288           goto parse_failed;
 289         }
 290     }
 291
 292   if ( mode_count != 1)
 293     {
 294       msg (SE, _("Exactly one of TESTVAL, GROUPS and PAIRS subcommands "
 295                  "must be specified."));
 296       goto parse_failed;
 297     }
 298
 299   if (tt.n_vars == 0 && tt.mode != MODE_PAIRED)
 300     {
 301       msg (SE, _("One or more VARIABLES must be specified."));
 302       goto parse_failed;
 303     }
 304
 305
 306
 307   /* Deal with splits etc */
 308   {
 309     struct casereader *group;
 310     struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), dict);
 311
 312     while (casegrouper_get_next_group (grouper, &group))
 313       {
 314         if ( tt.mode == MODE_SINGLE)
 315           {
 316             if ( tt.missing_type == MISS_LISTWISE )
 317               group  = casereader_create_filter_missing (group,
 318                                                          tt.vars, tt.n_vars,
 319                                                          tt.exclude,
 320                                                          NULL,  NULL);
 321             one_sample_run (&tt, testval, group);
 322           }
 323         else if ( tt.mode == MODE_PAIRED)
 324           {
 325             if ( tt.missing_type == MISS_LISTWISE )
 326               {
 327                 group  = casereader_create_filter_missing (group,
 328                                                            v1, n_v1,
 329                                                            tt.exclude,
 330                                                            NULL,  NULL);
 331                 group  = casereader_create_filter_missing (group,
 332                                                            v2, n_v2,
 333                                                            tt.exclude,
 334                                                            NULL,  NULL);
 335               }
 336
 337             paired_run (&tt, n_pairs, pairs, group);
 338           }
 339         else /* tt.mode == MODE_INDEP */
 340           {
 341             if ( tt.missing_type == MISS_LISTWISE )
 342               {
 343                 group  = casereader_create_filter_missing (group,
 344                                                            tt.vars, tt.n_vars,
 345                                                            tt.exclude,
 346                                                            NULL,  NULL);
 347
 348                 group  = casereader_create_filter_missing (group,
 349                                                            &gvar, 1,
 350                                                            tt.exclude,
 351                                                            NULL,  NULL);
 352
 353               }
 354
 355             indep_run (&tt, gvar, cut, &gval0, &gval1, group);
 356           }
 357       }
 358
 359     ok = casegrouper_destroy (grouper);
 360     ok = proc_commit (ds) && ok;
 361   }
 362
 363   free (pairs);
 364   free (v1);
 365   free (v2);
 366
 367   free (tt.vars);
 368
 369   return ok ? CMD_SUCCESS : CMD_FAILURE;
 370
 371  parse_failed:
 372   return CMD_FAILURE;
 373 }
 374