X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fcasereader-translator.c;h=996dc24f5a55a6bcdf94a526bca2744c42d6fe23;hb=6d7eed1c12693a3688a3c16f634a5b816660085b;hp=062184691defe569321351b5f1304709fcfb2273;hpb=81579d9e9f994fb2908f50af41c3eb033d216e58;p=pspp diff --git a/src/data/casereader-translator.c b/src/data/casereader-translator.c index 062184691d..996dc24f5a 100644 --- a/src/data/casereader-translator.c +++ b/src/data/casereader-translator.c @@ -75,7 +75,7 @@ casereader_create_translator (struct casereader *subreader, ct->destroy = destroy; ct->aux = aux; reader = casereader_create_sequential ( - NULL, output_proto, casereader_get_case_cnt (ct->subreader), + NULL, output_proto, casereader_get_n_cases (ct->subreader), &casereader_translator_class, ct); taint_propagate (casereader_get_taint (ct->subreader), casereader_get_taint (reader)); @@ -170,7 +170,7 @@ casereader_translate_stateless ( cst->destroy = destroy; cst->aux = aux; reader = casereader_create_random ( - output_proto, casereader_get_case_cnt (cst->subreader), + output_proto, casereader_get_n_cases (cst->subreader), &casereader_stateless_translator_class, cst); taint_propagate (casereader_get_taint (cst->subreader), casereader_get_taint (reader)); @@ -202,10 +202,10 @@ casereader_stateless_translator_destroy (struct casereader *reader UNUSED, static void casereader_stateless_translator_advance (struct casereader *reader UNUSED, - void *cst_, casenumber cnt) + void *cst_, casenumber n) { struct casereader_stateless_translator *cst = cst_; - cst->case_offset += casereader_advance (cst->subreader, cnt); + cst->case_offset += casereader_advance (cst->subreader, n); } /* Casereader class for stateless translating casereader. */ @@ -264,7 +264,7 @@ can_translate (struct ccase *c, void *can_) struct casereader_append_numeric *can = can_; double new_value = can->func (c, can->n++, can->aux); c = case_unshare_and_resize (c, can->proto); - case_data_rw_idx (c, caseproto_get_n_widths (can->proto) - 1)->f = new_value; + *case_num_rw_idx (c, caseproto_get_n_widths (can->proto) - 1) = new_value; return c; } @@ -309,7 +309,7 @@ struct casereader * casereader_create_arithmetic_sequence (struct casereader *subreader, double first, double increment) { - struct arithmetic_sequence *as = xzalloc (sizeof *as); + struct arithmetic_sequence *as = XZALLOC (struct arithmetic_sequence); as->first = first; as->increment = increment; return casereader_create_append_numeric (subreader, next_arithmetic, @@ -357,7 +357,7 @@ static struct ccase *car_translate (struct ccase *input, void *car_); If DISTINCT_CALLBACK is non-null, then it will be called exactly once for every case containing a distinct value of V. AUX is - an auxilliary pointer passed to DISTINCT_CALLBACK. + an auxiliary pointer passed to DISTINCT_CALLBACK. After this function is called, SUBREADER must not ever again be referenced directly. It will be destroyed automatically @@ -369,7 +369,7 @@ casereader_create_append_rank (struct casereader *subreader, enum rank_error *err, distinct_func *distinct_callback, void *aux - ) + ) { struct casereader_append_rank *car = xmalloc (sizeof *car); car->proto = caseproto_ref (casereader_get_proto (subreader)); @@ -405,23 +405,23 @@ car_translate (struct ccase *input, void *car_) { struct casereader_append_rank *car = car_; - const double value = case_data (input, car->var)->f; + const double value = case_num (input, car->var); - if ( car->prev_value != SYSMIS) + if (car->prev_value != SYSMIS) { if (car->err && value < car->prev_value) *car->err |= RANK_ERR_UNSORTED; } - if ( car->n_common == 1) + if (car->n_common == 1) { double vxx = SYSMIS; casenumber k = 0; double weight = 1.0; if (car->weight) { - weight = case_data (input, car->weight)->f; - if ( car->err && weight < 0 ) + weight = case_num (input, car->weight); + if (car->err && weight < 0) *car->err |= RANK_ERR_NEGATIVE_WEIGHT; } @@ -430,15 +430,15 @@ car_translate (struct ccase *input, void *car_) struct ccase *c = casereader_peek (car->clone, car->n + ++k); if (c == NULL) break; - vxx = case_data (c, car->var)->f; + vxx = case_num (c, car->var); - if ( vxx == value) + if (vxx == value) { if (car->weight) { - double w = case_data (c, car->weight)->f; + double w = case_num (c, car->weight); - if ( car->err && w < 0 ) + if (car->err && w < 0) *car->err |= RANK_ERR_NEGATIVE_WEIGHT; weight += w; @@ -462,7 +462,7 @@ car_translate (struct ccase *input, void *car_) car->n++; input = case_unshare_and_resize (input, car->proto); - case_data_rw_idx (input, caseproto_get_n_widths (car->proto) - 1)->f + *case_num_rw_idx (input, caseproto_get_n_widths (car->proto) - 1) = car->mean_rank; car->prev_value = value; return input; @@ -490,27 +490,32 @@ uniquify (const struct ccase *c, void *aux) struct consolidator *cdr = aux; const union value *current_value = case_data (c, cdr->key); const int key_width = var_get_width (cdr->key); - const double weight = cdr->weight ? case_data (c, cdr->weight)->f : 1.0; + const double weight = cdr->weight ? case_num (c, cdr->weight) : 1.0; struct ccase *next_case = casereader_peek (cdr->clone, cdr->n + 1); int dir = 0; cdr->n ++; cdr->cc += weight; - if ( NULL == next_case) + if (NULL == next_case) goto end; - + dir = value_compare_3way (case_data (next_case, cdr->key), current_value, key_width); + if (dir > 0) + dir = 1; + if (dir < 0) + dir = -1; + case_unref (next_case); - if ( dir != 0 ) + if (dir != 0) { /* Insist that the data are sorted */ assert (cdr->direction == 0 || dir == cdr->direction); cdr->direction = dir; goto end; } - + return false; end: @@ -530,12 +535,12 @@ consolodate_weight (struct ccase *input, void *aux) if (cdr->weight) { c = case_unshare (input); - case_data_rw (c, cdr->weight)->f = cdr->prev_cc; + *case_num_rw (c, cdr->weight) = cdr->prev_cc; } else { c = case_unshare_and_resize (input, cdr->proto); - case_data_rw_idx (c, caseproto_get_n_widths (cdr->proto) - 1)->f = cdr->prev_cc; + *case_num_rw_idx (c, caseproto_get_n_widths (cdr->proto) - 1) = cdr->prev_cc; } return c; @@ -556,7 +561,7 @@ uniquify_destroy (void *aux) -/* Returns a new casereader which is based upon INPUT, but which contains a maximum +/* Returns a new casereader which is based upon INPUT, but which contains a maximum of one case for each distinct value of KEY. If WEIGHT is non-null, then the new casereader's values for this variable will be the sum of all values matching KEY. @@ -582,7 +587,7 @@ casereader_create_distinct (struct casereader *input, cdr->clone = casereader_clone (input); cdr->direction = 0; - if ( NULL == cdr->weight ) + if (NULL == cdr->weight) output_proto = caseproto_add_width (output_proto, 0); cdr->proto = output_proto;