X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Ffrequencies.q;h=c00e645f82e9ccd27a05e4a540b2f96e813405e2;hb=2be9bee9da6a2ce27715e58128569594319abfa2;hp=45c969d4c00a5edaaeac0fce56ed8721a36cff1f;hpb=f229deb221f9de45a7368070e188c53eba0662b9;p=pspp-builds.git diff --git a/src/language/stats/frequencies.q b/src/language/stats/frequencies.q index 45c969d4..c00e645f 100644 --- a/src/language/stats/frequencies.q +++ b/src/language/stats/frequencies.q @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2007, 2009, 2010 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2007, 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 @@ -20,37 +20,36 @@ #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "freq.h" - -#include "minmax.h" -#include "xalloc.h" +#include "data/case.h" +#include "data/casegrouper.h" +#include "data/casereader.h" +#include "data/dataset.h" +#include "data/dictionary.h" +#include "data/format.h" +#include "data/settings.h" +#include "data/value-labels.h" +#include "data/variable.h" +#include "language/command.h" +#include "language/dictionary/split-file.h" +#include "language/lexer/lexer.h" +#include "language/stats/freq.h" +#include "libpspp/array.h" +#include "libpspp/bit-vector.h" +#include "libpspp/compiler.h" +#include "libpspp/hmap.h" +#include "libpspp/message.h" +#include "libpspp/misc.h" +#include "libpspp/pool.h" +#include "libpspp/str.h" +#include "math/histogram.h" +#include "math/moments.h" +#include "output/chart-item.h" +#include "output/charts/piechart.h" +#include "output/charts/plot-hist.h" +#include "output/tab.h" + +#include "gl/minmax.h" +#include "gl/xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -88,9 +87,9 @@ /* 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 + FRQ_MEAN, 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. */ @@ -101,7 +100,7 @@ struct frq_info }; /* Table of statistics, indexed by dsc_*. */ -static const struct frq_info st_name[frq_n_stats + 1] = +static const struct frq_info st_name[FRQ_N_STATS + 1] = { {FRQ_ST_MEAN, N_("Mean")}, {FRQ_ST_SEMEAN, N_("S.E. Mean")}, @@ -126,33 +125,19 @@ struct percentile { double p; /* the %ile to be calculated */ double value; /* the %ile's value */ - double x1; /* The datum value <= the percentile */ - double x2; /* The datum value >= the percentile */ - int flag; - int flag2; /* Set to 1 if this percentile value has been found */ bool show; /* True to show this percentile in the statistics box. */ }; - -static void add_percentile (double x, bool show); - -static struct percentile *percentiles; -static int n_percentiles, n_show_percentiles; - /* Groups of statistics. */ #define BI BIT_INDEX -#define frq_default \ - (BI (frq_mean) | BI (frq_stddev) | BI (frq_min) | BI (frq_max)) -#define frq_all \ - (BI (frq_sum) | BI(frq_min) | BI(frq_max) \ - | BI(frq_mean) | BI(frq_semean) | BI(frq_stddev) \ - | BI(frq_variance) | BI(frq_kurt) | BI(frq_sekurt) \ - | BI(frq_skew) | BI(frq_seskew) | BI(frq_range) \ - | BI(frq_range) | BI(frq_mode) | BI(frq_median)) - -/* Statistics; number of statistics. */ -static unsigned long stats; -static int n_stats; +#define FRQ_DEFAULT \ + (BI (FRQ_MEAN) | BI (FRQ_STDDEV) | BI (FRQ_MIN) | BI (FRQ_MAX)) +#define FRQ_ALL \ + (BI (FRQ_SUM) | BI(FRQ_MIN) | BI(FRQ_MAX) \ + | BI(FRQ_MEAN) | BI(FRQ_SEMEAN) | BI(FRQ_STDDEV) \ + | BI(FRQ_VARIANCE) | BI(FRQ_KURT) | BI(FRQ_SEKURT) \ + | BI(FRQ_SKEW) | BI(FRQ_SESKEW) | BI(FRQ_RANGE) \ + | BI(FRQ_RANGE) | BI(FRQ_MODE) | BI(FRQ_MEDIAN)) struct frq_chart { @@ -168,32 +153,17 @@ struct frq_chart bool include_missing; /* Whether to include missing values. */ }; -/* Histogram and pie chart settings. */ -static struct frq_chart hist, pie; - -/* Parsed command. */ -static struct cmd_frequencies cmd; - -/* Variables for which to calculate statistics. */ -static size_t n_variables; -static const struct variable **v_variables; - -/* Pools. */ -static struct pool *data_pool; /* For per-SPLIT FILE group data. */ -static struct pool *syntax_pool; /* For syntax-related data. */ - /* Frequency tables. */ /* Entire frequency table. */ struct freq_tab { - struct hsh_table *data; /* Undifferentiated data. */ - struct freq_mutable *valid; /* Valid freqs. */ + struct hmap data; /* Hash table for accumulating counts. */ + struct freq *valid; /* Valid freqs. */ int n_valid; /* Number of total freqs. */ - const struct dictionary *dict; /* The dict from whence entries in the table - come */ + const struct dictionary *dict; /* Source of entries in the table. */ - struct freq_mutable *missing; /* Missing freqs. */ + struct freq *missing; /* Missing freqs. */ int n_missing; /* Number of missing freqs. */ /* Statistics. */ @@ -204,6 +174,8 @@ struct freq_tab /* Per-variable frequency data. */ struct var_freqs { + struct variable *var; + /* Freqency table. */ struct freq_tab tab; /* Frequencies table to use. */ @@ -212,108 +184,129 @@ struct var_freqs double *groups; /* Groups. */ /* Statistics. */ - double stat[frq_n_stats]; + double stat[FRQ_N_STATS]; /* Variable attributes. */ int width; struct fmt_spec print; }; -static inline struct var_freqs * -get_var_freqs (const struct variable *v) -{ - return var_get_aux (v); -} +struct frq_proc + { + struct pool *pool; -static void determine_charts (void); + struct var_freqs *vars; + size_t n_vars; -static void calc_stats (const struct variable *v, double d[frq_n_stats]); + /* Percentiles to calculate and possibly display. */ + struct percentile *percentiles; + int n_percentiles, n_show_percentiles; -static void precalc (struct casereader *, struct dataset *); -static void calc (const struct ccase *, const struct dataset *); -static void postcalc (const struct dataset *); + /* Frequency table display. */ + int max_categories; /* Maximum categories to show. */ + int sort; /* FRQ_AVALUE or FRQ_DVALUE + or FRQ_ACOUNT or FRQ_DCOUNT. */ -static void postprocess_freq_tab (const struct variable *); -static void dump_freq_table (const struct variable *, const struct variable *); -static void dump_statistics (const struct variable *, const struct variable *); -static void cleanup_freq_tab (const struct variable *); + /* Statistics; number of statistics. */ + unsigned long stats; + int n_stats; -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; + /* Histogram and pie chart settings. */ + struct frq_chart *hist, *pie; + }; +static void determine_charts (struct frq_proc *, + const struct cmd_frequencies *); -static void do_piechart(const struct variable *var, - const struct freq_tab *frq_tab); +static void calc_stats (const struct var_freqs *, double d[FRQ_N_STATS]); +static void calc_percentiles (const struct frq_proc *, + const struct var_freqs *); -struct histogram * -freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var); +static void precalc (struct frq_proc *, struct casereader *, struct dataset *); +static void calc (struct frq_proc *, const struct ccase *, + const struct dataset *); +static void postcalc (struct frq_proc *, const struct dataset *); + +static void postprocess_freq_tab (const struct frq_proc *, struct var_freqs *); +static void dump_freq_table (const struct var_freqs *, + const struct variable *weight_var); +static void dump_statistics (const struct frq_proc *, const struct var_freqs *, + const struct variable *weight_var); +static void cleanup_freq_tab (struct var_freqs *); +static void add_percentile (struct frq_proc *, double x, bool show, + size_t *allocated_percentiles); +static void do_piechart(const struct frq_chart *, const struct variable *, + const struct freq_tab *); + +struct histogram *freq_tab_to_hist(const struct frq_proc *, + const struct freq_tab *, + const struct variable *); /* Parser and outline. */ -static int internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds); - int cmd_frequencies (struct lexer *lexer, struct dataset *ds) { - int result; - - syntax_pool = pool_create (); - result = internal_cmd_frequencies (lexer, ds); - pool_destroy (syntax_pool); - syntax_pool=0; - pool_destroy (data_pool); - data_pool=0; - free (v_variables); - v_variables=0; - return result; -} - -static int -internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds) -{ + struct cmd_frequencies cmd; + struct frq_proc frq; struct casegrouper *grouper; struct casereader *input, *group; + size_t allocated_percentiles; bool ok; int i; - n_percentiles = 0; - n_show_percentiles = 0; - percentiles = NULL; + frq.pool = pool_create (); + + frq.vars = NULL; + frq.n_vars = 0; + + frq.percentiles = NULL; + frq.n_percentiles = 0; + frq.n_show_percentiles = 0; - n_variables = 0; - v_variables = NULL; + frq.hist = NULL; + frq.pie = NULL; - if (!parse_frequencies (lexer, ds, &cmd, NULL)) - return CMD_FAILURE; + allocated_percentiles = 0; + + if (!parse_frequencies (lexer, ds, &cmd, &frq)) + { + pool_destroy (frq.pool); + return CMD_FAILURE; + } + + /* Figure out when to show frequency tables. */ + frq.max_categories = (cmd.table == FRQ_NOTABLE ? -1 + : cmd.table == FRQ_TABLE ? INT_MAX + : cmd.limit); + frq.sort = cmd.sort; /* Figure out statistics to calculate. */ - stats = 0; + frq.stats = 0; if (cmd.a_statistics[FRQ_ST_DEFAULT] || !cmd.sbc_statistics) - stats |= frq_default; + frq.stats |= FRQ_DEFAULT; if (cmd.a_statistics[FRQ_ST_ALL]) - stats |= frq_all; + frq.stats |= FRQ_ALL; if (cmd.sort != FRQ_AVALUE && cmd.sort != FRQ_DVALUE) - stats &= ~BIT_INDEX (frq_median); - for (i = 0; i < frq_n_stats; i++) + frq.stats &= ~BIT_INDEX (FRQ_MEDIAN); + for (i = 0; i < FRQ_N_STATS; i++) if (cmd.a_statistics[st_name[i].st_indx]) - stats |= BIT_INDEX (i); - if (stats & frq_kurt) - stats |= BIT_INDEX (frq_sekurt); - if (stats & frq_skew) - stats |= BIT_INDEX (frq_seskew); + frq.stats |= BIT_INDEX (i); + if (frq.stats & FRQ_KURT) + frq.stats |= BIT_INDEX (FRQ_SEKURT); + if (frq.stats & FRQ_SKEW) + frq.stats |= BIT_INDEX (FRQ_SESKEW); /* Calculate n_stats. */ - n_stats = 0; - for (i = 0; i < frq_n_stats; i++) - if ((stats & BIT_INDEX (i))) - n_stats++; + frq.n_stats = 0; + for (i = 0; i < FRQ_N_STATS; i++) + if ((frq.stats & BIT_INDEX (i))) + frq.n_stats++; /* Charting. */ - determine_charts (); + determine_charts (&frq, &cmd); if (cmd.sbc_histogram || cmd.sbc_piechart || cmd.sbc_ntiles) cmd.sort = FRQ_AVALUE; @@ -325,7 +318,8 @@ internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds) 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, true); + add_percentile (&frq, subc_list_double_at(ptl_list, pl) / 100.0, + true, &allocated_percentiles); } } if ( cmd.sbc_ntiles ) @@ -334,21 +328,22 @@ internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds) { int j; for (j = 0; j <= cmd.n_ntiles[i]; ++j ) - add_percentile (j / (double) cmd.n_ntiles[i], true); + add_percentile (&frq, j / (double) cmd.n_ntiles[i], true, + &allocated_percentiles); } } - if (stats & BIT_INDEX (frq_median)) + if (frq.stats & BIT_INDEX (FRQ_MEDIAN)) { /* Treat the median as the 50% percentile. We output it in the percentiles table as "50 (Median)." */ - add_percentile (0.5, true); - stats &= ~BIT_INDEX (frq_median); - n_stats--; + add_percentile (&frq, 0.5, true, &allocated_percentiles); + frq.stats &= ~BIT_INDEX (FRQ_MEDIAN); + frq.n_stats--; } if (cmd.sbc_histogram) { - add_percentile (0.25, false); - add_percentile (0.75, false); + add_percentile (&frq, 0.25, false, &allocated_percentiles); + add_percentile (&frq, 0.75, false, &allocated_percentiles); } /* Do it! */ @@ -360,101 +355,102 @@ internal_cmd_frequencies (struct lexer *lexer, struct dataset *ds) { struct ccase *c; - precalc (group, ds); + precalc (&frq, group, ds); for (; (c = casereader_read (group)) != NULL; case_unref (c)) - calc (c, ds); - postcalc (ds); + calc (&frq, c, ds); + postcalc (&frq, ds); } ok = casegrouper_destroy (grouper); ok = proc_commit (ds) && ok; free_frequencies(&cmd); + pool_destroy (frq.pool); + free (frq.vars); + free (frq.percentiles); + free (frq.hist); + free (frq.pie); + return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE; } /* Figure out which charts the user requested. */ static void -determine_charts (void) +determine_charts (struct frq_proc *frq, const struct cmd_frequencies *cmd) { - if (cmd.sbc_barchart) + if (cmd->sbc_barchart) msg (SW, _("Bar charts are not implemented.")); - if (cmd.sbc_histogram) + if (cmd->sbc_histogram) { - hist.x_min = cmd.hi_min; - hist.x_max = cmd.hi_max; - hist.y_scale = cmd.hi_scale; - hist.y_max = cmd.hi_scale == FRQ_FREQ ? cmd.hi_freq : cmd.hi_pcnt; - hist.draw_normal = cmd.hi_norm != FRQ_NONORMAL; - hist.include_missing = false; - - if (hist.x_min != SYSMIS && hist.x_max != SYSMIS - && hist.x_min >= hist.x_max) + struct frq_chart *hist; + + hist = frq->hist = xmalloc (sizeof *frq->hist); + hist->x_min = cmd->hi_min; + hist->x_max = cmd->hi_max; + hist->y_scale = cmd->hi_scale; + hist->y_max = cmd->hi_scale == FRQ_FREQ ? cmd->hi_freq : cmd->hi_pcnt; + hist->draw_normal = cmd->hi_norm != FRQ_NONORMAL; + hist->include_missing = false; + + if (hist->x_min != SYSMIS && hist->x_max != SYSMIS + && hist->x_min >= hist->x_max) { msg (SE, _("MAX for histogram must be greater than or equal to MIN, " "but MIN was specified as %.15g and MAX as %.15g. " - "MIN and MAX will be ignored."), hist.x_min, hist.x_max); - hist.x_min = hist.x_max = SYSMIS; + "MIN and MAX will be ignored."), + hist->x_min, hist->x_max); + hist->x_min = hist->x_max = SYSMIS; } } - if (cmd.sbc_piechart) + if (cmd->sbc_piechart) { - pie.x_min = cmd.pie_min; - pie.x_max = cmd.pie_max; - pie.y_scale = cmd.pie_scale; - pie.include_missing = cmd.pie_missing == FRQ_MISSING; + struct frq_chart *pie; - if (pie.x_min != SYSMIS && pie.x_max != SYSMIS - && pie.x_min >= pie.x_max) + pie = frq->pie = xmalloc (sizeof *frq->pie); + pie->x_min = cmd->pie_min; + pie->x_max = cmd->pie_max; + pie->y_scale = cmd->pie_scale; + pie->include_missing = cmd->pie_missing == FRQ_MISSING; + + if (pie->x_min != SYSMIS && pie->x_max != SYSMIS + && pie->x_min >= pie->x_max) { msg (SE, _("MAX for pie chart must be greater than or equal to MIN, " "but MIN was specified as %.15g and MAX as %.15g. " - "MIN and MAX will be ignored."), pie.x_min, pie.x_max); - pie.x_min = pie.x_max = SYSMIS; + "MIN and MAX will be ignored."), pie->x_min, pie->x_max); + pie->x_min = pie->x_max = SYSMIS; } } - } /* Add data from case C to the frequency table. */ static void -calc (const struct ccase *c, const struct dataset *ds) +calc (struct frq_proc *frq, const struct ccase *c, const struct dataset *ds) { double weight = dict_get_case_weight (dataset_dict (ds), c, NULL); size_t i; - for (i = 0; i < n_variables; i++) + for (i = 0; i < frq->n_vars; i++) { - const struct variable *v = v_variables[i]; - const union value *val = case_data (c, v); - struct var_freqs *vf = get_var_freqs (v); - struct freq_tab *ft = &vf->tab; - - struct freq_mutable target; - struct freq_mutable **fpp; + struct var_freqs *vf = &frq->vars[i]; + const union value *value = case_data (c, vf->var); + size_t hash = value_hash (value, vf->width, 0); + struct freq *f; - target.value = *val; - fpp = (struct freq_mutable **) hsh_probe (ft->data, &target); + f = freq_hmap_search (&vf->tab.data, value, vf->width, hash); + if (f == NULL) + f = freq_hmap_insert (&vf->tab.data, value, vf->width, hash); - if (*fpp != NULL) - (*fpp)->count += weight; - else - { - struct freq_mutable *fp = pool_alloc (data_pool, sizeof *fp); - fp->count = weight; - value_init_pool (data_pool, &fp->value, vf->width); - value_copy (&fp->value, val, vf->width); - *fpp = fp; - } + f->count += weight; } } /* Prepares each variable that is the target of FREQUENCIES by setting up its hash table. */ static void -precalc (struct casereader *input, struct dataset *ds) +precalc (struct frq_proc *frq, struct casereader *input, struct dataset *ds) { struct ccase *c; size_t i; @@ -466,141 +462,125 @@ precalc (struct casereader *input, struct dataset *ds) case_unref (c); } - pool_destroy (data_pool); - data_pool = pool_create (); - - for (i = 0; i < n_variables; i++) - { - const struct variable *v = v_variables[i]; - struct freq_tab *ft = &get_var_freqs (v)->tab; - - ft->data = hsh_create (16, compare_freq, hash_freq, NULL, v); - } + for (i = 0; i < frq->n_vars; i++) + hmap_init (&frq->vars[i].tab.data); } /* Finishes up with the variables after frequencies have been calculated. Displays statistics, percentiles, ... */ static void -postcalc (const struct dataset *ds) +postcalc (struct frq_proc *frq, const struct dataset *ds) { const struct dictionary *dict = dataset_dict (ds); const struct variable *wv = dict_get_weight (dict); size_t i; - for (i = 0; i < n_variables; i++) + for (i = 0; i < frq->n_vars; i++) { - const struct variable *v = v_variables[i]; - struct var_freqs *vf = get_var_freqs (v); - struct freq_tab *ft = &vf->tab; - int n_categories; + struct var_freqs *vf = &frq->vars[i]; - postprocess_freq_tab (v); + postprocess_freq_tab (frq, vf); /* Frequencies tables. */ - n_categories = ft->n_valid + ft->n_missing; - if (cmd.table == FRQ_TABLE - || (cmd.table == FRQ_LIMIT && n_categories <= cmd.limit)) - dump_freq_table (v, wv); + if (vf->tab.n_valid + vf->tab.n_missing <= frq->max_categories) + dump_freq_table (vf, wv); /* Statistics. */ - if (n_stats) - dump_statistics (v, wv); + if (frq->n_stats) + dump_statistics (frq, vf, wv); - if (cmd.sbc_histogram && var_is_numeric (v) && ft->n_valid > 0) + if (frq->hist && var_is_numeric (vf->var) && vf->tab.n_valid > 0) { - double d[frq_n_stats]; + double d[FRQ_N_STATS]; struct histogram *histogram; - calc_stats (v, d); + calc_stats (vf, d); - histogram = freq_tab_to_hist (ft, v); + histogram = freq_tab_to_hist (frq, &vf->tab, vf->var); chart_item_submit (histogram_chart_create ( - histogram->gsl_hist, var_to_string(v), + histogram->gsl_hist, var_to_string(vf->var), vf->tab.valid_cases, - d[frq_mean], - d[frq_stddev], - hist.draw_normal)); + d[FRQ_MEAN], + d[FRQ_STDDEV], + frq->hist->draw_normal)); statistic_destroy (&histogram->parent); } - if (cmd.sbc_piechart) - do_piechart(v_variables[i], ft); + if (frq->pie) + do_piechart(frq->pie, vf->var, &vf->tab); - cleanup_freq_tab (v); + cleanup_freq_tab (vf); } } -/* Returns the comparison function that should be used for - sorting a frequency table by FRQ_SORT using VAL_TYPE - values. */ -static hsh_compare_func * -get_freq_comparator (int frq_sort, enum val_type val_type) -{ - bool is_numeric = val_type == VAL_NUMERIC; - switch (frq_sort) - { - case FRQ_AVALUE: - return is_numeric ? compare_value_numeric_a : compare_value_alpha_a; - case FRQ_DVALUE: - return is_numeric ? compare_value_numeric_d : compare_value_alpha_d; - case FRQ_AFREQ: - return is_numeric ? compare_freq_numeric_a : compare_freq_alpha_a; - case FRQ_DFREQ: - return is_numeric ? compare_freq_numeric_d : compare_freq_alpha_d; - default: - NOT_REACHED (); - } -} - -/* Returns true iff the value in struct freq_mutable F is non-missing +/* Returns true iff the value in struct freq F is non-missing for variable V. */ static bool not_missing (const void *f_, const void *v_) { - const struct freq_mutable *f = f_; + const struct freq *f = f_; const struct variable *v = v_; return !var_is_value_missing (v, &f->value, MV_ANY); } +struct freq_compare_aux + { + bool by_freq; + bool ascending_freq; + + int width; + bool ascending_value; + }; + +static int +compare_freq (const void *a_, const void *b_, const void *aux_) +{ + const struct freq_compare_aux *aux = aux_; + const struct freq *a = a_; + const struct freq *b = b_; + + if (aux->by_freq && a->count != b->count) + { + int cmp = a->count > b->count ? 1 : -1; + return aux->ascending_freq ? cmp : -cmp; + } + else + { + int cmp = value_compare_3way (&a->value, &b->value, aux->width); + return aux->ascending_value ? cmp : -cmp; + } +} /* Summarizes the frequency table data for variable V. */ static void -postprocess_freq_tab (const struct variable *v) +postprocess_freq_tab (const struct frq_proc *frq, struct var_freqs *vf) { - hsh_compare_func *compare; - struct freq_tab *ft; + struct freq_tab *ft = &vf->tab; + struct freq_compare_aux aux; size_t count; - void *const *data; - struct freq_mutable *freqs, *f; + struct freq *freqs, *f; size_t i; - ft = &get_var_freqs (v)->tab; - compare = get_freq_comparator (cmd.sort, var_get_type (v)); - /* Extract data from hash table. */ - count = hsh_count (ft->data); - data = hsh_data (ft->data); - - /* Copy dereferenced data into freqs. */ - freqs = xnmalloc (count, sizeof *freqs); - for (i = 0; i < count; i++) - { - struct freq_mutable *f = data[i]; - freqs[i] = *f; - } + count = hmap_count (&ft->data); + freqs = freq_hmap_extract (&ft->data); /* Put data into ft. */ ft->valid = freqs; - ft->n_valid = partition (freqs, count, sizeof *freqs, not_missing, v); + ft->n_valid = partition (freqs, count, sizeof *freqs, not_missing, vf->var); ft->missing = freqs + ft->n_valid; ft->n_missing = count - ft->n_valid; /* Sort data. */ - sort (ft->valid, ft->n_valid, sizeof *ft->valid, compare, v); - sort (ft->missing, ft->n_missing, sizeof *ft->missing, compare, v); + aux.by_freq = frq->sort == FRQ_AFREQ || frq->sort == FRQ_DFREQ; + aux.ascending_freq = frq->sort != FRQ_DFREQ; + aux.width = vf->width; + aux.ascending_value = frq->sort != FRQ_DVALUE; + sort (ft->valid, ft->n_valid, sizeof *ft->valid, compare_freq, &aux); + sort (ft->missing, ft->n_missing, sizeof *ft->missing, compare_freq, &aux); /* Summary statistics. */ ft->valid_cases = 0.0; @@ -622,59 +602,69 @@ postprocess_freq_tab (const struct variable *v) /* Frees the frequency table for variable V. */ static void -cleanup_freq_tab (const struct variable *v) +cleanup_freq_tab (struct var_freqs *vf) { - struct freq_tab *ft = &get_var_freqs (v)->tab; - free (ft->valid); - hsh_destroy (ft->data); + free (vf->tab.valid); + freq_hmap_destroy (&vf->tab.data, vf->width); } -/* Parses the VARIABLES subcommand, adding to - {n_variables,v_variables}. */ +/* Parses the VARIABLES subcommand. */ static int -frq_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_frequencies *cmd UNUSED, void *aux UNUSED) +frq_custom_variables (struct lexer *lexer, struct dataset *ds, + struct cmd_frequencies *cmd UNUSED, void *frq_ UNUSED) { - size_t old_n_variables = n_variables; + struct frq_proc *frq = frq_; + struct variable **vars; + size_t n_vars; size_t i; - lex_match (lexer, '='); - if (lex_token (lexer) != T_ALL && (lex_token (lexer) != T_ID - || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)) + lex_match (lexer, T_EQUALS); + if (lex_token (lexer) != T_ALL + && (lex_token (lexer) != T_ID + || dict_lookup_var (dataset_dict (ds), lex_tokcstr (lexer)) == NULL)) return 2; - if (!parse_variables_const (lexer, dataset_dict (ds), &v_variables, &n_variables, - PV_APPEND | PV_NO_SCRATCH)) + /* Get list of current variables, to avoid duplicates. */ + vars = xmalloc (frq->n_vars * sizeof *vars); + n_vars = frq->n_vars; + for (i = 0; i < frq->n_vars; i++) + vars[i] = frq->vars[i].var; + + if (!parse_variables (lexer, dataset_dict (ds), &vars, &n_vars, + PV_APPEND | PV_NO_SCRATCH)) return 0; - for (i = old_n_variables; i < n_variables; i++) + frq->vars = xrealloc (frq->vars, n_vars * sizeof *frq->vars); + for (i = frq->n_vars; i < n_vars; i++) { - const struct variable *v = v_variables[i]; - struct var_freqs *vf; + struct variable *var = vars[i]; + struct var_freqs *vf = &frq->vars[i]; - if (var_get_aux (v) != NULL) - { - msg (SE, _("Variable %s specified multiple times on VARIABLES " - "subcommand."), var_get_name (v)); - return 0; - } - vf = var_attach_aux (v, xmalloc (sizeof *vf), var_dtor_free); + vf->var = var; vf->tab.valid = vf->tab.missing = NULL; vf->tab.dict = dataset_dict (ds); vf->n_groups = 0; vf->groups = NULL; - vf->width = var_get_width (v); - vf->print = *var_get_print_format (v); + vf->width = var_get_width (var); + vf->print = *var_get_print_format (var); } + frq->n_vars = n_vars; + + free (vars); + return 1; } /* Parses the GROUPED subcommand, setting the n_grouped, grouped fields of specified variables. */ static int -frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequencies *cmd UNUSED, void *aux UNUSED) +frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequencies *cmd UNUSED, void *frq_ UNUSED) { - lex_match (lexer, '='); - if ((lex_token (lexer) == T_ID && dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) != NULL) + struct frq_proc *frq = frq_; + + lex_match (lexer, T_EQUALS); + if ((lex_token (lexer) == T_ID + && dict_lookup_var (dataset_dict (ds), lex_tokcstr (lexer)) != NULL) || lex_token (lexer) == T_ID) for (;;) { @@ -691,7 +681,7 @@ frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequenc if (!parse_variables_const (lexer, dataset_dict (ds), &v, &n, PV_NO_DUPLICATE | PV_NUMERIC)) return 0; - if (lex_match (lexer, '(')) + if (lex_match (lexer, T_LPAREN)) { nl = ml = 0; dl = NULL; @@ -700,15 +690,15 @@ frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequenc if (nl >= ml) { ml += 16; - dl = pool_nrealloc (syntax_pool, dl, ml, sizeof *dl); + dl = pool_nrealloc (frq->pool, dl, ml, sizeof *dl); } dl[nl++] = lex_tokval (lexer); lex_get (lexer); - lex_match (lexer, ','); + lex_match (lexer, T_COMMA); } /* Note that nl might still be 0 and dl might still be NULL. That's okay. */ - if (!lex_match (lexer, ')')) + if (!lex_match (lexer, T_RPAREN)) { free (v); msg (SE, _("`)' expected after GROUPED interval list.")); @@ -722,31 +712,49 @@ frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequenc } for (i = 0; i < n; i++) - if (var_get_aux (v[i]) == NULL) + { + size_t j; + + for (j = 0; j < frq->n_vars; j++) + { + struct var_freqs *vf = &frq->vars[j]; + if (vf->var == v[i]) + { + if (vf->groups != NULL) + msg (SE, _("Variables %s specified multiple times on " + "GROUPED subcommand."), var_get_name (v[i])); + else + { + vf->n_groups = nl; + vf->groups = dl; + } + goto found; + } + } msg (SE, _("Variables %s specified on GROUPED but not on " "VARIABLES."), var_get_name (v[i])); - else - { - struct var_freqs *vf = get_var_freqs (v[i]); - - if (vf->groups != NULL) - msg (SE, _("Variables %s specified multiple times on GROUPED " - "subcommand."), var_get_name (v[i])); - else - { - vf->n_groups = nl; - vf->groups = dl; - } - } + + found:; + } + free (v); - if (!lex_match (lexer, '/')) - break; - if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) != NULL) - && lex_token (lexer) != T_ALL) - { - lex_put_back (lexer, '/'); - break; - } + if (lex_token (lexer) != T_SLASH) + break; + + if ((lex_next_token (lexer, 1) == T_ID + && dict_lookup_var (dataset_dict (ds), + lex_next_tokcstr (lexer, 1))) + || lex_next_token (lexer, 1) == T_ALL) + { + /* The token after the slash is a variable name. Keep parsing. */ + lex_get (lexer); + } + else + { + /* The token after the slash must be the start of a new + subcommand. Let the caller see the slash. */ + break; + } } return 1; @@ -756,172 +764,55 @@ frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequenc order. If SHOW is true, the percentile will be shown in the statistics box, otherwise it will be hidden. */ static void -add_percentile (double x, bool show) +add_percentile (struct frq_proc *frq, double x, bool show, + size_t *allocated_percentiles) { int i; - for (i = 0; i < n_percentiles; i++) + /* Do nothing if it's already in the list */ + for (i = 0; i < frq->n_percentiles; i++) { - /* Do nothing if it's already in the list */ - if ( fabs(x - percentiles[i].p) < DBL_EPSILON ) + struct percentile *pc = &frq->percentiles[i]; + + if ( fabs(x - pc->p) < DBL_EPSILON ) { - if (show && !percentiles[i].show) + if (show && !pc->show) { - n_show_percentiles++; - percentiles[i].show = true; + frq->n_show_percentiles++; + pc->show = true; } return; } - if (x < percentiles[i].p) + if (x < pc->p) break; } - if (i >= n_percentiles || x != percentiles[i].p) - { - percentiles = pool_nrealloc (syntax_pool, percentiles, - n_percentiles + 1, sizeof *percentiles); - insert_element (percentiles, n_percentiles, sizeof *percentiles, i); - percentiles[i].p = x; - percentiles[i].show = show; - n_percentiles++; - if (show) - n_show_percentiles++; - } + if (frq->n_percentiles >= *allocated_percentiles) + frq->percentiles = x2nrealloc (frq->percentiles, allocated_percentiles, + sizeof *frq->percentiles); + insert_element (frq->percentiles, frq->n_percentiles, + sizeof *frq->percentiles, i); + frq->percentiles[i].p = x; + frq->percentiles[i].show = show; + frq->n_percentiles++; + if (show) + frq->n_show_percentiles++; } /* Comparison functions. */ -/* Ascending numeric compare of values. */ -static int -compare_value_numeric_a (const void *a_, const void *b_, const void *aux UNUSED) -{ - const struct freq_mutable *a = a_; - const struct freq_mutable *b = b_; - - if (a->value.f > b->value.f) - return 1; - else if (a->value.f < b->value.f) - return -1; - else - return 0; -} - -/* Ascending string compare of values. */ -static int -compare_value_alpha_a (const void *a_, const void *b_, const void *v_) -{ - const struct freq_mutable *a = a_; - const struct freq_mutable *b = b_; - const struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); - - return value_compare_3way (&a->value, &b->value, vf->width); -} - -/* Descending numeric compare of values. */ -static int -compare_value_numeric_d (const void *a, const void *b, const void *aux UNUSED) -{ - return -compare_value_numeric_a (a, b, aux); -} - -/* Descending string compare of values. */ -static int -compare_value_alpha_d (const void *a, const void *b, const void *v) -{ - return -compare_value_alpha_a (a, b, v); -} - -/* Ascending numeric compare of frequency; - secondary key on ascending numeric value. */ -static int -compare_freq_numeric_a (const void *a_, const void *b_, const void *aux UNUSED) -{ - const struct freq_mutable *a = a_; - const struct freq_mutable *b = b_; - - if (a->count > b->count) - return 1; - else if (a->count < b->count) - return -1; - - if (a->value.f > b->value.f) - return 1; - else if (a->value.f < b->value.f) - return -1; - else - return 0; -} - -/* Ascending numeric compare of frequency; - secondary key on ascending string value. */ -static int -compare_freq_alpha_a (const void *a_, const void *b_, const void *v_) -{ - const struct freq_mutable *a = a_; - const struct freq_mutable *b = b_; - const struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); - - if (a->count > b->count) - return 1; - else if (a->count < b->count) - return -1; - else - return value_compare_3way (&a->value, &b->value, vf->width); -} - -/* Descending numeric compare of frequency; - secondary key on ascending numeric value. */ -static int -compare_freq_numeric_d (const void *a_, const void *b_, const void *aux UNUSED) -{ - const struct freq_mutable *a = a_; - const struct freq_mutable *b = b_; - - if (a->count > b->count) - return -1; - else if (a->count < b->count) - return 1; - - if (a->value.f > b->value.f) - return 1; - else if (a->value.f < b->value.f) - return -1; - else - return 0; -} - -/* Descending numeric compare of frequency; - secondary key on ascending string value. */ -static int -compare_freq_alpha_d (const void *a_, const void *b_, const void *v_) -{ - const struct freq_mutable *a = a_; - const struct freq_mutable *b = b_; - const struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); - - if (a->count > b->count) - return -1; - else if (a->count < b->count) - return 1; - else - return value_compare_3way (&a->value, &b->value, vf->width); -} /* Frequency table display. */ /* Displays a full frequency table for variable V. */ static void -dump_freq_table (const struct variable *v, const struct variable *wv) +dump_freq_table (const struct var_freqs *vf, const struct variable *wv) { const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0; + const struct freq_tab *ft = &vf->tab; int n_categories; - struct var_freqs *vf; - struct freq_tab *ft; - struct freq_mutable *f; + struct freq *f; struct tab_table *t; int r, x; double cum_total = 0.0; @@ -936,8 +827,6 @@ dump_freq_table (const struct variable *v, const struct variable *wv) N_("Cum Percent") }; - vf = get_var_freqs (v); - ft = &vf->tab; n_categories = ft->n_valid + ft->n_missing; t = tab_create (6, n_categories + 2); tab_headers (t, 0, 0, 1, 0); @@ -957,7 +846,7 @@ dump_freq_table (const struct variable *v, const struct variable *wv) valid_percent = f->count / ft->valid_cases * 100.0; cum_total += valid_percent; - label = var_lookup_value_label (v, &f->value); + label = var_lookup_value_label (vf->var, &f->value); if (label != NULL) tab_text (t, 0, r, TAB_LEFT, label); @@ -974,7 +863,7 @@ dump_freq_table (const struct variable *v, const struct variable *wv) cum_freq += f->count; - label = var_lookup_value_label (v, &f->value); + label = var_lookup_value_label (vf->var, &f->value); if (label != NULL) tab_text (t, 0, r, TAB_LEFT, label); @@ -995,113 +884,79 @@ dump_freq_table (const struct variable *v, const struct variable *wv) tab_fixed (t, 3, r, TAB_NONE, 100.0, 5, 1); tab_fixed (t, 4, r, TAB_NONE, 100.0, 5, 1); - tab_title (t, "%s", var_to_string (v)); + tab_title (t, "%s", var_to_string (vf->var)); tab_submit (t); } /* Statistical display. */ -/* Calculates all the pertinent statistics for variable V, putting them in - array D[]. */ +static double +calc_percentile (double p, double valid_cases, double x1, double x2) +{ + double s, dummy; + + s = (settings_get_algorithm () != COMPATIBLE + ? modf ((valid_cases - 1) * p, &dummy) + : modf ((valid_cases + 1) * p - 1, &dummy)); + + return x1 + (x2 - x1) * s; +} + +/* Calculates all of the percentiles for VF within FRQ. */ static void -calc_stats (const struct variable *v, double d[frq_n_stats]) +calc_percentiles (const struct frq_proc *frq, const struct var_freqs *vf) { - struct freq_tab *ft = &get_var_freqs (v)->tab; + const struct freq_tab *ft = &vf->tab; double W = ft->valid_cases; - struct moments *m; - struct freq_mutable *f=0; - int most_often; - double X_mode; - + const struct freq *f; + int percentile_idx; double rank; - int i = 0; - int idx; - - /* Calculate percentiles. */ assert (ft->n_valid > 0); - for (i = 0; i < n_percentiles; i++) - { - percentiles[i].flag = 0; - percentiles[i].flag2 = 0; - } - rank = 0; - for (idx = 0; idx < ft->n_valid; ++idx) + percentile_idx = 0; + for (f = ft->valid; f < ft->missing; f++) { - static double prev_value = SYSMIS; - f = &ft->valid[idx]; - rank += f->count ; - for (i = 0; i < n_percentiles; i++) + rank += f->count; + for (; percentile_idx < frq->n_percentiles; percentile_idx++) { - double tp; - if ( percentiles[i].flag2 ) continue ; - - if ( settings_get_algorithm () != COMPATIBLE ) - tp = - (ft->valid_cases - 1) * percentiles[i].p; - else - tp = - (ft->valid_cases + 1) * percentiles[i].p - 1; - - if ( percentiles[i].flag ) - { - percentiles[i].x2 = f->value.f; - percentiles[i].x1 = prev_value; - percentiles[i].flag2 = 1; - continue; - } - - if (rank > tp ) - { - if ( f->count > 1 && rank - (f->count - 1) > tp ) - { - percentiles[i].x2 = percentiles[i].x1 = f->value.f; - percentiles[i].flag2 = 1; - } - else - { - percentiles[i].flag=1; - } + struct percentile *pc = &frq->percentiles[percentile_idx]; + double tp; - continue; - } + tp = (settings_get_algorithm () == ENHANCED + ? (W - 1) * pc->p + : (W + 1) * pc->p - 1); + + if (rank <= tp) + break; + + if (tp + 1 < rank || f + 1 >= ft->missing) + pc->value = f->value.f; + else + pc->value = calc_percentile (pc->p, W, f->value.f, f[1].value.f); } - prev_value = f->value.f; } - - for (i = 0; i < n_percentiles; i++) + for (; percentile_idx < frq->n_percentiles; percentile_idx++) { - /* Catches the case when p == 100% */ - if ( ! percentiles[i].flag2 ) - percentiles[i].x1 = percentiles[i].x2 = f->value.f; - - /* - printf("percentile %d (p==%.2f); X1 = %g; X2 = %g\n", - i,percentiles[i].p,percentiles[i].x1,percentiles[i].x2); - */ + struct percentile *pc = &frq->percentiles[percentile_idx]; + pc->value = ft->valid[ft->n_valid - 1].value.f; } +} - for (i = 0; i < n_percentiles; i++) - { - struct freq_tab *ft = &get_var_freqs (v)->tab; - double s; - - double dummy; - if ( settings_get_algorithm () != COMPATIBLE ) - { - s = modf((ft->valid_cases - 1) * percentiles[i].p , &dummy); - } - else - { - s = modf((ft->valid_cases + 1) * percentiles[i].p -1, &dummy); - } - - percentiles[i].value = percentiles[i].x1 + - ( percentiles[i].x2 - percentiles[i].x1) * s ; - } +/* Calculates all the pertinent statistics for VF, putting them in array + D[]. */ +static void +calc_stats (const struct var_freqs *vf, double d[FRQ_N_STATS]) +{ + const struct freq_tab *ft = &vf->tab; + double W = ft->valid_cases; + const struct freq *f; + struct moments *m; + int most_often; + double X_mode; + assert (ft->n_valid > 0); /* Calculate the mode. */ most_often = -1; @@ -1127,44 +982,46 @@ calc_stats (const struct variable *v, double d[frq_n_stats]) moments_pass_one (m, f->value.f, f->count); for (f = ft->valid; f < ft->missing; f++) moments_pass_two (m, f->value.f, f->count); - moments_calculate (m, NULL, &d[frq_mean], &d[frq_variance], - &d[frq_skew], &d[frq_kurt]); + 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] = ft->valid[0].value.f; - d[frq_max] = ft->valid[ft->n_valid - 1].value.f; - d[frq_mode] = X_mode; - d[frq_range] = d[frq_max] - d[frq_min]; - d[frq_sum] = d[frq_mean] * W; - d[frq_stddev] = sqrt (d[frq_variance]); - d[frq_semean] = d[frq_stddev] / sqrt (W); - d[frq_seskew] = calc_seskew (W); - d[frq_sekurt] = calc_sekurt (W); + d[FRQ_MIN] = ft->valid[0].value.f; + d[FRQ_MAX] = ft->valid[ft->n_valid - 1].value.f; + d[FRQ_MODE] = X_mode; + d[FRQ_RANGE] = d[FRQ_MAX] - d[FRQ_MIN]; + d[FRQ_SUM] = d[FRQ_MEAN] * W; + d[FRQ_STDDEV] = sqrt (d[FRQ_VARIANCE]); + d[FRQ_SEMEAN] = d[FRQ_STDDEV] / sqrt (W); + d[FRQ_SESKEW] = calc_seskew (W); + d[FRQ_SEKURT] = calc_sekurt (W); } /* Displays a table of all the statistics requested for variable V. */ static void -dump_statistics (const struct variable *v, const struct variable *wv) +dump_statistics (const struct frq_proc *frq, const struct var_freqs *vf, + const struct variable *wv) { const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0; - struct freq_tab *ft; - double stat_value[frq_n_stats]; + const struct freq_tab *ft = &vf->tab; + double stat_value[FRQ_N_STATS]; struct tab_table *t; int i, r; - if (var_is_alpha (v)) + if (var_is_alpha (vf->var)) return; - ft = &get_var_freqs (v)->tab; + if (ft->n_valid == 0) { msg (SW, _("No valid data for variable %s; statistics not displayed."), - var_get_name (v)); + var_get_name (vf->var)); return; } - calc_stats (v, stat_value); + calc_stats (vf, stat_value); + calc_percentiles (frq, vf); - t = tab_create (3, n_stats + n_show_percentiles + 2); + t = tab_create (3, frq->n_stats + frq->n_show_percentiles + 2); tab_box (t, TAL_1, TAL_1, -1, -1 , 0 , 0 , 2, tab_nr(t) - 1) ; @@ -1174,8 +1031,8 @@ dump_statistics (const struct variable *v, const struct variable *wv) r=2; /* N missing and N valid are always dumped */ - for (i = 0; i < frq_n_stats; i++) - if (stats & BIT_INDEX (i)) + for (i = 0; i < FRQ_N_STATS; i++) + if (frq->stats & BIT_INDEX (i)) { tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, gettext (st_name[i].s10)); @@ -1190,9 +1047,11 @@ dump_statistics (const struct variable *v, const struct variable *wv) tab_double (t, 2, 0, TAB_NONE, ft->valid_cases, wfmt); tab_double (t, 2, 1, TAB_NONE, ft->total_cases - ft->valid_cases, wfmt); - for (i = 0; i < n_percentiles; i++, r++) + for (i = 0; i < frq->n_percentiles; i++, r++) { - if (!percentiles[i].show) + struct percentile *pc = &frq->percentiles[i]; + + if (!pc->show) continue; if ( i == 0 ) @@ -1200,32 +1059,34 @@ dump_statistics (const struct variable *v, const struct variable *wv) tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Percentiles")); } - if (percentiles[i].p == 0.5) + if (pc->p == 0.5) tab_text (t, 1, r, TAB_LEFT, _("50 (Median)")); else - tab_fixed (t, 1, r, TAB_LEFT, percentiles[i].p * 100, 3, 0); - tab_double (t, 2, r, TAB_NONE, percentiles[i].value, - var_get_print_format (v)); + tab_fixed (t, 1, r, TAB_LEFT, pc->p * 100, 3, 0); + tab_double (t, 2, r, TAB_NONE, pc->value, + var_get_print_format (vf->var)); } - tab_title (t, "%s", var_to_string (v)); + tab_title (t, "%s", var_to_string (vf->var)); tab_submit (t); } static double -calculate_iqr (void) +calculate_iqr (const struct frq_proc *frq) { double q1 = SYSMIS; double q3 = SYSMIS; int i; - for (i = 0; i < n_percentiles; i++) + for (i = 0; i < frq->n_percentiles; i++) { - if (fabs (0.25 - percentiles[i].p) < DBL_EPSILON) - q1 = percentiles[i].value; - else if (fabs (0.75 - percentiles[i].p) < DBL_EPSILON) - q3 = percentiles[i].value; + struct percentile *pc = &frq->percentiles[i]; + + if (fabs (0.25 - pc->p) < DBL_EPSILON) + q1 = pc->value; + else if (fabs (0.75 - pc->p) < DBL_EPSILON) + q3 = pc->value; } return q1 == SYSMIS || q3 == SYSMIS ? SYSMIS : q3 - q1; @@ -1249,7 +1110,8 @@ chart_includes_value (const struct frq_chart *chart, /* Create a gsl_histogram from a freq_tab */ struct histogram * -freq_tab_to_hist (const struct freq_tab *ft, const struct variable *var) +freq_tab_to_hist (const struct frq_proc *frq, const struct freq_tab *ft, + const struct variable *var) { double x_min, x_max, valid_freq; int i; @@ -1265,17 +1127,17 @@ freq_tab_to_hist (const struct freq_tab *ft, const struct variable *var) valid_freq = 0; for (i = 0; i < ft->n_valid; i++) { - const struct freq_mutable *frq = &ft->valid[i]; - if (chart_includes_value (&hist, var, &frq->value)) + const struct freq *f = &ft->valid[i]; + if (chart_includes_value (frq->hist, var, &f->value)) { - x_min = MIN (x_min, frq->value.f); - x_max = MAX (x_max, frq->value.f); - valid_freq += frq->count; + x_min = MIN (x_min, f->value.f); + x_max = MAX (x_max, f->value.f); + valid_freq += f->count; } } /* Freedman-Diaconis' choice of bin width. */ - iqr = calculate_iqr (); + iqr = calculate_iqr (frq); if (iqr != SYSMIS) { double bin_width = 2 * iqr / pow (valid_freq, 1.0 / 3.0); @@ -1291,19 +1153,19 @@ freq_tab_to_hist (const struct freq_tab *ft, const struct variable *var) histogram = histogram_create (bins, x_min, x_max); for (i = 0; i < ft->n_valid; i++) { - const struct freq_mutable *frq = &ft->valid[i]; - if (chart_includes_value (&hist, var, &frq->value)) - histogram_add (histogram, frq->value.f, frq->count); + const struct freq *f = &ft->valid[i]; + if (chart_includes_value (frq->hist, var, &f->value)) + histogram_add (histogram, f->value.f, f->count); } return histogram; } static int -add_slice (const struct freq_mutable *freq, const struct variable *var, - struct slice *slice) +add_slice (const struct frq_chart *pie, const struct freq *freq, + const struct variable *var, struct slice *slice) { - if (chart_includes_value (&pie, var, &freq->value)) + if (chart_includes_value (pie, var, &freq->value)) { ds_init_empty (&slice->label); var_append_value_name (var, &freq->value, &slice->label); @@ -1319,7 +1181,8 @@ add_slice (const struct freq_mutable *freq, const struct variable *var, The caller is responsible for freeing slices */ static struct slice * -freq_tab_to_slice_array(const struct freq_tab *frq_tab, +freq_tab_to_slice_array(const struct frq_chart *pie, + const struct freq_tab *frq_tab, const struct variable *var, int *n_slicesp) { @@ -1331,9 +1194,9 @@ freq_tab_to_slice_array(const struct freq_tab *frq_tab, n_slices = 0; for (i = 0; i < frq_tab->n_valid; i++) - n_slices += add_slice (&frq_tab->valid[i], var, &slices[n_slices]); + n_slices += add_slice (pie, &frq_tab->valid[i], var, &slices[n_slices]); for (i = 0; i < frq_tab->n_missing; i++) - n_slices += add_slice (&frq_tab->missing[i], var, &slices[n_slices]); + n_slices += add_slice (pie, &frq_tab->missing[i], var, &slices[n_slices]); *n_slicesp = n_slices; return slices; @@ -1343,12 +1206,13 @@ freq_tab_to_slice_array(const struct freq_tab *frq_tab, static void -do_piechart(const struct variable *var, const struct freq_tab *frq_tab) +do_piechart(const struct frq_chart *pie, const struct variable *var, + const struct freq_tab *frq_tab) { struct slice *slices; int n_slices, i; - slices = freq_tab_to_slice_array (frq_tab, var, &n_slices); + slices = freq_tab_to_slice_array (pie, frq_tab, var, &n_slices); if (n_slices < 2) msg (SW, _("Omitting pie chart for %s, which has only %d unique values."),