X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Frank.q;h=894d2769b68d8125636992cfb5f5570830806743;hb=687adf53eae434e88a47bb3409f946f3a26115a4;hp=5f58f8c65c07af06cb5e38cb618eedef839a687c;hpb=8eac4df36306cd357bba29ffbfaddc537fc0be47;p=pspp-builds.git diff --git a/src/language/stats/rank.q b/src/language/stats/rank.q index 5f58f8c6..894d2769 100644 --- a/src/language/stats/rank.q +++ b/src/language/stats/rank.q @@ -1,7 +1,6 @@ /* PSPP - RANK. -*-c-*- Copyright (C) 2005, 2006 Free Software Foundation, Inc. -Author: John Darrington , Ben Pfaff . This program is free software; you can redistribute it and/or @@ -24,6 +23,8 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA #include "sort-criteria.h" #include +#include +#include #include #include #include @@ -148,7 +149,7 @@ struct rank_spec /* Function to use for testing for missing values */ -static is_missing_func *value_is_missing; +static mv_is_missing_func *value_is_missing; static struct rank_spec *rank_specs; static size_t n_rank_specs; @@ -168,6 +169,7 @@ static struct cmd_rank cmd; static struct casefile *rank_sorted_casefile (struct casefile *cf, const struct sort_criteria *, + const struct dictionary *, const struct rank_spec *rs, int n_rank_specs, int idx, @@ -215,44 +217,45 @@ create_var_label (struct variable *dest_var, for (g = 0 ; g < n_group_vars ; ++g ) { if ( g > 0 ) ds_put_cstr (&group_var_str, " "); - ds_put_cstr (&group_var_str, group_vars[g]->name); + ds_put_cstr (&group_var_str, var_get_name (group_vars[g])); } ds_put_format (&label, _("%s of %s by %s"), function_name[f], - src_var->name, ds_cstr (&group_var_str)); + var_get_name (src_var), ds_cstr (&group_var_str)); ds_destroy (&group_var_str); } else - ds_put_format (&label,_("%s of %s"), function_name[f], src_var->name); + ds_put_format (&label, _("%s of %s"), + function_name[f], var_get_name (src_var)); - dest_var->label = strdup (ds_cstr (&label) ); + var_set_label (dest_var, ds_cstr (&label)); ds_destroy (&label); } static bool -rank_cmd (const struct sort_criteria *sc, - const struct rank_spec *rank_specs, int n_rank_specs) +rank_cmd (struct dataset *ds, const struct sort_criteria *sc, + const struct rank_spec *rank_specs, int n_rank_specs) { struct sort_criteria criteria; bool result = true; int i; - const int n_splits = dict_get_split_cnt (dataset_dict (current_dataset)); + const int n_splits = dict_get_split_cnt (dataset_dict (ds)); criteria.crit_cnt = n_splits + n_group_vars + 1; criteria.crits = xnmalloc (criteria.crit_cnt, sizeof *criteria.crits); for (i = 0; i < n_splits ; i++) { - struct variable *v = dict_get_split_vars (dataset_dict (current_dataset))[i]; - criteria.crits[i].fv = v->fv; - criteria.crits[i].width = v->width; + struct variable *v = dict_get_split_vars (dataset_dict (ds))[i]; + criteria.crits[i].fv = var_get_case_index (v); + criteria.crits[i].width = var_get_width (v); criteria.crits[i].dir = SRT_ASCEND; } for (i = 0; i < n_group_vars; i++) { - criteria.crits[i + n_splits].fv = group_vars[i]->fv; - criteria.crits[i + n_splits].width = group_vars[i]->width; + criteria.crits[i + n_splits].fv = var_get_case_index (group_vars[i]); + criteria.crits[i + n_splits].width = var_get_width (group_vars[i]); criteria.crits[i + n_splits].dir = SRT_ASCEND; } for (i = 0 ; i < sc->crit_cnt ; ++i ) @@ -263,28 +266,29 @@ rank_cmd (const struct sort_criteria *sc, struct casefile *sorted_cf ; /* Obtain active file in CF. */ - if (!procedure (current_dataset, NULL, NULL)) + if (!procedure (ds, NULL, NULL)) goto error; - cf = proc_capture_output (current_dataset); + cf = proc_capture_output (ds); /* Sort CF into SORTED_CF. */ reader = casefile_get_destructive_reader (cf) ; criteria.crits[criteria.crit_cnt - 1] = sc->crits[i]; - assert ( sc->crits[i].fv == src_vars[i]->fv ); - sorted_cf = sort_execute (reader, &criteria); + assert ( sc->crits[i].fv == var_get_case_index (src_vars[i]) ); + sorted_cf = sort_execute (reader, &criteria, NULL); casefile_destroy (cf); out = rank_sorted_casefile (sorted_cf, &criteria, + dataset_dict (ds), rank_specs, n_rank_specs, - i, &src_vars[i]->miss) ; + i, var_get_missing_values (src_vars[i])); if ( NULL == out ) { result = false ; continue ; } - proc_set_source (current_dataset, storage_source_create (out)); + proc_set_source (ds, storage_source_create (out)); } free (criteria.crits); @@ -487,6 +491,7 @@ rank_savage (double c, double cc, double cc_1, static void rank_cases (struct casereader *cr, unsigned long end, + const struct dictionary *dict, const struct sort_criterion *criterion, const struct missing_values *mv, double w, @@ -515,15 +520,15 @@ rank_cases (struct casereader *cr, if (!casereader_read_xfer (cr, &this_case)) break; - this_value = case_data (&this_case, fv); - c = dict_get_case_weight (dataset_dict (current_dataset), &this_case, &warn); + this_value = case_data_idx (&this_case, fv); + c = dict_get_case_weight (dict, &this_case, &warn); lookahead = casereader_clone (cr); n = 0; while (casereader_cnum (lookahead) < end && casereader_read_xfer (lookahead, &lookahead_case)) { - const union value *lookahead_value = case_data (&lookahead_case, fv); + const union value *lookahead_value = case_data_idx (&lookahead_case, fv); int diff = compare_values (this_value, lookahead_value, width); if (diff != 0) @@ -535,7 +540,7 @@ rank_cases (struct casereader *cr, break; } - c += dict_get_case_weight (dataset_dict (current_dataset), &lookahead_case, &warn); + c += dict_get_case_weight (dict, &lookahead_case, &warn); case_destroy (&lookahead_case); n++; } @@ -549,12 +554,12 @@ rank_cases (struct casereader *cr, { for (i = 0; i < n_rank_specs; ++i) { - const int dest_idx = rs[i].destvars[dest_var_index]->fv; + const struct variable *dst_var = rs[i].destvars[dest_var_index]; if ( value_is_missing (mv, this_value) ) - case_data_rw (&this_case, dest_idx)->f = SYSMIS; + case_data_rw (&this_case, dst_var)->f = SYSMIS; else - case_data_rw (&this_case, dest_idx)->f = + case_data_rw (&this_case, dst_var)->f = rank_func[rs[i].rfunc](c, cc, cc_1, iter, w); } casefile_append_xfer (dest, &this_case); @@ -578,8 +583,8 @@ same_group (const struct ccase *a, const struct ccase *b, for (i = 0; i < crit->crit_cnt - 1; i++) { struct sort_criterion *c = &crit->crits[i]; - if (compare_values (case_data (a, c->fv), case_data (b, c->fv), - c->width) != 0) + if (compare_values (case_data_idx (a, c->fv), + case_data_idx (b, c->fv), c->width) != 0) return false; } @@ -589,13 +594,14 @@ same_group (const struct ccase *a, const struct ccase *b, static struct casefile * rank_sorted_casefile (struct casefile *cf, const struct sort_criteria *crit, + const struct dictionary *dict, const struct rank_spec *rs, int n_rank_specs, int dest_idx, const struct missing_values *mv) { struct casefile *dest = fastfile_create (casefile_get_value_cnt (cf)); - struct casereader *lookahead = casefile_get_reader (cf); + struct casereader *lookahead = casefile_get_reader (cf, NULL); struct casereader *pos = casereader_clone (lookahead); struct ccase group_case; bool warn = true; @@ -607,19 +613,20 @@ rank_sorted_casefile (struct casefile *cf, struct ccase this_case; const union value *this_value ; double w = 0.0; - this_value = case_data( &group_case, ultimate_crit->fv); + this_value = case_data_idx( &group_case, ultimate_crit->fv); if ( !value_is_missing(mv, this_value) ) - w = dict_get_case_weight (dataset_dict (current_dataset), &group_case, &warn); + w = dict_get_case_weight (dict, &group_case, &warn); while (casereader_read (lookahead, &this_case)) { const union value *this_value = - case_data(&this_case, ultimate_crit->fv); - double c = dict_get_case_weight (dataset_dict (current_dataset), &this_case, &warn); + case_data_idx(&this_case, ultimate_crit->fv); + double c = dict_get_case_weight (dict, &this_case, &warn); if (!same_group (&group_case, &this_case, crit)) { rank_cases (pos, casereader_cnum (lookahead) - 1, + dict, ultimate_crit, mv, w, rs, n_rank_specs, @@ -634,7 +641,7 @@ rank_sorted_casefile (struct casefile *cf, case_destroy (&this_case); } case_destroy (&group_case); - rank_cases (pos, ULONG_MAX, ultimate_crit, mv, w, + rank_cases (pos, ULONG_MAX, dict, ultimate_crit, mv, w, rs, n_rank_specs, dest_idx, dest); } @@ -651,11 +658,11 @@ rank_sorted_casefile (struct casefile *cf, /* Transformation function to enumerate all the cases */ static int -create_resort_key (void *key_var_, struct ccase *cc, casenum_t 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->fv)->f = case_num; + case_data_rw(cc, key_var)->f = case_num; return TRNS_CONTINUE; } @@ -667,7 +674,7 @@ create_resort_key (void *key_var_, struct ccase *cc, casenum_t case_num) If VNAME is NULL, then a name will be automatically chosen. */ static struct variable * -create_rank_variable (enum RANK_FUNC f, +create_rank_variable (struct dictionary *dict, enum RANK_FUNC f, const struct variable *src_var, const char *vname) { @@ -676,14 +683,14 @@ create_rank_variable (enum RANK_FUNC f, char name[SHORT_NAME_LEN + 1]; if ( vname ) - var = dict_create_var(dataset_dict (current_dataset), vname, 0); + var = dict_create_var(dict, vname, 0); if ( NULL == var ) { - snprintf(name, SHORT_NAME_LEN + 1, "%c%s", - function_name[f][0], src_var->name); + snprintf (name, SHORT_NAME_LEN + 1, "%c%s", + function_name[f][0], var_get_name (src_var)); - var = dict_create_var(dataset_dict (current_dataset), name, 0); + var = dict_create_var(dict, name, 0); } i = 1; @@ -694,7 +701,7 @@ create_rank_variable (enum RANK_FUNC f, snprintf(name, SHORT_NAME_LEN + 1, "%s%03d", func_abb, i); - var = dict_create_var(dataset_dict (current_dataset), name, 0); + var = dict_create_var(dict, name, 0); if (i++ >= 999) break; } @@ -708,7 +715,7 @@ create_rank_variable (enum RANK_FUNC f, snprintf(name, SHORT_NAME_LEN + 1, "RNK%s%02d", func_abb, i); - var = dict_create_var(dataset_dict (current_dataset), name, 0); + var = dict_create_var(dict, name, 0); if ( i++ >= 99 ) break; } @@ -719,12 +726,11 @@ create_rank_variable (enum RANK_FUNC f, return NULL; } - var->write = var->print = dest_format[f]; + var_set_both_formats (var, &dest_format[f]); return var; } -int cmd_rank(void); static void rank_cleanup(void) @@ -753,14 +759,14 @@ rank_cleanup(void) } int -cmd_rank(void) +cmd_rank (struct lexer *lexer, struct dataset *ds) { bool result; struct variable *order; size_t i; n_rank_specs = 0; - if ( !parse_rank(&cmd, NULL) ) + if ( !parse_rank (lexer, ds, &cmd, NULL) ) { rank_cleanup (); return CMD_FAILURE; @@ -802,7 +808,7 @@ cmd_rank(void) if ( rank_specs[i].destvars[v] == NULL ) { rank_specs[i].destvars[v] = - create_rank_variable (rank_specs[i].rfunc, src_vars[v], NULL); + create_rank_variable (dataset_dict(ds), rank_specs[i].rfunc, src_vars[v], NULL); } create_var_label ( rank_specs[i].destvars[v], @@ -830,7 +836,7 @@ cmd_rank(void) ds_init_empty (&varlist); for ( g = 0 ; g < n_group_vars ; ++g ) { - ds_put_cstr (&varlist, group_vars[g]->name); + ds_put_cstr (&varlist, var_get_name (group_vars[g])); if ( g < n_group_vars - 1) ds_put_cstr (&varlist, " "); @@ -840,10 +846,10 @@ cmd_rank(void) rank_specs[i].rfunc == PROPORTION ) tab_output_text (TAT_PRINTF, _("%s into %s(%s of %s using %s BY %s)"), - src_vars[v]->name, - rank_specs[i].destvars[v]->name, + var_get_name (src_vars[v]), + var_get_name (rank_specs[i].destvars[v]), function_name[rank_specs[i].rfunc], - src_vars[v]->name, + var_get_name (src_vars[v]), fraction_name(), ds_cstr (&varlist) ); @@ -851,10 +857,10 @@ cmd_rank(void) else tab_output_text (TAT_PRINTF, _("%s into %s(%s of %s BY %s)"), - src_vars[v]->name, - rank_specs[i].destvars[v]->name, + var_get_name (src_vars[v]), + var_get_name (rank_specs[i].destvars[v]), function_name[rank_specs[i].rfunc], - src_vars[v]->name, + var_get_name (src_vars[v]), ds_cstr (&varlist) ); ds_destroy (&varlist); @@ -865,20 +871,20 @@ cmd_rank(void) rank_specs[i].rfunc == PROPORTION ) tab_output_text (TAT_PRINTF, _("%s into %s(%s of %s using %s)"), - src_vars[v]->name, - rank_specs[i].destvars[v]->name, + var_get_name (src_vars[v]), + var_get_name (rank_specs[i].destvars[v]), function_name[rank_specs[i].rfunc], - src_vars[v]->name, + var_get_name (src_vars[v]), fraction_name() ); else tab_output_text (TAT_PRINTF, _("%s into %s(%s of %s)"), - src_vars[v]->name, - rank_specs[i].destvars[v]->name, + var_get_name (src_vars[v]), + var_get_name (rank_specs[i].destvars[v]), function_name[rank_specs[i].rfunc], - src_vars[v]->name + var_get_name (src_vars[v]) ); } } @@ -891,29 +897,29 @@ cmd_rank(void) /* Add a variable which we can sort by to get back the original order */ - order = dict_create_var_assert (dataset_dict (current_dataset), "$ORDER_", 0); + order = dict_create_var_assert (dataset_dict (ds), "$ORDER_", 0); - add_transformation (current_dataset, create_resort_key, 0, order); + add_transformation (ds, create_resort_key, 0, order); /* Do the ranking */ - result = rank_cmd (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 */ { struct sort_criteria criteria; struct sort_criterion restore_criterion ; - restore_criterion.fv = order->fv; + restore_criterion.fv = var_get_case_index (order); restore_criterion.width = 0; restore_criterion.dir = SRT_ASCEND; criteria.crits = &restore_criterion; criteria.crit_cnt = 1; - sort_active_file_in_place (&criteria); + sort_active_file_in_place (ds, &criteria); } /* ... and we don't need our sort key anymore. So delete it */ - dict_delete_var (dataset_dict (current_dataset), order); + dict_delete_var (dataset_dict (ds), order); rank_cleanup(); @@ -924,28 +930,29 @@ cmd_rank(void) /* Parser for the variables sub command Returns 1 on success */ static int -rank_custom_variables(struct cmd_rank *cmd UNUSED, void *aux UNUSED) +rank_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd UNUSED, void *aux UNUSED) { static const int terminators[2] = {T_BY, 0}; - lex_match('='); + lex_match (lexer, '='); - if ((token != T_ID || dict_lookup_var (dataset_dict (current_dataset), tokid) == NULL) - && token != T_ALL) + if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL) + && lex_token (lexer) != T_ALL) return 2; - sc = sort_parse_criteria (dataset_dict (current_dataset), + sc = sort_parse_criteria (lexer, dataset_dict (ds), &src_vars, &n_src_vars, 0, terminators); - if ( lex_match(T_BY) ) + if ( lex_match (lexer, T_BY) ) { - if ((token != T_ID || dict_lookup_var (dataset_dict (current_dataset), tokid) == NULL)) + if ((lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)) { return 2; } - if (!parse_variables (dataset_dict (current_dataset), &group_vars, &n_group_vars, - PV_NO_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH) ) + if (!parse_variables (lexer, dataset_dict (ds), + &group_vars, &n_group_vars, + PV_NO_DUPLICATE | PV_NO_SCRATCH) ) { free (group_vars); return 0; @@ -958,7 +965,7 @@ rank_custom_variables(struct cmd_rank *cmd UNUSED, void *aux UNUSED) /* Parse the [/rank INTO var1 var2 ... varN ] clause */ static int -parse_rank_function(struct cmd_rank *cmd UNUSED, enum RANK_FUNC f) +parse_rank_function (struct lexer *lexer, struct dictionary *dict, struct cmd_rank *cmd UNUSED, enum RANK_FUNC f) { int var_count = 0; @@ -970,16 +977,16 @@ parse_rank_function(struct cmd_rank *cmd UNUSED, enum RANK_FUNC f) rank_specs[n_rank_specs - 1].destvars = xcalloc (sc->crit_cnt, sizeof (struct variable *)); - if (lex_match_id("INTO")) + if (lex_match_id (lexer, "INTO")) { struct variable *destvar; - while( token == T_ID ) + while( lex_token (lexer) == T_ID ) { - if ( dict_lookup_var (dataset_dict (current_dataset), tokid) != NULL ) + if ( dict_lookup_var (dict, lex_tokid (lexer)) != NULL ) { - msg(SE, _("Variable %s already exists."), tokid); + msg(SE, _("Variable %s already exists."), lex_tokid (lexer)); return 0; } if ( var_count >= sc->crit_cnt ) @@ -988,10 +995,10 @@ parse_rank_function(struct cmd_rank *cmd UNUSED, enum RANK_FUNC f) return 0; } - destvar = create_rank_variable (f, src_vars[var_count], tokid); + destvar = create_rank_variable (dict, f, src_vars[var_count], lex_tokid (lexer)); rank_specs[n_rank_specs - 1].destvars[var_count] = destvar ; - lex_get(); + lex_get (lexer); ++var_count; } } @@ -1001,58 +1008,74 @@ parse_rank_function(struct cmd_rank *cmd UNUSED, enum RANK_FUNC f) static int -rank_custom_rank(struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_rank (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { - return parse_rank_function(cmd, RANK); + struct dictionary *dict = dataset_dict (ds); + + return parse_rank_function (lexer, dict, cmd, RANK); } static int -rank_custom_normal(struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_normal (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { - return parse_rank_function(cmd, NORMAL); + struct dictionary *dict = dataset_dict (ds); + + return parse_rank_function (lexer, dict, cmd, NORMAL); } static int -rank_custom_percent(struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_percent (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { - return parse_rank_function (cmd, PERCENT); + struct dictionary *dict = dataset_dict (ds); + + return parse_rank_function (lexer, dict, cmd, PERCENT); } static int -rank_custom_rfraction(struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_rfraction (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { - return parse_rank_function(cmd, RFRACTION); + struct dictionary *dict = dataset_dict (ds); + + return parse_rank_function (lexer, dict, cmd, RFRACTION); } static int -rank_custom_proportion(struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_proportion (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { - return parse_rank_function(cmd, PROPORTION); + struct dictionary *dict = dataset_dict (ds); + + return parse_rank_function (lexer, dict, cmd, PROPORTION); } static int -rank_custom_n(struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_n (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { - return parse_rank_function(cmd, N); + struct dictionary *dict = dataset_dict (ds); + + return parse_rank_function (lexer, dict, cmd, N); } static int -rank_custom_savage(struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_savage (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { - return parse_rank_function(cmd, SAVAGE); + struct dictionary *dict = dataset_dict (ds); + + return parse_rank_function (lexer, dict, cmd, SAVAGE); } static int -rank_custom_ntiles(struct cmd_rank *cmd, void *aux UNUSED ) +rank_custom_ntiles (struct lexer *lexer, struct dataset *ds, struct cmd_rank *cmd, void *aux UNUSED ) { - if ( lex_force_match('(') ) + struct dictionary *dict = dataset_dict (ds); + + if ( lex_force_match (lexer, '(') ) { - if ( lex_force_int() ) + if ( lex_force_int (lexer) ) { - k_ntiles = lex_integer (); - lex_get(); - lex_force_match(')'); + k_ntiles = lex_integer (lexer); + lex_get (lexer); + lex_force_match (lexer, ')'); } else return 0; @@ -1060,5 +1083,5 @@ rank_custom_ntiles(struct cmd_rank *cmd, void *aux UNUSED ) else return 0; - return parse_rank_function(cmd, NTILES); + return parse_rank_function (lexer, dict, cmd, NTILES); }