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>
43 struct interaction_variable
46 const struct variable **members;
47 struct variable *intr;
51 struct interaction_value
53 const struct interaction_variable *intr;
54 union value val; /* Concatenation of the string values in this
55 interaction's value, or the product of a bunch
56 of numeric values for a purely numeric
59 double f; /* Product of the numerical values in this interaction's value. */
63 An interaction_variable has type alpha if any of members have type
64 alpha. Otherwise, its type is numeric.
66 struct interaction_variable *
67 interaction_variable_create (const struct variable **vars, int n_vars)
69 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]))
89 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;
155 result = xmalloc (sizeof (*result));
157 n_vars = interaction_get_n_vars (var);
158 value_init (&result->val, val_width);
159 val = value_str_rw (&result->val, val_width);
162 for (i = 0; i < n_vars; i++)
164 member = interaction_get_member (var, i);
166 if (var_is_value_missing (member, vals[i], MV_ANY))
168 value_set_missing (&result->val, MAX_SHORT_STRING);
174 if (var_is_alpha (var->members[i]))
176 int w = var_get_width (var->members[i]);
177 value_resize (result, val_width, val_width + w);
178 u8_strncat (val, value_str (vals[i], w), w);
179 val = value_str_rw (&result->val, val_width);
181 else if (var_is_numeric (var->members[i]))
183 result->f *= vals[i]->f;
187 if (interaction_get_n_alpha (var) == 0)
190 If there are no categorical variables, then the
191 interaction consists of only numeric data. In this case,
192 code that uses this interaction_value will see the union
193 member as the numeric value. If we were to store that
194 numeric value in result->f as well, the calling code may
195 inadvertently square this value by multiplying by
196 result->val->f. Such multiplication would be correct for an
197 interaction consisting of both categorical and numeric
198 data, but a mistake for purely numerical interactions. To
199 avoid the error, we set result->f to 1.0 for numeric
202 result->val.f = result->f;
210 interaction_value_get (const struct interaction_value *val)
216 Returns the numeric value of the non-zero entry for the vector
217 corresponding to this interaction. Do not use this function to get
218 the numeric value of a purley numeric interaction. Instead, use the
219 union value * returned by interaction_value_get.
222 interaction_value_get_nonzero_entry (const struct interaction_value *val)
230 interaction_value_destroy (struct interaction_value *val)
234 size_t n_vars = interaction_get_n_vars (val->intr);
235 int val_width = n_vars * MAX_SHORT_STRING + 1;
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))