src/data/caseinit.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2007, 2009 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 <data/caseinit.h>
  20
  21 #include <stdbool.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <data/case.h>
  26 #include <data/dictionary.h>
  27 #include <data/value.h>
  28 #include <data/variable.h>
  29 #include <libpspp/array.h>
  30 #include <libpspp/assertion.h>
  31 #include <libpspp/compiler.h>
  32
  33 #include "xalloc.h"
  34 \f
  35 /* Initializer list: a set of values to write to locations within
  36    a case. */
  37
  38 /* Binds a value with a place to put it. */
  39 struct init_value
  40   {
  41     union value value;
  42     size_t case_index;
  43   };
  44
  45 /* A set of values to initialize in a case. */
  46 struct init_list
  47   {
  48     struct init_value *values;
  49     size_t cnt;
  50   };
  51
  52 /* A bitmap of the "left" status of variables. */
  53 enum leave_class
  54   {
  55     LEAVE_REINIT = 0x001,       /* Reinitalize for every case. */
  56     LEAVE_LEFT = 0x002          /* Keep the value from one case to the next. */
  57   };
  58
  59 /* Initializes LIST as an empty initializer list. */
  60 static void
  61 init_list_create (struct init_list *list)
  62 {
  63   list->values = NULL;
  64   list->cnt = 0;
  65 }
  66
  67 /* Frees the storage associated with LIST. */
  68 static void
  69 init_list_destroy (struct init_list *list)
  70 {
  71   free (list->values);
  72 }
  73
  74 /* Clears LIST, making it an empty list. */
  75 static void
  76 init_list_clear (struct init_list *list)
  77 {
  78   init_list_destroy (list);
  79   init_list_create (list);
  80 }
  81
  82 /* Compares `struct init_value's A and B by case_index and
  83    returns a strcmp()-type result. */
  84 static int
  85 compare_init_values (const void *a_, const void *b_, const void *aux UNUSED)
  86 {
  87   const struct init_value *a = a_;
  88   const struct init_value *b = b_;
  89
  90   return a->case_index < b->case_index ? -1 : a->case_index > b->case_index;
  91 }
  92
  93 /* Returns true if LIST includes CASE_INDEX, false otherwise. */
  94 static bool
  95 init_list_includes (const struct init_list *list, size_t case_index)
  96 {
  97   struct init_value value;
  98   value.case_index = case_index;
  99   return binary_search (list->values, list->cnt, sizeof *list->values,
 100                         &value, compare_init_values, NULL) != NULL;
 101 }
 102
 103 /* Marks LIST to initialize the `union value's for the variables
 104    in dictionary D that both (1) fall in the leave class or
 105    classes designated by INCLUDE and (2) are not in EXCLUDE. */
 106 static void
 107 init_list_mark (struct init_list *list, const struct init_list *exclude,
 108                 enum leave_class include, const struct dictionary *d)
 109 {
 110   size_t var_cnt = dict_get_var_cnt (d);
 111   size_t i;
 112
 113   assert (list != exclude);
 114   list->values = xnrealloc (list->values,
 115                             list->cnt + dict_get_next_value_idx (d),
 116                             sizeof *list->values);
 117   for (i = 0; i < var_cnt; i++)
 118     {
 119       struct variable *v = dict_get_var (d, i);
 120       size_t case_index = var_get_case_index (v);
 121       int offset;
 122
 123       /* Only include the correct class. */
 124       if (!(include & (var_get_leave (v) ? LEAVE_LEFT : LEAVE_REINIT)))
 125         continue;
 126
 127       /* Don't include those to be excluded. */
 128       if (exclude != NULL && init_list_includes (exclude, case_index))
 129         continue;
 130
 131       offset = 0;
 132       do
 133         {
 134           struct init_value *iv = &list->values[list->cnt++];
 135           iv->case_index = case_index++;
 136           if (var_is_numeric (v))
 137             iv->value.f = var_get_leave (v) ? 0 : SYSMIS;
 138           else
 139             memset (iv->value.s, ' ', sizeof iv->value.s);
 140
 141           offset += sizeof iv->value.s;
 142         }
 143       while (offset < var_get_width (v));
 144     }
 145
 146   /* Drop duplicates. */
 147   list->cnt = sort_unique (list->values, list->cnt, sizeof *list->values,
 148                            compare_init_values, NULL);
 149 }
 150
 151 /* Initializes data in case C to the values in the initializer
 152    LIST. */
 153 static void
 154 init_list_init (const struct init_list *list, struct ccase *c)
 155 {
 156   size_t i;
 157
 158   for (i = 0; i < list->cnt; i++)
 159     {
 160       const struct init_value *value = &list->values[i];
 161       *case_data_rw_idx (c, value->case_index) = value->value;
 162     }
 163 }
 164
 165 /* Updates the values in the initializer LIST from the data in
 166    case C. */
 167 static void
 168 init_list_update (const struct init_list *list, const struct ccase *c)
 169 {
 170   size_t i;
 171
 172   for (i = 0; i < list->cnt; i++)
 173     {
 174       struct init_value *value = &list->values[i];
 175       value->value = *case_data_idx (c, value->case_index);
 176     }
 177 }
 178 \f
 179 /* A case initializer. */
 180 struct caseinit
 181   {
 182     /* Values that do not need to be initialized by the
 183        procedure, because they are initialized by the data
 184        source. */
 185     struct init_list preinited_values;
 186
 187     /* Values that need to be initialized to SYSMIS or spaces in
 188        each case. */
 189     struct init_list reinit_values;
 190
 191     /* Values that need to be initialized to 0 or spaces in the
 192        first case and thereafter retain their values from case to
 193        case. */
 194     struct init_list left_values;
 195   };
 196
 197 /* Creates and returns a new case initializer. */
 198 struct caseinit *
 199 caseinit_create (void)
 200 {
 201   struct caseinit *ci = xmalloc (sizeof *ci);
 202   init_list_create (&ci->preinited_values);
 203   init_list_create (&ci->reinit_values);
 204   init_list_create (&ci->left_values);
 205   return ci;
 206 }
 207
 208 /* Clears the contents of case initializer CI. */
 209 void
 210 caseinit_clear (struct caseinit *ci)
 211 {
 212   init_list_clear (&ci->preinited_values);
 213   init_list_clear (&ci->reinit_values);
 214   init_list_clear (&ci->left_values);
 215 }
 216
 217 /* Destroys case initializer CI. */
 218 void
 219 caseinit_destroy (struct caseinit *ci)
 220 {
 221   if (ci != NULL)
 222     {
 223       init_list_destroy (&ci->preinited_values);
 224       init_list_destroy (&ci->reinit_values);
 225       init_list_destroy (&ci->left_values);
 226       free (ci);
 227     }
 228 }
 229
 230 /* Marks the variables from dictionary D in CI as being
 231    initialized by the data source, so that the case initializer
 232    need not initialize them itself. */
 233 void
 234 caseinit_mark_as_preinited (struct caseinit *ci, const struct dictionary *d)
 235 {
 236   init_list_mark (&ci->preinited_values, NULL, LEAVE_REINIT | LEAVE_LEFT, d);
 237 }
 238
 239 /* Marks in CI the variables from dictionary D, except for any
 240    variables that were already marked with
 241    caseinit_mark_as_preinited, as needing initialization
 242    according to their leave status. */
 243 void
 244 caseinit_mark_for_init (struct caseinit *ci, const struct dictionary *d)
 245 {
 246   init_list_mark (&ci->reinit_values, &ci->preinited_values, LEAVE_REINIT, d);
 247   init_list_mark (&ci->left_values, &ci->preinited_values, LEAVE_LEFT, d);
 248 }
 249
 250 /* Initializes variables in *C as described by CI.
 251    C must not be shared. */
 252 void
 253 caseinit_init_vars (const struct caseinit *ci, struct ccase *c)
 254 {
 255   init_list_init (&ci->reinit_values, c);
 256   init_list_init (&ci->left_values, c);
 257 }
 258
 259 /* Updates the left vars in CI from the data in C, so that the
 260    next call to caseinit_init_vars will store those values in the
 261    next case. */
 262 void
 263 caseinit_update_left_vars (struct caseinit *ci, const struct ccase *c)
 264 {
 265   init_list_update (&ci->left_values, c);
 266 }
 267