Update all #include directives to the currently preferred style.

[pspp-builds.git] / src / math / interaction.c

diff --git a/src/math/interaction.c b/src/math/interaction.c
index 444edbfa308723a5638bb726a84fdc8e59ff729e..87f4836da23479ced8fa9a2069841ada800408d9 100644 (file)
--- a/src/math/interaction.c
+++ b/src/math/interaction.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 2009 Free Software Foundation, Inc.
+   Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 /*
-  An interaction is a gsl_vector containing a "product" of other
+  An interaction is a structure containing a "product" of other
   variables. The variables can be either categorical or numeric.
   If the variables are all numeric, the interaction is just the
   scalar product. If any of the variables are categorical, their
@@ -30,14 +30,18 @@
  */
 
 #include <config.h>
+
+#include "math/interaction.h"
+
 #include <assert.h>
-#include <gsl/gsl_math.h>
-#include <gsl/gsl_vector.h>
-#include <data/value.h>
-#include <data/variable.h>
-#include <math/interaction.h>
 #include <string.h>
-#include <xalloc.h>
+#include <unistr.h>
+
+#include "data/dictionary.h"
+#include "data/value.h"
+#include "data/variable.h"
+
+#include "gl/xalloc.h"
 
 struct interaction_variable
 {
@@ -67,10 +71,11 @@ interaction_variable_create (const struct variable **vars, int n_vars)
 {
   struct interaction_variable *result = NULL;
   size_t i;
-  int width = 0;
 
   if (n_vars > 0)
     {
+      int width = 0;
+
       result = xmalloc (sizeof (*result));
       result->n_alpha = 0;
       result->members = xnmalloc (n_vars, sizeof (*result->members));
@@ -81,17 +86,17 @@ interaction_variable_create (const struct variable **vars, int n_vars)
          if (var_is_alpha (vars[i]))
            {
              result->n_alpha++;
-             width = 1;
+             width += var_get_width (vars[i]);
            }
        }
+      result->intr = dict_create_internal_var (0, width);
     }
-  result->intr = var_create_internal (0, width);
 
   return result;
 }
 void interaction_variable_destroy (struct interaction_variable *iv)
 {
-  var_destroy (iv->intr);
+  dict_destroy_internal_var (iv->intr);
   free (iv->members);
   free (iv);
 }
@@ -142,29 +147,27 @@ struct interaction_value *
 interaction_value_create (const struct interaction_variable *var, const union value **vals)
 {
   struct interaction_value *result = NULL;
-  const struct variable *member;
-  size_t i;
-  size_t n_vars;
   
   if (var != NULL)
     {
-      int val_width = 1;
-      char *val;
+      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_get_n_vars (var);
+
       value_init (&result->val, val_width);
-      val = value_str_rw (&result->val, val_width);
-      val[0] = '\0';
+
       result->f = 1.0;
       for (i = 0; i < n_vars; i++)
        {
-         member = interaction_get_member (var, i);
+          const struct variable *member = interaction_get_member (var, i);
 
          if (var_is_value_missing (member, vals[i], MV_ANY))
            {
-             value_set_missing (&result->val, MAX_SHORT_STRING);
+             value_set_missing (&result->val, val_width);
              result->f = SYSMIS;
              break;
            }
@@ -172,10 +175,10 @@ interaction_value_create (const struct interaction_variable *var, const union va
            {
              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]);
-                 value_resize (result, val_width, val_width + w);
-                 strncat (val, value_str (vals[i], w), w);
-                 val = value_str_rw (&result->val, val_width);
+                  u8_cpy (val + offset, value_str (vals[i], w), w);
+                  offset += w;
                }
              else if (var_is_numeric (var->members[i]))
                {
@@ -214,7 +217,7 @@ interaction_value_get (const struct interaction_value *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 purley numeric interaction. Instead, use the
+  the numeric value of a purely numeric interaction. Instead, use the
   union value * returned by interaction_value_get.
  */
 double 
@@ -230,8 +233,7 @@ interaction_value_destroy (struct interaction_value *val)
 {
   if (val != NULL)
     {
-      size_t n_vars = interaction_get_n_vars (val->intr);
-      int val_width = n_vars * MAX_SHORT_STRING + 1;
+      int val_width = var_get_width (interaction_get_variable (val->intr));
 
       value_destroy (&val->val, val_width);
       free (val);
@@ -270,7 +272,7 @@ is_interaction (const struct variable *var, const struct interaction_variable **
   for (i = 0; i < n_intr; i++)
     {
       intr = interaction_get_variable (iv[i]);
-      if (var_get_dict_index (intr) == var_get_dict_index (var))
+      if (intr == var)
        {
          return true;
        }