Added a counter for the number of variables which actually contribute
to categories. Due to the possibility of missing values, this may
not be equal to the number of variables passed to the contructor.
+ /* The weight variable */
const struct variable *wv;
const struct variable *wv;
/* An array of var_params */
struct var_params *vp;
/* An array of var_params */
struct var_params *vp;
+ /* The size of VP. (ie, the number of variables involved.) */
+ size_t n_vp;
+
+ /* The number of categorical variables which contain entries.
+ In the absence of missing values, this will be equal to N_VP */
+ size_t n_vars;
+
/* A map to enable the lookup of variables indexed by subscript */
int *reverse_variable_map;
/* A map to enable the lookup of variables indexed by subscript */
int *reverse_variable_map;
categoricals_destroy ( struct categoricals *cat)
{
int i;
categoricals_destroy ( struct categoricals *cat)
{
int i;
- for (i = 0 ; i < cat->n_vars; ++i)
+ for (i = 0 ; i < cat->n_vp; ++i)
hmap_destroy (&cat->vp[i].map);
pool_destroy (cat->pool);
hmap_destroy (&cat->vp[i].map);
pool_destroy (cat->pool);
- for (v = 0 ; v < cat->n_vars; ++v)
+ for (v = 0 ; v < cat->n_vp; ++v)
{
const struct var_params *vp = &cat->vp[v];
const struct hmap *m = &vp->map;
struct hmap_node *node ;
int x;
{
const struct var_params *vp = &cat->vp[v];
const struct hmap *m = &vp->map;
struct hmap_node *node ;
int x;
- printf ("\n%s (%d) CC=%g n_cats=%d:\n", var_get_name (vp->var), vp->base_subscript, vp->cc, vp->n_cats);
+ printf ("\n%s (%d) CC=%g n_cats=%d:\n",
+ var_get_name (vp->var), vp->base_subscript, vp->cc, vp->n_cats);
printf ("Reverse map\n");
for (x = 0 ; x < vp->n_cats; ++x)
printf ("Reverse map\n");
for (x = 0 ; x < vp->n_cats; ++x)
+
+ assert (cat->n_vars <= cat->n_vp);
+
+ printf ("\n");
+ printf ("Number of categorical variables: %d\n", cat->n_vp);
+ printf ("Number of non-empty categorical variables: %d\n", cat->n_vars);
+ printf ("Total number of categories: %d\n", cat->n_cats_total);
size_t i;
struct categoricals *cat = xmalloc (sizeof *cat);
size_t i;
struct categoricals *cat = xmalloc (sizeof *cat);
cat->wv = wv;
cat->n_cats_total = 0;
cat->wv = wv;
cat->n_cats_total = 0;
cat->reverse_variable_map = NULL;
cat->pool = pool_create ();
cat->exclude = exclude;
cat->reverse_variable_map = NULL;
cat->pool = pool_create ();
cat->exclude = exclude;
- cat->vp = pool_calloc (cat->pool, n_vars, sizeof *cat->vp);
+ cat->vp = pool_calloc (cat->pool, cat->n_vp, sizeof *cat->vp);
- for (i = 0 ; i < cat->n_vars; ++i)
+ for (i = 0 ; i < cat->n_vp; ++i)
{
hmap_init (&cat->vp[i].map);
cat->vp[i].var = v[i];
{
hmap_init (&cat->vp[i].map);
cat->vp[i].var = v[i];
assert (NULL == cat->reverse_variable_map);
assert (NULL == cat->reverse_variable_map);
- for (i = 0 ; i < cat->n_vars; ++i)
+ for (i = 0 ; i < cat->n_vp; ++i)
{
const struct variable *var = cat->vp[i].var;
unsigned int width = var_get_width (var);
{
const struct variable *var = cat->vp[i].var;
unsigned int width = var_get_width (var);
hmap_insert (&cat->vp[i].map, &node->node, hash);
cat->n_cats_total++;
hmap_insert (&cat->vp[i].map, &node->node, hash);
cat->n_cats_total++;
+
+ if ( 0 == cat->vp[i].n_cats)
+ cat->n_vars++;
+
node->subscript = cat->vp[i].n_cats++ ;
}
node->subscript = cat->vp[i].n_cats++ ;
}
int idx = 0;
cat->reverse_variable_map = pool_calloc (cat->pool, cat->n_cats_total, sizeof *cat->reverse_variable_map);
int idx = 0;
cat->reverse_variable_map = pool_calloc (cat->pool, cat->n_cats_total, sizeof *cat->reverse_variable_map);
- for (v = 0 ; v < cat->n_vars; ++v)
+ for (v = 0 ; v < cat->n_vp; ++v)
{
int i;
struct var_params *vp = &cat->vp[v];
{
int i;
struct var_params *vp = &cat->vp[v];
for (i = 0; i < vp->n_cats; ++i)
cat->reverse_variable_map[idx++] = v;
}
for (i = 0; i < vp->n_cats; ++i)
cat->reverse_variable_map[idx++] = v;
}
+
+ assert (cat->n_vars <= cat->n_vp);
return value_equal (val, categoricals_get_value_by_subscript (cat, subscript), width);
}
return value_equal (val, categoricals_get_value_by_subscript (cat, subscript), width);
}
+
+
+size_t
+categoricals_get_n_variables (const struct categoricals *cat)
+{
+ return cat->n_vars;
+}
/* Return the total number of categories */
size_t categoricals_total (const struct categoricals *cat);
/* Return the total number of categories */
size_t categoricals_total (const struct categoricals *cat);
+/*
+ Return the total number of variables which participated in these categoricals.
+ Due to the possibility of missing values, this is NOT necessarily
+ equal to the number of variables passed in when the object was
+ created.
+*/
+size_t categoricals_get_n_variables (const struct categoricals *cat);
+
/* Return the index for variable N */
int categoricals_index (const struct categoricals *cat, size_t n, const union value *val);
/* Return the index for variable N */
int categoricals_index (const struct categoricals *cat, size_t n, const union value *val);