static void
run_old_and_new_dialog (struct recode_dialog *rd)
{
gint response;
GtkListStore *local_store = clone_list_store (rd->value_map);
psppire_acr_set_model (rd->acr, local_store);
psppire_acr_set_get_value_func (rd->acr, set_value, rd);
gtk_window_set_title (GTK_WINDOW (rd->old_and_new_dialog),
rd->different
? _("Recode into Different Variables: Old and New Values ")
: _("Recode into Same Variables: Old and New Values")
);
{
/* Find the type of the first variable (it's invariant that
all variables are of the same type) */
const struct variable *v;
GtkTreeIter iter;
GtkTreeModel *model =
gtk_tree_view_get_model (GTK_TREE_VIEW (rd->variable_treeview));
gboolean not_empty = gtk_tree_model_get_iter_first (model, &iter);
g_return_if_fail (not_empty);
gtk_tree_model_get (model, &iter, 0, &v, -1);
rd->input_var_is_string = var_is_alpha (v);
g_object_set (rd->old_value_chooser, "is-string", rd->input_var_is_string, NULL);
gtk_widget_set_sensitive (rd->toggle [BUTTON_NEW_SYSMIS],
var_is_numeric (v));
gtk_widget_set_sensitive (rd->convert_button, var_is_alpha (v));
}
response = psppire_dialog_run (rd->old_and_new_dialog);
psppire_acr_set_model (rd->acr, NULL);
if ( response == PSPPIRE_RESPONSE_CONTINUE )
{
g_object_unref (rd->value_map);
rd->value_map = clone_list_store (local_store);
}
else
g_object_unref (local_store);
psppire_dialog_notify_change (PSPPIRE_DIALOG (rd->dialog));
}
/* Returns true iff the variable selected by SOURCE is numeric */
gboolean
numeric_only (GtkWidget *source, GtkWidget *dest)
{
gboolean retval = TRUE;
GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (source));
PsppireDict *dict;
GtkTreeSelection *selection;
GList *list, *l;
while (GTK_IS_TREE_MODEL_FILTER (model))
{
model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
}
dict = PSPPIRE_DICT (model);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source));
list = gtk_tree_selection_get_selected_rows (selection, &model);
/* Iterate through the selection of the source treeview */
for (l = list; l ; l = l->next)
{
GtkTreePath *path = l->data;
GtkTreePath *fpath = gtk_tree_model_filter_convert_path_to_child_path
(GTK_TREE_MODEL_FILTER (model), path);
gint *idx = gtk_tree_path_get_indices (fpath);
const struct variable *v = psppire_dict_get_variable (dict, idx[0]);
gtk_tree_path_free (fpath);
if ( var_is_alpha (v))
{
retval = FALSE;
break;
}
}
g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (list);
return retval;
}
/* Returns true iff the variable selected by SOURCE is numeric */
gboolean
numeric_only (GtkWidget *source, GtkWidget *dest)
{
gboolean retval = TRUE;
GtkTreeModel *top_model = gtk_tree_view_get_model (GTK_TREE_VIEW (source));
GtkTreeModel *model = NULL;
PsppireDict *dict;
GtkTreeSelection *selection;
GList *list, *l;
get_base_model (top_model, NULL, &model, NULL);
dict = PSPPIRE_DICT (model);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source));
list = gtk_tree_selection_get_selected_rows (selection, &top_model);
/* Iterate through the selection of the source treeview */
for (l = list; l ; l = l->next)
{
GtkTreePath *p = get_base_tree_path (top_model, l->data);
gint *idx = gtk_tree_path_get_indices (p);
const struct variable *v = psppire_dict_get_variable (dict, idx[0]);
gtk_tree_path_free (p);
if ( var_is_alpha (v))
{
retval = FALSE;
break;
}
}
g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (list);
return retval;
}
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 gchar *
generate_syntax (const struct tt_indep_samples_dialog *d)
{
struct variable *group_variable;
gchar *text;
GtkWidget *tv =
get_widget_assert (d->xml, "indep-samples-t-test-treeview2");
GString *str = g_string_new ("T-TEST /VARIABLES=");
psppire_var_view_append_names (PSPPIRE_VAR_VIEW (tv), 0, str);
g_string_append (str, "\n\t/GROUPS=");
group_variable =
psppire_dict_lookup_var (d->dict,
gtk_entry_get_text (GTK_ENTRY (d->groups_entry)));
g_string_append (str, var_get_name (group_variable));
if (d->grps->group_defn != GROUPS_UNDEF)
{
g_string_append (str, "(");
if ( var_is_alpha (group_variable))
{
struct string s = DS_EMPTY_INITIALIZER;
syntax_gen_string (&s, ss_cstr (d->grps->val[0]));
g_string_append (str, ds_cstr (&s));
ds_destroy (&s);
}
else
{
g_string_append (str, d->grps->val[0]);
}
if ( d->grps->group_defn == GROUPS_VALUES )
{
g_string_append (str, ",");
if ( var_is_alpha (group_variable))
{
struct string s = DS_EMPTY_INITIALIZER;
syntax_gen_string (&s, ss_cstr (d->grps->val[1]));
g_string_append (str, ds_cstr (&s));
ds_destroy (&s);
}
else
{
g_string_append (str, d->grps->val[1]);
}
}
g_string_append (str, ")");
}
tt_options_dialog_append_syntax (d->opts, str);
g_string_append (str, ".\n");
text = str->str;
g_string_free (str, FALSE);
return text;
}
/* Parse all the aggregate functions. */
static bool
parse_aggregate_functions (struct lexer *lexer, const struct dictionary *dict,
struct agr_proc *agr)
{
struct agr_var *tail; /* Tail of linked list starting at agr->vars. */
/* Parse everything. */
tail = NULL;
for (;;)
{
char **dest;
char **dest_label;
size_t n_dest;
struct string function_name;
enum mv_class exclude;
const struct agr_func *function;
int func_index;
union agr_argument arg[2];
const struct variable **src;
size_t n_src;
size_t i;
dest = NULL;
dest_label = NULL;
n_dest = 0;
src = NULL;
function = NULL;
n_src = 0;
arg[0].c = NULL;
arg[1].c = NULL;
ds_init_empty (&function_name);
/* Parse the list of target variables. */
while (!lex_match (lexer, T_EQUALS))
{
size_t n_dest_prev = n_dest;
if (!parse_DATA_LIST_vars (lexer, dict, &dest, &n_dest,
(PV_APPEND | PV_SINGLE | PV_NO_SCRATCH
| PV_NO_DUPLICATE)))
goto error;
/* Assign empty labels. */
{
int j;
dest_label = xnrealloc (dest_label, n_dest, sizeof *dest_label);
for (j = n_dest_prev; j < n_dest; j++)
dest_label[j] = NULL;
}
if (lex_is_string (lexer))
{
dest_label[n_dest - 1] = xstrdup (lex_tokcstr (lexer));
lex_get (lexer);
}
}
/* Get the name of the aggregation function. */
if (lex_token (lexer) != T_ID)
{
lex_error (lexer, _("expecting aggregation function"));
goto error;
}
ds_assign_substring (&function_name, lex_tokss (lexer));
exclude = ds_chomp_byte (&function_name, '.') ? MV_SYSTEM : MV_ANY;
for (function = agr_func_tab; function->name; function++)
if (!c_strcasecmp (function->name, ds_cstr (&function_name)))
break;
if (NULL == function->name)
{
msg (SE, _("Unknown aggregation function %s."),
ds_cstr (&function_name));
goto error;
}
ds_destroy (&function_name);
func_index = function - agr_func_tab;
lex_get (lexer);
/* Check for leading lparen. */
if (!lex_match (lexer, T_LPAREN))
{
if (function->src_vars == AGR_SV_YES)
{
lex_force_match (lexer, T_LPAREN);
goto error;
}
}
else
{
/* Parse list of source variables. */
{
int pv_opts = PV_NO_SCRATCH;
if (func_index == SUM || func_index == MEAN || func_index == SD)
pv_opts |= PV_NUMERIC;
else if (function->n_args)
pv_opts |= PV_SAME_TYPE;
if (!parse_variables_const (lexer, dict, &src, &n_src, pv_opts))
goto error;
}
/* Parse function arguments, for those functions that
require arguments. */
if (function->n_args != 0)
for (i = 0; i < function->n_args; i++)
{
int type;
lex_match (lexer, T_COMMA);
if (lex_is_string (lexer))
{
arg[i].c = recode_string (dict_get_encoding (agr->dict),
"UTF-8", lex_tokcstr (lexer),
-1);
type = VAL_STRING;
}
else if (lex_is_number (lexer))
{
arg[i].f = lex_tokval (lexer);
type = VAL_NUMERIC;
}
else
{
msg (SE, _("Missing argument %zu to %s."),
i + 1, function->name);
goto error;
}
lex_get (lexer);
if (type != var_get_type (src[0]))
{
msg (SE, _("Arguments to %s must be of same type as "
"source variables."),
function->name);
goto error;
}
}
/* Trailing rparen. */
if (!lex_force_match (lexer, T_RPAREN))
goto error;
/* Now check that the number of source variables match
the number of target variables. If we check earlier
than this, the user can get very misleading error
message, i.e. `AGGREGATE x=SUM(y t).' will get this
error message when a proper message would be more
like `unknown variable t'. */
if (n_src != n_dest)
{
msg (SE, _("Number of source variables (%zu) does not match "
"number of target variables (%zu)."),
n_src, n_dest);
goto error;
}
if ((func_index == PIN || func_index == POUT
|| func_index == FIN || func_index == FOUT)
&& (var_is_numeric (src[0])
? arg[0].f > arg[1].f
: str_compare_rpad (arg[0].c, arg[1].c) > 0))
{
union agr_argument t = arg[0];
arg[0] = arg[1];
arg[1] = t;
msg (SW, _("The value arguments passed to the %s function "
"are out-of-order. They will be treated as if "
"they had been specified in the correct order."),
function->name);
}
}
/* Finally add these to the linked list of aggregation
variables. */
for (i = 0; i < n_dest; i++)
{
struct agr_var *v = xzalloc (sizeof *v);
/* Add variable to chain. */
if (agr->agr_vars != NULL)
tail->next = v;
else
agr->agr_vars = v;
tail = v;
tail->next = NULL;
v->moments = NULL;
/* Create the target variable in the aggregate
dictionary. */
{
struct variable *destvar;
v->function = func_index;
if (src)
{
v->src = src[i];
if (var_is_alpha (src[i]))
{
v->function |= FSTRING;
v->string = xmalloc (var_get_width (src[i]));
}
if (function->alpha_type == VAL_STRING)
destvar = dict_clone_var_as (agr->dict, v->src, dest[i]);
else
{
assert (var_is_numeric (v->src)
|| function->alpha_type == VAL_NUMERIC);
destvar = dict_create_var (agr->dict, dest[i], 0);
if (destvar != NULL)
{
struct fmt_spec f;
if ((func_index == N || func_index == NMISS)
&& dict_get_weight (dict) != NULL)
f = fmt_for_output (FMT_F, 8, 2);
else
f = function->format;
var_set_both_formats (destvar, &f);
}
}
} else {
struct fmt_spec f;
v->src = NULL;
destvar = dict_create_var (agr->dict, dest[i], 0);
if (destvar != NULL)
{
if ((func_index == N || func_index == NMISS)
&& dict_get_weight (dict) != NULL)
f = fmt_for_output (FMT_F, 8, 2);
else
f = function->format;
var_set_both_formats (destvar, &f);
}
}
if (!destvar)
{
msg (SE, _("Variable name %s is not unique within the "
"aggregate file dictionary, which contains "
"the aggregate variables and the break "
"variables."),
dest[i]);
goto error;
}
free (dest[i]);
if (dest_label[i])
var_set_label (destvar, dest_label[i]);
v->dest = destvar;
}
v->exclude = exclude;
if (v->src != NULL)
{
int j;
if (var_is_numeric (v->src))
for (j = 0; j < function->n_args; j++)
v->arg[j].f = arg[j].f;
else
for (j = 0; j < function->n_args; j++)
v->arg[j].c = xstrdup (arg[j].c);
}
}
if (src != NULL && var_is_alpha (src[0]))
for (i = 0; i < function->n_args; i++)
{
free (arg[i].c);
arg[i].c = NULL;
}
free (src);
free (dest);
free (dest_label);
if (!lex_match (lexer, T_SLASH))
{
if (lex_token (lexer) == T_ENDCMD)
return true;
lex_error (lexer, "expecting end of command");
return false;
}
continue;
error:
ds_destroy (&function_name);
for (i = 0; i < n_dest; i++)
{
free (dest[i]);
free (dest_label[i]);
}
free (dest);
free (dest_label);
free (arg[0].c);
free (arg[1].c);
if (src && n_src && var_is_alpha (src[0]))
for (i = 0; i < function->n_args; i++)
{
free (arg[i].c);
arg[i].c = NULL;
}
free (src);
return false;
}
}
