X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Frank.q;h=eb16f3113b9b3396b6096e1bfd7898f345a2e19d;hb=9e24f9a5c52650da0700066e8d9e72261c6492ad;hp=13facbdbbf59f85e43bd350578d4633cb07b880e;hpb=015e221b0f8578afee769528572c76387f26c629;p=pspp-builds.git diff --git a/src/language/stats/rank.q b/src/language/stats/rank.q index 13facbdb..eb16f311 100644 --- a/src/language/stats/rank.q +++ b/src/language/stats/rank.q @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc. + Copyright (C) 2005, 2006, 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 @@ -16,29 +16,27 @@ #include +#include #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include +#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/format.h" +#include "data/missing-values.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/tab.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -152,7 +150,7 @@ static enum mv_class exclude_values; 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; @@ -200,7 +198,8 @@ fraction_name(void) /* Create a label on DEST_VAR, describing its derivation from SRC_VAR and F */ static void create_var_label (struct variable *dest_var, - const struct variable *src_var, enum RANK_FUNC f) + const struct variable *src_var, enum RANK_FUNC f, + const char *dict_encoding) { struct string label; ds_init_empty (&label); @@ -226,21 +225,21 @@ create_var_label (struct variable *dest_var, ds_put_format (&label, _("%s of %s"), function_name[f], var_get_name (src_var)); - var_set_label (dest_var, ds_cstr (&label)); + var_set_label (dest_var, ds_cstr (&label), dict_encoding, false); ds_destroy (&label); } 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; @@ -249,25 +248,22 @@ rank_cmd (struct dataset *ds, const struct case_ordering *sc, 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 (); - 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, @@ -284,7 +280,7 @@ rank_cmd (struct dataset *ds, const struct case_ordering *sc, } ok = casegrouper_destroy (split_grouper); ok = proc_commit (ds) && ok; - ok = (proc_set_active_file_data (ds, casewriter_make_reader (output)) + ok = (dataset_set_source (ds, casewriter_make_reader (output)) && ok); if (!ok) break; @@ -479,7 +475,7 @@ rank_sorted_file (struct casereader *input, { 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; @@ -492,8 +488,8 @@ rank_sorted_file (struct casereader *input, 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. */ @@ -510,21 +506,22 @@ rank_sorted_file (struct casereader *input, 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); @@ -535,11 +532,12 @@ rank_sorted_file (struct casereader *input, /* 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; } @@ -625,8 +623,7 @@ rank_cleanup(void) rank_specs = NULL; n_rank_specs = 0; - case_ordering_destroy (sc); - sc = NULL; + subcase_destroy (&sc); free (src_vars); src_vars = NULL; @@ -641,6 +638,7 @@ cmd_rank (struct lexer *lexer, struct dataset *ds) size_t i; n_rank_specs = 0; + subcase_init_empty (&sc); if ( !parse_rank (lexer, ds, &cmd, NULL) ) { rank_cleanup (); @@ -660,12 +658,12 @@ cmd_rank (struct lexer *lexer, struct dataset *ds) 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. @@ -676,15 +674,18 @@ cmd_rank (struct lexer *lexer, struct dataset *ds) int v; for ( v = 0 ; v < n_src_vars ; v ++ ) { + struct dictionary *dict = dataset_dict (ds); + if ( rank_specs[i].destvars[v] == NULL ) { rank_specs[i].destvars[v] = - create_rank_variable (dataset_dict(ds), rank_specs[i].rfunc, src_vars[v], NULL); + create_rank_variable (dict, rank_specs[i].rfunc, src_vars[v], NULL); } create_var_label ( rank_specs[i].destvars[v], src_vars[v], - rank_specs[i].rfunc); + rank_specs[i].rfunc, + dict_get_encoding (dict)); } } @@ -693,7 +694,7 @@ cmd_rank (struct lexer *lexer, struct dataset *ds) 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 ) { @@ -715,48 +716,44 @@ cmd_rank (struct lexer *lexer, struct dataset *ds) 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])); } } } @@ -773,21 +770,21 @@ cmd_rank (struct lexer *lexer, struct dataset *ds) 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 (); 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); - result = proc_set_active_file_data (ds, sorted) && result; + result = dataset_set_source (ds, sorted) && result; } rank_cleanup(); @@ -802,20 +799,19 @@ cmd_rank (struct lexer *lexer, struct dataset *ds) 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; } @@ -845,8 +841,7 @@ parse_rank_function (struct lexer *lexer, struct dictionary *dict, struct cmd_ra 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")) { @@ -855,18 +850,18 @@ parse_rank_function (struct lexer *lexer, struct dictionary *dict, struct cmd_ra 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); @@ -940,13 +935,13 @@ rank_custom_ntiles (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cm { 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;