1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 2009 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/>. */
18 An interaction is a gsl_vector containing a "product" of other
19 variables. The variables can be either categorical or numeric.
20 If the variables are all numeric, the interaction is just the
21 scalar product. If any of the variables are categorical, their
22 product is a vector containing 0's in all but one entry. This entry
23 is found by combining the vectors corresponding to the variables'
24 OBS_VALS member. If there are K categorical variables, each with
25 N_1, N_2, ..., N_K categories, then the interaction will have
26 N_1 * N_2 * N_3 *...* N_K - 1 entries.
28 When using these functions, make sure the orders of variables and
29 values match when appropriate.
34 #include <gsl/gsl_math.h>
35 #include <gsl/gsl_vector.h>
36 #include <data/value.h>
37 #include <data/variable.h>
38 #include <math/interaction.h>
42 struct interaction_variable
45 const struct variable **members;
46 struct variable *intr;
50 struct interaction_value
52 const struct interaction_variable *intr;
53 union value val; /* Concatenation of the string values in this
54 interaction's value, or the product of a bunch
55 of numeric values for a purely numeric
58 double f; /* Product of the numerical values in this interaction's value. */
62 An interaction_variable has type alpha if any of members have type
63 alpha. Otherwise, its type is numeric.
65 struct interaction_variable *
66 interaction_variable_create (const struct variable **vars, int n_vars)
68 struct interaction_variable *result = NULL;
75 result = xmalloc (sizeof (*result));
77 result->members = xnmalloc (n_vars, sizeof (*result->members));
78 result->n_vars = n_vars;
79 for (i = 0; i < n_vars; i++)
81 result->members[i] = vars[i];
82 if (var_is_alpha (vars[i]))
85 width += var_get_width (vars[i]);
88 result->intr = var_create_internal (0, width);
93 void interaction_variable_destroy (struct interaction_variable *iv)
95 var_destroy (iv->intr);
101 Get one of the member variables.
103 const struct variable *
104 interaction_get_member (const struct interaction_variable *iv, size_t i)
106 return iv->members[i];
110 interaction_get_n_vars (const struct interaction_variable *iv)
112 return (iv == NULL) ? 0 : iv->n_vars;
116 interaction_get_n_alpha (const struct interaction_variable *iv)
122 interaction_get_n_numeric (const struct interaction_variable *iv)
124 return (interaction_get_n_vars (iv) - interaction_get_n_alpha (iv));
128 Get the interaction variable itself.
130 const struct variable *
131 interaction_get_variable (const struct interaction_variable *iv)
136 Given list of values, compute the value of the corresponding
137 interaction. This "value" is not stored as the typical vector of
138 0's and one double, but rather the string values are concatenated to
139 make one big string value, and the numerical values are multiplied
140 together to give the non-zero entry of the corresponding vector.
142 struct interaction_value *
143 interaction_value_create (const struct interaction_variable *var, const union value **vals)
145 struct interaction_value *result = NULL;
146 const struct variable *member;
152 int val_width = var_get_width (interaction_get_variable (var));
155 result = xmalloc (sizeof (*result));
157 n_vars = interaction_get_n_vars (var);
159 value_init (&result->val, val_width);
163 for (i = 0; i < n_vars; i++)
165 member = interaction_get_member (var, i);
167 if (var_is_value_missing (member, vals[i], MV_ANY))
169 value_set_missing (&result->val, val_width);
175 if (var_is_alpha (var->members[i]))
177 char *val = value_str_rw (&result->val, val_width);
178 int w = var_get_width (var->members[i]);
179 memcpy (val + offset, value_str (vals[i], w), w);
182 else if (var_is_numeric (var->members[i]))
184 result->f *= vals[i]->f;
188 if (interaction_get_n_alpha (var) == 0)
191 If there are no categorical variables, then the
192 interaction consists of only numeric data. In this case,
193 code that uses this interaction_value will see the union
194 member as the numeric value. If we were to store that
195 numeric value in result->f as well, the calling code may
196 inadvertently square this value by multiplying by
197 result->val->f. Such multiplication would be correct for an
198 interaction consisting of both categorical and numeric
199 data, but a mistake for purely numerical interactions. To
200 avoid the error, we set result->f to 1.0 for numeric
203 result->val.f = result->f;
211 interaction_value_get (const struct interaction_value *val)
217 Returns the numeric value of the non-zero entry for the vector
218 corresponding to this interaction. Do not use this function to get
219 the numeric value of a purely numeric interaction. Instead, use the
220 union value * returned by interaction_value_get.
223 interaction_value_get_nonzero_entry (const struct interaction_value *val)
231 interaction_value_destroy (struct interaction_value *val)
235 int val_width = var_get_width (interaction_get_variable (val->intr));
237 value_destroy (&val->val, val_width);
243 Return a value from a variable that is an interaction.
245 struct interaction_value *
246 interaction_case_data (const struct ccase *ccase, const struct interaction_variable *iv)
250 const struct variable *member;
251 const union value **vals = NULL;
253 n_vars = interaction_get_n_vars (iv);
254 vals = xnmalloc (n_vars, sizeof (*vals));
256 for (i = 0; i < n_vars; i++)
258 member = interaction_get_member (iv, i);
259 vals[i] = case_data (ccase, member);
262 return interaction_value_create (iv, vals);
266 is_interaction (const struct variable *var, const struct interaction_variable **iv, size_t n_intr)
269 const struct variable *intr;
271 for (i = 0; i < n_intr; i++)
273 intr = interaction_get_variable (iv[i]);
274 if (var_get_dict_index (intr) == var_get_dict_index (var))