static void
acc (struct statistic *s, const struct ccase *cx,
double c UNUSED, double cc UNUSED, double y)
{
struct box_whisker *bw = UP_CAST (s, struct box_whisker, parent.parent);
bool extreme;
struct outlier *o;
if ( y > bw->hinges[2] + bw->step) /* Upper outlier */
{
extreme = (y > bw->hinges[2] + 2 * bw->step) ;
}
else if (y < bw->hinges[0] - bw->step) /* Lower outlier */
{
extreme = (y < bw->hinges[0] - 2 * bw->step) ;
}
else /* Not an outlier */
{
if (bw->whiskers[0] == SYSMIS)
bw->whiskers[0] = y;
if (y > bw->whiskers[1])
bw->whiskers[1] = y;
return;
}
/* y is an outlier */
o = xzalloc (sizeof *o) ;
o->value = y;
o->extreme = extreme;
ds_init_empty (&o->label);
if (bw->id_var)
{
char *s = data_out (case_data_idx (cx, bw->id_idx),
var_get_encoding (bw->id_var),
var_get_print_format (bw->id_var));
ds_put_cstr (&o->label, s);
free (s);
}
else
{
ds_put_format (&o->label,
"%ld",
(casenumber) case_data_idx (cx, bw->id_idx)->f);
}
ll_push_head (&bw->outliers, &o->ll);
}
void
order_stats_accumulate_idx (struct order_stats **os, size_t nos,
struct casereader *reader,
int wt_idx,
int val_idx)
{
struct ccase *cx;
struct ccase *prev_cx = NULL;
double prev_value = -DBL_MAX;
double cc_i = 0;
double c_i = 0;
for (; (cx = casereader_read (reader)) != NULL; case_unref (cx))
{
const double weight = (wt_idx == -1) ? 1.0 : case_data_idx (cx, wt_idx)->f;
const double this_value = case_data_idx (cx, val_idx)->f;
/* The casereader MUST be sorted */
assert (this_value >= prev_value);
if ( prev_value == -DBL_MAX || prev_value == this_value)
c_i += weight;
if ( prev_value > -DBL_MAX && this_value > prev_value)
{
update_k_values (prev_cx, prev_value, c_i, cc_i, os, nos);
c_i = weight;
}
case_unref (prev_cx);
cc_i += weight;
prev_value = this_value;
prev_cx = case_ref (cx);
}
update_k_values (prev_cx, prev_value, c_i, cc_i, os, nos);
case_unref (prev_cx);
casereader_destroy (reader);
}
static void
csv_write_case (struct csv_writer *w, const struct ccase *c)
{
size_t i;
for (i = 0; i < w->n_csv_vars; i++)
{
const struct csv_var *cv = &w->csv_vars[i];
if (i > 0)
putc (w->opts.delimiter, w->file);
csv_write_var (w, cv, case_data_idx (c, cv->case_index));
}
putc ('\n', w->file);
}
/* Copies the data from FILE's case into output case OUTPUT,
skipping values that are missing or all spaces.
If FILE has an IN variable, then it is set to 1 in OUTPUT. */
static void
apply_nonmissing_case (const struct comb_file *file, struct ccase *output)
{
size_t i;
for (i = 0; i < subcase_get_n_fields (&file->src); i++)
{
const struct subcase_field *src_field = &file->src.fields[i];
const struct subcase_field *dst_field = &file->dst.fields[i];
const union value *src_value
= case_data_idx (file->data, src_field->case_index);
int width = src_field->width;
if (!mv_is_value_missing (file->mv[i], src_value, MV_ANY)
&& !(width > 0 && value_is_spaces (src_value, width)))
value_copy (case_data_rw_idx (output, dst_field->case_index),
src_value, width);
}
mark_file_used (file, output);
}
static void
do_reliability (struct casereader *input, struct dataset *ds,
const struct reliability *rel)
{
int i;
int si;
struct ccase *c;
casenumber n_missing ;
casenumber n_valid = 0;
for (si = 0 ; si < rel->n_sc; ++si)
{
struct cronbach *s = &rel->sc[si];
s->m = xzalloc (sizeof (s->m) * s->n_items);
s->total = moments1_create (MOMENT_VARIANCE);
for (i = 0 ; i < s->n_items ; ++i )
s->m[i] = moments1_create (MOMENT_VARIANCE);
}
input = casereader_create_filter_missing (input,
rel->variables,
rel->n_variables,
rel->exclude,
&n_missing,
NULL);
for (si = 0 ; si < rel->n_sc; ++si)
{
struct cronbach *s = &rel->sc[si];
s->totals_idx = caseproto_get_n_widths (casereader_get_proto (input));
input =
casereader_create_append_numeric (input, append_sum,
s, NULL);
}
for (; (c = casereader_read (input)) != NULL; case_unref (c))
{
double weight = 1.0;
n_valid ++;
for (si = 0; si < rel->n_sc; ++si)
{
struct cronbach *s = &rel->sc[si];
for (i = 0 ; i < s->n_items ; ++i )
moments1_add (s->m[i], case_data (c, s->items[i])->f, weight);
moments1_add (s->total, case_data_idx (c, s->totals_idx)->f, weight);
}
}
casereader_destroy (input);
for (si = 0; si < rel->n_sc; ++si)
{
struct cronbach *s = &rel->sc[si];
s->sum_of_variances = 0;
for (i = 0 ; i < s->n_items ; ++i )
{
double weight, mean, variance;
moments1_calculate (s->m[i], &weight, &mean, &variance, NULL, NULL);
s->sum_of_variances += variance;
}
moments1_calculate (s->total, NULL, NULL, &s->variance_of_sums,
NULL, NULL);
s->alpha =
alpha (s->n_items, s->sum_of_variances, s->variance_of_sums);
}
text_item_submit (text_item_create_format (TEXT_ITEM_PARAGRAPH, _("Scale: %s"),
ds_cstr (&rel->scale_name)));
case_processing_summary (n_valid, n_missing, dataset_dict (ds));
}
