X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fmath%2Fcategoricals.c;h=f40ae10b5d7dca7714cf8aea4e88314792bea795;hb=refs%2Fbuilds%2F20110627030508%2Fpspp;hp=ef9c528994428775614adedc1e59ab0949fb1ebc;hpb=c360fff4fd3e4a98cfe02441f43c27725cead44b;p=pspp diff --git a/src/math/categoricals.c b/src/math/categoricals.c index ef9c528994..f40ae10b5d 100644 --- a/src/math/categoricals.c +++ b/src/math/categoricals.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 @@ -16,18 +16,19 @@ #include -#include +#include "math/categoricals.h" -#include "categoricals.h" +#include -#include -#include -#include -#include -#include -#include +#include "data/case.h" +#include "data/value.h" +#include "data/variable.h" +#include "libpspp/array.h" +#include "libpspp/hmap.h" +#include "libpspp/pool.h" +#include "libpspp/str.h" -#include +#include "gl/xalloc.h" struct value_node { @@ -41,7 +42,6 @@ struct value_node Can be used as an index into an array */ }; - struct var_params { /* A map indexed by a union values */ @@ -62,6 +62,18 @@ struct var_params }; +/* Comparison function to sort the reverse_value_map in ascending order */ +static int +compare_value_node (const void *vn1_, const void *vn2_, const void *aux) +{ + const struct value_node * const *vn1 = vn1_; + const struct value_node * const *vn2 = vn2_; + const struct var_params *vp = aux; + + return value_compare_3way (&(*vn1)->value, &(*vn2)->value, var_get_width (vp->var)); +} + + struct categoricals { /* The weight variable */ @@ -88,16 +100,15 @@ struct categoricals /* Missing values to be excluded */ enum mv_class exclude; - - /* Function to be called on each update */ update_func *update; - /* Auxilliary data to be passed to update */ - void *update_aux; - /* Function specified by the caller to create user_data */ user_data_create_func *user_data_create; + + /* Auxilliary data to be passed to update and user_data_create_func*/ + void *aux1; + void *aux2; }; @@ -166,7 +177,7 @@ categoricals_dump (const struct categoricals *cat) printf ("\nReverse variable map:\n"); - for (v = 0 ; v < cat->n_cats_total; ++v) + for (v = 0 ; v < cat->n_cats_total - cat->n_vars; ++v) printf ("%d ", cat->reverse_variable_map[v]); printf ("\n"); } @@ -197,7 +208,7 @@ struct categoricals * categoricals_create (const struct variable *const *v, size_t n_vars, const struct variable *wv, enum mv_class exclude, user_data_create_func *udf, - update_func *update, void *aux + update_func *update, void *aux1, void *aux2 ) { size_t i; @@ -211,9 +222,12 @@ categoricals_create (const struct variable *const *v, size_t n_vars, cat->pool = pool_create (); cat->exclude = exclude; cat->update = update; - cat->update_aux = aux; cat->user_data_create = udf; + cat->aux1 = aux1; + cat->aux2 = aux2; + + cat->vp = pool_calloc (cat->pool, cat->n_vp, sizeof *cat->vp); for (i = 0 ; i < cat->n_vp; ++i) @@ -266,15 +280,15 @@ categoricals_update (struct categoricals *cat, const struct ccase *c) node->subscript = cat->vp[i].n_cats++ ; - if ( cat->user_data_create ) - node->user_data = cat->user_data_create (); + if (cat->user_data_create) + node->user_data = cat->user_data_create (cat->aux1, cat->aux2); } node->cc += weight; cat->vp[i].cc += weight; - if ( cat->update) - cat->update (node->user_data, cat->wv, var, c, cat->update_aux); + if (cat->update) + cat->update (node->user_data, cat->exclude, cat->wv, var, c, cat->aux1, cat->aux2); } } @@ -297,7 +311,7 @@ categoricals_total (const struct categoricals *cat) /* This function must be called *before* any call to categoricals_get_*_by subscript an *after* all calls to categoricals_update */ void -categoricals_done (struct categoricals *cat) +categoricals_done (const struct categoricals *cat_) { /* Implementation Note: Whilst this function is O(n) in cat->n_cats_total, in most uses it will be more efficient that using a tree based structure, since it @@ -305,10 +319,11 @@ categoricals_done (struct categoricals *cat) 1 call of O(n) + 10^9 calls of O(1) is better than 10^9 calls of O(log n). */ + struct categoricals *cat = CONST_CAST (struct categoricals *, cat_); int v; int idx = 0; cat->reverse_variable_map = pool_calloc (cat->pool, - cat->n_cats_total, + cat->n_cats_total - cat->n_vars, sizeof *cat->reverse_variable_map); for (v = 0 ; v < cat->n_vp; ++v) @@ -328,9 +343,13 @@ categoricals_done (struct categoricals *cat) vp->reverse_value_map[vn->subscript] = vn; } + /* For some purposes (eg CONTRASTS in ONEWAY) the values need to be sorted */ + sort (vp->reverse_value_map, vp->n_cats, sizeof (const struct value_node *), + compare_value_node, vp); + /* Populate the reverse variable map. */ - for (i = 0; i < vp->n_cats; ++i) + for (i = 0; i < vp->n_cats - 1; ++i) cat->reverse_variable_map[idx++] = v; } @@ -343,7 +362,7 @@ reverse_variable_lookup (const struct categoricals *cat, int subscript) { assert (cat->reverse_variable_map); assert (subscript >= 0); - assert (subscript < cat->n_cats_total); + assert (subscript < cat->n_cats_total - cat->n_vars); return cat->reverse_variable_map[subscript]; }