X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Ffrequencies.q;h=adc4f16b359876ff350f2c5b36c2ecdaa37a6ee6;hb=26ff6fce95fb38f0986017dd922c36d4b1b239c7;hp=827f02af33342e8e29d2803b1526fc698636f823;hpb=6fb2b277fd19b32f58cce5fde996208706fc9828;p=pspp-builds.git diff --git a/src/language/stats/frequencies.q b/src/language/stats/frequencies.q index 827f02af..adc4f16b 100644 --- a/src/language/stats/frequencies.q +++ b/src/language/stats/frequencies.q @@ -1,27 +1,18 @@ -/* PSPP - computes sample statistics. - Copyright (C) 1997-9, 2000 Free Software Foundation, Inc. - Written by Ben Pfaff . +/* PSPP - a program for statistical analysis. + 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 the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. + 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 + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. 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., 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301, USA. */ - -/* - TODO: - - * Remember that histograms, bar charts need mean, stddev. -*/ + along with this program. If not, see . */ #include @@ -29,36 +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 -#include - -#include "minmax.h" +#include "data/case.h" +#include "data/casegrouper.h" +#include "data/casereader.h" +#include "data/dictionary.h" +#include "data/format.h" +#include "data/procedure.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) @@ -68,36 +59,27 @@ /* (specification) FREQUENCIES (frq_): - *variables=custom; - format=cond:condense/onepage(*n:onepage_limit,"%s>=0")/!standard, - table:limit(n:limit,"%s>0")/notable/!table, - labels:!labels/nolabels, - sort:!avalue/dvalue/afreq/dfreq, - spaces:!single/double, - paging:newpage/!oldpage; + *+variables=custom; + +format=table:limit(n:limit,"%s>0")/notable/!table, + sort:!avalue/dvalue/afreq/dfreq; missing=miss:include/!exclude; barchart(ba_)=:minimum(d:min), :maximum(d:max), scale:freq(*n:freq,"%s>0")/percent(*n:pcnt,"%s>0"); piechart(pie_)=:minimum(d:min), :maximum(d:max), - missing:missing/!nomissing; + missing:missing/!nomissing, + scale:!freq/percent; histogram(hi_)=:minimum(d:min), :maximum(d:max), scale:freq(*n:freq,"%s>0")/percent(*n:pcnt,"%s>0"), - norm:!nonormal/normal, - incr:increment(d:inc,"%s>0"); - hbar(hb_)=:minimum(d:min), - :maximum(d:max), - scale:freq(*n:freq,"%s>0")/percent(*n:pcnt,"%s>0"), - norm:!nonormal/normal, - incr:increment(d:inc,"%s>0"); - grouped=custom; - ntiles=integer; + norm:!nonormal/normal; + +grouped=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. + +statistics[st_]=mean,semean,median,mode,stddev,variance, + kurtosis,skewness,range,minimum,maximum,sum, + default,seskewness,sekurtosis,all,none. */ /* (declarations) */ /* (functions) */ @@ -105,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. */ @@ -118,7 +100,7 @@ struct frq_info }; /* Table of statistics, indexed by dsc_*. */ -static 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")}, @@ -143,99 +125,45 @@ 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) ; - -static struct percentile *percentiles; -static int n_percentiles; - -static int implicit_50th ; - /* 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; - -/* Types of graphs. */ -enum +#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 { - GFT_NONE, /* Don't draw graphs. */ - GFT_BAR, /* Draw bar charts. */ - GFT_HIST, /* Draw histograms. */ - GFT_PIE, /* Draw piechart */ - GFT_HBAR /* Draw bar charts or histograms at our discretion. */ - }; - -/* Parsed command. */ -static struct cmd_frequencies cmd; + double x_min; /* X axis minimum value. */ + double x_max; /* X axis maximum value. */ + int y_scale; /* Y axis scale: FRQ_FREQ or FRQ_PERCENT. */ -/* Summary of the barchart, histogram, and hbar subcommands. */ -/* FIXME: These should not be mututally exclusive */ -static int chart; /* NONE/BAR/HIST/HBAR/PIE. */ -static double min, max; /* Minimum, maximum on y axis. */ -static int format; /* FREQ/PERCENT: Scaling of y axis. */ -static double scale, incr; /* FIXME */ -static int normal; /* FIXME */ + /* Histograms only. */ + double y_max; /* Y axis maximum value. */ + bool draw_normal; /* Whether to draw normal curve. */ -/* Variables for which to calculate statistics. */ -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. */ - -/* Frequency tables. */ - -/* Frequency table entry. */ -struct freq - { - union value *v; /* The value. */ - double c; /* The number of occurrences of the value. */ + /* Pie charts only. */ + bool include_missing; /* Whether to include missing values. */ }; -/* Types of frequency tables. */ -enum - { - FRQM_GENERAL, - FRQM_INTEGER - }; +/* Frequency tables. */ /* 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 hmap data; /* Hash table for accumulating counts. */ struct freq *valid; /* Valid freqs. */ int n_valid; /* Number of total freqs. */ + const struct dictionary *dict; /* Source of entries in the table. */ - struct freq *missing; /* Missing freqs. */ + struct freq *missing; /* Missing freqs. */ int n_missing; /* Number of missing freqs. */ /* Statistics. */ @@ -243,10 +171,11 @@ struct freq_tab double valid_cases; /* Sum of weights of valid cases. */ }; - /* Per-variable frequency data. */ struct var_freqs { + struct variable *var; + /* Freqency table. */ struct freq_tab tab; /* Frequencies table to use. */ @@ -255,635 +184,488 @@ struct var_freqs double *groups; /* Groups. */ /* Statistics. */ - double stat[frq_n_stats]; + double stat[FRQ_N_STATS]; - /* Width and format for analysis and display. - This is normally the same as "width" and "print" in struct - variable, but in SPSS-compatible mode only the first - MAX_SHORT_STRING bytes of long string variables are - included. */ + /* Variable attributes. */ int width; struct fmt_spec print; }; -static inline struct var_freqs * -get_var_freqs (struct variable *v) -{ - assert (v != NULL); - assert (v->aux != NULL); - return v->aux; -} +struct frq_proc + { + struct pool *pool; + + struct var_freqs *vars; + size_t n_vars; -static void determine_charts (void); + /* Percentiles to calculate and possibly display. */ + struct percentile *percentiles; + int n_percentiles, n_show_percentiles; -static void calc_stats (struct variable *v, double d[frq_n_stats]); + /* 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 precalc (const struct ccase *, void *); -static bool calc (const struct ccase *, void *); -static void postcalc (void *); + /* Statistics; number of statistics. */ + unsigned long stats; + int n_stats; -static void postprocess_freq_tab (struct variable *); -static void dump_full (struct variable *); -static void dump_condensed (struct variable *); -static void dump_statistics (struct variable *, int show_varname); -static void cleanup_freq_tab (struct variable *); + /* Histogram and pie chart settings. */ + struct frq_chart *hist, *pie; + }; + +static void determine_charts (struct frq_proc *, + const struct cmd_frequencies *); -static hsh_hash_func hash_value_numeric, hash_value_alpha; -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 calc_stats (const struct var_freqs *, double d[FRQ_N_STATS]); +static void calc_percentiles (const struct frq_proc *, + const struct var_freqs *); +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 do_piechart(const struct variable *var, - const struct freq_tab *frq_tab); +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 *); -gsl_histogram * -freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var); +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 (void); - int -cmd_frequencies (void) -{ - int result; - - int_pool = pool_create (); - result = internal_cmd_frequencies (); - pool_destroy (int_pool); - int_pool=0; - pool_destroy (gen_pool); - gen_pool=0; - free (v_variables); - v_variables=0; - return result; -} - -static int -internal_cmd_frequencies (void) +cmd_frequencies (struct lexer *lexer, struct dataset *ds) { - int i; + struct cmd_frequencies cmd; + struct frq_proc frq; + struct casegrouper *grouper; + struct casereader *input, *group; + size_t allocated_percentiles; bool ok; + int i; + + frq.pool = pool_create (); + + frq.vars = NULL; + frq.n_vars = 0; + + frq.percentiles = NULL; + frq.n_percentiles = 0; + frq.n_show_percentiles = 0; - n_percentiles = 0; - percentiles = NULL; + frq.hist = NULL; + frq.pie = NULL; - n_variables = 0; - v_variables = NULL; + allocated_percentiles = 0; - if (!parse_frequencies (&cmd)) - return CMD_FAILURE; + if (!parse_frequencies (lexer, ds, &cmd, &frq)) + { + pool_destroy (frq.pool); + return CMD_FAILURE; + } - if (cmd.onepage_limit == NOT_LONG) - cmd.onepage_limit = 50; + /* 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 &= ~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 |= frq_sekurt; - if (stats & frq_skew) - stats |= 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 (); - if (chart != GFT_NONE || cmd.sbc_ntiles) + determine_charts (&frq, &cmd); + if (cmd.sbc_histogram || cmd.sbc_piechart || cmd.sbc_ntiles) cmd.sort = FRQ_AVALUE; /* Work out what percentiles need to be calculated */ - if ( cmd.sbc_percentiles ) + if ( cmd.sbc_percentiles ) { - for ( i = 0 ; i < MAXLISTS ; ++i ) + 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 ); + add_percentile (&frq, subc_list_double_at(ptl_list, pl) / 100.0, + true, &allocated_percentiles); } } - if ( cmd.sbc_ntiles ) + if ( cmd.sbc_ntiles ) { - for ( i = 0 ; i < cmd.sbc_ntiles ; ++i ) + 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]); + for (j = 0; j <= cmd.n_ntiles[i]; ++j ) + add_percentile (&frq, j / (double) cmd.n_ntiles[i], true, + &allocated_percentiles); } } - + 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 (&frq, 0.5, true, &allocated_percentiles); + frq.stats &= ~BIT_INDEX (FRQ_MEDIAN); + frq.n_stats--; + } + if (cmd.sbc_histogram) + { + add_percentile (&frq, 0.25, false, &allocated_percentiles); + add_percentile (&frq, 0.75, false, &allocated_percentiles); + } /* Do it! */ - ok = procedure_with_splits (precalc, calc, postcalc, NULL); + input = casereader_create_filter_weight (proc_open (ds), dataset_dict (ds), + NULL, NULL); + grouper = casegrouper_create_splits (input, dataset_dict (ds)); + for (; casegrouper_get_next_group (grouper, &group); + casereader_destroy (group)) + { + struct ccase *c; + + precalc (&frq, group, ds); + for (; (c = casereader_read (group)) != NULL; case_unref (c)) + 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) { - int count = (!!cmd.sbc_histogram) + (!!cmd.sbc_barchart) + - (!!cmd.sbc_hbar) + (!!cmd.sbc_piechart); - - if (!count) - { - chart = GFT_NONE; - return; - } - else if (count > 1) - { - chart = GFT_HBAR; - msg (SW, _("At most one of BARCHART, HISTOGRAM, or HBAR should be " - "given. HBAR will be assumed. Argument values will be " - "given precedence increasing along the order given.")); - } - else if (cmd.sbc_histogram) - chart = GFT_HIST; - else if (cmd.sbc_barchart) - chart = GFT_BAR; - else if (cmd.sbc_piechart) - chart = GFT_PIE; - else - chart = GFT_HBAR; + if (cmd->sbc_barchart) + msg (SW, _("Bar charts are not implemented.")); - min = max = SYSMIS; - format = FRQ_FREQ; - scale = SYSMIS; - incr = SYSMIS; - normal = 0; - - if (cmd.sbc_barchart) + if (cmd->sbc_histogram) { - if (cmd.ba_min != SYSMIS) - min = cmd.ba_min; - if (cmd.ba_max != SYSMIS) - max = cmd.ba_max; - if (cmd.ba_scale == FRQ_FREQ) - { - format = FRQ_FREQ; - scale = cmd.ba_freq; - } - else if (cmd.ba_scale == FRQ_PERCENT) - { - format = FRQ_PERCENT; - scale = cmd.ba_pcnt; - } + 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; + } } - if (cmd.sbc_histogram) + if (cmd->sbc_piechart) { - if (cmd.hi_min != SYSMIS) - min = cmd.hi_min; - if (cmd.hi_max != SYSMIS) - max = cmd.hi_max; - if (cmd.hi_scale == FRQ_FREQ) - { - format = FRQ_FREQ; - scale = cmd.hi_freq; - } - else if (cmd.hi_scale == FRQ_PERCENT) - { - format = FRQ_PERCENT; - scale = cmd.ba_pcnt; - } - if (cmd.hi_norm != FRQ_NONORMAL ) - normal = 1; - if (cmd.hi_incr == FRQ_INCREMENT) - incr = cmd.hi_inc; - } + struct frq_chart *pie; - if (cmd.sbc_hbar) - { - if (cmd.hb_min != SYSMIS) - min = cmd.hb_min; - if (cmd.hb_max != SYSMIS) - max = cmd.hb_max; - if (cmd.hb_scale == FRQ_FREQ) - { - format = FRQ_FREQ; - scale = cmd.hb_freq; - } - else if (cmd.hb_scale == FRQ_PERCENT) - { - format = FRQ_PERCENT; - scale = cmd.ba_pcnt; - } - if (cmd.hb_norm) - normal = 1; - if (cmd.hb_incr == FRQ_INCREMENT) - incr = cmd.hb_inc; - } + 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 (min != SYSMIS && max != SYSMIS && min >= max) - { - msg (SE, _("MAX must be greater than or equal to MIN, if both are " - "specified. However, MIN was specified as %g and MAX as %g. " - "MIN and MAX will be ignored."), min, max); - min = max = SYSMIS; + 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; + } } } /* Add data from case C to the frequency table. */ -static bool -calc (const struct ccase *c, void *aux UNUSED) +static void +calc (struct frq_proc *frq, const struct ccase *c, const struct dataset *ds) { - double weight; + double weight = dict_get_case_weight (dataset_dict (ds), c, NULL); size_t i; - int bad_warn = 1; - weight = dict_get_case_weight (default_dict, c, &bad_warn); - - for (i = 0; i < n_variables; i++) + for (i = 0; i < frq->n_vars; i++) { - struct variable *v = v_variables[i]; - const union value *val = case_data (c, v->fv); - struct var_freqs *vf = get_var_freqs (v); - struct freq_tab *ft = &vf->tab; + 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; - switch (ft->mode) - { - case FRQM_GENERAL: - { - /* General mode. */ - struct freq target; - struct freq **fpp; - - target.v = (union value *) val; - fpp = (struct freq **) hsh_probe (ft->data, &target); - - if (*fpp != NULL) - (*fpp)->c += weight; - else - { - struct freq *fp = pool_alloc (gen_pool, sizeof *fp); - fp->c = weight; - fp->v = pool_clone (gen_pool, - val, MAX (MAX_SHORT_STRING, vf->width)); - *fpp = fp; - } - } - break; - case FRQM_INTEGER: - /* Integer mode. */ - if (val->f == SYSMIS) - ft->sysmis += weight; - else if (val->f > INT_MIN+1 && val->f < INT_MAX-1) - { - int i = val->f; - if (i >= ft->min && i <= ft->max) - ft->vector[i - ft->min] += weight; - } - else - ft->out_of_range += weight; - break; - default: - assert (0); - } + 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); + + f->count += weight; } - return true; } /* Prepares each variable that is the target of FREQUENCIES by setting up its hash table. */ static void -precalc (const struct ccase *first, void *aux UNUSED) +precalc (struct frq_proc *frq, struct casereader *input, struct dataset *ds) { + struct ccase *c; size_t i; - output_split_file_values (first); - - pool_destroy (gen_pool); - gen_pool = pool_create (); - - for (i = 0; i < n_variables; i++) + c = casereader_peek (input, 0); + if (c != NULL) { - struct variable *v = v_variables[i]; - struct freq_tab *ft = &get_var_freqs (v)->tab; - - if (ft->mode == FRQM_GENERAL) - { - hsh_hash_func *hash; - hsh_compare_func *compare; - - if (v->type == NUMERIC) - { - hash = hash_value_numeric; - compare = compare_value_numeric_a; - } - else - { - hash = hash_value_alpha; - compare = compare_value_alpha_a; - } - ft->data = hsh_create (16, compare, hash, NULL, v); - } - else - { - int j; - - for (j = (ft->max - ft->min); j >= 0; j--) - ft->vector[j] = 0.0; - ft->out_of_range = 0.0; - ft->sysmis = 0.0; - } + output_split_file_values (ds, c); + case_unref (c); } + + 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 (void *aux UNUSED) +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++) { - 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; + 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)) - switch (cmd.cond) - { - case FRQ_CONDENSE: - dump_condensed (v); - break; - case FRQ_STANDARD: - dump_full (v); - break; - case FRQ_ONEPAGE: - if (n_categories > cmd.onepage_limit) - dump_condensed (v); - else - dump_full (v); - break; - default: - assert (0); - } - else - dumped_freq_tab = 0; + if (vf->tab.n_valid + vf->tab.n_missing <= frq->max_categories) + dump_freq_table (vf, wv); /* Statistics. */ - if (n_stats) - dump_statistics (v, !dumped_freq_tab); + if (frq->n_stats) + dump_statistics (frq, vf, wv); - - - if ( chart == GFT_HIST) + if (frq->hist && var_is_numeric (vf->var) && vf->tab.n_valid > 0) { - double d[frq_n_stats]; - struct normal_curve norm; - gsl_histogram *hist ; - + double d[FRQ_N_STATS]; + struct histogram *histogram; - norm.N = vf->tab.valid_cases; + calc_stats (vf, d); - calc_stats(v,d); - norm.mean = d[frq_mean]; - norm.stddev = d[frq_stddev]; + histogram = freq_tab_to_hist (frq, &vf->tab, vf->var); - hist = freq_tab_to_hist(ft,v); + chart_item_submit (histogram_chart_create ( + histogram->gsl_hist, var_to_string(vf->var), + vf->tab.valid_cases, + d[FRQ_MEAN], + d[FRQ_STDDEV], + frq->hist->draw_normal)); - histogram_plot(hist, var_to_string(v), &norm, normal); - - gsl_histogram_free(hist); - } - - - if ( chart == GFT_PIE) - { - do_piechart(v_variables[i], ft); + statistic_destroy (&histogram->parent); } + 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 VAR_TYPE - variables. */ -static hsh_compare_func * -get_freq_comparator (int frq_sort, int var_type) +/* 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_) { - /* Note that q2c generates tags beginning with 1000. */ - switch (frq_sort | (var_type << 16)) - { - case FRQ_AVALUE | (NUMERIC << 16): return compare_value_numeric_a; - case FRQ_AVALUE | (ALPHA << 16): return compare_value_alpha_a; - case FRQ_DVALUE | (NUMERIC << 16): return compare_value_numeric_d; - case FRQ_DVALUE | (ALPHA << 16): return compare_value_alpha_d; - case FRQ_AFREQ | (NUMERIC << 16): return compare_freq_numeric_a; - case FRQ_AFREQ | (ALPHA << 16): return compare_freq_alpha_a; - case FRQ_DFREQ | (NUMERIC << 16): return compare_freq_numeric_d; - case FRQ_DFREQ | (ALPHA << 16): return compare_freq_alpha_d; - default: assert (0); - } + const struct freq *f = f_; + const struct variable *v = v_; - return 0; + return !var_is_value_missing (v, &f->value, MV_ANY); } -/* Returns nonzero iff the value in struct freq F is non-missing - for variable V. */ +struct freq_compare_aux + { + bool by_freq; + bool ascending_freq; + + int width; + bool ascending_value; + }; + static int -not_missing (const void *f_, void *v_) +compare_freq (const void *a_, const void *b_, const void *aux_) { - const struct freq *f = f_; - struct variable *v = v_; + const struct freq_compare_aux *aux = aux_; + const struct freq *a = a_; + const struct freq *b = b_; - return !mv_is_value_missing (&v->miss, f->v); + 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 (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 *freqs, *f; size_t i; - ft = &get_var_freqs (v)->tab; - assert (ft->mode == FRQM_GENERAL); - compare = get_freq_comparator (cmd.sort, v->type); - /* 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 *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; - for(i = 0 ; i < ft->n_valid ; ++i ) + for(i = 0 ; i < ft->n_valid ; ++i ) { f = &ft->valid[i]; - ft->valid_cases += f->c; + ft->valid_cases += f->count; } - ft->total_cases = ft->valid_cases ; - for(i = 0 ; i < ft->n_missing ; ++i ) + ft->total_cases = ft->valid_cases ; + for(i = 0 ; i < ft->n_missing ; ++i ) { f = &ft->missing[i]; - ft->total_cases += f->c; + ft->total_cases += f->count; } } /* Frees the frequency table for variable V. */ static void -cleanup_freq_tab (struct variable *v) +cleanup_freq_tab (struct var_freqs *vf) { - struct freq_tab *ft = &get_var_freqs (v)->tab; - assert (ft->mode == FRQM_GENERAL); - 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 cmd_frequencies *cmd UNUSED) +frq_custom_variables (struct lexer *lexer, struct dataset *ds, + struct cmd_frequencies *cmd UNUSED, void *frq_ UNUSED) { - int mode; - int min = 0, max = 0; - - size_t old_n_variables = n_variables; + struct frq_proc *frq = frq_; + struct variable **vars; + size_t n_vars; size_t i; - lex_match ('='); - if (token != T_ALL && (token != T_ID - || dict_lookup_var (default_dict, tokid) == 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 (default_dict, &v_variables, &n_variables, - PV_APPEND | PV_NO_SCRATCH)) - return 0; + /* 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 (!lex_match ('(')) - mode = FRQM_GENERAL; - else - { - mode = FRQM_INTEGER; - if (!lex_force_int ()) - return 0; - min = lex_integer (); - lex_get (); - if (!lex_force_match (',')) - return 0; - if (!lex_force_int ()) - return 0; - max = lex_integer (); - lex_get (); - if (!lex_force_match (')')) - return 0; - if (max < min) - { - msg (SE, _("Upper limit of integer mode value range must be " - "greater than lower limit.")); - return 0; - } - } + 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++) { - struct variable *v = v_variables[i]; - struct var_freqs *vf; - - if (v->aux != NULL) - { - msg (SE, _("Variable %s specified multiple times on VARIABLES " - "subcommand."), v->name); - return 0; - } - if (mode == FRQM_INTEGER && v->type != NUMERIC) - { - msg (SE, _("Integer mode specified, but %s is not a numeric " - "variable."), v->name); - return 0; - } + struct variable *var = vars[i]; + struct var_freqs *vf = &frq->vars[i]; - vf = var_attach_aux (v, xmalloc (sizeof *vf), var_dtor_free); - vf->tab.mode = mode; + vf->var = var; vf->tab.valid = vf->tab.missing = NULL; - if (mode == FRQM_INTEGER) - { - vf->tab.min = min; - vf->tab.max = max; - vf->tab.vector = pool_nalloc (int_pool, - max - min + 1, sizeof *vf->tab.vector); - } - else - vf->tab.vector = NULL; + vf->tab.dict = dataset_dict (ds); vf->n_groups = 0; vf->groups = NULL; - vf->width = v->width; - vf->print = v->print; - if (vf->width > MAX_SHORT_STRING && get_algorithm () == COMPATIBLE) - { - vf->width = MAX_SHORT_STRING; - vf->print.w = MAX_SHORT_STRING * (v->print.type == FMT_AHEX ? 2 : 1); - } + 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 cmd_frequencies *cmd UNUSED) +frq_custom_grouped (struct lexer *lexer, struct dataset *ds, struct cmd_frequencies *cmd UNUSED, void *frq_ UNUSED) { - lex_match ('='); - if ((token == T_ID && dict_lookup_var (default_dict, tokid) != NULL) - || token == T_ID) + 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 (;;) { size_t i; @@ -894,65 +676,74 @@ frq_custom_grouped (struct cmd_frequencies *cmd UNUSED) /* Variable list. */ size_t n; - struct variable **v; + const struct variable **v; - if (!parse_variables (default_dict, &v, &n, + if (!parse_variables_const (lexer, dataset_dict (ds), &v, &n, PV_NO_DUPLICATE | PV_NUMERIC)) return 0; - if (lex_match ('(')) + if (lex_match (lexer, T_LPAREN)) { nl = ml = 0; dl = NULL; - while (lex_integer ()) + while (lex_integer (lexer)) { if (nl >= ml) { ml += 16; - dl = pool_nrealloc (int_pool, dl, ml, sizeof *dl); + dl = pool_nrealloc (frq->pool, dl, ml, sizeof *dl); } - dl[nl++] = tokval; - lex_get (); - lex_match (','); + dl[nl++] = lex_tokval (lexer); + lex_get (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 (')')) + if (!lex_match (lexer, T_RPAREN)) { free (v); msg (SE, _("`)' expected after GROUPED interval list.")); return 0; } } - else + else { nl = 0; dl = NULL; } for (i = 0; i < n; i++) - if (v[i]->aux == 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."), 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; - } - } + "VARIABLES."), var_get_name (v[i])); + + found:; + } + free (v); - if (!lex_match ('/')) + if (!lex_match (lexer, T_SLASH)) break; - if ((token != T_ID || dict_lookup_var (default_dict, tokid) != NULL) - && token != T_ALL) + if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokcstr (lexer)) != NULL) + && lex_token (lexer) != T_ALL) { - lex_put_back ('/'); + lex_put_back (lexer, T_SLASH); break; } } @@ -961,517 +752,214 @@ frq_custom_grouped (struct cmd_frequencies *cmd UNUSED) } /* Adds X to the list of percentiles, keeping the list in proper - order. */ + 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) +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 ) - return; + struct percentile *pc = &frq->percentiles[i]; + + if ( fabs(x - pc->p) < DBL_EPSILON ) + { + if (show && !pc->show) + { + frq->n_show_percentiles++; + pc->show = true; + } + return; + } - if (x < percentiles[i].p) + if (x < pc->p) break; } - if (i >= n_percentiles || tokval != percentiles[i].p) - { - percentiles = pool_nrealloc (int_pool, percentiles, - n_percentiles + 1, sizeof *percentiles); - - if (i < n_percentiles) - memmove (&percentiles[i + 1], &percentiles[i], - (n_percentiles - i) * sizeof (struct percentile) ); - - percentiles[i].p = x; - n_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. */ -/* Hash of numeric values. */ -static unsigned -hash_value_numeric (const void *value_, void *foo UNUSED) -{ - const struct freq *value = value_; - return hsh_hash_double (value->v[0].f); -} - -/* Hash of string values. */ -static unsigned -hash_value_alpha (const void *value_, void *v_) -{ - const struct freq *value = value_; - struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); - - return hsh_hash_bytes (value->v[0].s, vf->width); -} - -/* Ascending numeric compare of values. */ -static int -compare_value_numeric_a (const void *a_, const void *b_, void *foo UNUSED) -{ - const struct freq *a = a_; - const struct freq *b = b_; - - if (a->v[0].f > b->v[0].f) - return 1; - else if (a->v[0].f < b->v[0].f) - return -1; - else - return 0; -} - -/* Ascending string compare of values. */ -static int -compare_value_alpha_a (const void *a_, const void *b_, void *v_) -{ - const struct freq *a = a_; - const struct freq *b = b_; - struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); - - return memcmp (a->v[0].s, b->v[0].s, vf->width); -} - -/* Descending numeric compare of values. */ -static int -compare_value_numeric_d (const void *a, const void *b, void *foo UNUSED) -{ - return -compare_value_numeric_a (a, b, foo); -} - -/* Descending string compare of values. */ -static int -compare_value_alpha_d (const void *a, const void *b, 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_, void *foo UNUSED) -{ - const struct freq *a = a_; - const struct freq *b = b_; - - if (a->c > b->c) - return 1; - else if (a->c < b->c) - return -1; - - if (a->v[0].f > b->v[0].f) - return 1; - else if (a->v[0].f < b->v[0].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_, void *v_) -{ - const struct freq *a = a_; - const struct freq *b = b_; - struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); - - if (a->c > b->c) - return 1; - else if (a->c < b->c) - return -1; - else - return memcmp (a->v[0].s, b->v[0].s, 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_, void *foo UNUSED) -{ - const struct freq *a = a_; - const struct freq *b = b_; - - if (a->c > b->c) - return -1; - else if (a->c < b->c) - return 1; - - if (a->v[0].f > b->v[0].f) - return 1; - else if (a->v[0].f < b->v[0].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_, void *v_) -{ - const struct freq *a = a_; - const struct freq *b = b_; - struct variable *v = v_; - struct var_freqs *vf = get_var_freqs (v); - - if (a->c > b->c) - return -1; - else if (a->c < b->c) - return 1; - else - return memcmp (a->v[0].s, b->v[0].s, vf->width); -} /* Frequency table display. */ -/* Sets the widths of all the columns and heights of all the rows in - table T for driver D. */ -static void -full_dim (struct tab_table *t, struct outp_driver *d) -{ - int lab = cmd.labels == FRQ_LABELS; - int i; - - if (lab) - t->w[0] = min (tab_natural_width (t, d, 0), d->prop_em_width * 15); - for (i = lab; i < lab + 5; i++) - t->w[i] = max (tab_natural_width (t, d, i), d->prop_em_width * 8); - for (i = 0; i < t->nr; i++) - t->h[i] = d->font_height; -} - /* Displays a full frequency table for variable V. */ static void -dump_full (struct variable *v) +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; + int r, x; double cum_total = 0.0; double cum_freq = 0.0; - struct init - { - int c, r; - const char *s; - }; - - struct init *p; - - static struct init vec[] = - { - {4, 0, N_("Valid")}, - {5, 0, N_("Cum")}, - {1, 1, N_("Value")}, - {2, 1, N_("Frequency")}, - {3, 1, N_("Percent")}, - {4, 1, N_("Percent")}, - {5, 1, N_("Percent")}, - {0, 0, NULL}, - {1, 0, NULL}, - {2, 0, NULL}, - {3, 0, NULL}, - {-1, -1, NULL}, + static const char *headings[] = { + N_("Value Label"), + N_("Value"), + N_("Frequency"), + N_("Percent"), + N_("Valid Percent"), + N_("Cum Percent") }; - int lab = cmd.labels == FRQ_LABELS; - - vf = get_var_freqs (v); - ft = &vf->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); + t = tab_create (6, n_categories + 2); + tab_headers (t, 0, 0, 1, 0); - if (lab) - tab_text (t, 0, 1, TAB_CENTER | TAT_TITLE, _("Value Label")); - for (p = vec; p->s; p++) - tab_text (t, p->c - (p->r ? !lab : 0), p->r, - TAB_CENTER | TAT_TITLE, gettext (p->s)); + for (x = 0; x < 6; x++) + tab_text (t, x, 0, TAB_CENTER | TAT_TITLE, gettext (headings[x])); - r = 2; + r = 1; for (f = ft->valid; f < ft->missing; f++) { + const char *label; double percent, valid_percent; - cum_freq += f->c; + cum_freq += f->count; - percent = f->c / ft->total_cases * 100.0; - valid_percent = f->c / ft->valid_cases * 100.0; + percent = f->count / ft->total_cases * 100.0; + valid_percent = f->count / ft->valid_cases * 100.0; cum_total += valid_percent; - if (lab) - { - const char *label = val_labs_find (v->val_labs, f->v[0]); - if (label != NULL) - tab_text (t, 0, r, TAB_LEFT, label); - } + label = var_lookup_value_label (vf->var, &f->value); + if (label != NULL) + tab_text (t, 0, r, TAB_LEFT, label); - tab_value (t, 0 + lab, r, TAB_NONE, f->v, &vf->print); - tab_float (t, 1 + lab, r, TAB_NONE, f->c, 8, 0); - tab_float (t, 2 + lab, r, TAB_NONE, percent, 5, 1); - tab_float (t, 3 + lab, r, TAB_NONE, valid_percent, 5, 1); - tab_float (t, 4 + lab, r, TAB_NONE, cum_total, 5, 1); + tab_value (t, 1, r, TAB_NONE, &f->value, ft->dict, &vf->print); + tab_double (t, 2, r, TAB_NONE, f->count, wfmt); + tab_double (t, 3, r, TAB_NONE, percent, NULL); + tab_double (t, 4, r, TAB_NONE, valid_percent, NULL); + tab_double (t, 5, r, TAB_NONE, cum_total, NULL); r++; } for (; f < &ft->valid[n_categories]; f++) { - cum_freq += f->c; + const char *label; - if (lab) - { - const char *label = val_labs_find (v->val_labs, f->v[0]); - if (label != NULL) - tab_text (t, 0, r, TAB_LEFT, label); - } + cum_freq += f->count; - tab_value (t, 0 + lab, r, TAB_NONE, f->v, &vf->print); - tab_float (t, 1 + lab, r, TAB_NONE, f->c, 8, 0); - tab_float (t, 2 + lab, r, TAB_NONE, - f->c / ft->total_cases * 100.0, 5, 1); - tab_text (t, 3 + lab, r, TAB_NONE, _("Missing")); + label = var_lookup_value_label (vf->var, &f->value); + if (label != NULL) + tab_text (t, 0, r, TAB_LEFT, label); + + tab_value (t, 1, r, TAB_NONE, &f->value, ft->dict, &vf->print); + tab_double (t, 2, r, TAB_NONE, f->count, wfmt); + tab_double (t, 3, r, TAB_NONE, + f->count / ft->total_cases * 100.0, NULL); + tab_text (t, 4, r, TAB_NONE, _("Missing")); r++; } - tab_box (t, TAL_1, TAL_1, - cmd.spaces == FRQ_SINGLE ? -1 : TAL_GAP, TAL_1, - 0, 0, 4 + lab, r); - tab_hline (t, TAL_2, 0, 4 + lab, 2); - tab_hline (t, TAL_2, 0, 4 + lab, r); - tab_joint_text (t, 0, r, 0 + lab, r, TAB_RIGHT | TAT_TITLE, _("Total")); + tab_box (t, TAL_1, TAL_1, -1, TAL_1, 0, 0, 5, r); + tab_hline (t, TAL_2, 0, 5, 1); + tab_hline (t, TAL_2, 0, 5, r); + tab_joint_text (t, 0, r, 1, r, TAB_RIGHT | TAT_TITLE, _("Total")); tab_vline (t, TAL_0, 1, r, r); - tab_float (t, 1 + lab, r, TAB_NONE, cum_freq, 8, 0); - tab_float (t, 2 + lab, r, TAB_NONE, 100.0, 5, 1); - tab_float (t, 3 + lab, r, TAB_NONE, 100.0, 5, 1); + tab_double (t, 2, r, TAB_NONE, cum_freq, wfmt); + 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: %s", v->name, v->label ? v->label : ""); + tab_title (t, "%s", var_to_string (vf->var)); tab_submit (t); - } + +/* Statistical display. */ -/* Sets the widths of all the columns and heights of all the rows in - table T for driver D. */ -static void -condensed_dim (struct tab_table *t, struct outp_driver *d) +static double +calc_percentile (double p, double valid_cases, double x1, double x2) { - int cum_w = max (outp_string_width (d, _("Cum"), OUTP_PROPORTIONAL), - max (outp_string_width (d, _("Cum"), OUTP_PROPORTIONAL), - outp_string_width (d, "000", OUTP_PROPORTIONAL))); + double s, dummy; - int i; + s = (settings_get_algorithm () != COMPATIBLE + ? modf ((valid_cases - 1) * p, &dummy) + : modf ((valid_cases + 1) * p - 1, &dummy)); - for (i = 0; i < 2; i++) - t->w[i] = max (tab_natural_width (t, d, i), d->prop_em_width * 8); - for (i = 2; i < 4; i++) - t->w[i] = cum_w; - for (i = 0; i < t->nr; i++) - t->h[i] = d->font_height; + return x1 + (x2 - x1) * s; } -/* Display condensed frequency table for variable V. */ +/* Calculates all of the percentiles for VF within FRQ. */ static void -dump_condensed (struct variable *v) +calc_percentiles (const struct frq_proc *frq, const struct var_freqs *vf) { - int n_categories; - struct var_freqs *vf; - struct freq_tab *ft; - struct freq *f; - struct tab_table *t; - int r; - double cum_total = 0.0; - - vf = get_var_freqs (v); - ft = &vf->tab; - n_categories = ft->n_valid + ft->n_missing; - t = tab_create (4, n_categories + 2, 0); + const struct freq_tab *ft = &vf->tab; + double W = ft->valid_cases; + const struct freq *f; + int percentile_idx; + double rank; - tab_headers (t, 0, 0, 2, 0); - tab_text (t, 0, 1, TAB_CENTER | TAT_TITLE, _("Value")); - tab_text (t, 1, 1, TAB_CENTER | TAT_TITLE, _("Freq")); - tab_text (t, 2, 1, TAB_CENTER | TAT_TITLE, _("Pct")); - tab_text (t, 3, 0, TAB_CENTER | TAT_TITLE, _("Cum")); - tab_text (t, 3, 1, TAB_CENTER | TAT_TITLE, _("Pct")); - tab_dim (t, condensed_dim); + assert (ft->n_valid > 0); - r = 2; + rank = 0; + percentile_idx = 0; for (f = ft->valid; f < ft->missing; f++) { - double percent; + rank += f->count; + for (; percentile_idx < frq->n_percentiles; percentile_idx++) + { + struct percentile *pc = &frq->percentiles[percentile_idx]; + double tp; - percent = f->c / ft->total_cases * 100.0; - cum_total += f->c / ft->valid_cases * 100.0; + tp = (settings_get_algorithm () == ENHANCED + ? (W - 1) * pc->p + : (W + 1) * pc->p - 1); - tab_value (t, 0, r, TAB_NONE, f->v, &vf->print); - tab_float (t, 1, r, TAB_NONE, f->c, 8, 0); - tab_float (t, 2, r, TAB_NONE, percent, 3, 0); - tab_float (t, 3, r, TAB_NONE, cum_total, 3, 0); - r++; + 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); + } } - for (; f < &ft->valid[n_categories]; f++) + for (; percentile_idx < frq->n_percentiles; percentile_idx++) { - tab_value (t, 0, r, TAB_NONE, f->v, &vf->print); - tab_float (t, 1, r, TAB_NONE, f->c, 8, 0); - tab_float (t, 2, r, TAB_NONE, - f->c / ft->total_cases * 100.0, 3, 0); - r++; + struct percentile *pc = &frq->percentiles[percentile_idx]; + pc->value = ft->valid[ft->n_valid - 1].value.f; } - - tab_box (t, TAL_1, TAL_1, - cmd.spaces == FRQ_SINGLE ? -1 : TAL_GAP, TAL_1, - 0, 0, 3, r - 1); - tab_hline (t, TAL_2, 0, 3, 2); - tab_title (t, "%s: %s", v->name, v->label ? v->label : ""); - tab_columns (t, SOM_COL_DOWN, 1); - tab_submit (t); } - -/* Statistical display. */ -/* Calculates all the pertinent statistics for variable V, putting - them in array D[]. FIXME: This could be made much more optimal. */ +/* Calculates all the pertinent statistics for VF, putting them in array + D[]. */ static void -calc_stats (struct variable *v, double d[frq_n_stats]) +calc_stats (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; + const struct freq *f; struct moments *m; - struct freq *f=0; int most_often; double X_mode; - double rank; - int i = 0; - int idx; - double *median_value; - - /* Calculate percentiles. */ - - /* If the 50th percentile was not explicitly requested then we must - calculate it anyway --- it's the median */ - median_value = 0 ; - for (i = 0; i < n_percentiles; i++) - { - if (percentiles[i].p == 0.5) - { - median_value = &percentiles[i].value; - break; - } - } - - if ( 0 == median_value ) - { - add_percentile (0.5); - implicit_50th = 1; - } - - 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) - { - static double prev_value = SYSMIS; - f = &ft->valid[idx]; - rank += f->c ; - for (i = 0; i < n_percentiles; i++) - { - double tp; - if ( percentiles[i].flag2 ) continue ; - - if ( 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->v[0].f; - percentiles[i].x1 = prev_value; - percentiles[i].flag2 = 1; - continue; - } - - if (rank > tp ) - { - if ( f->c > 1 && rank - (f->c - 1) > tp ) - { - percentiles[i].x2 = percentiles[i].x1 = f->v[0].f; - percentiles[i].flag2 = 1; - } - else - { - percentiles[i].flag=1; - } - - continue; - } - } - prev_value = f->v[0].f; - } - - for (i = 0; i < n_percentiles; i++) - { - /* Catches the case when p == 100% */ - if ( ! percentiles[i].flag2 ) - percentiles[i].x1 = percentiles[i].x2 = f->v[0].f; - - /* - printf("percentile %d (p==%.2f); X1 = %g; X2 = %g\n", - i,percentiles[i].p,percentiles[i].x1,percentiles[i].x2); - */ - } - - for (i = 0; i < n_percentiles; i++) - { - 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); - } - 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 ; - - if ( percentiles[i].p == 0.50) - median_value = &percentiles[i].value; - } - + assert (ft->n_valid > 0); /* Calculate the mode. */ most_often = -1; X_mode = SYSMIS; for (f = ft->valid; f < ft->missing; f++) { - if (most_often < f->c) + if (most_often < f->count) { - most_often = f->c; - X_mode = f->v[0].f; + most_often = f->count; + X_mode = f->value.f; } - else if (most_often == f->c) + else if (most_often == f->count) { /* A duplicate mode is undefined. FIXME: keep track of *all* the modes. */ @@ -1482,68 +970,64 @@ calc_stats (struct variable *v, double d[frq_n_stats]) /* Calculate moments. */ m = moments_create (MOMENT_KURTOSIS); for (f = ft->valid; f < ft->missing; f++) - moments_pass_one (m, f->v[0].f, f->c); + moments_pass_one (m, f->value.f, f->count); for (f = ft->valid; f < ft->missing; f++) - moments_pass_two (m, f->v[0].f, f->c); - moments_calculate (m, NULL, &d[frq_mean], &d[frq_variance], - &d[frq_skew], &d[frq_kurt]); + 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_destroy (m); - + /* Formulas below are taken from _SPSS Statistical Algorithms_. */ - d[frq_min] = ft->valid[0].v[0].f; - d[frq_max] = ft->valid[ft->n_valid - 1].v[0].f; - d[frq_mode] = X_mode; - d[frq_range] = d[frq_max] - d[frq_min]; - d[frq_median] = *median_value; - 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 (struct variable *v, int show_varname) +dump_statistics (const struct frq_proc *frq, const struct var_freqs *vf, + const struct variable *wv) { - struct freq_tab *ft; - double stat_value[frq_n_stats]; + const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0; + const struct freq_tab *ft = &vf->tab; + double stat_value[FRQ_N_STATS]; struct tab_table *t; int i, r; - int n_explicit_percentiles = n_percentiles; - - if ( implicit_50th && n_percentiles > 0 ) - --n_percentiles; - - if (v->type == ALPHA) + 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."), - v->name); + 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_explicit_percentiles + 2, 0); - tab_dim (t, tab_natural_dimensions); + 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) ; tab_vline (t, TAL_1 , 2, 0, tab_nr(t) - 1); tab_vline (t, TAL_GAP , 1, 0, tab_nr(t) - 1 ) ; - + 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)); - tab_float (t, 2, r, TAB_NONE, stat_value[i], 11, 3); + tab_double (t, 2, r, TAB_NONE, stat_value[i], NULL); r++; } @@ -1551,106 +1035,161 @@ 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, ft->valid_cases, 11, 0); - tab_float(t, 2, 1, TAB_NONE, ft->total_cases - ft->valid_cases, 11, 0); - + 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_explicit_percentiles; i++, r++) + for (i = 0; i < frq->n_percentiles; i++, r++) { - if ( i == 0 ) - { - tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Percentiles")); - } + struct percentile *pc = &frq->percentiles[i]; - tab_float (t, 1, r, TAB_LEFT, percentiles[i].p * 100, 3, 0 ); - tab_float (t, 2, r, TAB_NONE, percentiles[i].value, 11, 3); + if (!pc->show) + continue; - } + if ( i == 0 ) + { + tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Percentiles")); + } - tab_columns (t, SOM_COL_DOWN, 1); - if (show_varname) - { - if (v->label) - tab_title (t, "%s: %s", v->name, v->label); + if (pc->p == 0.5) + tab_text (t, 1, r, TAB_LEFT, _("50 (Median)")); else - tab_title (t, "%s", v->name); + 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)); } - else - tab_flags (t, SOMF_NO_TITLE); + tab_title (t, "%s", var_to_string (vf->var)); tab_submit (t); } +static double +calculate_iqr (const struct frq_proc *frq) +{ + double q1 = SYSMIS; + double q3 = SYSMIS; + int i; + + for (i = 0; i < frq->n_percentiles; i++) + { + 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; +} + +static bool +chart_includes_value (const struct frq_chart *chart, + const struct variable *var, + const union value *value) +{ + if (!chart->include_missing && var_is_value_missing (var, value, MV_ANY)) + return false; + + if (var_is_numeric (var) + && ((chart->x_min != SYSMIS && value->f < chart->x_min) + || (chart->x_max != SYSMIS && value->f > chart->x_max))) + return false; + + return true; +} /* Create a gsl_histogram from a freq_tab */ -gsl_histogram * -freq_tab_to_hist(const struct freq_tab *ft, const struct variable *var) +struct histogram * +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; - 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; + struct histogram *histogram; + double iqr; + int bins; - /* Find out the extremes of the x value */ - for ( frq = hsh_first(fh, &hi); frq != 0; frq = hsh_next(fh, &hi) ) + /* Find out the extremes of the x value, within the range to be included in + the histogram, and sum the total frequency of those values. */ + x_min = DBL_MAX; + x_max = -DBL_MAX; + valid_freq = 0; + for (i = 0; i < ft->n_valid; i++) { - if ( mv_is_value_missing(&var->miss, frq->v)) - continue; - - if ( frq->v[0].f < x_min ) x_min = frq->v[0].f ; - if ( frq->v[0].f > x_max ) x_max = frq->v[0].f ; + const struct freq *f = &ft->valid[i]; + if (chart_includes_value (frq->hist, var, &f->value)) + { + x_min = MIN (x_min, f->value.f); + x_max = MAX (x_max, f->value.f); + valid_freq += f->count; + } } - hist = histogram_create(bins, x_min, x_max); + /* Freedman-Diaconis' choice of bin width. */ + iqr = calculate_iqr (frq); + if (iqr != SYSMIS) + { + double bin_width = 2 * iqr / pow (valid_freq, 1.0 / 3.0); + bins = (x_max - x_min) / bin_width; + if (bins < 5) + bins = 5; + else if (bins > 400) + bins = 400; + } + else + bins = 5; - for( i = 0 ; i < ft->n_valid ; ++i ) + histogram = 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[0].f, frq->c); + 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 hist; + return histogram; } - -static struct slice * -freq_tab_to_slice_array(const struct freq_tab *frq_tab, - const struct variable *var, - int *n_slices); - +static int +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)) + { + ds_init_empty (&slice->label); + var_append_value_name (var, &freq->value, &slice->label); + slice->magnitude = freq->count; + return 1; + } + else + return 0; +} /* 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, +freq_tab_to_slice_array(const struct frq_chart *pie, + const struct freq_tab *frq_tab, const struct variable *var, - int *n_slices) + int *n_slicesp) { - int i; struct slice *slices; + int n_slices; + int i; - *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 = xnmalloc (frq_tab->n_valid + frq_tab->n_missing, sizeof *slices); + n_slices = 0; - slices[i].magnetude = frq->c; - } + for (i = 0; i < frq_tab->n_valid; i++) + 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 (pie, &frq_tab->missing[i], var, &slices[n_slices]); + *n_slicesp = n_slices; return slices; } @@ -1658,20 +1197,30 @@ 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; + 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); - piechart_plot(var_to_string(var), slices, n_slices); + if (n_slices < 2) + msg (SW, _("Omitting pie chart for %s, which has only %d unique values."), + var_get_name (var), n_slices); + else if (n_slices > 50) + msg (SW, _("Omitting pie chart for %s, which has over 50 unique values."), + var_get_name (var)); + else + chart_item_submit (piechart_create (var_to_string(var), slices, n_slices)); - free(slices); + for (i = 0; i < n_slices; i++) + ds_destroy (&slices[i].label); + free (slices); } -/* +/* Local Variables: mode: c End: