/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2008, 2009, 2010, 2011, 2012, 2014 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 <config.h>
+#include "language/stats/aggregate.h"
+
#include <stdlib.h>
-#include <data/any-writer.h>
-#include <data/case-ordering.h>
-#include <data/case.h>
-#include <data/casegrouper.h>
-#include <data/casereader.h>
-#include <data/casewriter.h>
-#include <data/dictionary.h>
-#include <data/file-handle-def.h>
-#include <data/format.h>
-#include <data/procedure.h>
-#include <data/settings.h>
-#include <data/sys-file-writer.h>
-#include <data/variable.h>
-#include <language/command.h>
-#include <language/data-io/file-handle.h>
-#include <language/lexer/lexer.h>
-#include <language/lexer/variable-parser.h>
-#include <language/stats/sort-criteria.h>
-#include <libpspp/assertion.h>
-#include <libpspp/message.h>
-#include <libpspp/misc.h>
-#include <libpspp/pool.h>
-#include <libpspp/str.h>
-#include <math/moments.h>
-#include <math/sort.h>
-
-#include "minmax.h"
-#include "xalloc.h"
+#include "data/any-writer.h"
+#include "data/case.h"
+#include "data/casegrouper.h"
+#include "data/casereader.h"
+#include "data/casewriter.h"
+#include "data/dataset.h"
+#include "data/dictionary.h"
+#include "data/file-handle-def.h"
+#include "data/format.h"
+#include "data/settings.h"
+#include "data/subcase.h"
+#include "data/sys-file-writer.h"
+#include "data/variable.h"
+#include "language/command.h"
+#include "language/data-io/file-handle.h"
+#include "language/lexer/lexer.h"
+#include "language/lexer/variable-parser.h"
+#include "language/stats/sort-criteria.h"
+#include "libpspp/assertion.h"
+#include "libpspp/i18n.h"
+#include "libpspp/message.h"
+#include "libpspp/misc.h"
+#include "libpspp/pool.h"
+#include "libpspp/str.h"
+#include "math/moments.h"
+#include "math/percentiles.h"
+#include "math/sort.h"
+#include "math/statistic.h"
+
+#include "gl/c-strcase.h"
+#include "gl/minmax.h"
+#include "gl/xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
+#define N_(msgid) msgid
/* Argument for AGGREGATE function. */
union agr_argument
char *string;
bool saw_missing;
struct moments1 *moments;
- };
+ double cc;
-/* Aggregation functions. */
-enum
- {
- NONE, SUM, MEAN, SD, MAX, MIN, PGT, PLT, PIN, POUT, FGT, FLT, FIN,
- FOUT, N, NU, NMISS, NUMISS, FIRST, LAST,
- N_AGR_FUNCS, N_NO_VARS, NU_NO_VARS,
- FUNC = 0x1f, /* Function mask. */
- FSTRING = 1<<5, /* String function bit. */
+ struct variable *subject;
+ struct variable *weight;
+ struct casewriter *writer;
};
-/* Attributes of an aggregation function. */
-struct agr_func
- {
- const char *name; /* Aggregation function name. */
- size_t n_args; /* Number of arguments. */
- enum var_type alpha_type; /* When given ALPHA arguments, output type. */
- struct fmt_spec format; /* Format spec if alpha_type != ALPHA. */
- };
/* Attributes of aggregation functions. */
-static const struct agr_func agr_func_tab[] =
+const struct agr_func agr_func_tab[] =
{
- {"<NONE>", 0, -1, {0, 0, 0}},
- {"SUM", 0, -1, {FMT_F, 8, 2}},
- {"MEAN", 0, -1, {FMT_F, 8, 2}},
- {"SD", 0, -1, {FMT_F, 8, 2}},
- {"MAX", 0, VAR_STRING, {-1, -1, -1}},
- {"MIN", 0, VAR_STRING, {-1, -1, -1}},
- {"PGT", 1, VAR_NUMERIC, {FMT_F, 5, 1}},
- {"PLT", 1, VAR_NUMERIC, {FMT_F, 5, 1}},
- {"PIN", 2, VAR_NUMERIC, {FMT_F, 5, 1}},
- {"POUT", 2, VAR_NUMERIC, {FMT_F, 5, 1}},
- {"FGT", 1, VAR_NUMERIC, {FMT_F, 5, 3}},
- {"FLT", 1, VAR_NUMERIC, {FMT_F, 5, 3}},
- {"FIN", 2, VAR_NUMERIC, {FMT_F, 5, 3}},
- {"FOUT", 2, VAR_NUMERIC, {FMT_F, 5, 3}},
- {"N", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"NU", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"NMISS", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"NUMISS", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"FIRST", 0, VAR_STRING, {-1, -1, -1}},
- {"LAST", 0, VAR_STRING, {-1, -1, -1}},
- {NULL, 0, -1, {-1, -1, -1}},
- {"N", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
- {"NU", 0, VAR_NUMERIC, {FMT_F, 7, 0}},
+ {"SUM", N_("Sum of values"), AGR_SV_YES, 0, -1, { .type = FMT_F, .w = 8, .d = 2 }},
+ {"MEAN", N_("Mean average"), AGR_SV_YES, 0, -1, { .type = FMT_F, .w = 8, .d = 2 }},
+ {"MEDIAN", N_("Median average"), AGR_SV_YES, 0, -1, { .type = FMT_F, .w = 8, .d = 2 }},
+ {"SD", N_("Standard deviation"), AGR_SV_YES, 0, -1, { .type = FMT_F, .w = 8, .d = 2 }},
+ {"MAX", N_("Maximum value"), AGR_SV_YES, 0, VAL_STRING, {-1, -1, -1}},
+ {"MIN", N_("Minimum value"), AGR_SV_YES, 0, VAL_STRING, {-1, -1, -1}},
+ {"PGT", N_("Percentage greater than"), AGR_SV_YES, 1, VAL_NUMERIC, { .type = FMT_F, .w = 5, .d = 1 }},
+ {"PLT", N_("Percentage less than"), AGR_SV_YES, 1, VAL_NUMERIC, { .type = FMT_F, .w = 5, .d = 1 }},
+ {"PIN", N_("Percentage included in range"), AGR_SV_YES, 2, VAL_NUMERIC, { .type = FMT_F, .w = 5, .d = 1 }},
+ {"POUT", N_("Percentage excluded from range"), AGR_SV_YES, 2, VAL_NUMERIC, { .type = FMT_F, .w = 5, .d = 1 }},
+ {"FGT", N_("Fraction greater than"), AGR_SV_YES, 1, VAL_NUMERIC, { .type = FMT_F, .w = 5, .d = 3 }},
+ {"FLT", N_("Fraction less than"), AGR_SV_YES, 1, VAL_NUMERIC, { .type = FMT_F, .w = 5, .d = 3 }},
+ {"FIN", N_("Fraction included in range"), AGR_SV_YES, 2, VAL_NUMERIC, { .type = FMT_F, .w = 5, .d = 3 }},
+ {"FOUT", N_("Fraction excluded from range"), AGR_SV_YES, 2, VAL_NUMERIC, { .type = FMT_F, .w = 5, .d = 3 }},
+ {"N", N_("Number of cases"), AGR_SV_NO, 0, VAL_NUMERIC, { .type = FMT_F, .w = 7, .d = 0 }},
+ {"NU", N_("Number of cases (unweighted)"), AGR_SV_OPT, 0, VAL_NUMERIC, { .type = FMT_F, .w = 7, .d = 0 }},
+ {"NMISS", N_("Number of missing values"), AGR_SV_YES, 0, VAL_NUMERIC, { .type = FMT_F, .w = 7, .d = 0 }},
+ {"NUMISS", N_("Number of missing values (unweighted)"), AGR_SV_YES, 0, VAL_NUMERIC, { .type = FMT_F, .w = 7, .d = 0 }},
+ {"FIRST", N_("First non-missing value"), AGR_SV_YES, 0, VAL_STRING, {-1, -1, -1}},
+ {"LAST", N_("Last non-missing value"), AGR_SV_YES, 0, VAL_STRING, {-1, -1, -1}},
+ {NULL, NULL, AGR_SV_NO, 0, -1, {-1, -1, -1}},
};
/* Missing value types. */
struct agr_proc
{
/* Break variables. */
- struct case_ordering *sort; /* Sort criteria. */
+ struct subcase sort; /* Sort criteria (break variables). */
const struct variable **break_vars; /* Break variables. */
- size_t break_var_cnt; /* Number of break variables. */
- struct ccase break_case; /* Last values of break variables. */
+ size_t break_n_vars; /* Number of break variables. */
enum missing_treatment missing; /* How to treat missing values. */
struct agr_var *agr_vars; /* First aggregate variable. */
struct dictionary *dict; /* Aggregate dictionary. */
const struct dictionary *src_dict; /* Dict of the source */
- int case_cnt; /* Counts aggregated cases. */
+ int n_cases; /* Counts aggregated cases. */
+
+ bool add_variables; /* True iff the aggregated variables should
+ be appended to the existing dictionary */
};
-static void initialize_aggregate_info (struct agr_proc *,
- const struct ccase *);
+static void initialize_aggregate_info (struct agr_proc *);
+
static void accumulate_aggregate_info (struct agr_proc *,
const struct ccase *);
/* Prototypes. */
static bool parse_aggregate_functions (struct lexer *, const struct dictionary *,
struct agr_proc *);
static void agr_destroy (struct agr_proc *);
-static void dump_aggregate_info (struct agr_proc *agr,
- struct casewriter *output);
+static void dump_aggregate_info (const struct agr_proc *agr,
+ struct casewriter *output,
+ const struct ccase *break_case);
\f
/* Parsing. */
memset(&agr, 0 , sizeof (agr));
agr.missing = ITEMWISE;
- case_nullify (&agr.break_case);
-
- agr.dict = dict_create ();
agr.src_dict = dict;
- dict_set_label (agr.dict, dict_get_label (dict));
- dict_set_documents (agr.dict, dict_get_documents (dict));
+ subcase_init_empty (&agr.sort);
/* OUTFILE subcommand must be first. */
+ lex_match (lexer, T_SLASH);
if (!lex_force_match_id (lexer, "OUTFILE"))
goto error;
- lex_match (lexer, '=');
- if (!lex_match (lexer, '*'))
+ lex_match (lexer, T_EQUALS);
+ if (!lex_match (lexer, T_ASTERISK))
{
- out_file = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
+ out_file = fh_parse (lexer, FH_REF_FILE, dataset_session (ds));
if (out_file == NULL)
goto error;
}
+ if (out_file == NULL && lex_match_id (lexer, "MODE"))
+ {
+ lex_match (lexer, T_EQUALS);
+ if (lex_match_id (lexer, "ADDVARIABLES"))
+ {
+ agr.add_variables = true;
+
+ /* presorted is assumed in ADDVARIABLES mode */
+ presorted = true;
+ }
+ else if (lex_match_id (lexer, "REPLACE"))
+ {
+ agr.add_variables = false;
+ }
+ else
+ goto error;
+ }
+
+ if (agr.add_variables)
+ agr.dict = dict_clone (dict);
+ else
+ agr.dict = dict_create (dict_get_encoding (dict));
+
+ dict_set_label (agr.dict, dict_get_label (dict));
+ dict_set_documents (agr.dict, dict_get_documents (dict));
+
/* Read most of the subcommands. */
for (;;)
{
- lex_match (lexer, '/');
+ lex_match (lexer, T_SLASH);
if (lex_match_id (lexer, "MISSING"))
{
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
if (!lex_match_id (lexer, "COLUMNWISE"))
{
- lex_error (lexer, _("while expecting COLUMNWISE"));
+ lex_error_expecting (lexer, "COLUMNWISE");
goto error;
}
agr.missing = COLUMNWISE;
copy_documents = true;
else if (lex_match_id (lexer, "PRESORTED"))
presorted = true;
- else if (lex_match_id (lexer, "BREAK"))
+ else if (lex_force_match_id (lexer, "BREAK"))
{
int i;
- lex_match (lexer, '=');
- agr.sort = parse_case_ordering (lexer, dict,
-
- &saw_direction);
- if (agr.sort == NULL)
+ lex_match (lexer, T_EQUALS);
+ if (!parse_sort_criteria (lexer, dict, &agr.sort, &agr.break_vars,
+ &saw_direction))
goto error;
- case_ordering_get_vars (agr.sort,
- &agr.break_vars, &agr.break_var_cnt);
+ agr.break_n_vars = subcase_get_n_fields (&agr.sort);
- for (i = 0; i < agr.break_var_cnt; i++)
- dict_clone_var_assert (agr.dict, agr.break_vars[i],
- var_get_name (agr.break_vars[i]));
+ if (! agr.add_variables)
+ for (i = 0; i < agr.break_n_vars; i++)
+ dict_clone_var_assert (agr.dict, agr.break_vars[i]);
/* BREAK must follow the options. */
break;
}
else
- {
- lex_error (lexer, _("expecting BREAK"));
- goto error;
- }
+ goto error;
+
}
if (presorted && saw_direction)
msg (SW, _("When PRESORTED is specified, specifying sorting directions "
"the same way as the input data."));
/* Read in the aggregate functions. */
- lex_match (lexer, '/');
+ lex_match (lexer, T_SLASH);
if (!parse_aggregate_functions (lexer, dict, &agr))
goto error;
dict_set_split_vars (agr.dict, NULL, 0);
/* Initialize. */
- agr.case_cnt = 0;
+ agr.n_cases = 0;
if (out_file == NULL)
{
- /* The active file will be replaced by the aggregated data,
+ /* The active dataset will be replaced by the aggregated data,
so TEMPORARY is moot. */
proc_cancel_temporary_transformations (ds);
proc_discard_output (ds);
- output = autopaging_writer_create (dict_get_next_value_idx (agr.dict));
+ output = autopaging_writer_create (dict_get_proto (agr.dict));
}
else
{
}
input = proc_open (ds);
- if (agr.sort != NULL && !presorted)
+ if (!subcase_is_empty (&agr.sort) && !presorted)
{
- input = sort_execute (input, agr.sort);
- agr.sort = NULL;
+ input = sort_execute (input, &agr.sort);
+ subcase_clear (&agr.sort);
}
for (grouper = casegrouper_create_vars (input, agr.break_vars,
- agr.break_var_cnt);
+ agr.break_n_vars);
casegrouper_get_next_group (grouper, &group);
casereader_destroy (group))
{
- struct ccase c;
+ struct casereader *placeholder = NULL;
+ struct ccase *c = casereader_peek (group, 0);
- if (!casereader_peek (group, 0, &c))
+ if (c == NULL)
{
casereader_destroy (group);
continue;
}
- initialize_aggregate_info (&agr, &c);
- case_destroy (&c);
- for (; casereader_read (group, &c); case_destroy (&c))
- accumulate_aggregate_info (&agr, &c);
- dump_aggregate_info (&agr, output);
+ initialize_aggregate_info (&agr);
+
+ if (agr.add_variables)
+ placeholder = casereader_clone (group);
+
+ {
+ struct ccase *cg;
+ for (; (cg = casereader_read (group)) != NULL; case_unref (cg))
+ accumulate_aggregate_info (&agr, cg);
+ }
+
+
+ if (agr.add_variables)
+ {
+ struct ccase *cg;
+ for (; (cg = casereader_read (placeholder)) != NULL; case_unref (cg))
+ dump_aggregate_info (&agr, output, cg);
+
+ casereader_destroy (placeholder);
+ }
+ else
+ {
+ dump_aggregate_info (&agr, output, c);
+ }
+ case_unref (c);
}
if (!casegrouper_destroy (grouper))
goto error;
if (next_input == NULL)
goto error;
- proc_set_active_file (ds, next_input, agr.dict);
+ dataset_set_dict (ds, agr.dict);
+ dataset_set_source (ds, next_input);
agr.dict = NULL;
}
else
/* Parse all the aggregate functions. */
static bool
-parse_aggregate_functions (struct lexer *lexer, const struct dictionary *dict, struct agr_proc *agr)
+parse_aggregate_functions (struct lexer *lexer, const struct dictionary *dict,
+ struct agr_proc *agr)
{
struct agr_var *tail; /* Tail of linked list starting at agr->vars. */
ds_init_empty (&function_name);
/* Parse the list of target variables. */
- while (!lex_match (lexer, '='))
+ while (!lex_match (lexer, T_EQUALS))
{
size_t n_dest_prev = n_dest;
- if (!parse_DATA_LIST_vars (lexer, &dest, &n_dest,
- PV_APPEND | PV_SINGLE | PV_NO_SCRATCH))
+ if (!parse_DATA_LIST_vars (lexer, dict, &dest, &n_dest,
+ (PV_APPEND | PV_SINGLE | PV_NO_SCRATCH
+ | PV_NO_DUPLICATE)))
goto error;
/* Assign empty labels. */
- if (lex_token (lexer) == T_STRING)
+ if (lex_is_string (lexer))
{
- struct string label;
- ds_init_string (&label, lex_tokstr (lexer));
-
- ds_truncate (&label, 255);
- dest_label[n_dest - 1] = ds_xstrdup (&label);
+ dest_label[n_dest - 1] = xstrdup (lex_tokcstr (lexer));
lex_get (lexer);
- ds_destroy (&label);
}
}
goto error;
}
- exclude = MV_ANY;
-
- ds_assign_string (&function_name, lex_tokstr (lexer));
-
- ds_chomp (&function_name, '.');
-
- if (lex_tokid(lexer)[strlen (lex_tokid (lexer)) - 1] == '.')
- exclude = MV_SYSTEM;
+ ds_assign_substring (&function_name, lex_tokss (lexer));
+ exclude = ds_chomp_byte (&function_name, '.') ? MV_SYSTEM : MV_ANY;
for (function = agr_func_tab; function->name; function++)
- if (!strcasecmp (function->name, ds_cstr (&function_name)))
+ if (!c_strcasecmp (function->name, ds_cstr (&function_name)))
break;
if (NULL == function->name)
{
lex_get (lexer);
/* Check for leading lparen. */
- if (!lex_match (lexer, '('))
+ if (!lex_match (lexer, T_LPAREN))
{
- if (func_index == N)
- func_index = N_NO_VARS;
- else if (func_index == NU)
- func_index = NU_NO_VARS;
- else
+ if (function->src_vars == AGR_SV_YES)
{
- lex_error (lexer, _("expecting `('"));
goto error;
}
}
{
int type;
- lex_match (lexer, ',');
- if (lex_token (lexer) == T_STRING)
+ lex_match (lexer, T_COMMA);
+ if (lex_is_string (lexer))
{
- arg[i].c = ds_xstrdup (lex_tokstr (lexer));
- type = VAR_STRING;
+ arg[i].c = recode_string (dict_get_encoding (agr->dict),
+ "UTF-8", lex_tokcstr (lexer),
+ -1);
+ type = VAL_STRING;
}
else if (lex_is_number (lexer))
{
arg[i].f = lex_tokval (lexer);
- type = VAR_NUMERIC;
+ type = VAL_NUMERIC;
}
else
{
}
/* Trailing rparen. */
- if (!lex_match (lexer, ')'))
- {
- lex_error (lexer, _("expecting `)'"));
- goto error;
- }
+ if (!lex_force_match (lexer, T_RPAREN))
+ goto error;
/* Now check that the number of source variables match
the number of target variables. If we check earlier
variables. */
for (i = 0; i < n_dest; i++)
{
- struct agr_var *v = xmalloc (sizeof *v);
+ struct agr_var *v = XZALLOC (struct agr_var);
/* Add variable to chain. */
if (agr->agr_vars != NULL)
v->string = xmalloc (var_get_width (src[i]));
}
- if (function->alpha_type == VAR_STRING)
- destvar = dict_clone_var (agr->dict, v->src, dest[i]);
+ if (function->alpha_type == VAL_STRING)
+ destvar = dict_clone_var_as (agr->dict, v->src, dest[i]);
else
{
assert (var_is_numeric (v->src)
- || function->alpha_type == VAR_NUMERIC);
+ || function->alpha_type == VAL_NUMERIC);
destvar = dict_create_var (agr->dict, dest[i], 0);
if (destvar != NULL)
{
struct fmt_spec f;
v->src = NULL;
destvar = dict_create_var (agr->dict, dest[i], 0);
- if (func_index == N_NO_VARS && dict_get_weight (dict) != NULL)
- f = fmt_for_output (FMT_F, 8, 2);
- else
- f = function->format;
- var_set_both_formats (destvar, &f);
- }
+ if (destvar != NULL)
+ {
+ if ((func_index == N || func_index == NMISS)
+ && dict_get_weight (dict) != NULL)
+ f = fmt_for_output (FMT_F, 8, 2);
+ else
+ f = function->format;
+ var_set_both_formats (destvar, &f);
+ }
+ }
if (!destvar)
{
free (dest);
free (dest_label);
- if (!lex_match (lexer, '/'))
+ if (!lex_match (lexer, T_SLASH))
{
- if (lex_token (lexer) == '.')
+ if (lex_token (lexer) == T_ENDCMD)
return true;
lex_error (lexer, "expecting end of command");
{
struct agr_var *iter, *next;
- case_ordering_destroy (agr->sort);
+ subcase_uninit (&agr->sort);
free (agr->break_vars);
- case_destroy (&agr->break_case);
for (iter = agr->agr_vars; iter; iter = next)
{
next = iter->next;
}
else if (iter->function == SD)
moments1_destroy (iter->moments);
+
+ dict_destroy_internal_var (iter->subject);
+ dict_destroy_internal_var (iter->weight);
+
free (iter);
}
if (agr->dict != NULL)
- dict_destroy (agr->dict);
+ dict_unref (agr->dict);
}
\f
/* Execution. */
const union value *v = case_data (input, iter->src);
int src_width = var_get_width (iter->src);
- if (var_is_value_missing (iter->src, v, iter->exclude))
+ if (var_is_value_missing (iter->src, v) & iter->exclude)
{
switch (iter->function)
{
iter->dbl[0] += v->f * weight;
iter->dbl[1] += weight;
break;
+ case MEDIAN:
+ {
+ double wv ;
+ struct ccase *cout;
+
+ cout = case_create (casewriter_get_proto (iter->writer));
+
+ *case_num_rw (cout, iter->subject) = case_num (input, iter->src);
+
+ wv = dict_get_case_weight (agr->src_dict, input, NULL);
+
+ *case_num_rw (cout, iter->weight) = wv;
+
+ iter->cc += wv;
+
+ casewriter_write (iter->writer, cout);
+ }
+ break;
case SD:
moments1_add (iter->moments, v->f, weight);
break;
iter->int1 = 1;
break;
case MAX | FSTRING:
+ /* Need to do some kind of Unicode collation thingy here */
if (memcmp (iter->string, v->s, src_width) < 0)
memcpy (iter->string, v->s, src_width);
iter->int1 = 1;
default:
NOT_REACHED ();
}
- } else {
+ } else {
switch (iter->function)
{
- case N_NO_VARS:
+ case N:
iter->dbl[0] += weight;
break;
- case NU_NO_VARS:
+ case NU:
iter->int1++;
break;
default:
/* Writes an aggregated record to OUTPUT. */
static void
-dump_aggregate_info (struct agr_proc *agr, struct casewriter *output)
+dump_aggregate_info (const struct agr_proc *agr, struct casewriter *output, const struct ccase *break_case)
{
- struct ccase c;
+ struct ccase *c = case_create (dict_get_proto (agr->dict));
- case_create (&c, dict_get_next_value_idx (agr->dict));
-
- {
- int value_idx = 0;
- int i;
+ if (agr->add_variables)
+ {
+ case_copy (c, 0, break_case, 0, dict_get_n_vars (agr->src_dict));
+ }
+ else
+ {
+ int value_idx = 0;
+ int i;
- for (i = 0; i < agr->break_var_cnt; i++)
- {
- const struct variable *v = agr->break_vars[i];
- size_t value_cnt = var_get_value_cnt (v);
- memcpy (case_data_rw_idx (&c, value_idx),
- case_data (&agr->break_case, v),
- sizeof (union value) * value_cnt);
- value_idx += value_cnt;
- }
- }
+ for (i = 0; i < agr->break_n_vars; i++)
+ {
+ const struct variable *v = agr->break_vars[i];
+ value_copy (case_data_rw_idx (c, value_idx),
+ case_data (break_case, v),
+ var_get_width (v));
+ value_idx++;
+ }
+ }
{
struct agr_var *i;
for (i = agr->agr_vars; i; i = i->next)
{
- union value *v = case_data_rw (&c, i->dest);
+ union value *v = case_data_rw (c, i->dest);
+ int width = var_get_width (i->dest);
if (agr->missing == COLUMNWISE && i->saw_missing
&& (i->function & FUNC) != N && (i->function & FUNC) != NU
&& (i->function & FUNC) != NMISS && (i->function & FUNC) != NUMISS)
{
- if (var_is_alpha (i->dest))
- memset (v->s, ' ', var_get_width (i->dest));
- else
- v->f = SYSMIS;
+ value_set_missing (v, width);
+ casewriter_destroy (i->writer);
continue;
}
case MEAN:
v->f = i->dbl[1] != 0.0 ? i->dbl[0] / i->dbl[1] : SYSMIS;
break;
+ case MEDIAN:
+ {
+ if (i->writer)
+ {
+ struct percentile *median = percentile_create (0.5, i->cc);
+ struct order_stats *os = &median->parent;
+ struct casereader *sorted_reader = casewriter_make_reader (i->writer);
+ i->writer = NULL;
+
+ order_stats_accumulate (&os, 1,
+ sorted_reader,
+ i->weight,
+ i->subject,
+ i->exclude);
+ i->dbl[0] = percentile_calculate (median, PC_HAVERAGE);
+ statistic_destroy (&median->parent.parent);
+ }
+ v->f = i->dbl[0];
+ }
+ break;
case SD:
{
double variance;
case MAX | FSTRING:
case MIN | FSTRING:
if (i->int1)
- memcpy (v->s, i->string, var_get_width (i->dest));
+ memcpy (v->s, i->string, width);
else
- memset (v->s, ' ', var_get_width (i->dest));
+ value_set_missing (v, width);
break;
case FGT:
case FGT | FSTRING:
break;
case N:
case N | FSTRING:
- v->f = i->dbl[0];
+ v->f = i->dbl[0];
break;
case NU:
case NU | FSTRING:
case FIRST | FSTRING:
case LAST | FSTRING:
if (i->int1)
- memcpy (v->s, i->string, var_get_width (i->dest));
+ memcpy (v->s, i->string, width);
else
- memset (v->s, ' ', var_get_width (i->dest));
- break;
- case N_NO_VARS:
- v->f = i->dbl[0];
- break;
- case NU_NO_VARS:
- v->f = i->int1;
+ value_set_missing (v, width);
break;
case NMISS:
case NMISS | FSTRING:
}
}
- casewriter_write (output, &c);
+ casewriter_write (output, c);
}
/* Resets the state for all the aggregate functions. */
static void
-initialize_aggregate_info (struct agr_proc *agr, const struct ccase *input)
+initialize_aggregate_info (struct agr_proc *agr)
{
struct agr_var *iter;
- case_destroy (&agr->break_case);
- case_clone (&agr->break_case, input);
-
for (iter = agr->agr_vars; iter; iter = iter->next)
{
iter->saw_missing = false;
case MAX | FSTRING:
memset (iter->string, 0, var_get_width (iter->src));
break;
+ case MEDIAN:
+ {
+ struct caseproto *proto;
+ struct subcase ordering;
+
+ proto = caseproto_create ();
+ proto = caseproto_add_width (proto, 0);
+ proto = caseproto_add_width (proto, 0);
+
+ if (! iter->subject)
+ iter->subject = dict_create_internal_var (0, 0);
+
+ if (! iter->weight)
+ iter->weight = dict_create_internal_var (1, 0);
+
+ subcase_init_var (&ordering, iter->subject, SC_ASCEND);
+ iter->writer = sort_create_writer (&ordering, proto);
+ subcase_uninit (&ordering);
+ caseproto_unref (proto);
+
+ iter->cc = 0;
+ }
+ break;
case SD:
if (iter->moments == NULL)
iter->moments = moments1_create (MOMENT_VARIANCE);