X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=src%2Ffrequencies.q;h=5754be7e61e6de277491488c814ba99af96c2057;hb=d5fd364b203a2a84e5034b6ff5ac5d6c4412edb7;hp=9eb171724565e65338b51d1c79de87256acabbbd;hpb=02ef5fef5288b80a4822e1006f6cb2b1369a55bd;p=pspp-builds.git diff --git a/src/frequencies.q b/src/frequencies.q index 9eb17172..5754be7e 100644 --- a/src/frequencies.q +++ b/src/frequencies.q @@ -14,8 +14,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. */ /* TODO: @@ -27,9 +27,12 @@ #include "error.h" #include #include +#include + #include "alloc.h" #include "bitvector.h" #include "case.h" +#include "dictionary.h" #include "hash.h" #include "pool.h" #include "command.h" @@ -49,6 +52,12 @@ #include "settings.h" #include "chart.h" +#include "gettext.h" +#define _(msgid) gettext (msgid) +#define N_(msgid) msgid + +/* (headers) */ + #include "debug-print.h" /* (specification) @@ -78,8 +87,8 @@ norm:!nonormal/normal, incr:increment(d:inc,"%s>0"); grouped=custom; - ntiles=custom; - percentiles=custom; + ntiles=integer; + +percentiles = double list; statistics[st_]=1|mean,2|semean,3|median,4|mode,5|stddev,6|variance, 7|kurtosis,8|skewness,9|range,10|minimum,11|maximum,12|sum, 13|default,14|seskewness,15|sekurtosis,all,none. @@ -87,6 +96,14 @@ /* (declarations) */ /* (functions) */ +/* Statistics. */ +enum + { + frq_mean = 0, frq_semean, frq_median, frq_mode, frq_stddev, frq_variance, + frq_kurt, frq_sekurt, frq_skew, frq_seskew, frq_range, frq_min, frq_max, + frq_sum, frq_n_stats + }; + /* Description of a statistic. */ struct frq_info { @@ -126,6 +143,9 @@ struct percentile int flag2; /* Set to 1 if this percentile value has been found */ }; + +static void add_percentile (double x) ; + static struct percentile *percentiles; static int n_percentiles; @@ -168,19 +188,81 @@ static double scale, incr; /* FIXME */ static int normal; /* FIXME */ /* Variables for which to calculate statistics. */ -static int n_variables; +static size_t n_variables; static struct variable **v_variables; /* Arenas used to store semi-permanent storage. */ static struct pool *int_pool; /* Integer mode. */ static struct pool *gen_pool; /* General mode. */ -/* Easier access to a_statistics. */ -#define stat cmd.a_statistics +/* Frequency tables. */ + +/* Frequency table entry. */ +struct freq + { + union value v; /* The value. */ + double c; /* The number of occurrences of the value. */ + }; + +/* Types of frequency tables. */ +enum + { + FRQM_GENERAL, + FRQM_INTEGER + }; + +/* Entire frequency table. */ +struct freq_tab + { + int mode; /* FRQM_GENERAL or FRQM_INTEGER. */ + + /* General mode. */ + struct hsh_table *data; /* Undifferentiated data. */ + + /* Integer mode. */ + double *vector; /* Frequencies proper. */ + int min, max; /* The boundaries of the table. */ + double out_of_range; /* Sum of weights of out-of-range values. */ + double sysmis; /* Sum of weights of SYSMIS values. */ + + /* All modes. */ + struct freq *valid; /* Valid freqs. */ + int n_valid; /* Number of total freqs. */ + + struct freq *missing; /* Missing freqs. */ + int n_missing; /* Number of missing freqs. */ + + /* Statistics. */ + double total_cases; /* Sum of weights of all cases. */ + double valid_cases; /* Sum of weights of valid cases. */ + }; + + +/* Per-variable frequency data. */ +struct var_freqs + { + /* Freqency table. */ + struct freq_tab tab; /* Frequencies table to use. */ + + /* Percentiles. */ + int n_groups; /* Number of groups. */ + double *groups; /* Groups. */ + + /* Statistics. */ + double stat[frq_n_stats]; + }; + +static inline struct var_freqs * +get_var_freqs (struct variable *v) +{ + assert (v != NULL); + assert (v->aux != NULL); + return v->aux; +} static void determine_charts (void); -static void calc_stats (struct variable * v, double d[frq_n_stats]); +static void calc_stats (struct variable *v, double d[frq_n_stats]); static void precalc (void *); static int calc (struct ccase *, void *); @@ -197,6 +279,15 @@ static hsh_compare_func compare_value_numeric_a, compare_value_alpha_a; static hsh_compare_func compare_value_numeric_d, compare_value_alpha_d; static hsh_compare_func compare_freq_numeric_a, compare_freq_alpha_a; static hsh_compare_func compare_freq_numeric_d, compare_freq_alpha_d; + + +static void do_piechart(const struct variable *var, + const struct freq_tab *frq_tab); + +gsl_histogram * +freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var); + + /* Parser and outline. */ @@ -229,9 +320,6 @@ internal_cmd_frequencies (void) n_variables = 0; v_variables = NULL; - for (i = 0; i < dict_get_var_cnt (default_dict); i++) - dict_get_var(default_dict, i)->p.frq.used = 0; - if (!parse_frequencies (&cmd)) return CMD_FAILURE; @@ -240,14 +328,14 @@ internal_cmd_frequencies (void) /* Figure out statistics to calculate. */ stats = 0; - if (stat[FRQ_ST_DEFAULT] || !cmd.sbc_statistics) + if (cmd.a_statistics[FRQ_ST_DEFAULT] || !cmd.sbc_statistics) stats |= frq_default; - if (stat[FRQ_ST_ALL]) + if (cmd.a_statistics[FRQ_ST_ALL]) stats |= frq_all; if (cmd.sort != FRQ_AVALUE && cmd.sort != FRQ_DVALUE) stats &= ~frq_median; for (i = 0; i < frq_n_stats; i++) - if (stat[st_name[i].st_indx]) + if (cmd.a_statistics[st_name[i].st_indx]) stats |= BIT_INDEX (i); if (stats & frq_kurt) stats |= frq_sekurt; @@ -265,9 +353,33 @@ internal_cmd_frequencies (void) if (chart != GFT_NONE || cmd.sbc_ntiles) cmd.sort = FRQ_AVALUE; + /* Work out what percentiles need to be calculated */ + if ( cmd.sbc_percentiles ) + { + for ( i = 0 ; i < MAXLISTS ; ++i ) + { + int pl; + subc_list_double *ptl_list = &cmd.dl_percentiles[i]; + for ( pl = 0 ; pl < subc_list_double_count(ptl_list); ++pl) + add_percentile(subc_list_double_at(ptl_list,pl) / 100.0 ); + } + } + if ( cmd.sbc_ntiles ) + { + for ( i = 0 ; i < cmd.sbc_ntiles ; ++i ) + { + int j; + for (j = 0; j <= cmd.n_ntiles[i]; ++j ) + add_percentile(j / (double) cmd.n_ntiles[i]); + } + } + + /* Do it! */ procedure_with_splits (precalc, calc, postcalc, NULL); + free_frequencies(&cmd); + return CMD_SUCCESS; } @@ -381,7 +493,7 @@ static int calc (struct ccase *c, void *aux UNUSED) { double weight; - int i; + size_t i; int bad_warn = 1; weight = dict_get_case_weight (default_dict, c, &bad_warn); @@ -390,9 +502,9 @@ calc (struct ccase *c, void *aux UNUSED) { struct variable *v = v_variables[i]; const union value *val = case_data (c, v->fv); - struct freq_tab *ft = &v->p.frq.tab; + struct freq_tab *ft = &get_var_freqs (v)->tab; - switch (v->p.frq.tab.mode) + switch (ft->mode) { case FRQM_GENERAL: { @@ -413,15 +525,15 @@ calc (struct ccase *c, void *aux UNUSED) case FRQM_INTEGER: /* Integer mode. */ if (val->f == SYSMIS) - v->p.frq.tab.sysmis += weight; + ft->sysmis += weight; else if (val->f > INT_MIN+1 && val->f < INT_MAX-1) { int i = val->f; - if (i >= v->p.frq.tab.min && i <= v->p.frq.tab.max) - v->p.frq.tab.vector[i - v->p.frq.tab.min] += weight; + if (i >= ft->min && i <= ft->max) + ft->vector[i - ft->min] += weight; } else - v->p.frq.tab.out_of_range += weight; + ft->out_of_range += weight; break; default: assert (0); @@ -435,7 +547,7 @@ calc (struct ccase *c, void *aux UNUSED) static void precalc (void *aux UNUSED) { - int i; + size_t i; pool_destroy (gen_pool); gen_pool = pool_create (); @@ -443,8 +555,9 @@ precalc (void *aux UNUSED) for (i = 0; i < n_variables; i++) { struct variable *v = v_variables[i]; + struct freq_tab *ft = &get_var_freqs (v)->tab; - if (v->p.frq.tab.mode == FRQM_GENERAL) + if (ft->mode == FRQM_GENERAL) { hsh_hash_func *hash; hsh_compare_func *compare; @@ -459,16 +572,16 @@ precalc (void *aux UNUSED) hash = hash_value_alpha; compare = compare_value_alpha_a; } - v->p.frq.tab.data = hsh_create (16, compare, hash, NULL, v); + ft->data = hsh_create (16, compare, hash, NULL, v); } else { int j; - for (j = (v->p.frq.tab.max - v->p.frq.tab.min); j >= 0; j--) - v->p.frq.tab.vector[j] = 0.0; - v->p.frq.tab.out_of_range = 0.0; - v->p.frq.tab.sysmis = 0.0; + for (j = (ft->max - ft->min); j >= 0; j--) + ft->vector[j] = 0.0; + ft->out_of_range = 0.0; + ft->sysmis = 0.0; } } } @@ -478,18 +591,20 @@ precalc (void *aux UNUSED) static void postcalc (void *aux UNUSED) { - int i; + size_t i; for (i = 0; i < n_variables; i++) { struct variable *v = v_variables[i]; + struct var_freqs *vf = get_var_freqs (v); + struct freq_tab *ft = &vf->tab; int n_categories; int dumped_freq_tab = 1; postprocess_freq_tab (v); /* Frequencies tables. */ - n_categories = v->p.frq.tab.n_valid + v->p.frq.tab.n_missing; + n_categories = ft->n_valid + ft->n_missing; if (cmd.table == FRQ_TABLE || (cmd.table == FRQ_LIMIT && n_categories <= cmd.limit)) switch (cmd.cond) @@ -517,37 +632,35 @@ postcalc (void *aux UNUSED) dump_statistics (v, !dumped_freq_tab); + if ( chart == GFT_HIST) { - struct chart ch; double d[frq_n_stats]; - struct frequencies_proc *frq = &v->p.frq; - struct normal_curve norm; - norm.N = frq->tab.total_cases ; + gsl_histogram *hist ; + + + norm.N = vf->tab.valid_cases; calc_stats(v,d); norm.mean = d[frq_mean]; norm.stddev = d[frq_stddev]; - chart_initialise(&ch); - draw_histogram(&ch, v_variables[i], "HISTOGRAM",&norm,normal); - chart_finalise(&ch); + hist = freq_tab_to_hist(ft,v); + + histogram_plot(hist, var_to_string(v), &norm, normal); + + gsl_histogram_free(hist); } if ( chart == GFT_PIE) { - struct chart ch; - - chart_initialise(&ch); - - draw_piechart(&ch, v_variables[i]); - - chart_finalise(&ch); + do_piechart(v_variables[i], ft); } + cleanup_freq_tab (v); } @@ -584,7 +697,7 @@ not_missing (const void *f_, void *v_) const struct freq *f = f_; struct variable *v = v_; - return !is_missing (&f->v, v); + return !mv_is_value_missing (&v->miss, &f->v); } /* Summarizes the frequency table data for variable V. */ @@ -594,20 +707,20 @@ postprocess_freq_tab (struct variable *v) hsh_compare_func *compare; struct freq_tab *ft; size_t count; - void **data; + void *const *data; struct freq *freqs, *f; size_t i; - assert (v->p.frq.tab.mode == FRQM_GENERAL); + ft = &get_var_freqs (v)->tab; + assert (ft->mode == FRQM_GENERAL); compare = get_freq_comparator (cmd.sort, v->type); - ft = &v->p.frq.tab; /* Extract data from hash table. */ count = hsh_count (ft->data); data = hsh_data (ft->data); /* Copy dereferenced data into freqs. */ - freqs = xmalloc (count * sizeof *freqs); + freqs = xnmalloc (count, sizeof *freqs); for (i = 0; i < count; i++) { struct freq *f = data[i]; @@ -646,9 +759,10 @@ postprocess_freq_tab (struct variable *v) static void cleanup_freq_tab (struct variable *v) { - assert (v->p.frq.tab.mode == FRQM_GENERAL); - free (v->p.frq.tab.valid); - hsh_destroy (v->p.frq.tab.data); + struct freq_tab *ft = &get_var_freqs (v)->tab; + assert (ft->mode == FRQM_GENERAL); + free (ft->valid); + hsh_destroy (ft->data); } /* Parses the VARIABLES subcommand, adding to @@ -659,8 +773,8 @@ frq_custom_variables (struct cmd_frequencies *cmd UNUSED) int mode; int min = 0, max = 0; - int old_n_variables = n_variables; - int i; + size_t old_n_variables = n_variables; + size_t i; lex_match ('='); if (token != T_ALL && (token != T_ID @@ -671,9 +785,6 @@ frq_custom_variables (struct cmd_frequencies *cmd UNUSED) PV_APPEND | PV_NO_SCRATCH)) return 0; - for (i = old_n_variables; i < n_variables; i++) - v_variables[i]->p.frq.tab.mode = FRQM_GENERAL; - if (!lex_match ('(')) mode = FRQM_GENERAL; else @@ -702,42 +813,40 @@ frq_custom_variables (struct cmd_frequencies *cmd UNUSED) for (i = old_n_variables; i < n_variables; i++) { struct variable *v = v_variables[i]; + struct var_freqs *vf; - if (v->p.frq.used != 0) + if (v->aux != NULL) { msg (SE, _("Variable %s specified multiple times on VARIABLES " "subcommand."), v->name); return 0; } - - v->p.frq.used = 1; /* Used simply as a marker. */ - - v->p.frq.tab.valid = v->p.frq.tab.missing = NULL; + if (mode == FRQM_INTEGER && v->type != NUMERIC) + { + msg (SE, _("Integer mode specified, but %s is not a numeric " + "variable."), v->name); + return 0; + } + vf = var_attach_aux (v, xmalloc (sizeof *vf), var_dtor_free); + vf->tab.mode = mode; + vf->tab.valid = vf->tab.missing = NULL; if (mode == FRQM_INTEGER) { - if (v->type != NUMERIC) - { - msg (SE, _("Integer mode specified, but %s is not a numeric " - "variable."), v->name); - return 0; - } - - v->p.frq.tab.min = min; - v->p.frq.tab.max = max; - v->p.frq.tab.vector = pool_alloc (int_pool, - sizeof (struct freq) * (max - min + 1)); + vf->tab.min = min; + vf->tab.max = max; + vf->tab.vector = pool_nalloc (int_pool, + max - min + 1, sizeof *vf->tab.vector); } else - v->p.frq.tab.vector = NULL; - - v->p.frq.n_groups = 0; - v->p.frq.groups = NULL; + vf->tab.vector = NULL; + vf->n_groups = 0; + vf->groups = NULL; } return 1; } -/* Parses the GROUPED subcommand, setting the frq.{n_grouped,grouped} +/* Parses the GROUPED subcommand, setting the n_grouped, grouped fields of specified variables. */ static int frq_custom_grouped (struct cmd_frequencies *cmd UNUSED) @@ -747,14 +856,14 @@ frq_custom_grouped (struct cmd_frequencies *cmd UNUSED) || token == T_ID) for (;;) { - int i; + size_t i; /* Max, current size of list; list itself. */ int nl, ml; double *dl; /* Variable list. */ - int n; + size_t n; struct variable **v; if (!parse_variables (default_dict, &v, &n, @@ -764,12 +873,12 @@ frq_custom_grouped (struct cmd_frequencies *cmd UNUSED) { nl = ml = 0; dl = NULL; - while (token == T_NUM) + while (lex_integer ()) { if (nl >= ml) { ml += 16; - dl = pool_realloc (int_pool, dl, ml * sizeof (double)); + dl = pool_nrealloc (int_pool, dl, ml, sizeof *dl); } dl[nl++] = tokval; lex_get (); @@ -791,19 +900,22 @@ frq_custom_grouped (struct cmd_frequencies *cmd UNUSED) } for (i = 0; i < n; i++) - { - if (v[i]->p.frq.used == 0) - msg (SE, _("Variables %s specified on GROUPED but not on " - "VARIABLES."), v[i]->name); - if (v[i]->p.frq.groups != NULL) - msg (SE, _("Variables %s specified multiple times on GROUPED " - "subcommand."), v[i]->name); - else - { - v[i]->p.frq.n_groups = nl; - v[i]->p.frq.groups = dl; - } - } + if (v[i]->aux == NULL) + msg (SE, _("Variables %s specified on GROUPED but not on " + "VARIABLES."), v[i]->name); + else + { + struct var_freqs *vf = get_var_freqs (v[i]); + + if (vf->groups != NULL) + msg (SE, _("Variables %s specified multiple times on GROUPED " + "subcommand."), v[i]->name); + else + { + vf->n_groups = nl; + vf->groups = dl; + } + } free (v); if (!lex_match ('/')) break; @@ -826,14 +938,19 @@ add_percentile (double x) int i; for (i = 0; i < n_percentiles; i++) - if (x <= percentiles[i].p) - break; + { + /* Do nothing if it's already in the list */ + if ( fabs(x - percentiles[i].p) < DBL_EPSILON ) + return; + + if (x < percentiles[i].p) + break; + } if (i >= n_percentiles || tokval != percentiles[i].p) { - percentiles - = pool_realloc (int_pool, percentiles, - (n_percentiles + 1) * sizeof (struct percentile )); + percentiles = pool_nrealloc (int_pool, percentiles, + n_percentiles + 1, sizeof *percentiles); if (i < n_percentiles) memmove (&percentiles[i + 1], &percentiles[i], @@ -844,50 +961,6 @@ add_percentile (double x) } } -/* Parses the PERCENTILES subcommand, adding user-specified - percentiles to the list. */ -static int -frq_custom_percentiles (struct cmd_frequencies *cmd UNUSED) -{ - lex_match ('='); - if (token != T_NUM) - { - msg (SE, _("Percentile list expected after PERCENTILES.")); - return 0; - } - - do - { - if (tokval < 0 || tokval > 100) - { - msg (SE, _("Percentiles must be between 0 and 100.")); - return 0; - } - - add_percentile (tokval / 100.0); - lex_get (); - lex_match (','); - } - while (token == T_NUM); - return 1; -} - -/* Parses the NTILES subcommand, adding the percentiles that - correspond to the specified evenly-distributed ntiles. */ -static int -frq_custom_ntiles (struct cmd_frequencies *cmd UNUSED) -{ - int i; - - lex_match ('='); - if (!lex_force_int ()) - return 0; - for (i = 1; i < lex_integer (); i++) - add_percentile (1.0 / lex_integer () * i); - lex_get (); - return 1; -} - /* Comparison functions. */ /* Hash of numeric values. */ @@ -1044,9 +1117,10 @@ full_dim (struct tab_table *t, struct outp_driver *d) /* Displays a full frequency table for variable V. */ static void -dump_full (struct variable * v) +dump_full (struct variable *v) { int n_categories; + struct freq_tab *ft; struct freq *f; struct tab_table *t; int r; @@ -1079,7 +1153,8 @@ dump_full (struct variable * v) int lab = cmd.labels == FRQ_LABELS; - n_categories = v->p.frq.tab.n_valid + v->p.frq.tab.n_missing; + ft = &get_var_freqs (v)->tab; + n_categories = ft->n_valid + ft->n_missing; t = tab_create (5 + lab, n_categories + 3, 0); tab_headers (t, 0, 0, 2, 0); tab_dim (t, full_dim); @@ -1091,14 +1166,14 @@ dump_full (struct variable * v) TAB_CENTER | TAT_TITLE, gettext (p->s)); r = 2; - for (f = v->p.frq.tab.valid; f < v->p.frq.tab.missing; f++) + for (f = ft->valid; f < ft->missing; f++) { double percent, valid_percent; cum_freq += f->c; - percent = f->c / v->p.frq.tab.total_cases * 100.0; - valid_percent = f->c / v->p.frq.tab.valid_cases * 100.0; + percent = f->c / ft->total_cases * 100.0; + valid_percent = f->c / ft->valid_cases * 100.0; cum_total += valid_percent; if (lab) @@ -1115,7 +1190,7 @@ dump_full (struct variable * v) tab_float (t, 4 + lab, r, TAB_NONE, cum_total, 5, 1); r++; } - for (; f < &v->p.frq.tab.valid[n_categories]; f++) + for (; f < &ft->valid[n_categories]; f++) { cum_freq += f->c; @@ -1129,7 +1204,7 @@ dump_full (struct variable * v) tab_value (t, 0 + lab, r, TAB_NONE, &f->v, &v->print); tab_float (t, 1 + lab, r, TAB_NONE, f->c, 8, 0); tab_float (t, 2 + lab, r, TAB_NONE, - f->c / v->p.frq.tab.total_cases * 100.0, 5, 1); + f->c / ft->total_cases * 100.0, 5, 1); tab_text (t, 3 + lab, r, TAB_NONE, _("Missing")); r++; } @@ -1171,15 +1246,17 @@ condensed_dim (struct tab_table *t, struct outp_driver *d) /* Display condensed frequency table for variable V. */ static void -dump_condensed (struct variable * v) +dump_condensed (struct variable *v) { int n_categories; + struct freq_tab *ft; struct freq *f; struct tab_table *t; int r; double cum_total = 0.0; - n_categories = v->p.frq.tab.n_valid + v->p.frq.tab.n_missing; + ft = &get_var_freqs (v)->tab; + n_categories = ft->n_valid + ft->n_missing; t = tab_create (4, n_categories + 2, 0); tab_headers (t, 0, 0, 2, 0); @@ -1191,12 +1268,12 @@ dump_condensed (struct variable * v) tab_dim (t, condensed_dim); r = 2; - for (f = v->p.frq.tab.valid; f < v->p.frq.tab.missing; f++) + for (f = ft->valid; f < ft->missing; f++) { double percent; - percent = f->c / v->p.frq.tab.total_cases * 100.0; - cum_total += f->c / v->p.frq.tab.valid_cases * 100.0; + percent = f->c / ft->total_cases * 100.0; + cum_total += f->c / ft->valid_cases * 100.0; tab_value (t, 0, r, TAB_NONE, &f->v, &v->print); tab_float (t, 1, r, TAB_NONE, f->c, 8, 0); @@ -1204,12 +1281,12 @@ dump_condensed (struct variable * v) tab_float (t, 3, r, TAB_NONE, cum_total, 3, 0); r++; } - for (; f < &v->p.frq.tab.valid[n_categories]; f++) + for (; f < &ft->valid[n_categories]; f++) { tab_value (t, 0, r, TAB_NONE, &f->v, &v->print); tab_float (t, 1, r, TAB_NONE, f->c, 8, 0); tab_float (t, 2, r, TAB_NONE, - f->c / v->p.frq.tab.total_cases * 100.0, 3, 0); + f->c / ft->total_cases * 100.0, 3, 0); r++; } @@ -1227,9 +1304,10 @@ dump_condensed (struct variable * v) /* Calculates all the pertinent statistics for variable V, putting them in array D[]. FIXME: This could be made much more optimal. */ static void -calc_stats (struct variable * v, double d[frq_n_stats]) +calc_stats (struct variable *v, double d[frq_n_stats]) { - double W = v->p.frq.tab.valid_cases; + struct freq_tab *ft = &get_var_freqs (v)->tab; + double W = ft->valid_cases; struct moments *m; struct freq *f=0; int most_often; @@ -1267,10 +1345,10 @@ calc_stats (struct variable * v, double d[frq_n_stats]) } rank = 0; - for (idx = 0; idx < v->p.frq.tab.n_valid; ++idx) + for (idx = 0; idx < ft->n_valid; ++idx) { static double prev_value = SYSMIS; - f = &v->p.frq.tab.valid[idx]; + f = &ft->valid[idx]; rank += f->c ; for (i = 0; i < n_percentiles; i++) { @@ -1279,10 +1357,10 @@ calc_stats (struct variable * v, double d[frq_n_stats]) if ( get_algorithm() != COMPATIBLE ) tp = - (v->p.frq.tab.valid_cases - 1) * percentiles[i].p; + (ft->valid_cases - 1) * percentiles[i].p; else tp = - (v->p.frq.tab.valid_cases + 1) * percentiles[i].p - 1; + (ft->valid_cases + 1) * percentiles[i].p - 1; if ( percentiles[i].flag ) { @@ -1324,17 +1402,17 @@ calc_stats (struct variable * v, double d[frq_n_stats]) for (i = 0; i < n_percentiles; i++) { - struct freq_tab *ft = &v->p.frq.tab; + struct freq_tab *ft = &get_var_freqs (v)->tab; double s; double dummy; if ( get_algorithm() != COMPATIBLE ) { - s = modf((ft->valid_cases - 1) * percentiles[i].p , &dummy); + s = modf((ft->valid_cases - 1) * percentiles[i].p , &dummy); } else { - s = modf((ft->valid_cases + 1) * percentiles[i].p -1, &dummy); + s = modf((ft->valid_cases + 1) * percentiles[i].p -1, &dummy); } percentiles[i].value = percentiles[i].x1 + @@ -1348,7 +1426,7 @@ calc_stats (struct variable * v, double d[frq_n_stats]) /* Calculate the mode. */ most_often = -1; X_mode = SYSMIS; - for (f = v->p.frq.tab.valid; f < v->p.frq.tab.missing; f++) + for (f = ft->valid; f < ft->missing; f++) { if (most_often < f->c) { @@ -1365,17 +1443,17 @@ calc_stats (struct variable * v, double d[frq_n_stats]) /* Calculate moments. */ m = moments_create (MOMENT_KURTOSIS); - for (f = v->p.frq.tab.valid; f < v->p.frq.tab.missing; f++) + for (f = ft->valid; f < ft->missing; f++) moments_pass_one (m, f->v.f, f->c); - for (f = v->p.frq.tab.valid; f < v->p.frq.tab.missing; f++) + for (f = ft->valid; f < ft->missing; f++) moments_pass_two (m, f->v.f, f->c); moments_calculate (m, NULL, &d[frq_mean], &d[frq_variance], &d[frq_skew], &d[frq_kurt]); moments_destroy (m); /* Formulas below are taken from _SPSS Statistical Algorithms_. */ - d[frq_min] = v->p.frq.tab.valid[0].v.f; - d[frq_max] = v->p.frq.tab.valid[v->p.frq.tab.n_valid - 1].v.f; + d[frq_min] = ft->valid[0].v.f; + d[frq_max] = ft->valid[ft->n_valid - 1].v.f; d[frq_mode] = X_mode; d[frq_range] = d[frq_max] - d[frq_min]; d[frq_median] = *median_value; @@ -1388,8 +1466,9 @@ calc_stats (struct variable * v, double d[frq_n_stats]) /* Displays a table of all the statistics requested for variable V. */ static void -dump_statistics (struct variable * v, int show_varname) +dump_statistics (struct variable *v, int show_varname) { + struct freq_tab *ft; double stat_value[frq_n_stats]; struct tab_table *t; int i, r; @@ -1401,7 +1480,8 @@ dump_statistics (struct variable * v, int show_varname) if (v->type == ALPHA) return; - if (v->p.frq.tab.n_valid == 0) + ft = &get_var_freqs (v)->tab; + if (ft->n_valid == 0) { msg (SW, _("No valid data for variable %s; statistics not displayed."), v->name); @@ -1433,9 +1513,8 @@ dump_statistics (struct variable * v, int show_varname) tab_text (t, 1, 0, TAB_LEFT | TAT_TITLE, _("Valid")); tab_text (t, 1, 1, TAB_LEFT | TAT_TITLE, _("Missing")); - tab_float(t, 2, 0, TAB_NONE, v->p.frq.tab.valid_cases, 11, 0); - tab_float(t, 2, 1, TAB_NONE, - v->p.frq.tab.total_cases - v->p.frq.tab.valid_cases, 11, 0); + tab_float(t, 2, 0, TAB_NONE, ft->valid_cases, 11, 0); + tab_float(t, 2, 1, TAB_NONE, ft->total_cases - ft->valid_cases, 11, 0); for (i = 0; i < n_explicit_percentiles; i++, r++) @@ -1464,6 +1543,96 @@ dump_statistics (struct variable * v, int show_varname) tab_submit (t); } + + +/* Create a gsl_histogram from a freq_tab */ +gsl_histogram * +freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var) +{ + int i; + double x_min = DBL_MAX; + double x_max = -DBL_MAX; + + gsl_histogram *hist; + const double bins = 11; + + struct hsh_iterator hi; + struct hsh_table *fh = ft->data; + struct freq *frq; + + /* Find out the extremes of the x value */ + for ( frq = hsh_first(fh, &hi); frq != 0; frq = hsh_next(fh, &hi) ) + { + if ( mv_is_value_missing(&var->miss, &frq->v)) + continue; + + if ( frq->v.f < x_min ) x_min = frq->v.f ; + if ( frq->v.f > x_max ) x_max = frq->v.f ; + } + + hist = histogram_create(bins, x_min, x_max); + + for( i = 0 ; i < ft->n_valid ; ++i ) + { + frq = &ft->valid[i]; + gsl_histogram_accumulate(hist, frq->v.f, frq->c); + } + + return hist; +} + + +static struct slice * +freq_tab_to_slice_array(const struct freq_tab *frq_tab, + const struct variable *var, + int *n_slices); + + +/* Allocate an array of slices and fill them from the data in frq_tab + n_slices will contain the number of slices allocated. + The caller is responsible for freeing slices +*/ +static struct slice * +freq_tab_to_slice_array(const struct freq_tab *frq_tab, + const struct variable *var, + int *n_slices) +{ + int i; + struct slice *slices; + + *n_slices = frq_tab->n_valid; + + slices = xnmalloc (*n_slices, sizeof *slices); + + for (i = 0 ; i < *n_slices ; ++i ) + { + const struct freq *frq = &frq_tab->valid[i]; + + slices[i].label = value_to_string(&frq->v, var); + + slices[i].magnetude = frq->c; + } + + return slices; +} + + + + +static void +do_piechart(const struct variable *var, const struct freq_tab *frq_tab) +{ + struct slice *slices; + int n_slices; + + slices = freq_tab_to_slice_array(frq_tab, var, &n_slices); + + piechart_plot(var_to_string(var), slices, n_slices); + + free(slices); +} + + /* Local Variables: mode: c