/* Performs DELETE VARIABLES command. */
int
cmd_delete_variables (struct lexer *lexer, struct dataset *ds)
{
struct variable **vars;
size_t var_cnt;
bool ok;
if (proc_make_temporary_transformations_permanent (ds))
msg (SE, _("DELETE VARIABLES may not be used after TEMPORARY. "
"Temporary transformations will be made permanent."));
if (!parse_variables (lexer, dataset_dict (ds), &vars, &var_cnt, PV_NONE))
goto error;
if (var_cnt == dict_get_var_cnt (dataset_dict (ds)))
{
msg (SE, _("DELETE VARIABLES may not be used to delete all variables "
"from the active dataset dictionary. "
"Use NEW FILE instead."));
goto error;
}
ok = casereader_destroy (proc_open (ds));
ok = proc_commit (ds) && ok;
if (!ok)
goto error;
dict_delete_vars (dataset_dict (ds), vars, var_cnt);
free (vars);
return CMD_SUCCESS;
error:
free (vars);
return CMD_CASCADING_FAILURE;
}
/* Perform BEGIN DATA...END DATA as a procedure in itself. */
int
cmd_begin_data (struct lexer *lexer, struct dataset *ds)
{
struct dfm_reader *r;
bool ok;
if (!fh_is_locked (fh_inline_file (), FH_ACC_READ))
{
msg (SE, _("This command is not valid here since the current "
"input program does not access the inline file."));
return CMD_CASCADING_FAILURE;
}
lex_match (lexer, T_ENDCMD);
/* Open inline file. */
r = dfm_open_reader (fh_inline_file (), lexer);
r->flags |= DFM_SAW_BEGIN_DATA;
r->flags &= ~DFM_CONSUME;
/* Input procedure reads from inline file. */
casereader_destroy (proc_open (ds));
ok = proc_commit (ds);
dfm_close_reader (r);
return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
}
static void
clipboard_clear_cb (GtkClipboard *clipboard,
gpointer data)
{
dict_destroy (clip_dict);
clip_dict = NULL;
casereader_destroy (clip_datasheet);
clip_datasheet = NULL;
}
void
merge_destroy (struct merge *m)
{
if (m != NULL)
{
size_t i;
subcase_destroy (&m->ordering);
for (i = 0; i < m->input_cnt; i++)
casereader_destroy (m->inputs[i].reader);
caseproto_unref (m->proto);
free (m);
}
}
static bool
read_input_case (struct merge *m, size_t idx)
{
struct merge_input *i = &m->inputs[idx];
i->c = casereader_read (i->reader);
if (i->c)
return true;
else
{
casereader_destroy (i->reader);
remove_element (m->inputs, m->input_cnt, sizeof *m->inputs, idx);
m->input_cnt--;
return false;
}
}
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);
}
/* Closes all the files in PROC and frees their associated data. */
static void
close_all_comb_files (struct comb_proc *proc)
{
size_t i;
for (i = 0; i < proc->n_files; i++)
{
struct comb_file *file = &proc->files[i];
subcase_destroy (&file->by_vars);
subcase_destroy (&file->src);
subcase_destroy (&file->dst);
free (file->mv);
fh_unref (file->handle);
dict_destroy (file->dict);
casereader_destroy (file->reader);
case_unref (file->data);
free (file->in_name);
}
free (proc->files);
proc->files = NULL;
proc->n_files = 0;
}
/* Set the clip according to the currently
selected range in the data sheet */
static void
data_sheet_set_clip (PsppireSheet *sheet)
{
int i;
struct casewriter *writer ;
PsppireSheetRange range;
PsppireDataStore *ds;
struct case_map *map = NULL;
casenumber max_rows;
size_t max_columns;
gint row0, rowi;
gint col0, coli;
ds = PSPPIRE_DATA_STORE (psppire_sheet_get_model (sheet));
psppire_sheet_get_selected_range (sheet, &range);
col0 = MIN (range.col0, range.coli);
coli = MAX (range.col0, range.coli);
row0 = MIN (range.row0, range.rowi);
rowi = MAX (range.row0, range.rowi);
/* If nothing selected, then use active cell */
if ( row0 < 0 || col0 < 0 )
{
gint row, col;
psppire_sheet_get_active_cell (sheet, &row, &col);
row0 = rowi = row;
col0 = coli = col;
}
/* The sheet range can include cells that do not include data.
Exclude them from the range. */
max_rows = psppire_data_store_get_case_count (ds);
if (rowi >= max_rows)
{
if (max_rows == 0)
return;
rowi = max_rows - 1;
}
max_columns = dict_get_var_cnt (ds->dict->dict);
if (coli >= max_columns)
{
if (max_columns == 0)
return;
coli = max_columns - 1;
}
/* Destroy any existing clip */
if ( clip_datasheet )
{
casereader_destroy (clip_datasheet);
clip_datasheet = NULL;
}
if ( clip_dict )
{
dict_destroy (clip_dict);
clip_dict = NULL;
}
/* Construct clip dictionary. */
clip_dict = dict_create (dict_get_encoding (ds->dict->dict));
for (i = col0; i <= coli; i++)
dict_clone_var_assert (clip_dict, dict_get_var (ds->dict->dict, i));
/* Construct clip data. */
map = case_map_by_name (ds->dict->dict, clip_dict);
writer = autopaging_writer_create (dict_get_proto (clip_dict));
for (i = row0; i <= rowi ; ++i )
{
struct ccase *old = psppire_data_store_get_case (ds, i);
if (old != NULL)
casewriter_write (writer, case_map_execute (map, old));
else
casewriter_force_error (writer);
}
case_map_destroy (map);
clip_datasheet = casewriter_make_reader (writer);
data_sheet_update_clipboard (sheet);
}
/* Parses and executes the AGGREGATE procedure. */
int
cmd_aggregate (struct lexer *lexer, struct dataset *ds)
{
struct dictionary *dict = dataset_dict (ds);
struct agr_proc agr;
struct file_handle *out_file = NULL;
struct casereader *input = NULL, *group;
struct casegrouper *grouper;
struct casewriter *output = NULL;
bool copy_documents = false;
bool presorted = false;
bool saw_direction;
bool ok;
memset(&agr, 0 , sizeof (agr));
agr.missing = ITEMWISE;
agr.src_dict = dict;
subcase_init_empty (&agr.sort);
/* OUTFILE subcommand must be first. */
lex_match (lexer, T_SLASH);
if (!lex_force_match_id (lexer, "OUTFILE"))
goto error;
lex_match (lexer, T_EQUALS);
if (!lex_match (lexer, T_ASTERISK))
{
out_file = fh_parse (lexer, FH_REF_FILE, dataset_session (ds));
if (out_file == NULL)
goto error;
}
if (out_file == NULL && lex_match_id (lexer, "MODE"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "ADDVARIABLES"))
{
agr.add_variables = true;
/* presorted is assumed in ADDVARIABLES mode */
presorted = true;
}
else if (lex_match_id (lexer, "REPLACE"))
{
agr.add_variables = false;
}
else
goto error;
}
if ( agr.add_variables )
agr.dict = dict_clone (dict);
else
agr.dict = dict_create (dict_get_encoding (dict));
dict_set_label (agr.dict, dict_get_label (dict));
dict_set_documents (agr.dict, dict_get_documents (dict));
/* Read most of the subcommands. */
for (;;)
{
lex_match (lexer, T_SLASH);
if (lex_match_id (lexer, "MISSING"))
{
lex_match (lexer, T_EQUALS);
if (!lex_match_id (lexer, "COLUMNWISE"))
{
lex_error_expecting (lexer, "COLUMNWISE", NULL);
goto error;
}
agr.missing = COLUMNWISE;
}
else if (lex_match_id (lexer, "DOCUMENT"))
copy_documents = true;
else if (lex_match_id (lexer, "PRESORTED"))
presorted = true;
else if (lex_force_match_id (lexer, "BREAK"))
{
int i;
lex_match (lexer, T_EQUALS);
if (!parse_sort_criteria (lexer, dict, &agr.sort, &agr.break_vars,
&saw_direction))
goto error;
agr.break_var_cnt = subcase_get_n_fields (&agr.sort);
if (! agr.add_variables)
for (i = 0; i < agr.break_var_cnt; i++)
dict_clone_var_assert (agr.dict, agr.break_vars[i]);
/* BREAK must follow the options. */
break;
}
else
goto error;
}
if (presorted && saw_direction)
msg (SW, _("When PRESORTED is specified, specifying sorting directions "
"with (A) or (D) has no effect. Output data will be sorted "
"the same way as the input data."));
/* Read in the aggregate functions. */
lex_match (lexer, T_SLASH);
if (!parse_aggregate_functions (lexer, dict, &agr))
goto error;
/* Delete documents. */
if (!copy_documents)
dict_clear_documents (agr.dict);
/* Cancel SPLIT FILE. */
dict_set_split_vars (agr.dict, NULL, 0);
/* Initialize. */
agr.case_cnt = 0;
if (out_file == NULL)
{
/* The active dataset will be replaced by the aggregated data,
so TEMPORARY is moot. */
proc_cancel_temporary_transformations (ds);
proc_discard_output (ds);
output = autopaging_writer_create (dict_get_proto (agr.dict));
}
else
{
output = any_writer_open (out_file, agr.dict);
if (output == NULL)
goto error;
}
input = proc_open (ds);
if (!subcase_is_empty (&agr.sort) && !presorted)
{
input = sort_execute (input, &agr.sort);
subcase_clear (&agr.sort);
}
for (grouper = casegrouper_create_vars (input, agr.break_vars,
agr.break_var_cnt);
casegrouper_get_next_group (grouper, &group);
casereader_destroy (group))
{
struct casereader *placeholder = NULL;
struct ccase *c = casereader_peek (group, 0);
if (c == NULL)
{
casereader_destroy (group);
continue;
}
initialize_aggregate_info (&agr);
if ( agr.add_variables )
placeholder = casereader_clone (group);
{
struct ccase *cg;
for (; (cg = casereader_read (group)) != NULL; case_unref (cg))
accumulate_aggregate_info (&agr, cg);
}
if (agr.add_variables)
{
struct ccase *cg;
for (; (cg = casereader_read (placeholder)) != NULL; case_unref (cg))
dump_aggregate_info (&agr, output, cg);
casereader_destroy (placeholder);
}
else
{
dump_aggregate_info (&agr, output, c);
}
case_unref (c);
}
if (!casegrouper_destroy (grouper))
goto error;
if (!proc_commit (ds))
{
input = NULL;
goto error;
}
input = NULL;
if (out_file == NULL)
{
struct casereader *next_input = casewriter_make_reader (output);
if (next_input == NULL)
goto error;
dataset_set_dict (ds, agr.dict);
dataset_set_source (ds, next_input);
agr.dict = NULL;
}
else
{
ok = casewriter_destroy (output);
output = NULL;
if (!ok)
goto error;
}
agr_destroy (&agr);
fh_unref (out_file);
return CMD_SUCCESS;
error:
if (input != NULL)
proc_commit (ds);
casewriter_destroy (output);
agr_destroy (&agr);
fh_unref (out_file);
return CMD_CASCADING_FAILURE;
}
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));
}
void
sign_execute (const struct dataset *ds,
struct casereader *input,
enum mv_class exclude,
const struct npar_test *test,
bool exact UNUSED,
double timer UNUSED)
{
int i;
bool warn = true;
const struct dictionary *dict = dataset_dict (ds);
const struct two_sample_test *t2s = UP_CAST (test, const struct two_sample_test, parent);
struct ccase *c;
struct sign_test_params *stp = xcalloc (t2s->n_pairs, sizeof *stp);
struct casereader *r = input;
for (; (c = casereader_read (r)) != NULL; case_unref (c))
{
const double weight = dict_get_case_weight (dict, c, &warn);
for (i = 0 ; i < t2s->n_pairs; ++i )
{
variable_pair *vp = &t2s->pairs[i];
const union value *value0 = case_data (c, (*vp)[0]);
const union value *value1 = case_data (c, (*vp)[1]);
const double diff = value0->f - value1->f;
if (var_is_value_missing ((*vp)[0], value0, exclude))
continue;
if (var_is_value_missing ((*vp)[1], value1, exclude))
continue;
if ( diff > 0)
stp[i].pos += weight;
else if (diff < 0)
stp[i].neg += weight;
else
stp[i].ties += weight;
}
}
casereader_destroy (r);
for (i = 0 ; i < t2s->n_pairs; ++i )
{
int r = MIN (stp[i].pos, stp[i].neg);
stp[i].one_tailed_sig = gsl_cdf_binomial_P (r,
0.5,
stp[i].pos + stp[i].neg);
stp[i].point_prob = gsl_ran_binomial_pdf (r, 0.5,
stp[i].pos + stp[i].neg);
}
output_frequency_table (t2s, stp, dict);
output_statistics_table (t2s, stp);
free (stp);
}
