/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+ Copyright (C) 2009, 2010, 2011, 2012, 2014 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
#include "math/categoricals.h"
#include "math/interaction.h"
+#include <float.h>
#include <stdio.h>
#include "data/case.h"
struct hmap valmap; /* A map of value nodes */
int n_vals; /* Number of values for this variable */
-
- int *indirection; /* An array (of size n_vals) of integers, which serve to
- permute the index members of the values in valmap.
-
- Doing this, means that categories are considered in the order
- of their values. Mathematically the order is irrelevant.
- However certain procedures (eg logistic regression) want to report
- statisitics for particular categories */
-
};
if (vn->var == var)
break;
- fprintf (stderr, "Warning: Hash table collision\n");
+ fprintf (stderr, "%s:%d Warning: Hash table collision\n", __FILE__, __LINE__);
}
return vn;
/* A map of cases indexed by a interaction_value */
struct hmap ivmap;
- struct interaction *iact;
+ const struct interaction *iact;
int base_subscript_short;
int base_subscript_long;
}
printf ("\n");
- printf ("Number of interactions %d\n", cat->n_iap);
+ printf ("Number of interactions %zu\n", cat->n_iap);
for (i = 0 ; i < cat->n_iap; ++i)
{
int v;
assert (vn->var == var);
- printf ("%g(%d)", val->f, valn->index);
+ printf ("%.*g(%d)", DBL_DIG + 1, val->f, valn->index);
if (vv < iact->n_vars - 1)
printf (", ");
}
int i;
if (NULL == cat)
return;
+
for (i = 0; i < cat->n_iap; ++i)
{
struct interaction_value *iv = NULL;
free (cat->iap[i].enc_sum);
free (cat->iap[i].df_prod);
hmap_destroy (&cat->iap[i].ivmap);
- interaction_destroy (cat->iap[i].iact);
}
/* Interate over each variable and delete its value map */
if (valn == NULL)
{
valn = pool_malloc (cat->pool, sizeof *valn);
- valn->index = vn->n_vals++;
+ valn->index = -1;
+ vn->n_vals++;
value_init (&valn->val, width);
value_copy (&valn->val, val, width);
hmap_insert (&vn->valmap, &valn->node, hash);
return;
}
- vn->indirection = pool_calloc (cat->pool, vn->n_vals, sizeof *vn->indirection);
-
/* Sort the VALMAP here */
array = xcalloc (sizeof *array, vn->n_vals);
+ x = 0;
HMAP_FOR_EACH (valnd, struct value_node, node, &vn->valmap)
{
/* Note: This loop is probably superfluous, it could be done in the
update stage (at the expense of a realloc) */
- array[valnd->index] = valnd;
+ array[x++] = valnd;
}
sort (array, vn->n_vals, sizeof (*array),
for (x = 0; x < vn->n_vals; ++x)
{
struct value_node *vvv = array[x];
- vn->indirection[vn->n_vals - x - 1] = vvv->index;
+ vvv->index = x;
}
free (array);
const int index = ((subscript - base_index) % iap->df_prod[v] ) / dfp;
dfp = iap->df_prod [v];
- if (effects_coding && vn->indirection [valn->index] == df )
+ if (effects_coding && valn->index == df )
bin = -1.0;
- else if ( vn->indirection [valn->index] != index )
+ else if ( valn->index != index )
bin = 0;
result *= bin;