X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fmath%2Finteraction.c;h=f2831d27680d26033965a756c0aebf5c808fd177;hb=8e16ce856374ec440157b80ac19ef6dd724a0bd1;hp=ff2c53571ac8bd79f79286cbfec054a992ece2b3;hpb=a1efcf97ca2f75f4be6a0389ff2372c03ed2d4e1;p=pspp-builds.git diff --git a/src/math/interaction.c b/src/math/interaction.c index ff2c5357..f2831d27 100644 --- a/src/math/interaction.c +++ b/src/math/interaction.c @@ -44,15 +44,24 @@ struct interaction_variable int n_vars; const struct variable **members; struct variable *intr; + size_t n_alpha; }; struct interaction_value { const struct interaction_variable *intr; - union value *strings; /* Concatenation of the string values in this interaction's value. */ + union value val; /* Concatenation of the string values in this + interaction's value, or the product of a bunch + of numeric values for a purely numeric + interaction. + */ double f; /* Product of the numerical values in this interaction's value. */ }; +/* + An interaction_variable has type alpha if any of members have type + alpha. Otherwise, its type is numeric. + */ struct interaction_variable * interaction_variable_create (const struct variable **vars, int n_vars) { @@ -61,18 +70,26 @@ interaction_variable_create (const struct variable **vars, int n_vars) if (n_vars > 0) { + int width = 0; + result = xmalloc (sizeof (*result)); + result->n_alpha = 0; result->members = xnmalloc (n_vars, sizeof (*result->members)); - result->intr = var_create_internal (0); result->n_vars = n_vars; for (i = 0; i < n_vars; i++) { result->members[i] = vars[i]; + if (var_is_alpha (vars[i])) + { + result->n_alpha++; + width += var_get_width (vars[i]); + } } + result->intr = var_create_internal (0, width); } + return result; } - void interaction_variable_destroy (struct interaction_variable *iv) { var_destroy (iv->intr); @@ -80,12 +97,41 @@ void interaction_variable_destroy (struct interaction_variable *iv) free (iv); } +/* + Get one of the member variables. + */ +const struct variable * +interaction_get_member (const struct interaction_variable *iv, size_t i) +{ + return iv->members[i]; +} + size_t -interaction_variable_get_n_vars (const struct interaction_variable *iv) +interaction_get_n_vars (const struct interaction_variable *iv) { return (iv == NULL) ? 0 : iv->n_vars; } +size_t +interaction_get_n_alpha (const struct interaction_variable *iv) +{ + return iv->n_alpha; +} + +size_t +interaction_get_n_numeric (const struct interaction_variable *iv) +{ + return (interaction_get_n_vars (iv) - interaction_get_n_alpha (iv)); +} + +/* + Get the interaction variable itself. + */ +const struct variable * +interaction_get_variable (const struct interaction_variable *iv) +{ + return iv->intr; +} /* Given list of values, compute the value of the corresponding interaction. This "value" is not stored as the typical vector of @@ -97,38 +143,136 @@ struct interaction_value * interaction_value_create (const struct interaction_variable *var, const union value **vals) { struct interaction_value *result = NULL; - size_t i; - size_t n_vars; if (var != NULL) { + size_t i; + int val_width = var_get_width (interaction_get_variable (var)); + int offset = 0; + size_t n_vars = interaction_get_n_vars (var); + result = xmalloc (sizeof (*result)); result->intr = var; - n_vars = interaction_variable_get_n_vars (var); - result->strings = value_create (n_vars * MAX_SHORT_STRING + 1); + + value_init (&result->val, val_width); + result->f = 1.0; for (i = 0; i < n_vars; i++) { - if (var_is_alpha (var->members[i])) + const struct variable *member = interaction_get_member (var, i); + + if (var_is_value_missing (member, vals[i], MV_ANY)) { - strncat (result->strings->s, vals[i]->s, MAX_SHORT_STRING); + value_set_missing (&result->val, val_width); + result->f = SYSMIS; + break; } - else if (var_is_numeric (var->members[i])) + else { - result->f *= vals[i]->f; + if (var_is_alpha (var->members[i])) + { + uint8_t *val = value_str_rw (&result->val, val_width); + int w = var_get_width (var->members[i]); + u8_cpy (val + offset, value_str (vals[i], w), w); + offset += w; + } + else if (var_is_numeric (var->members[i])) + { + result->f *= vals[i]->f; + } } } + if (interaction_get_n_alpha (var) == 0) + { + /* + If there are no categorical variables, then the + interaction consists of only numeric data. In this case, + code that uses this interaction_value will see the union + member as the numeric value. If we were to store that + numeric value in result->f as well, the calling code may + inadvertently square this value by multiplying by + result->val->f. Such multiplication would be correct for an + interaction consisting of both categorical and numeric + data, but a mistake for purely numerical interactions. To + avoid the error, we set result->f to 1.0 for numeric + interactions. + */ + result->val.f = result->f; + result->f = 1.0; + } } return result; } +const union value * +interaction_value_get (const struct interaction_value *val) +{ + return &val->val; +} + +/* + Returns the numeric value of the non-zero entry for the vector + corresponding to this interaction. Do not use this function to get + the numeric value of a purely numeric interaction. Instead, use the + union value * returned by interaction_value_get. + */ +double +interaction_value_get_nonzero_entry (const struct interaction_value *val) +{ + if (val != NULL) + return val->f; + return 1.0; +} + void interaction_value_destroy (struct interaction_value *val) { if (val != NULL) { - free (val->strings); + int val_width = var_get_width (interaction_get_variable (val->intr)); + + value_destroy (&val->val, val_width); free (val); } } +/* + Return a value from a variable that is an interaction. + */ +struct interaction_value * +interaction_case_data (const struct ccase *ccase, const struct interaction_variable *iv) +{ + size_t i; + size_t n_vars; + const struct variable *member; + const union value **vals = NULL; + + n_vars = interaction_get_n_vars (iv); + vals = xnmalloc (n_vars, sizeof (*vals)); + + for (i = 0; i < n_vars; i++) + { + member = interaction_get_member (iv, i); + vals[i] = case_data (ccase, member); + } + + return interaction_value_create (iv, vals); +} + +bool +is_interaction (const struct variable *var, const struct interaction_variable **iv, size_t n_intr) +{ + size_t i; + const struct variable *intr; + + for (i = 0; i < n_intr; i++) + { + intr = interaction_get_variable (iv[i]); + if (var_get_dict_index (intr) == var_get_dict_index (var)) + { + return true; + } + } + return false; +} +