X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=src%2Flanguage%2Fstats%2Faggregate.c;h=c217310910271f2639830eb09d44b2fcdffd69db;hb=d75247c28e0dce9c21070e4ee14fdc6a2338fb77;hp=e1dcd12342ff2b42ff94dcbf472affeb58bb51c1;hpb=015e221b0f8578afee769528572c76387f26c629;p=pspp-builds.git diff --git a/src/language/stats/aggregate.c b/src/language/stats/aggregate.c index e1dcd123..c2173109 100644 --- a/src/language/stats/aggregate.c +++ b/src/language/stats/aggregate.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2006, 2008 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2008, 2009 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 @@ -19,7 +19,6 @@ #include #include -#include #include #include #include @@ -29,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -143,10 +143,10 @@ enum missing_treatment struct agr_proc { /* Break variables. */ - struct case_ordering *sort; /* Sort criteria (break variable). */ + 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. */ + struct ccase *break_case; /* Last values of break variables. */ enum missing_treatment missing; /* How to treat missing values. */ struct agr_var *agr_vars; /* First aggregate variable. */ @@ -187,10 +187,11 @@ cmd_aggregate (struct lexer *lexer, struct dataset *ds) memset(&agr, 0 , sizeof (agr)); agr.missing = ITEMWISE; - case_nullify (&agr.break_case); + agr.break_case = NULL; agr.dict = dict_create (); agr.src_dict = dict; + subcase_init_empty (&agr.sort); dict_set_label (agr.dict, dict_get_label (dict)); dict_set_documents (agr.dict, dict_get_documents (dict)); @@ -229,13 +230,10 @@ cmd_aggregate (struct lexer *lexer, struct dataset *ds) int i; lex_match (lexer, '='); - agr.sort = parse_case_ordering (lexer, dict, - - &saw_direction); - if (agr.sort == NULL) + 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_var_cnt = 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], @@ -286,10 +284,10 @@ cmd_aggregate (struct lexer *lexer, struct dataset *ds) } 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, @@ -297,18 +295,17 @@ cmd_aggregate (struct lexer *lexer, struct dataset *ds) casegrouper_get_next_group (grouper, &group); casereader_destroy (group)) { - struct ccase c; - - if (!casereader_peek (group, 0, &c)) + struct ccase *c = casereader_peek (group, 0); + if (c == NULL) { casereader_destroy (group); continue; } - initialize_aggregate_info (&agr, &c); - case_destroy (&c); + initialize_aggregate_info (&agr, c); + case_unref (c); - for (; casereader_read (group, &c); case_destroy (&c)) - accumulate_aggregate_info (&agr, &c); + for (; (c = casereader_read (group)) != NULL; case_unref (c)) + accumulate_aggregate_info (&agr, c); dump_aggregate_info (&agr, output); } if (!casegrouper_destroy (grouper)) @@ -694,9 +691,9 @@ agr_destroy (struct agr_proc *agr) { struct agr_var *iter, *next; - case_ordering_destroy (agr->sort); + subcase_destroy (&agr->sort); free (agr->break_vars); - case_destroy (&agr->break_case); + case_unref (agr->break_case); for (iter = agr->agr_vars; iter; iter = next) { next = iter->next; @@ -772,20 +769,18 @@ accumulate_aggregate_info (struct agr_proc *agr, const struct ccase *input) case MEDIAN: { double wv ; - struct ccase cout; - case_create (&cout, 2); + struct ccase *cout = case_create (2); - case_data_rw (&cout, iter->subject)->f = - case_data (input, iter->src)->f; + case_data_rw (cout, iter->subject)->f + = case_data (input, iter->src)->f; wv = dict_get_case_weight (agr->src_dict, input, NULL); - case_data_rw (&cout, iter->weight)->f = wv; + case_data_rw (cout, iter->weight)->f = wv; iter->cc += wv; - casewriter_write (iter->writer, &cout); - case_destroy (&cout); + casewriter_write (iter->writer, cout); } break; case SD: @@ -918,9 +913,7 @@ accumulate_aggregate_info (struct agr_proc *agr, const struct ccase *input) static void dump_aggregate_info (struct agr_proc *agr, struct casewriter *output) { - struct ccase c; - - case_create (&c, dict_get_next_value_idx (agr->dict)); + struct ccase *c = case_create (dict_get_next_value_idx (agr->dict)); { int value_idx = 0; @@ -930,8 +923,8 @@ dump_aggregate_info (struct agr_proc *agr, struct casewriter *output) { 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), + memcpy (case_data_rw_idx (c, value_idx), + case_data (agr->break_case, v), sizeof (union value) * value_cnt); value_idx += value_cnt; } @@ -942,7 +935,7 @@ dump_aggregate_info (struct agr_proc *agr, struct casewriter *output) 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); if (agr->missing == COLUMNWISE && i->saw_missing @@ -1069,7 +1062,7 @@ dump_aggregate_info (struct agr_proc *agr, struct casewriter *output) } } - casewriter_write (output, &c); + casewriter_write (output, c); } /* Resets the state for all the aggregate functions. */ @@ -1078,8 +1071,8 @@ initialize_aggregate_info (struct agr_proc *agr, const struct ccase *input) { struct agr_var *iter; - case_destroy (&agr->break_case); - case_clone (&agr->break_case, input); + case_unref (agr->break_case); + agr->break_case = case_ref (input); for (iter = agr->agr_vars; iter; iter = iter->next) { @@ -1102,7 +1095,7 @@ initialize_aggregate_info (struct agr_proc *agr, const struct ccase *input) break; case MEDIAN: { - struct case_ordering *ordering = case_ordering_create (); + struct subcase ordering; if ( ! iter->subject) iter->subject = var_create_internal (0); @@ -1110,9 +1103,10 @@ initialize_aggregate_info (struct agr_proc *agr, const struct ccase *input) if ( ! iter->weight) iter->weight = var_create_internal (1); - case_ordering_add_var (ordering, iter->subject, SRT_ASCEND); + subcase_init_var (&ordering, iter->subject, SC_ASCEND); + iter->writer = sort_create_writer (&ordering, 2); + subcase_destroy (&ordering); - iter->writer = sort_create_writer (ordering, 2); iter->cc = 0; } break;