/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2007 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
#include <language/command.h>
#include <language/dictionary/split-file.h>
#include <language/lexer/lexer.h>
-#include <libpspp/alloc.h>
#include <libpspp/array.h>
#include <libpspp/bit-vector.h>
#include <libpspp/compiler.h>
#include <libpspp/hash.h>
-#include <libpspp/magic.h>
#include <libpspp/message.h>
#include <libpspp/misc.h>
#include <libpspp/pool.h>
#include "freq.h"
#include "minmax.h"
+#include "xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
static struct percentile *percentiles;
static int n_percentiles;
-static int implicit_50th ;
-
/* Groups of statistics. */
#define BI BIT_INDEX
#define frq_default \
static size_t n_variables;
static const 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. */
+/* Pools. */
+static struct pool *data_pool; /* For per-SPLIT FILE group data. */
+static struct pool *syntax_pool; /* For syntax-related data. */
/* Frequency tables. */
-/* Types of frequency tables. */
-enum
- {
- FRQM_GENERAL,
- FRQM_INTEGER
- };
-
/* Entire frequency table. */
struct freq_tab
{
- int mode; /* FRQM_GENERAL or FRQM_INTEGER. */
-
- /* General mode. */
struct hsh_table *data; /* Undifferentiated data. */
-
- /* Integer mode. */
- double *vector; /* Frequencies proper. */
- int min, max; /* The boundaries of the table. */
- double out_of_range; /* Sum of weights of out-of-range values. */
- double sysmis; /* Sum of weights of SYSMIS values. */
-
- /* All modes. */
struct freq *valid; /* Valid freqs. */
int n_valid; /* Number of total freqs. */
{
int result;
- int_pool = pool_create ();
+ syntax_pool = pool_create ();
result = internal_cmd_frequencies (lexer, ds);
- pool_destroy (int_pool);
- int_pool=0;
- pool_destroy (gen_pool);
- gen_pool=0;
+ pool_destroy (syntax_pool);
+ syntax_pool=0;
+ pool_destroy (data_pool);
+ data_pool=0;
free (v_variables);
v_variables=0;
return result;
if (!parse_frequencies (lexer, ds, &cmd, NULL))
return CMD_FAILURE;
- if (cmd.onepage_limit == NOT_LONG)
+ if (cmd.onepage_limit == LONG_MIN)
cmd.onepage_limit = 50;
/* Figure out statistics to calculate. */
if (cmd.a_statistics[FRQ_ST_ALL])
stats |= frq_all;
if (cmd.sort != FRQ_AVALUE && cmd.sort != FRQ_DVALUE)
- stats &= ~frq_median;
+ 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;
+ stats |= BIT_INDEX (frq_sekurt);
if (stats & frq_skew)
- stats |= frq_seskew;
+ stats |= BIT_INDEX (frq_seskew);
/* Calculate n_stats. */
n_stats = 0;
add_percentile (j / (double) cmd.n_ntiles[i]);
}
}
-
+ if (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);
+ stats &= ~BIT_INDEX (frq_median);
+ n_stats--;
+ }
/* Do it! */
input = casereader_create_filter_weight (proc_open (ds), dataset_dict (ds),
struct var_freqs *vf = get_var_freqs (v);
struct freq_tab *ft = &vf->tab;
- switch (ft->mode)
- {
- case FRQM_GENERAL:
- {
- /* General mode. */
- struct freq target;
- struct freq **fpp;
-
- target.value = (union value *) val;
- fpp = (struct freq **) hsh_probe (ft->data, &target);
-
- if (*fpp != NULL)
- (*fpp)->count += weight;
- else
- {
- struct freq *fp = pool_alloc (gen_pool, sizeof *fp);
- fp->count = weight;
- fp->value = 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:
- NOT_REACHED ();
- }
+ struct freq target;
+ struct freq **fpp;
+
+ target.value = (union value *) val;
+ fpp = (struct freq **) hsh_probe (ft->data, &target);
+
+ if (*fpp != NULL)
+ (*fpp)->count += weight;
+ else
+ {
+ struct freq *fp = pool_alloc (data_pool, sizeof *fp);
+ fp->count = weight;
+ fp->value = pool_clone (data_pool,
+ val,
+ MAX (MAX_SHORT_STRING, vf->width));
+ *fpp = fp;
+ }
}
}
struct ccase c;
size_t i;
- if (!casereader_peek (input, 0, &c))
- return;
- output_split_file_values (ds, &c);
- case_destroy (&c);
+ if (casereader_peek (input, 0, &c))
+ {
+ output_split_file_values (ds, &c);
+ case_destroy (&c);
+ }
- pool_destroy (gen_pool);
- gen_pool = pool_create ();
+ 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;
- if (ft->mode == FRQM_GENERAL)
- {
- ft->data = hsh_create (16, compare_freq, hash_freq, 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;
- }
+ ft->data = hsh_create (16, compare_freq, hash_freq, NULL, v);
}
}
}
/* Returns the comparison function that should be used for
- sorting a frequency table by FRQ_SORT using VAR_TYPE
- variables. */
+ sorting a frequency table by FRQ_SORT using VAL_TYPE
+ values. */
static hsh_compare_func *
-get_freq_comparator (int frq_sort, enum var_type var_type)
+get_freq_comparator (int frq_sort, enum val_type val_type)
{
- bool is_numeric = var_type == VAR_NUMERIC;
+ bool is_numeric = val_type == VAL_NUMERIC;
switch (frq_sort)
{
case FRQ_AVALUE:
size_t i;
ft = &get_var_freqs (v)->tab;
- assert (ft->mode == FRQM_GENERAL);
compare = get_freq_comparator (cmd.sort, var_get_type (v));
/* Extract data from hash table. */
cleanup_freq_tab (const struct variable *v)
{
struct freq_tab *ft = &get_var_freqs (v)->tab;
- assert (ft->mode == FRQM_GENERAL);
free (ft->valid);
hsh_destroy (ft->data);
}
static int
frq_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_frequencies *cmd UNUSED, void *aux UNUSED)
{
- int mode;
- int min = 0, max = 0;
-
size_t old_n_variables = n_variables;
size_t i;
PV_APPEND | PV_NO_SCRATCH))
return 0;
- if (!lex_match (lexer, '('))
- mode = FRQM_GENERAL;
- else
- {
- mode = FRQM_INTEGER;
- if (!lex_force_int (lexer))
- return 0;
- min = lex_integer (lexer);
- lex_get (lexer);
- if (!lex_force_match (lexer, ','))
- return 0;
- if (!lex_force_int (lexer))
- return 0;
- max = lex_integer (lexer);
- lex_get (lexer);
- if (!lex_force_match (lexer, ')'))
- return 0;
- if (max < min)
- {
- msg (SE, _("Upper limit of integer mode value range must be "
- "greater than lower limit."));
- return 0;
- }
- }
-
for (i = old_n_variables; i < n_variables; i++)
{
const struct variable *v = v_variables[i];
"subcommand."), var_get_name (v));
return 0;
}
- if (mode == FRQM_INTEGER && !var_is_numeric (v))
- {
- msg (SE, _("Integer mode specified, but %s is not a numeric "
- "variable."), var_get_name (v));
- return 0;
- }
-
vf = var_attach_aux (v, xmalloc (sizeof *vf), var_dtor_free);
- vf->tab.mode = mode;
vf->tab.valid = vf->tab.missing = NULL;
- if (mode == FRQM_INTEGER)
- {
- 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->n_groups = 0;
vf->groups = NULL;
vf->width = var_get_width (v);
vf->print = *var_get_print_format (v);
- if (vf->width > MAX_SHORT_STRING && get_algorithm () == COMPATIBLE)
+ if (vf->width > MAX_SHORT_STRING && settings_get_algorithm () == COMPATIBLE)
{
enum fmt_type type = var_get_print_format (v)->type;
vf->width = MAX_SHORT_STRING;
if (nl >= ml)
{
ml += 16;
- dl = pool_nrealloc (int_pool, dl, ml, sizeof *dl);
+ dl = pool_nrealloc (syntax_pool, dl, ml, sizeof *dl);
}
dl[nl++] = lex_tokval (lexer);
lex_get (lexer);
if (i >= n_percentiles || x != percentiles[i].p)
{
- percentiles = pool_nrealloc (int_pool, percentiles,
+ percentiles = pool_nrealloc (syntax_pool, percentiles,
n_percentiles + 1, sizeof *percentiles);
-
- if (i < n_percentiles)
- memmove (&percentiles[i + 1], &percentiles[i],
- (n_percentiles - i) * sizeof (struct percentile) );
-
+ insert_element (percentiles, n_percentiles, sizeof *percentiles, i);
percentiles[i].p = x;
n_percentiles++;
}
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;
double tp;
if ( percentiles[i].flag2 ) continue ;
- if ( get_algorithm() != COMPATIBLE )
+ if ( settings_get_algorithm () != COMPATIBLE )
tp =
(ft->valid_cases - 1) * percentiles[i].p;
else
double s;
double dummy;
- if ( get_algorithm() != COMPATIBLE )
+ if ( settings_get_algorithm () != COMPATIBLE )
{
s = modf((ft->valid_cases - 1) * percentiles[i].p , &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;
}
d[frq_max] = ft->valid[ft->n_valid - 1].value[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);
struct tab_table *t;
int i, r;
- int n_explicit_percentiles = n_percentiles;
-
- if ( implicit_50th && n_percentiles > 0 )
- --n_percentiles;
-
if (var_is_alpha (v))
return;
ft = &get_var_freqs (v)->tab;
}
calc_stats (v, stat_value);
- t = tab_create (3, n_stats + n_explicit_percentiles + 2, 0);
+ t = tab_create (3, n_stats + n_percentiles + 2, 0);
tab_dim (t, tab_natural_dimensions);
tab_box (t, TAL_1, TAL_1, -1, -1 , 0 , 0 , 2, tab_nr(t) - 1) ;
tab_float(t, 2, 1, TAB_NONE, ft->total_cases - ft->valid_cases, 11, 0);
- for (i = 0; i < n_explicit_percentiles; i++, r++)
+ for (i = 0; i < n_percentiles; i++, r++)
{
if ( i == 0 )
{
tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Percentiles"));
}
- tab_float (t, 1, r, TAB_LEFT, percentiles[i].p * 100, 3, 0 );
+ if (percentiles[i].p == 0.5)
+ tab_text (t, 1, r, TAB_LEFT, _("50 (Median)"));
+ else
+ 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);
}
{
const struct freq *frq = &frq_tab->valid[i];
- slices[i].label = var_get_value_name (var, frq->value);
+ ds_init_empty (&slices[i].label);
+ var_append_value_name (var, frq->value, &slices[i].label);
slices[i].magnetude = frq->count;
}
do_piechart(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);
piechart_plot(var_to_string(var), slices, n_slices);
+ for (i = 0 ; i < n_slices ; ++i )
+ {
+ ds_destroy (&slices[i].label);
+ }
+
free(slices);
}