int
cmd_sample (struct lexer *lexer, struct dataset *ds)
{
struct sample_trns *trns;
int type;
int a, b;
unsigned frac;
if (!lex_force_num (lexer))
return CMD_FAILURE;
if (!lex_is_integer (lexer))
{
unsigned long min = gsl_rng_min (get_rng ());
unsigned long max = gsl_rng_max (get_rng ());
type = TYPE_FRACTION;
if (lex_tokval (lexer) <= 0 || lex_tokval (lexer) >= 1)
{
msg (SE, _("The sampling factor must be between 0 and 1 "
"exclusive."));
return CMD_FAILURE;
}
frac = lex_tokval (lexer) * (max - min) + min;
a = b = 0;
}
else
{
type = TYPE_A_FROM_B;
a = lex_integer (lexer);
lex_get (lexer);
if (!lex_force_match_id (lexer, "FROM"))
return CMD_FAILURE;
if (!lex_force_int (lexer))
return CMD_FAILURE;
b = lex_integer (lexer);
if (a >= b)
{
msg (SE, _("Cannot sample %d observations from a population of "
"%d."),
a, b);
return CMD_FAILURE;
}
frac = 0;
}
lex_get (lexer);
trns = xmalloc (sizeof *trns);
trns->type = type;
trns->n = a;
trns->N = b;
trns->m = trns->t = 0;
trns->frac = frac;
add_transformation (ds, sample_trns_proc, sample_trns_free, trns);
return CMD_SUCCESS;
}
/* Reads a record from the inline file into R.
Returns true if successful, false on failure. */
static bool
read_inline_record (struct dfm_reader *r)
{
if ((r->flags & DFM_SAW_BEGIN_DATA) == 0)
{
r->flags |= DFM_SAW_BEGIN_DATA;
r->flags &= ~DFM_CONSUME;
while (lex_token (r->lexer) == T_ENDCMD)
lex_get (r->lexer);
if (!lex_force_match_id (r->lexer, "BEGIN")
|| !lex_force_match_id (r->lexer, "DATA"))
return false;
lex_match (r->lexer, T_ENDCMD);
}
if (r->flags & DFM_CONSUME)
lex_get (r->lexer);
if (!lex_is_string (r->lexer))
{
if (!lex_match_id (r->lexer, "END") || !lex_match_id (r->lexer, "DATA"))
{
msg (SE, _("Missing END DATA while reading inline data. "
"This probably indicates a missing or incorrectly "
"formatted END DATA command. END DATA must appear "
"by itself on a single line with exactly one space "
"between words."));
lex_discard_rest_of_command (r->lexer);
}
return false;
}
ds_assign_substring (&r->line, lex_tokss (r->lexer));
r->flags |= DFM_CONSUME;
return true;
}
int
cmd_t_test (struct lexer *lexer, struct dataset *ds)
{
bool ok;
const struct dictionary *dict = dataset_dict (ds);
struct tt tt;
int mode_count = 0;
/* Variables pertaining to the paired mode */
const struct variable **v1 = NULL;
size_t n_v1;
const struct variable **v2 = NULL;
size_t n_v2;
size_t n_pairs = 0;
vp *pairs = NULL;
/* One sample mode */
double testval = SYSMIS;
/* Independent samples mode */
const struct variable *gvar;
union value gval0;
union value gval1;
bool cut = false;
tt.wv = dict_get_weight (dict);
tt.dict = dict;
tt.confidence = 0.95;
tt.exclude = MV_ANY;
tt.missing_type = MISS_ANALYSIS;
tt.n_vars = 0;
tt.vars = NULL;
tt.mode = MODE_undef;
lex_match (lexer, T_EQUALS);
for (; lex_token (lexer) != T_ENDCMD; )
{
lex_match (lexer, T_SLASH);
if (lex_match_id (lexer, "TESTVAL"))
{
mode_count++;
tt.mode = MODE_SINGLE;
lex_match (lexer, T_EQUALS);
lex_force_num (lexer);
testval = lex_number (lexer);
lex_get (lexer);
}
else if (lex_match_id (lexer, "GROUPS"))
{
mode_count++;
cut = false;
tt.mode = MODE_INDEP;
lex_match (lexer, T_EQUALS);
if (NULL == (gvar = parse_variable (lexer, dict)))
goto parse_failed;
if (lex_match (lexer, T_LPAREN))
{
value_init (&gval0, var_get_width (gvar));
parse_value (lexer, &gval0, gvar);
cut = true;
if (lex_match (lexer, T_COMMA))
{
value_init (&gval1, var_get_width (gvar));
parse_value (lexer, &gval1, gvar);
cut = false;
}
lex_force_match (lexer, T_RPAREN);
}
else
{
value_init (&gval0, 0);
value_init (&gval1, 0);
gval0.f = 1.0;
gval1.f = 2.0;
cut = false;
}
if ( cut == true && var_is_alpha (gvar))
{
msg (SE, _("When applying GROUPS to a string variable, two "
"values must be specified."));
goto parse_failed;
}
}
else if (lex_match_id (lexer, "PAIRS"))
{
bool with = false;
bool paired = false;
if (tt.n_vars > 0)
{
msg (SE, _("VARIABLES subcommand may not be used with PAIRS."));
goto parse_failed;
}
mode_count++;
tt.mode = MODE_PAIRED;
lex_match (lexer, T_EQUALS);
if (!parse_variables_const (lexer, dict,
&v1, &n_v1,
PV_NO_DUPLICATE | PV_NUMERIC))
goto parse_failed;
if ( lex_match (lexer, T_WITH))
{
with = true;
if (!parse_variables_const (lexer, dict,
&v2, &n_v2,
PV_NO_DUPLICATE | PV_NUMERIC))
goto parse_failed;
if (lex_match (lexer, T_LPAREN)
&& lex_match_id (lexer, "PAIRED")
&& lex_match (lexer, T_RPAREN))
{
paired = true;
if (n_v1 != n_v2)
{
msg (SE, _("PAIRED was specified but the number of variables "
"preceding WITH (%zu) did not match the number "
"following (%zu)."),
n_v1, n_v2);
goto parse_failed;
}
}
}
{
int i;
if ( !with )
n_pairs = (n_v1 * (n_v1 - 1)) / 2.0;
else if ( paired )
n_pairs = n_v1;
else
n_pairs = n_v1 * n_v2;
pairs = xcalloc (n_pairs, sizeof *pairs);
if ( with)
{
int x = 0;
if (paired)
{
for (i = 0 ; i < n_v1; ++i)
{
vp *pair = &pairs[i];
(*pair)[0] = v1[i];
(*pair)[1] = v2[i];
}
}
else
{
for (i = 0 ; i < n_v1; ++i)
{
int j;
for (j = 0 ; j < n_v2; ++j)
{
vp *pair = &pairs[x++];
(*pair)[0] = v1[i];
(*pair)[1] = v2[j];
}
}
}
}
else
{
int x = 0;
for (i = 0 ; i < n_v1; ++i)
{
int j;
for (j = i + 1 ; j < n_v1; ++j)
{
vp *pair = &pairs[x++];
(*pair)[0] = v1[i];
(*pair)[1] = v1[j];
}
}
}
}
}
else if (lex_match_id (lexer, "VARIABLES"))
{
if ( tt.mode == MODE_PAIRED)
{
msg (SE, _("VARIABLES subcommand may not be used with PAIRS."));
goto parse_failed;
}
lex_match (lexer, T_EQUALS);
if (!parse_variables_const (lexer, dict,
&tt.vars,
&tt.n_vars,
PV_NO_DUPLICATE | PV_NUMERIC))
goto parse_failed;
}
else if ( lex_match_id (lexer, "MISSING"))
{
lex_match (lexer, T_EQUALS);
while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
{
if (lex_match_id (lexer, "INCLUDE"))
{
tt.exclude = MV_SYSTEM;
}
else if (lex_match_id (lexer, "EXCLUDE"))
{
tt.exclude = MV_ANY;
}
else if (lex_match_id (lexer, "LISTWISE"))
{
tt.missing_type = MISS_LISTWISE;
}
else if (lex_match_id (lexer, "ANALYSIS"))
{
tt.missing_type = MISS_ANALYSIS;
}
else
{
lex_error (lexer, NULL);
goto parse_failed;
}
lex_match (lexer, T_COMMA);
}
}
else if (lex_match_id (lexer, "CRITERIA"))
{
lex_match (lexer, T_EQUALS);
if ( lex_force_match_id (lexer, "CIN"))
if ( lex_force_match (lexer, T_LPAREN))
{
lex_force_num (lexer);
tt.confidence = lex_number (lexer);
lex_get (lexer);
lex_force_match (lexer, T_RPAREN);
}
}
else
{
lex_error (lexer, NULL);
goto parse_failed;
}
}
if ( mode_count != 1)
{
msg (SE, _("Exactly one of TESTVAL, GROUPS and PAIRS subcommands "
"must be specified."));
goto parse_failed;
}
if (tt.n_vars == 0 && tt.mode != MODE_PAIRED)
{
lex_sbc_missing ("VARIABLES");
goto parse_failed;
}
/* Deal with splits etc */
{
struct casereader *group;
struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), dict);
while (casegrouper_get_next_group (grouper, &group))
{
if ( tt.mode == MODE_SINGLE)
{
if ( tt.missing_type == MISS_LISTWISE )
group = casereader_create_filter_missing (group,
tt.vars, tt.n_vars,
tt.exclude,
NULL, NULL);
one_sample_run (&tt, testval, group);
}
else if ( tt.mode == MODE_PAIRED)
{
if ( tt.missing_type == MISS_LISTWISE )
{
group = casereader_create_filter_missing (group,
v1, n_v1,
tt.exclude,
NULL, NULL);
group = casereader_create_filter_missing (group,
v2, n_v2,
tt.exclude,
NULL, NULL);
}
paired_run (&tt, n_pairs, pairs, group);
}
else /* tt.mode == MODE_INDEP */
{
if ( tt.missing_type == MISS_LISTWISE )
{
group = casereader_create_filter_missing (group,
tt.vars, tt.n_vars,
tt.exclude,
NULL, NULL);
group = casereader_create_filter_missing (group,
&gvar, 1,
tt.exclude,
NULL, NULL);
}
indep_run (&tt, gvar, cut, &gval0, &gval1, group);
}
}
ok = casegrouper_destroy (grouper);
ok = proc_commit (ds) && ok;
}
free (pairs);
free (v1);
free (v2);
free (tt.vars);
return ok ? CMD_SUCCESS : CMD_FAILURE;
parse_failed:
return CMD_FAILURE;
}
static bool
parse_commands (struct lexer *lexer, struct hmap *dummies)
{
enum lex_syntax_mode syntax_mode;
enum segmenter_mode mode;
struct string *outputs;
struct string input;
size_t input_len;
size_t n_values;
char *file_name;
int line_number;
bool ok;
size_t i;
if (lex_get_file_name (lexer) != NULL)
file_name = xstrdup (lex_get_file_name (lexer));
else
file_name = NULL;
line_number = lex_get_first_line_number (lexer, 0);
ds_init_empty (&input);
while (lex_is_string (lexer))
{
ds_put_substring (&input, lex_tokss (lexer));
ds_put_byte (&input, '\n');
lex_get (lexer);
}
if (ds_is_empty (&input))
ds_put_byte (&input, '\n');
ds_put_byte (&input, '\0');
input_len = ds_length (&input);
n_values = count_values (dummies);
outputs = xmalloc (n_values * sizeof *outputs);
for (i = 0; i < n_values; i++)
ds_init_empty (&outputs[i]);
syntax_mode = lex_get_syntax_mode (lexer);
if (syntax_mode == LEX_SYNTAX_AUTO)
mode = SEG_MODE_AUTO;
else if (syntax_mode == LEX_SYNTAX_INTERACTIVE)
mode = SEG_MODE_INTERACTIVE;
else if (syntax_mode == LEX_SYNTAX_BATCH)
mode = SEG_MODE_BATCH;
else
NOT_REACHED ();
do_parse_commands (ds_ss (&input), mode, dummies, outputs, n_values);
ds_destroy (&input);
while (lex_match (lexer, T_ENDCMD))
continue;
ok = (lex_force_match_id (lexer, "END")
&& lex_force_match_id (lexer, "REPEAT"));
if (ok)
lex_match_id (lexer, "PRINT"); /* XXX */
lex_discard_rest_of_command (lexer);
for (i = 0; i < n_values; i++)
{
struct string *output = &outputs[n_values - i - 1];
struct lex_reader *reader;
reader = lex_reader_for_substring_nocopy (ds_ss (output));
lex_reader_set_file_name (reader, file_name);
reader->line_number = line_number;
lex_include (lexer, reader);
}
free (file_name);
return ok;
}
/* 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;
}
int
cmd_reliability (struct lexer *lexer, struct dataset *ds)
{
const struct dictionary *dict = dataset_dict (ds);
struct reliability reliability;
reliability.n_variables = 0;
reliability.variables = NULL;
reliability.model = MODEL_ALPHA;
reliability.exclude = MV_ANY;
reliability.summary = 0;
reliability.wv = dict_get_weight (dict);
reliability.total_start = 0;
lex_match (lexer, T_SLASH);
if (!lex_force_match_id (lexer, "VARIABLES"))
{
goto error;
}
lex_match (lexer, T_EQUALS);
if (!parse_variables_const (lexer, dict, &reliability.variables, &reliability.n_variables,
PV_NO_DUPLICATE | PV_NUMERIC))
goto error;
if (reliability.n_variables < 2)
msg (MW, _("Reliability on a single variable is not useful."));
{
int i;
struct cronbach *c;
/* Create a default Scale */
reliability.n_sc = 1;
reliability.sc = xzalloc (sizeof (struct cronbach) * reliability.n_sc);
ds_init_cstr (&reliability.scale_name, "ANY");
c = &reliability.sc[0];
c->n_items = reliability.n_variables;
c->items = xzalloc (sizeof (struct variable*) * c->n_items);
for (i = 0 ; i < c->n_items ; ++i)
c->items[i] = reliability.variables[i];
}
while (lex_token (lexer) != T_ENDCMD)
{
lex_match (lexer, T_SLASH);
if (lex_match_id (lexer, "SCALE"))
{
struct const_var_set *vs;
if ( ! lex_force_match (lexer, T_LPAREN))
goto error;
if ( ! lex_force_string (lexer) )
goto error;
ds_init_substring (&reliability.scale_name, lex_tokss (lexer));
lex_get (lexer);
if ( ! lex_force_match (lexer, T_RPAREN))
goto error;
lex_match (lexer, T_EQUALS);
vs = const_var_set_create_from_array (reliability.variables, reliability.n_variables);
if (!parse_const_var_set_vars (lexer, vs, &reliability.sc->items, &reliability.sc->n_items, 0))
{
const_var_set_destroy (vs);
goto error;
}
const_var_set_destroy (vs);
}
else if (lex_match_id (lexer, "MODEL"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "ALPHA"))
{
reliability.model = MODEL_ALPHA;
}
else if (lex_match_id (lexer, "SPLIT"))
{
reliability.model = MODEL_SPLIT;
reliability.split_point = -1;
if ( lex_match (lexer, T_LPAREN))
{
lex_force_num (lexer);
reliability.split_point = lex_number (lexer);
lex_get (lexer);
lex_force_match (lexer, T_RPAREN);
}
}
else
goto error;
}
else if (lex_match_id (lexer, "SUMMARY"))
{
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "TOTAL"))
{
reliability.summary |= SUMMARY_TOTAL;
}
else if (lex_match (lexer, T_ALL))
{
reliability.summary = 0xFFFF;
}
else
goto error;
}
else if (lex_match_id (lexer, "MISSING"))
{
lex_match (lexer, T_EQUALS);
while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH)
{
if (lex_match_id (lexer, "INCLUDE"))
{
reliability.exclude = MV_SYSTEM;
}
else if (lex_match_id (lexer, "EXCLUDE"))
{
reliability.exclude = MV_ANY;
}
else
{
lex_error (lexer, NULL);
goto error;
}
}
}
else
{
lex_error (lexer, NULL);
goto error;
}
}
if ( reliability.model == MODEL_SPLIT)
{
int i;
const struct cronbach *s;
if ( reliability.split_point >= reliability.n_variables)
{
msg (ME, _("The split point must be less than the number of variables"));
goto error;
}
reliability.n_sc += 2 ;
reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
s = &reliability.sc[0];
reliability.sc[1].n_items =
(reliability.split_point == -1) ? s->n_items / 2 : reliability.split_point;
reliability.sc[2].n_items = s->n_items - reliability.sc[1].n_items;
reliability.sc[1].items = xzalloc (sizeof (struct variable *)
* reliability.sc[1].n_items);
reliability.sc[2].items = xzalloc (sizeof (struct variable *) *
reliability.sc[2].n_items);
for (i = 0; i < reliability.sc[1].n_items ; ++i)
reliability.sc[1].items[i] = s->items[i];
while (i < s->n_items)
{
reliability.sc[2].items[i - reliability.sc[1].n_items] = s->items[i];
i++;
}
}
if ( reliability.summary & SUMMARY_TOTAL)
{
int i;
const int base_sc = reliability.n_sc;
reliability.total_start = base_sc;
reliability.n_sc += reliability.sc[0].n_items ;
reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
for (i = 0 ; i < reliability.sc[0].n_items; ++i )
{
int v_src;
int v_dest = 0;
struct cronbach *s = &reliability.sc[i + base_sc];
s->n_items = reliability.sc[0].n_items - 1;
s->items = xzalloc (sizeof (struct variable *) * s->n_items);
for (v_src = 0 ; v_src < reliability.sc[0].n_items ; ++v_src)
{
if ( v_src != i)
s->items[v_dest++] = reliability.sc[0].items[v_src];
}
}
}
if ( ! run_reliability (ds, &reliability))
goto error;
free (reliability.variables);
return CMD_SUCCESS;
error:
free (reliability.variables);
return CMD_FAILURE;
}
