X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Ffrequencies.q;h=ba7dd57feb35a13c56b3d3920e9ada048e4dbb0f;hb=74242052a357f0285b5ae7d02a3bef4cd2017c7d;hp=ef36f139d59b971403ad9d43557df81db145c5e0;hpb=3c9825c825998664d992841d851e23a0adf8af6e;p=pspp diff --git a/src/language/stats/frequencies.q b/src/language/stats/frequencies.q index ef36f139d5..ba7dd57feb 100644 --- a/src/language/stats/frequencies.q +++ b/src/language/stats/frequencies.q @@ -87,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. */ @@ -100,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")}, @@ -132,26 +132,16 @@ struct percentile 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 { @@ -167,20 +157,6 @@ 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. */ @@ -202,6 +178,8 @@ struct freq_tab /* Per-variable frequency data. */ struct var_freqs { + struct variable *var; + /* Freqency table. */ struct freq_tab tab; /* Frequencies table to use. */ @@ -210,108 +188,133 @@ 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; + + struct var_freqs *vars; + size_t n_vars; + + /* Percentiles to calculate and possibly display. */ + struct percentile *percentiles; + int n_percentiles, n_show_percentiles; + + /* Frequency table display. */ + int max_categories; /* Maximum categories to show. */ + int sort; /* FRQ_AVALUE or FRQ_DVALUE + or FRQ_ACOUNT or FRQ_DCOUNT. */ + + /* Statistics; number of statistics. */ + unsigned long stats; + int n_stats; + + /* Histogram and pie chart settings. */ + struct frq_chart *hist, *pie; + }; -static void determine_charts (void); +static void determine_charts (struct frq_proc *, + const struct cmd_frequencies *); -static void calc_stats (const struct variable *v, double d[frq_n_stats]); +static void calc_stats (const struct frq_proc *, const struct var_freqs *, + double d[FRQ_N_STATS]); -static void precalc (struct casereader *, struct dataset *); -static void calc (const struct ccase *, const struct dataset *); -static void postcalc (const struct dataset *); +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 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 *); +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 algo_compare_func compare_value_numeric_a, compare_value_alpha_a; static algo_compare_func compare_value_numeric_d, compare_value_alpha_d; static algo_compare_func compare_freq_numeric_a, compare_freq_alpha_a; static algo_compare_func compare_freq_numeric_d, compare_freq_alpha_d; +static void add_percentile (struct frq_proc *, double x, bool show, + size_t *allocated_percentiles); -static void do_piechart(const struct variable *var, - const struct freq_tab *frq_tab); - -struct histogram * -freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var); - +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; - n_variables = 0; - v_variables = NULL; + frq.percentiles = NULL; + frq.n_percentiles = 0; + frq.n_show_percentiles = 0; - if (!parse_frequencies (lexer, ds, &cmd, NULL)) - return CMD_FAILURE; + frq.hist = NULL; + frq.pie = NULL; + + 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; @@ -323,7 +326,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 ) @@ -332,21 +336,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! */ @@ -358,85 +363,93 @@ 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; + + 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) + 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 *var = v_variables[i]; - int width = var_get_width (var); - - const union value *value = case_data (c, var); - size_t hash = value_hash (value, width, 0); - - struct hmap *hmap = &get_var_freqs (var)->tab.data; + 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; - f = freq_hmap_search (hmap, value, width, hash); + f = freq_hmap_search (&vf->tab.data, value, vf->width, hash); if (f == NULL) - f = freq_hmap_insert (hmap, value, width, hash); + f = freq_hmap_insert (&vf->tab.data, value, vf->width, hash); f->count += weight; } @@ -445,7 +458,7 @@ calc (const struct ccase *c, const struct dataset *ds) /* 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; @@ -457,69 +470,56 @@ 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; - - hmap_init (&ft->data); - } + 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 (frq, 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); } } @@ -559,30 +559,28 @@ not_missing (const void *f_, const void *v_) /* 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) { + struct freq_tab *ft = &vf->tab; algo_compare_func *compare; - struct freq_tab *ft; size_t count; 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 = 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); + compare = get_freq_comparator (frq->sort, var_get_type (vf->var)); + sort (ft->valid, ft->n_valid, sizeof *ft->valid, compare, vf); + sort (ft->missing, ft->n_missing, sizeof *ft->missing, compare, vf); /* Summary statistics. */ ft->valid_cases = 0.0; @@ -604,57 +602,66 @@ 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 var_freqs *vf = get_var_freqs (v); 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)) + if (lex_token (lexer) != T_ALL + && (lex_token (lexer) != T_ID + || dict_lookup_var (dataset_dict (ds), lex_tokid (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) { + struct frq_proc *frq = frq_; + lex_match (lexer, '='); if ((lex_token (lexer) == T_ID && dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) != NULL) || lex_token (lexer) == T_ID) @@ -682,7 +689,7 @@ 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); @@ -704,22 +711,31 @@ 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; @@ -738,45 +754,48 @@ 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) +compare_value_numeric_a (const void *a_, const void *b_, + const void *vf_ UNUSED) { const struct freq *a = a_; const struct freq *b = b_; @@ -791,34 +810,33 @@ compare_value_numeric_a (const void *a_, const void *b_, const void *aux UNUSED) /* Ascending string compare of values. */ static int -compare_value_alpha_a (const void *a_, const void *b_, const void *v_) +compare_value_alpha_a (const void *a_, const void *b_, const void *vf_) { const struct freq *a = a_; const struct freq *b = b_; - const struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); + const struct var_freqs *vf = vf_; 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) +compare_value_numeric_d (const void *a, const void *b, const void *vf_ UNUSED) { - return -compare_value_numeric_a (a, b, aux); + return -compare_value_numeric_a (a, b, vf_); } /* Descending string compare of values. */ static int -compare_value_alpha_d (const void *a, const void *b, const void *v) +compare_value_alpha_d (const void *a, const void *b, const void *vf_) { - return -compare_value_alpha_a (a, b, v); + return -compare_value_alpha_a (a, b, vf_); } /* 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) +compare_freq_numeric_a (const void *a_, const void *b_, const void *vf_ UNUSED) { const struct freq *a = a_; const struct freq *b = b_; @@ -839,12 +857,11 @@ compare_freq_numeric_a (const void *a_, const void *b_, const void *aux UNUSED) /* 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_) +compare_freq_alpha_a (const void *a_, const void *b_, const void *vf_) { const struct freq *a = a_; const struct freq *b = b_; - const struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); + const struct var_freqs *vf = vf_; if (a->count > b->count) return 1; @@ -857,7 +874,7 @@ compare_freq_alpha_a (const void *a_, const void *b_, const void *v_) /* 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) +compare_freq_numeric_d (const void *a_, const void *b_, const void *vf_ UNUSED) { const struct freq *a = a_; const struct freq *b = b_; @@ -878,12 +895,11 @@ compare_freq_numeric_d (const void *a_, const void *b_, const void *aux UNUSED) /* 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_) +compare_freq_alpha_d (const void *a_, const void *b_, const void *vf_) { const struct freq *a = a_; const struct freq *b = b_; - const struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); + const struct var_freqs *vf = vf_; if (a->count > b->count) return -1; @@ -897,12 +913,11 @@ compare_freq_alpha_d (const void *a_, const void *b_, const void *v_) /* 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 *f; struct tab_table *t; int r, x; @@ -918,8 +933,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); @@ -939,7 +952,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); @@ -956,7 +969,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); @@ -977,7 +990,7 @@ 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); } @@ -986,12 +999,14 @@ dump_freq_table (const struct variable *v, const struct variable *wv) /* Calculates all the pertinent statistics for variable V, putting them in array D[]. */ static void -calc_stats (const struct variable *v, double d[frq_n_stats]) +calc_stats (const struct frq_proc *frq, + const struct var_freqs *vf, double d[FRQ_N_STATS]) { - 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 *f=0; + double prev_value; int most_often; double X_mode; @@ -1003,35 +1018,39 @@ calc_stats (const struct variable *v, double d[frq_n_stats]) assert (ft->n_valid > 0); - for (i = 0; i < n_percentiles; i++) + for (i = 0; i < frq->n_percentiles; i++) { - percentiles[i].flag = 0; - percentiles[i].flag2 = 0; + struct percentile *pc = &frq->percentiles[i]; + + pc->flag = 0; + pc->flag2 = 0; } rank = 0; + prev_value = SYSMIS; for (idx = 0; idx < ft->n_valid; ++idx) { - static double prev_value = SYSMIS; f = &ft->valid[idx]; rank += f->count ; - for (i = 0; i < n_percentiles; i++) + for (i = 0; i < frq->n_percentiles; i++) { + struct percentile *pc = &frq->percentiles[i]; double tp; - if ( percentiles[i].flag2 ) continue ; + + if ( pc->flag2 ) continue ; if ( settings_get_algorithm () != COMPATIBLE ) tp = - (ft->valid_cases - 1) * percentiles[i].p; + (ft->valid_cases - 1) * pc->p; else tp = - (ft->valid_cases + 1) * percentiles[i].p - 1; + (ft->valid_cases + 1) * pc->p - 1; - if ( percentiles[i].flag ) + if ( pc->flag ) { - percentiles[i].x2 = f->value.f; - percentiles[i].x1 = prev_value; - percentiles[i].flag2 = 1; + pc->x2 = f->value.f; + pc->x1 = prev_value; + pc->flag2 = 1; continue; } @@ -1039,12 +1058,12 @@ calc_stats (const struct variable *v, double d[frq_n_stats]) { if ( f->count > 1 && rank - (f->count - 1) > tp ) { - percentiles[i].x2 = percentiles[i].x1 = f->value.f; - percentiles[i].flag2 = 1; + pc->x2 = pc->x1 = f->value.f; + pc->flag2 = 1; } else { - percentiles[i].flag=1; + pc->flag=1; } continue; @@ -1053,35 +1072,36 @@ calc_stats (const struct variable *v, double d[frq_n_stats]) prev_value = f->value.f; } - for (i = 0; i < n_percentiles; i++) + for (i = 0; i < frq->n_percentiles; i++) { + struct percentile *pc = &frq->percentiles[i]; + /* Catches the case when p == 100% */ - if ( ! percentiles[i].flag2 ) - percentiles[i].x1 = percentiles[i].x2 = f->value.f; + if ( ! pc->flag2 ) + pc->x1 = pc->x2 = f->value.f; /* printf("percentile %d (p==%.2f); X1 = %g; X2 = %g\n", - i,percentiles[i].p,percentiles[i].x1,percentiles[i].x2); + i,pc->p,pc->x1,pc->x2); */ } - for (i = 0; i < n_percentiles; i++) + for (i = 0; i < frq->n_percentiles; i++) { - struct freq_tab *ft = &get_var_freqs (v)->tab; + struct percentile *pc = &frq->percentiles[i]; double s; double dummy; if ( settings_get_algorithm () != COMPATIBLE ) { - s = modf((ft->valid_cases - 1) * percentiles[i].p , &dummy); + s = modf((ft->valid_cases - 1) * pc->p , &dummy); } else { - s = modf((ft->valid_cases + 1) * percentiles[i].p -1, &dummy); + s = modf((ft->valid_cases + 1) * pc->p -1, &dummy); } - percentiles[i].value = percentiles[i].x1 + - ( percentiles[i].x2 - percentiles[i].x1) * s ; + pc->value = pc->x1 + (pc->x2 - pc->x1) * s ; } @@ -1109,44 +1129,45 @@ 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 (frq, vf, stat_value); - 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) ; @@ -1156,8 +1177,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)); @@ -1172,9 +1193,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 ) @@ -1182,32 +1205,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; @@ -1231,7 +1256,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; @@ -1247,17 +1273,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 *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); @@ -1273,19 +1299,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 *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 *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); @@ -1301,7 +1327,8 @@ add_slice (const struct freq *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) { @@ -1313,9 +1340,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; @@ -1325,12 +1352,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."),