/* PSPP - a program for statistical analysis.
- Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2005, 2006, 2007, 2009, 2010 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 <limits.h>
#include <math.h>
-#include <data/case-ordering.h>
#include <data/case.h>
#include <data/casegrouper.h>
#include <data/casereader.h>
#include <data/missing-values.h>
#include <data/procedure.h>
#include <data/short-names.h>
+#include <data/subcase.h>
#include <data/variable.h>
#include <language/command.h>
#include <language/stats/sort-criteria.h>
#include <libpspp/compiler.h>
#include <libpspp/taint.h>
#include <math/sort.h>
-#include <output/manager.h>
-#include <output/table.h>
+#include <output/tab.h>
#include <gsl/gsl_cdf.h>
static struct rank_spec *rank_specs;
static size_t n_rank_specs;
-static struct case_ordering *sc;
+static struct subcase sc;
static const struct variable **group_vars;
static size_t n_group_vars;
static bool
-rank_cmd (struct dataset *ds, const struct case_ordering *sc,
+rank_cmd (struct dataset *ds, const struct subcase *sc,
const struct rank_spec *rank_specs, int n_rank_specs)
{
struct dictionary *d = dataset_dict (ds);
bool ok = true;
int i;
- for (i = 0 ; i < case_ordering_get_var_cnt (sc) ; ++i )
+ for (i = 0 ; i < subcase_get_n_fields (sc) ; ++i )
{
/* Rank variable at index I in SC. */
struct casegrouper *split_grouper;
proc_discard_output (ds);
split_grouper = casegrouper_create_splits (proc_open (ds), d);
- output = autopaging_writer_create (dict_get_next_value_idx (d));
+ output = autopaging_writer_create (dict_get_proto (d));
while (casegrouper_get_next_group (split_grouper, &split_group))
{
- struct case_ordering *ordering;
+ struct subcase ordering;
struct casereader *ordered;
struct casegrouper *by_grouper;
struct casereader *by_group;
- int j;
/* Sort this split group by the BY variables as primary
keys and the rank variable as secondary key. */
- ordering = case_ordering_create (d);
- for (j = 0; j < n_group_vars; j++)
- case_ordering_add_var (ordering, group_vars[j], SRT_ASCEND);
- case_ordering_add_var (ordering,
- case_ordering_get_var (sc, i),
- case_ordering_get_direction (sc, i));
- ordered = sort_execute (split_group, ordering);
+ subcase_init_vars (&ordering, group_vars, n_group_vars);
+ subcase_add_var (&ordering, src_vars[i],
+ subcase_get_direction (sc, i));
+ ordered = sort_execute (split_group, &ordering);
+ subcase_destroy (&ordering);
/* Rank the rank variable within this split group. */
by_grouper = casegrouper_create_vars (ordered,
{
struct casereader *pass1, *pass2, *pass2_1;
struct casegrouper *tie_grouper;
- struct ccase c;
+ struct ccase *c;
double w = 0.0;
double cc = 0.0;
int tie_group = 1;
input = casereader_create_filter_missing (input, &rank_var, 1,
- exclude_values, output);
+ exclude_values, NULL, output);
input = casereader_create_filter_weight (input, dict, NULL, output);
casereader_split (input, &pass1, &pass2);
/* Pass 1: Get total group weight. */
- for (; casereader_read (pass1, &c); case_destroy (&c))
- w += dict_get_case_weight (dict, &c, NULL);
+ for (; (c = casereader_read (pass1)) != NULL; case_unref (c))
+ w += dict_get_case_weight (dict, c, NULL);
casereader_destroy (pass1);
/* Pass 2: Do ranking. */
casewriter_get_taint (output));
/* Pass 2.1: Sum up weight for tied cases. */
- for (; casereader_read (pass2_1, &c); case_destroy (&c))
- tw += dict_get_case_weight (dict, &c, NULL);
+ for (; (c = casereader_read (pass2_1)) != NULL; case_unref (c))
+ tw += dict_get_case_weight (dict, c, NULL);
cc += tw;
casereader_destroy (pass2_1);
/* Pass 2.2: Rank tied cases. */
- while (casereader_read (pass2_2, &c))
+ while ((c = casereader_read (pass2_2)) != NULL)
{
+ c = case_unshare (c);
for (i = 0; i < n_rank_specs; ++i)
{
const struct variable *dst_var = rs[i].destvars[dest_idx];
- double *dst_value = &case_data_rw (&c, dst_var)->f;
+ double *dst_value = &case_data_rw (c, dst_var)->f;
*dst_value = rank_func[rs[i].rfunc] (tw, cc, cc_1, tie_group, w);
}
- casewriter_write (output, &c);
+ casewriter_write (output, c);
}
casereader_destroy (pass2_2);
/* Transformation function to enumerate all the cases */
static int
-create_resort_key (void *key_var_, struct ccase *cc, casenumber case_num)
+create_resort_key (void *key_var_, struct ccase **cc, casenumber case_num)
{
struct variable *key_var = key_var_;
- case_data_rw(cc, key_var)->f = case_num;
+ *cc = case_unshare (*cc);
+ case_data_rw (*cc, key_var)->f = case_num;
return TRNS_CONTINUE;
}
rank_specs = NULL;
n_rank_specs = 0;
- case_ordering_destroy (sc);
- sc = NULL;
+ subcase_destroy (&sc);
free (src_vars);
src_vars = NULL;
size_t i;
n_rank_specs = 0;
+ subcase_init_empty (&sc);
if ( !parse_rank (lexer, ds, &cmd, NULL) )
{
rank_cleanup ();
rank_specs = xmalloc (sizeof (*rank_specs));
rank_specs[0].rfunc = RANK;
rank_specs[0].destvars =
- xcalloc (case_ordering_get_var_cnt (sc), sizeof (struct variable *));
+ xcalloc (subcase_get_n_fields (&sc), sizeof (struct variable *));
n_rank_specs = 1;
}
- assert ( case_ordering_get_var_cnt (sc) == n_src_vars);
+ assert ( subcase_get_n_fields (&sc) == n_src_vars);
/* Create variables for all rank destinations which haven't
already been created with INTO.
int v;
tab_output_text (0, _("Variables Created By RANK"));
- tab_output_text (0, "\n");
+ tab_output_text (0, "");
for (i = 0 ; i < n_rank_specs ; ++i )
{
if ( rank_specs[i].rfunc == NORMAL ||
rank_specs[i].rfunc == PROPORTION )
- tab_output_text (TAT_PRINTF,
- _("%s into %s(%s of %s using %s BY %s)"),
- var_get_name (src_vars[v]),
- var_get_name (rank_specs[i].destvars[v]),
- function_name[rank_specs[i].rfunc],
- var_get_name (src_vars[v]),
- fraction_name(),
- ds_cstr (&varlist)
- );
+ tab_output_text_format (0,
+ _("%s into %s(%s of %s using %s BY %s)"),
+ var_get_name (src_vars[v]),
+ var_get_name (rank_specs[i].destvars[v]),
+ function_name[rank_specs[i].rfunc],
+ var_get_name (src_vars[v]),
+ fraction_name(),
+ ds_cstr (&varlist));
else
- tab_output_text (TAT_PRINTF,
- _("%s into %s(%s of %s BY %s)"),
- var_get_name (src_vars[v]),
- var_get_name (rank_specs[i].destvars[v]),
- function_name[rank_specs[i].rfunc],
- var_get_name (src_vars[v]),
- ds_cstr (&varlist)
- );
+ tab_output_text_format (0,
+ _("%s into %s(%s of %s BY %s)"),
+ var_get_name (src_vars[v]),
+ var_get_name (rank_specs[i].destvars[v]),
+ function_name[rank_specs[i].rfunc],
+ var_get_name (src_vars[v]),
+ ds_cstr (&varlist));
ds_destroy (&varlist);
}
else
{
if ( rank_specs[i].rfunc == NORMAL ||
rank_specs[i].rfunc == PROPORTION )
- tab_output_text (TAT_PRINTF,
- _("%s into %s(%s of %s using %s)"),
- var_get_name (src_vars[v]),
- var_get_name (rank_specs[i].destvars[v]),
- function_name[rank_specs[i].rfunc],
- var_get_name (src_vars[v]),
- fraction_name()
- );
+ tab_output_text_format (0,
+ _("%s into %s(%s of %s using %s)"),
+ var_get_name (src_vars[v]),
+ var_get_name (rank_specs[i].destvars[v]),
+ function_name[rank_specs[i].rfunc],
+ var_get_name (src_vars[v]),
+ fraction_name());
else
- tab_output_text (TAT_PRINTF,
- _("%s into %s(%s of %s)"),
- var_get_name (src_vars[v]),
- var_get_name (rank_specs[i].destvars[v]),
- function_name[rank_specs[i].rfunc],
- var_get_name (src_vars[v])
- );
+ tab_output_text_format (0,
+ _("%s into %s(%s of %s)"),
+ var_get_name (src_vars[v]),
+ var_get_name (rank_specs[i].destvars[v]),
+ function_name[rank_specs[i].rfunc],
+ var_get_name (src_vars[v]));
}
}
}
add_transformation (ds, create_resort_key, 0, order);
/* Do the ranking */
- result = rank_cmd (ds, sc, rank_specs, n_rank_specs);
+ result = rank_cmd (ds, &sc, rank_specs, n_rank_specs);
/* Put the active file back in its original order. Delete
our sort key, which we don't need anymore. */
{
- struct case_ordering *ordering = case_ordering_create (dataset_dict (ds));
struct casereader *sorted;
- case_ordering_add_var (ordering, order, SRT_ASCEND);
+
/* FIXME: loses error conditions. */
+
proc_discard_output (ds);
- sorted = sort_execute (proc_open (ds), ordering);
+ sorted = sort_execute_1var (proc_open (ds), order);
result = proc_commit (ds) && result;
dict_delete_var (dataset_dict (ds), order);
static int
rank_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd UNUSED, void *aux UNUSED)
{
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
- if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)
+ if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokcstr (lexer)) == NULL)
&& lex_token (lexer) != T_ALL)
return 2;
- sc = parse_case_ordering (lexer, dataset_dict (ds), NULL);
- if (sc == NULL)
+ if (!parse_sort_criteria (lexer, dataset_dict (ds), &sc, &src_vars, NULL))
return 0;
- case_ordering_get_vars (sc, &src_vars, &n_src_vars);
+ n_src_vars = subcase_get_n_fields (&sc);
if ( lex_match (lexer, T_BY) )
{
- if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL))
+ if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokcstr (lexer)) == NULL))
{
return 2;
}
rank_specs[n_rank_specs - 1].destvars = NULL;
rank_specs[n_rank_specs - 1].destvars =
- xcalloc (case_ordering_get_var_cnt (sc),
- sizeof (struct variable *));
+ xcalloc (subcase_get_n_fields (&sc), sizeof (struct variable *));
if (lex_match_id (lexer, "INTO"))
{
while( lex_token (lexer) == T_ID )
{
- if ( dict_lookup_var (dict, lex_tokid (lexer)) != NULL )
+ if ( dict_lookup_var (dict, lex_tokcstr (lexer)) != NULL )
{
- msg(SE, _("Variable %s already exists."), lex_tokid (lexer));
+ msg(SE, _("Variable %s already exists."), lex_tokcstr (lexer));
return 0;
}
- if ( var_count >= case_ordering_get_var_cnt (sc) )
+ if ( var_count >= subcase_get_n_fields (&sc) )
{
msg(SE, _("Too many variables in INTO clause."));
return 0;
}
- destvar = create_rank_variable (dict, f, src_vars[var_count], lex_tokid (lexer));
+ destvar = create_rank_variable (dict, f, src_vars[var_count], lex_tokcstr (lexer));
rank_specs[n_rank_specs - 1].destvars[var_count] = destvar ;
lex_get (lexer);
{
struct dictionary *dict = dataset_dict (ds);
- if ( lex_force_match (lexer, '(') )
+ if ( lex_force_match (lexer, T_LPAREN) )
{
if ( lex_force_int (lexer) )
{
k_ntiles = lex_integer (lexer);
lex_get (lexer);
- lex_force_match (lexer, ')');
+ lex_force_match (lexer, T_RPAREN);
}
else
return 0;