X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fcasereader-translator.c;h=ae22f1297e19dbe5a12e6d9e2ec49f75ce8de087;hb=c9e28aa922c35b8764925fe824794886b8f17a86;hp=229dac2e54944c8df81088080c1032330c0cd84e;hpb=0bd3b06bbdf530044eeb6b1518edbffd7124fcb7;p=pspp-builds.git
diff --git a/src/data/casereader-translator.c b/src/data/casereader-translator.c
index 229dac2e..ae22f129 100644
--- a/src/data/casereader-translator.c
+++ b/src/data/casereader-translator.c
@@ -15,9 +15,8 @@
along with this program. If not, see . */
#include
-
+#include
#include
-
#include
#include
@@ -110,18 +109,86 @@ static const struct casereader_class casereader_translator_class =
NULL,
NULL,
};
+
-struct casereader_arithmetic_sequence
- {
- int value_ofs;
- double first;
- double increment;
- casenumber n;
- };
-static void cas_translate (struct ccase *input, struct ccase *output,
- void *aux);
-static bool cas_destroy (void *aux);
+struct casereader_append_numeric
+{
+ int value_ofs;
+ casenumber n;
+ new_value_func *func;
+ void *aux;
+ void (*destroy) (void *aux);
+};
+
+static bool can_destroy (void *can_);
+
+static void can_translate (struct ccase *input, struct ccase *output,
+ void *can_);
+
+/* Creates and returns a new casereader whose cases are produced
+ by reading from SUBREADER and appending an additional value,
+ generated by FUNC. AUX is an optional parameter which
+ gets passed to FUNC. FUNC will also receive N as it, which is
+ the ordinal number of the case in the reader. DESTROY is an
+ optional parameter used to destroy AUX.
+
+ After this function is called, SUBREADER must not ever again
+ be referenced directly. It will be destroyed automatically
+ when the translating casereader is destroyed. */
+struct casereader *
+casereader_create_append_numeric (struct casereader *subreader,
+ new_value_func func, void *aux,
+ void (*destroy) (void *aux))
+{
+ struct casereader_append_numeric *can = xmalloc (sizeof *can);
+ can->value_ofs = casereader_get_value_cnt (subreader);
+ can->n = 0;
+ can->aux = aux;
+ can->func = func;
+ can->destroy = destroy;
+ return casereader_create_translator (subreader, can->value_ofs + 1,
+ can_translate, can_destroy, can);
+}
+
+
+static void
+can_translate (struct ccase *input, struct ccase *output, void *can_)
+{
+ struct casereader_append_numeric *can = can_;
+ double new_value = can->func (input, can->n++, can->aux);
+ case_nullify (output);
+ case_move (output, input);
+ case_resize (output, can->value_ofs + 1);
+ case_data_rw_idx (output, can->value_ofs)->f = new_value;
+}
+
+static bool
+can_destroy (void *can_)
+{
+ struct casereader_append_numeric *can = can_;
+ if (can->destroy)
+ can->destroy (can->aux);
+ free (can);
+ return true;
+}
+
+
+
+struct arithmetic_sequence
+{
+ double first;
+ double increment;
+};
+
+static double
+next_arithmetic (const struct ccase *c UNUSED,
+ casenumber n,
+ void *aux)
+{
+ struct arithmetic_sequence *as = aux;
+ return n * as->increment + as->first;
+}
/* Creates and returns a new casereader whose cases are produced
by reading from SUBREADER and appending an additional value,
@@ -136,32 +203,163 @@ struct casereader *
casereader_create_arithmetic_sequence (struct casereader *subreader,
double first, double increment)
{
- /* This could be implemented with a great deal more efficiency
- and generality. However, this implementation is easy. */
- struct casereader_arithmetic_sequence *cas = xmalloc (sizeof *cas);
- cas->value_ofs = casereader_get_value_cnt (subreader);
- cas->first = first;
- cas->increment = increment;
- cas->n = 0;
- return casereader_create_translator (subreader, cas->value_ofs + 1,
- cas_translate, cas_destroy, cas);
+ struct arithmetic_sequence *as = xzalloc (sizeof *as);
+ as->first = first;
+ as->increment = increment;
+ return casereader_create_append_numeric (subreader, next_arithmetic,
+ as, free);
}
-static void
-cas_translate (struct ccase *input, struct ccase *output, void *cas_)
+
+
+
+struct casereader_append_rank
{
- struct casereader_arithmetic_sequence *cas = cas_;
- case_nullify (output);
- case_move (output, input);
- case_resize (output, cas->value_ofs + 1);
- case_data_rw_idx (output, cas->value_ofs)->f
- = cas->first + cas->increment * cas->n++;
+ struct casereader *clone;
+ casenumber n;
+ const struct variable *var;
+ const struct variable *weight;
+ int value_ofs;
+ casenumber n_common;
+ double mean_rank;
+ double cc;
+ distinct_func *distinct;
+ void *aux;
+ enum rank_error *err;
+ double prev_value;
+};
+
+static bool car_destroy (void *car_);
+
+static void car_translate (struct ccase *input, struct ccase *output,
+ void *car_);
+
+/* Creates and returns a new casereader whose cases are produced
+ by reading from SUBREADER and appending an additional value,
+ which is the rank of the observation. W is the weight variable
+ of the dictionary containing V, or NULL if there is no weight
+ variable.
+
+ The following preconditions must be met:
+
+ 1. SUBREADER must be sorted on V.
+
+ 2. The weight variables, must be non-negative.
+
+ If either of these preconditions are not satisfied, then the rank
+ variables may not be correct. In this case, if ERR is non-null,
+ it will be set according to the erroneous conditions encountered.
+
+ 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.
+
+ After this function is called, SUBREADER must not ever again
+ be referenced directly. It will be destroyed automatically
+ when the translating casereader is destroyed. */
+struct casereader *
+casereader_create_append_rank (struct casereader *subreader,
+ const struct variable *v,
+ const struct variable *w,
+ enum rank_error *err,
+ distinct_func *distinct_callback,
+ void *aux
+ )
+{
+ struct casereader_append_rank *car = xmalloc (sizeof *car);
+ car->value_ofs = casereader_get_value_cnt (subreader);
+ car->weight = w;
+ car->var = v;
+ car->n = 0;
+ car->n_common = 1;
+ car->cc = 0.0;
+ car->clone = casereader_clone (subreader);
+ car->distinct = distinct_callback;
+ car->aux = aux;
+ car->err = err;
+ car->prev_value = SYSMIS;
+
+ return casereader_create_translator (subreader, car->value_ofs + 1,
+ car_translate, car_destroy, car);
}
+
static bool
-cas_destroy (void *cas_)
+car_destroy (void *car_)
{
- struct casereader_arithmetic_sequence *cas = cas_;
- free (cas);
+ struct casereader_append_rank *car = car_;
+ casereader_destroy (car->clone);
+ free (car);
return true;
}
+
+
+static void
+car_translate (struct ccase *input, struct ccase *output, void *car_)
+{
+ struct casereader_append_rank *car = car_;
+
+ const double value = case_data (input, car->var)->f;
+
+ if ( car->prev_value != SYSMIS)
+ {
+ if (car->err && value < car->prev_value)
+ *car->err |= RANK_ERR_UNSORTED;
+ }
+
+ 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 )
+ *car->err |= RANK_ERR_NEGATIVE_WEIGHT;
+ }
+
+ do
+ {
+ struct ccase c;
+ if ( ! casereader_peek (car->clone, car->n + ++k, &c))
+ break;
+ vxx = case_data (&c, car->var)->f;
+
+ if ( vxx == value)
+ {
+ if (car->weight)
+ {
+ double w = case_data (&c, car->weight)->f;
+
+ if ( car->err && w < 0 )
+ *car->err |= RANK_ERR_NEGATIVE_WEIGHT;
+
+ weight += w;
+ }
+ else
+ weight += 1.0;
+ car->n_common++;
+ }
+ case_destroy (&c);
+ }
+ while (vxx == value);
+ car->mean_rank = car->cc + (weight + 1) / 2.0;
+ car->cc += weight;
+
+ if (car->distinct)
+ car->distinct (value, car->n_common, weight, car->aux);
+ }
+ else
+ car->n_common--;
+
+ car->n++;
+
+ case_nullify (output);
+ case_move (output, input);
+ case_resize (output, car->value_ofs + 1);
+ case_data_rw_idx (output, car->value_ofs)->f = car->mean_rank ;
+ car->prev_value = value;
+}
+
+