pintos-os.org Git - pspp/blob - src/math/categoricals.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2009, 2010, 2011, 2012, 2014 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/categoricals.h"
  20 #include "math/interaction.h"
  21
  22 #include <float.h>
  23 #include <stdio.h>
  24
  25 #include "data/case.h"
  26 #include "data/value.h"
  27 #include "data/variable.h"
  28 #include "libpspp/array.h"
  29 #include "libpspp/hmap.h"
  30 #include "libpspp/pool.h"
  31 #include "libpspp/str.h"
  32 #include "libpspp/hash-functions.h"
  33
  34 #include "gl/xalloc.h"
  35
  36 #define CATEGORICALS_DEBUG 0
  37
  38 struct value_node
  39 {
  40   struct hmap_node node;      /* Node in hash map. */
  41
  42   union value val;            /* The value */
  43
  44   int index;                  /* A zero based unique index for this value */
  45 };
  46
  47
  48 struct interaction_value
  49 {
  50   struct hmap_node node;      /* Node in hash map */
  51
  52   struct ccase *ccase;        /* A case (probably the first in the dataset) which matches
  53                                  this value */
  54
  55   double cc;                  /* Total of the weights of cases matching this interaction */
  56
  57   void *user_data;            /* A pointer to data which the caller can store stuff */
  58 };
  59
  60 static struct value_node *
  61 lookup_value (const struct hmap *map, const union value *val, unsigned int hash, int width)
  62 {
  63   struct value_node *vn = NULL;
  64   HMAP_FOR_EACH_WITH_HASH (vn, struct value_node, node, hash, map)
  65     {
  66       if (value_equal (&vn->val, val, width))
  67         break;
  68     }
  69
  70   return vn;
  71 }
  72
  73 struct variable_node
  74 {
  75   struct hmap_node node;      /* Node in hash map. */
  76   const struct variable *var; /* The variable */
  77
  78   struct hmap valmap;         /* A map of value nodes */
  79   int n_vals;                 /* Number of values for this variable */
  80 };
  81
  82
  83 /* Comparison function to sort value_nodes in ascending order */
  84 static int
  85 compare_value_node_3way (const void *vn1_, const void *vn2_, const void *aux)
  86 {
  87   const struct value_node *const *vn1p = vn1_;
  88   const struct value_node *const *vn2p = vn2_;
  89
  90   const struct variable_node *vn = aux;
  91
  92
  93   return value_compare_3way (&(*vn1p)->val, &(*vn2p)->val, var_get_width (vn->var));
  94 }
  95
  96
  97
  98 static struct variable_node *
  99 lookup_variable (const struct hmap *map, const struct variable *var, unsigned int hash)
 100 {
 101   struct variable_node *vn = NULL;
 102   HMAP_FOR_EACH_WITH_HASH (vn, struct variable_node, node, hash, map)
 103     {
 104       if (vn->var == var)
 105         break;
 106     }
 107
 108   return vn;
 109 }
 110
 111
 112 struct interact_params
 113 {
 114   /* An example of each interaction that appears in the data, like a frequency
 115      table for 'iact'.  By construction, the number of elements must be less
 116      than or equal to 'n_cats'.
 117
 118      categoricals_update() updates 'ivmap' case-by-case, then
 119      categoricals_done() dumps 'ivmap' into 'ivs' and sorts it. */
 120   struct hmap ivmap;
 121   struct interaction_value **ivs;
 122
 123   const struct interaction *iact;
 124
 125   int base_df;
 126   int base_cats;
 127
 128   /* Product of hmap_count(&varnodes[*]->valmap), that is, the maximum number
 129      of distinct values of this interaction. */
 130   int n_cats;
 131
 132   /* An array of integers df_n * df_{n-1} * df_{n-2} ...
 133      These are the products of the degrees of freedom for the current
 134      variable and all preceding variables */
 135   int *df_prod;
 136
 137   double *enc_sum;
 138
 139   /* Sum of ivs[*]->cc. */
 140   double cc;
 141 };
 142
 143
 144 static int
 145 compare_interaction_value_3way (const void *vn1_, const void *vn2_, const void *aux)
 146 {
 147   const struct interaction_value *const *vn1p = vn1_;
 148   const struct interaction_value *const *vn2p = vn2_;
 149
 150   const struct interact_params *iap = aux;
 151
 152   return interaction_case_cmp_3way (iap->iact, (*vn1p)->ccase, (*vn2p)->ccase);
 153 }
 154
 155 struct categoricals
 156 {
 157   /* The weight variable */
 158   const struct variable *wv;
 159
 160   /* An array of interact_params */
 161   struct interact_params *iap;
 162   size_t n_iap;
 163
 164   /* Map whose members are the union of the variables which comprise IAP */
 165   struct hmap varmap;
 166
 167   /* The number of categorical variables which contain entries.
 168      In the absence of missing values, this will be equal to N_IAP */
 169   size_t n_vars;
 170
 171   /* A map to enable the lookup of variables indexed by subscript.
 172      This map considers only the N - 1 of the N variables.
 173   */
 174   int *df_to_iact; /* 'df_sum' elements. */
 175   size_t df_sum;
 176
 177   /* Like the above, but uses all N variables */
 178   int *cat_to_iact; /* 'n_cats_total' elements. */
 179   size_t n_cats_total;
 180
 181   struct pool *pool;
 182
 183   /* Missing values in the factor variables to be excluded */
 184   enum mv_class fctr_excl;
 185
 186   const void *aux1;
 187   void *aux2;
 188
 189   bool sane;
 190
 191   const struct payload *payload;
 192 };
 193
 194
 195 bool
 196 categoricals_isbalanced (const struct categoricals *cat)
 197 {
 198   int i;
 199
 200   for (i = 0 ; i < cat->n_iap; ++i)
 201     {
 202       int v;
 203       const struct interact_params *iap = &cat->iap[i];
 204
 205       double oval = -1.0;
 206       for (v = 0; v < hmap_count (&iap->ivmap); ++v)
 207         {
 208           const struct interaction_value *iv = iap->ivs[v];
 209           if (oval == -1.0)
 210             oval = iv->cc;
 211           if (oval != iv->cc)
 212             return false;
 213         }
 214     }
 215   return true;
 216 }
 217
 218
 219 static void
 220 categoricals_dump (const struct categoricals *cat)
 221 {
 222   if (CATEGORICALS_DEBUG)
 223     {
 224       int i;
 225
 226       printf ("df to interaction map:\n");
 227       for (i = 0; i < cat->df_sum; ++i)
 228         {
 229           printf (" %d", cat->df_to_iact[i]);
 230         }
 231       printf ("\n");
 232
 233       printf ("Category to interaction map:\n");
 234       for (i = 0; i < cat->n_cats_total; ++i)
 235         {
 236           printf (" %d", cat->cat_to_iact[i]);
 237         }
 238       printf ("\n");
 239
 240       printf ("Number of interactions %zu\n", cat->n_iap);
 241       for (i = 0 ; i < cat->n_iap; ++i)
 242         {
 243           int v;
 244           struct string str;
 245           const struct interact_params *iap = &cat->iap[i];
 246           const struct interaction *iact = iap->iact;
 247
 248           ds_init_empty (&str);
 249           interaction_to_string (iact, &str);
 250
 251           printf ("\nInteraction: \"%s\" (number of categories: %d); ", ds_cstr (&str), iap->n_cats);
 252           ds_destroy (&str);
 253           printf ("Base index (df/categories): %d/%d\n", iap->base_df, iap->base_cats);
 254
 255           printf ("\t(");
 256           for (v = 0; v < hmap_count (&iap->ivmap); ++v)
 257             {
 258               int vv;
 259               const struct interaction_value *iv = iap->ivs[v];
 260
 261               if (v > 0)  printf ("   ");
 262               printf ("{");
 263               for (vv = 0; vv < iact->n_vars; ++vv)
 264                 {
 265                   const struct variable *var = iact->vars[vv];
 266                   const union value *val = case_data (iv->ccase, var);
 267                   unsigned int varhash = hash_pointer (var, 0);
 268                   struct variable_node *vn = lookup_variable (&cat->varmap, var, varhash);
 269
 270                   const int width = var_get_width (var);
 271                   unsigned int valhash = value_hash (val, width, 0);
 272                   struct value_node *valn = lookup_value (&vn->valmap, val, valhash, width);
 273
 274                   assert (vn->var == var);
 275
 276                   printf ("%.*g(%d)", DBL_DIG + 1, val->f, valn->index);
 277                   if (vv < iact->n_vars - 1)
 278                     printf (", ");
 279                 }
 280               printf ("}");
 281             }
 282           printf (")\n");
 283         }
 284     }
 285 }
 286
 287 void
 288 categoricals_destroy (struct categoricals *cat)
 289 {
 290   struct variable_node *vn = NULL;
 291   int i;
 292   if (NULL == cat)
 293     return;
 294
 295   for (i = 0; i < cat->n_iap; ++i)
 296     {
 297       struct interaction_value *iv = NULL;
 298       /* Interate over each interaction value, and unref any cases that we reffed */
 299       HMAP_FOR_EACH (iv, struct interaction_value, node, &cat->iap[i].ivmap)
 300         {
 301           if (cat->payload && cat->payload->destroy)
 302             cat->payload->destroy (cat->aux1, cat->aux2, iv->user_data);
 303           case_unref (iv->ccase);
 304         }
 305
 306       free (cat->iap[i].enc_sum);
 307       free (cat->iap[i].df_prod);
 308       hmap_destroy (&cat->iap[i].ivmap);
 309     }
 310
 311   /* Interate over each variable and delete its value map */
 312   HMAP_FOR_EACH (vn, struct variable_node, node, &cat->varmap)
 313     {
 314       hmap_destroy (&vn->valmap);
 315     }
 316
 317   hmap_destroy (&cat->varmap);
 318
 319   pool_destroy (cat->pool);
 320
 321   free (cat);
 322 }
 323
 324
 325
 326 static struct interaction_value *
 327 lookup_case (const struct hmap *map, const struct interaction *iact, const struct ccase *c)
 328 {
 329   struct interaction_value *iv = NULL;
 330   size_t hash = interaction_case_hash (iact, c, 0);
 331
 332   HMAP_FOR_EACH_WITH_HASH (iv, struct interaction_value, node, hash, map)
 333     {
 334       if (interaction_case_equal (iact, c, iv->ccase))
 335         break;
 336     }
 337
 338   return iv;
 339 }
 340
 341 /* Returns true iff CAT is sane, that is, if it is complete and has at least
 342    one value. */
 343 bool
 344 categoricals_sane (const struct categoricals *cat)
 345 {
 346   return cat->sane;
 347 }
 348
 349 /* Creates and returns a new categoricals object whose variables come from the
 350    N_INTER interactions objects in the array starting at INTER.  (The INTER
 351    objects must outlive the categoricals object because it uses them
 352    internally.)
 353
 354    FCTR_EXCL determines which cases are listwise ignored by
 355    categoricals_update(). */
 356 struct categoricals *
 357 categoricals_create (struct interaction *const*inter, size_t n_inter,
 358                      const struct variable *wv, enum mv_class fctr_excl)
 359 {
 360   size_t i;
 361   struct categoricals *cat = xmalloc (sizeof *cat);
 362
 363   cat->n_iap = n_inter;
 364   cat->wv = wv;
 365   cat->n_cats_total = 0;
 366   cat->n_vars = 0;
 367   cat->df_to_iact = NULL;
 368   cat->cat_to_iact = NULL;
 369   cat->pool = pool_create ();
 370   cat->fctr_excl = fctr_excl;
 371   cat->payload = NULL;
 372   cat->aux2 = NULL;
 373   cat->sane = false;
 374
 375   cat->iap = pool_calloc (cat->pool, cat->n_iap, sizeof *cat->iap);
 376
 377   hmap_init (&cat->varmap);
 378   for (i = 0 ; i < cat->n_iap; ++i)
 379     {
 380       int v;
 381       hmap_init (&cat->iap[i].ivmap);
 382       cat->iap[i].iact = inter[i];
 383       cat->iap[i].cc = 0.0;
 384       for (v = 0; v < inter[i]->n_vars; ++v)
 385         {
 386           const struct variable *var = inter[i]->vars[v];
 387           unsigned int hash = hash_pointer (var, 0);
 388           struct variable_node *vn = lookup_variable (&cat->varmap, var, hash);
 389           if (vn == NULL)
 390             {
 391               vn = pool_malloc (cat->pool, sizeof *vn);
 392               vn->var = var;
 393               vn->n_vals = 0;
 394               hmap_init (&vn->valmap);
 395
 396               hmap_insert (&cat->varmap, &vn->node,  hash);
 397             }
 398         }
 399     }
 400
 401   return cat;
 402 }
 403
 404
 405
 406 void
 407 categoricals_update (struct categoricals *cat, const struct ccase *c)
 408 {
 409   int i;
 410   struct variable_node *vn = NULL;
 411   double weight;
 412
 413   if (NULL == cat)
 414     return;
 415
 416   weight = cat->wv ? case_data (c, cat->wv)->f : 1.0;
 417   weight = var_force_valid_weight (cat->wv, weight, NULL);
 418
 419   assert (NULL == cat->df_to_iact);
 420   assert (NULL == cat->cat_to_iact);
 421
 422   /* Interate over each variable, and add the value of that variable
 423      to the appropriate map, if it's not already present. */
 424   HMAP_FOR_EACH (vn, struct variable_node, node, &cat->varmap)
 425     {
 426       const int width = var_get_width (vn->var);
 427       const union value *val = case_data (c, vn->var);
 428       unsigned int hash = value_hash (val, width, 0);
 429
 430       struct value_node *valn = lookup_value (&vn->valmap, val, hash, width);
 431       if (valn == NULL)
 432         {
 433           valn = pool_malloc (cat->pool, sizeof *valn);
 434           valn->index = -1;
 435           vn->n_vals++;
 436           value_init (&valn->val, width);
 437           value_copy (&valn->val, val, width);
 438           hmap_insert (&vn->valmap, &valn->node, hash);
 439         }
 440     }
 441
 442   for (i = 0 ; i < cat->n_iap; ++i)
 443     {
 444       const struct interaction *iact = cat->iap[i].iact;
 445
 446       size_t hash;
 447       struct interaction_value *node;
 448
 449       if ( interaction_case_is_missing (iact, c, cat->fctr_excl))
 450         continue;
 451
 452       hash = interaction_case_hash (iact, c, 0);
 453       node = lookup_case (&cat->iap[i].ivmap, iact, c);
 454
 455       if ( NULL == node)
 456         {
 457           node = pool_malloc (cat->pool, sizeof *node);
 458           node->ccase = case_ref (c);
 459           node->cc = weight;
 460
 461           hmap_insert (&cat->iap[i].ivmap, &node->node, hash);
 462
 463           if (cat->payload)
 464             {
 465               node->user_data = cat->payload->create (cat->aux1, cat->aux2);
 466             }
 467         }
 468       else
 469         {
 470           node->cc += weight;
 471         }
 472       cat->iap[i].cc += weight;
 473
 474       if (cat->payload)
 475         {
 476           cat->payload->update (cat->aux1, cat->aux2, node->user_data, c, weight);
 477         }
 478     }
 479 }
 480
 481 /* Return the number of categories (distinct values) for interaction IDX in
 482    CAT. */
 483 size_t
 484 categoricals_n_count (const struct categoricals *cat, size_t n)
 485 {
 486   return hmap_count (&cat->iap[n].ivmap);
 487 }
 488
 489
 490 /* Returns the number of degrees of freedom for interaction IDX within CAT. */
 491 size_t
 492 categoricals_df (const struct categoricals *cat, size_t n)
 493 {
 494   const struct interact_params *iap = &cat->iap[n];
 495   return iap->df_prod[iap->iact->n_vars - 1];
 496 }
 497
 498
 499 /* Return the total number of categories across all interactions in CAT. */
 500 size_t
 501 categoricals_n_total (const struct categoricals *cat)
 502 {
 503   if (!categoricals_is_complete (cat))
 504     return 0;
 505
 506   return cat->n_cats_total;
 507 }
 508
 509 /* Returns the total degrees of freedom for CAT. */
 510 size_t
 511 categoricals_df_total (const struct categoricals *cat)
 512 {
 513   if (NULL == cat)
 514     return 0;
 515
 516   return cat->df_sum;
 517 }
 518
 519 /* Returns true iff categoricals_done() has been called for CAT. */
 520 bool
 521 categoricals_is_complete (const struct categoricals *cat)
 522 {
 523   return (NULL != cat->df_to_iact);
 524 }
 525
 526
 527 /* This function must be called (once) before any call to the *_by_subscript or
 528   *_by_category functions, but AFTER any calls to categoricals_update.  If this
 529   function returns false, then no calls to _by_subscript or *_by_category are
 530   allowed. */
 531 void
 532 categoricals_done (const struct categoricals *cat_)
 533 {
 534   /* Implementation Note: Whilst this function is O(n) in cat->n_cats_total, in most
 535      uses it will be more efficient that using a tree based structure, since it
 536      is called only once, and means that subsequent lookups will be O(1).
 537
 538      1 call of O(n) + 10^9 calls of O(1) is better than 10^9 calls of O(log n).
 539   */
 540   struct categoricals *cat = CONST_CAST (struct categoricals *, cat_);
 541   int v;
 542   int i;
 543   int idx_df = 0;
 544   int idx_cat = 0;
 545
 546   if (NULL == cat)
 547     return;
 548
 549   cat->df_sum = 0;
 550   cat->n_cats_total = 0;
 551
 552   /* Assign 'index' to each variables' value_nodes, counting up from 0 in
 553      ascending order by value. */
 554   struct variable_node *vn;
 555   HMAP_FOR_EACH (vn, struct variable_node, node, &cat->varmap)
 556     {
 557       size_t n_vals = hmap_count (&vn->valmap);
 558       if (!n_vals)
 559         {
 560           cat->sane = false;
 561           return;
 562         }
 563
 564       struct value_node **nodes = xcalloc (sizeof *nodes, n_vals);
 565       int x = 0;
 566       struct value_node *valnd;
 567       HMAP_FOR_EACH (valnd, struct value_node, node, &vn->valmap)
 568         nodes[x++] = valnd;
 569       sort (nodes, n_vals, sizeof *nodes, compare_value_node_3way, vn);
 570       for (x = 0; x < n_vals; ++x)
 571         nodes[x]->index = x;
 572       free (nodes);
 573     }
 574
 575   /* Calculate the degrees of freedom, and the number of categories */
 576   for (i = 0 ; i < cat->n_iap; ++i)
 577     {
 578       int df = 1;
 579       const struct interaction *iact = cat->iap[i].iact;
 580
 581       cat->iap[i].df_prod = iact->n_vars ? xcalloc (iact->n_vars, sizeof (int)) : NULL;
 582
 583       cat->iap[i].n_cats = 1;
 584
 585       for (v = 0 ; v < iact->n_vars; ++v)
 586         {
 587           const struct variable *var = iact->vars[v];
 588           struct variable_node *vn = lookup_variable (&cat->varmap, var, hash_pointer (var, 0));
 589           cat->iap[i].df_prod[v] = df * (vn->n_vals - 1);
 590           df = cat->iap[i].df_prod[v];
 591
 592           cat->iap[i].n_cats *= vn->n_vals;
 593         }
 594
 595       if (v > 0)
 596         cat->df_sum += cat->iap[i].df_prod [v - 1];
 597
 598       cat->n_cats_total += cat->iap[i].n_cats;
 599     }
 600
 601
 602   cat->df_to_iact = pool_calloc (cat->pool, cat->df_sum,
 603                                  sizeof *cat->df_to_iact);
 604
 605   cat->cat_to_iact = pool_calloc (cat->pool, cat->n_cats_total,
 606                                   sizeof *cat->cat_to_iact);
 607
 608   for (i = 0 ; i < cat->n_iap; ++i)
 609     {
 610       struct interaction_value *ivn = NULL;
 611       int x = 0;
 612       int ii;
 613       struct interact_params *iap = &cat->iap[i];
 614
 615       iap->base_df = idx_df;
 616       iap->base_cats = idx_cat;
 617
 618       iap->ivs = pool_calloc (cat->pool, iap->n_cats, sizeof *iap->ivs);
 619
 620       HMAP_FOR_EACH (ivn, struct interaction_value, node, &iap->ivmap)
 621         {
 622           iap->ivs[x++] = ivn;
 623         }
 624
 625       assert (x <= iap->n_cats);
 626
 627       /* For some purposes (eg CONTRASTS in ONEWAY) the values need to be sorted */
 628       sort (iap->ivs, x, sizeof *iap->ivs,
 629             compare_interaction_value_3way, iap);
 630
 631       /* Fill the remaining values with null */
 632       for (ii = x ; ii < iap->n_cats; ++ii)
 633         iap->ivs[ii] = NULL;
 634
 635       /* Populate the variable maps. */
 636       if (iap->df_prod)
 637         {
 638           for (ii = 0; ii < iap->df_prod [iap->iact->n_vars - 1]; ++ii)
 639             cat->df_to_iact[idx_df++] = i;
 640         }
 641
 642       for (ii = 0; ii < iap->n_cats; ++ii)
 643         cat->cat_to_iact[idx_cat++] = i;
 644     }
 645
 646   assert (cat->n_vars <= cat->n_iap);
 647
 648   categoricals_dump (cat);
 649
 650   /* Tally up the sums for all the encodings */
 651   for (i = 0 ; i < cat->n_iap; ++i)
 652     {
 653       int x, y;
 654       struct interact_params *iap = &cat->iap[i];
 655       const struct interaction *iact = iap->iact;
 656
 657       const int df = iap->df_prod ? iap->df_prod [iact->n_vars - 1] : 0;
 658
 659       iap->enc_sum = xcalloc (df, sizeof (*(iap->enc_sum)));
 660
 661       for (y = 0; y < hmap_count (&iap->ivmap); ++y)
 662         {
 663           struct interaction_value *iv = iap->ivs[y];
 664           for (x = iap->base_df; x < iap->base_df + df ;++x)
 665             {
 666               const double bin = categoricals_get_effects_code_for_case (cat, x, iv->ccase);
 667               iap->enc_sum [x - iap->base_df] += bin * iv->cc;
 668             }
 669           if (cat->payload && cat->payload->calculate)
 670             cat->payload->calculate (cat->aux1, cat->aux2, iv->user_data);
 671         }
 672     }
 673
 674   cat->sane = true;
 675 }
 676
 677
 678 static int
 679 df_to_iap (const struct categoricals *cat, int subscript)
 680 {
 681   assert (cat->df_to_iact);
 682   assert (subscript >= 0);
 683   assert (subscript < cat->df_sum);
 684
 685   return cat->df_to_iact[subscript];
 686 }
 687
 688 static int
 689 cat_index_to_iap (const struct categoricals *cat, int subscript)
 690 {
 691   assert (cat->cat_to_iact);
 692   assert (subscript >= 0);
 693   assert (subscript < cat->n_cats_total);
 694
 695   return cat->cat_to_iact[subscript];
 696 }
 697
 698
 699 /* Return the interaction corresponding to SUBSCRIPT */
 700 const struct interaction *
 701 categoricals_get_interaction_by_subscript (const struct categoricals *cat, int subscript)
 702 {
 703   int index = df_to_iap (cat, subscript);
 704
 705   return cat->iap[index].iact;
 706 }
 707
 708 double
 709 categoricals_get_weight_by_subscript (const struct categoricals *cat, int subscript)
 710 {
 711   int vindex = df_to_iap (cat, subscript);
 712   const struct interact_params *vp = &cat->iap[vindex];
 713
 714   return vp->cc;
 715 }
 716
 717 double
 718 categoricals_get_sum_by_subscript (const struct categoricals *cat, int subscript)
 719 {
 720   int vindex = df_to_iap (cat, subscript);
 721   const struct interact_params *vp = &cat->iap[vindex];
 722
 723   return   vp->enc_sum[subscript - vp->base_df];
 724 }
 725
 726
 727 /* Returns unity if the value in case C at SUBSCRIPT is equal to the category
 728    for that subscript */
 729 static double
 730 categoricals_get_code_for_case (const struct categoricals *cat, int subscript,
 731                                 const struct ccase *c,
 732                                 bool effects_coding)
 733 {
 734   const struct interaction *iact = categoricals_get_interaction_by_subscript (cat, subscript);
 735
 736   const int i = df_to_iap (cat, subscript);
 737
 738   const int base_index = cat->iap[i].base_df;
 739
 740   int v;
 741   double result = 1.0;
 742
 743   const struct interact_params *iap = &cat->iap[i];
 744
 745   double dfp = 1.0;
 746   for (v = 0; v < iact->n_vars; ++v)
 747     {
 748       const struct variable *var = iact->vars[v];
 749
 750       const union value *val = case_data (c, var);
 751       const int width = var_get_width (var);
 752       const struct variable_node *vn = lookup_variable (&cat->varmap, var, hash_pointer (var, 0));
 753
 754       const unsigned int hash = value_hash (val, width, 0);
 755       const struct value_node *valn = lookup_value (&vn->valmap, val, hash, width);
 756
 757       double bin = 1.0;
 758
 759       const double df = iap->df_prod[v] / dfp;
 760
 761       /* Translate the subscript into an index for the individual variable */
 762       const int index = ((subscript - base_index) % iap->df_prod[v] ) / dfp;
 763       dfp = iap->df_prod [v];
 764
 765       if (effects_coding && valn->index == df )
 766         bin = -1.0;
 767       else if ( valn->index != index )
 768         bin = 0;
 769
 770       result *= bin;
 771     }
 772
 773   return result;
 774 }
 775
 776
 777 /* Returns unity if the value in case C at SUBSCRIPT is equal to the category
 778    for that subscript */
 779 double
 780 categoricals_get_dummy_code_for_case (const struct categoricals *cat, int subscript,
 781                                      const struct ccase *c)
 782 {
 783   return categoricals_get_code_for_case (cat, subscript, c, false);
 784 }
 785
 786 /* Returns unity if the value in case C at SUBSCRIPT is equal to the category
 787    for that subscript.
 788    Else if it is the last category, return -1.
 789    Otherwise return 0.
 790  */
 791 double
 792 categoricals_get_effects_code_for_case (const struct categoricals *cat, int subscript,
 793                                         const struct ccase *c)
 794 {
 795   return categoricals_get_code_for_case (cat, subscript, c, true);
 796 }
 797
 798 /* Return a case containing the set of values corresponding to
 799    the Nth Category of the IACTth interaction */
 800 const struct ccase *
 801 categoricals_get_case_by_category_real (const struct categoricals *cat, int iact, int n)
 802 {
 803   const struct interaction_value *vn;
 804
 805   const struct interact_params *vp = &cat->iap[iact];
 806
 807   if ( n >= hmap_count (&vp->ivmap))
 808     return NULL;
 809
 810   vn = vp->ivs [n];
 811
 812   return vn->ccase;
 813 }
 814
 815 /* Return a the user data corresponding to the Nth Category of the IACTth interaction. */
 816 void *
 817 categoricals_get_user_data_by_category_real (const struct categoricals *cat, int iact, int n)
 818 {
 819   const struct interact_params *vp = &cat->iap[iact];
 820   const struct interaction_value *iv ;
 821
 822   if ( n >= hmap_count (&vp->ivmap))
 823     return NULL;
 824
 825   iv = vp->ivs [n];
 826
 827   return iv->user_data;
 828 }
 829
 830
 831
 832 /* Return a case containing the set of values corresponding to SUBSCRIPT */
 833 const struct ccase *
 834 categoricals_get_case_by_category (const struct categoricals *cat, int subscript)
 835 {
 836   int vindex = cat_index_to_iap (cat, subscript);
 837   const struct interact_params *vp = &cat->iap[vindex];
 838   const struct interaction_value *vn = vp->ivs [subscript - vp->base_cats];
 839
 840   return vn->ccase;
 841 }
 842
 843 void *
 844 categoricals_get_user_data_by_category (const struct categoricals *cat, int subscript)
 845 {
 846   int vindex = cat_index_to_iap (cat, subscript);
 847   const struct interact_params *vp = &cat->iap[vindex];
 848
 849   const struct interaction_value *iv = vp->ivs [subscript - vp->base_cats];
 850   return iv->user_data;
 851 }
 852
 853
 854 \f
 855
 856 void
 857 categoricals_set_payload (struct categoricals *cat, const struct payload *p,
 858                           const void *aux1, void *aux2)
 859 {
 860   cat->payload = p;
 861   cat->aux1 = aux1;
 862   cat->aux2 = aux2;
 863 }