/* Converts TEXT to a value.
VAL will be initialised and filled by this function.
It is the caller's responsibility to destroy VAL when no longer needed.
VAR must be the variable with which VAL is associated.
On success, VAL is returned, NULL otherwise.
*/
union value *
text_to_value (const gchar *text,
const struct variable *var,
union value *val)
{
const struct fmt_spec *format = var_get_print_format (var);
int width = var_get_width (var);
if ( format->type != FMT_A)
{
if ( ! text ) return NULL;
{
const gchar *s = text;
while (*s)
{
if ( !isspace (*s))
break;
s++;
}
if ( !*s) return NULL;
}
}
value_init (val, width);
free (data_in (ss_cstr (text), UTF8, format->type, val, width,
var_get_encoding (var)));
return val;
}
static void
output_frequency_table (const struct two_sample_test *t2s,
const struct sign_test_params *param,
const struct dictionary *dict)
{
int i;
struct tab_table *table = tab_create (3, 1 + 4 * t2s->n_pairs);
const struct variable *wv = dict_get_weight (dict);
const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : & F_8_0;
tab_set_format (table, RC_WEIGHT, wfmt);
tab_title (table, _("Frequencies"));
tab_headers (table, 2, 0, 1, 0);
/* Vertical lines inside the box */
tab_box (table, 0, 0, -1, TAL_1,
1, 0, tab_nc (table) - 1, tab_nr (table) - 1 );
/* Box around entire table */
tab_box (table, TAL_2, TAL_2, -1, -1,
0, 0, tab_nc (table) - 1, tab_nr (table) - 1 );
tab_text (table, 2, 0, TAB_CENTER, _("N"));
for (i = 0 ; i < t2s->n_pairs; ++i)
{
variable_pair *vp = &t2s->pairs[i];
struct string pair_name;
ds_init_cstr (&pair_name, var_to_string ((*vp)[0]));
ds_put_cstr (&pair_name, " - ");
ds_put_cstr (&pair_name, var_to_string ((*vp)[1]));
tab_text (table, 0, 1 + i * 4, TAB_LEFT, ds_cstr (&pair_name));
ds_destroy (&pair_name);
tab_hline (table, TAL_1, 0, tab_nc (table) - 1, 1 + i * 4);
tab_text (table, 1, 1 + i * 4, TAB_LEFT, _("Negative Differences"));
tab_text (table, 1, 2 + i * 4, TAB_LEFT, _("Positive Differences"));
tab_text (table, 1, 3 + i * 4, TAB_LEFT, _("Ties"));
tab_text (table, 1, 4 + i * 4, TAB_LEFT, _("Total"));
tab_double (table, 2, 1 + i * 4, TAB_RIGHT, param[i].neg, NULL, RC_WEIGHT);
tab_double (table, 2, 2 + i * 4, TAB_RIGHT, param[i].pos, NULL, RC_WEIGHT);
tab_double (table, 2, 3 + i * 4, TAB_RIGHT, param[i].ties, NULL, RC_WEIGHT);
tab_double (table, 2, 4 + i * 4, TAB_RIGHT,
param[i].ties + param[i].neg + param[i].pos, NULL, RC_WEIGHT);
}
tab_submit (table);
}
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);
}
/* Formats a value according to VAR's print format and strips white space
appropriately for VAR's type. That is, if VAR is numeric, strips leading
white space (because numbers are right-justified within their fields), and
if VAR is string, strips trailing white space (because spaces pad out string
values on the right).
Returns an allocated string. The returned string must be freed when no
longer required. */
gchar *
value_to_text (union value v, const struct variable *var)
{
gchar *s;
s = data_out (&v, var_get_encoding (var), var_get_print_format (var));
if (var_is_numeric (var))
g_strchug (s);
else
g_strchomp (s);
return s;
}
/* Perform data_out for case CC, variable V, appending to STRING */
static void
data_out_g_string (GString *string, const struct variable *v,
const struct ccase *cc)
{
const struct fmt_spec *fs = var_get_print_format (v);
const union value *val = case_data (cc, v);
char *s = data_out (val, var_get_encoding (v), fs);
g_string_append (string, s);
g_free (s);
}
/*
Update IA according to the contents of DICT and CREADER.
CREADER will be destroyed by this function.
*/
void
update_assistant (struct import_assistant *ia)
{
struct sheet_spec_page *ssp = ia->sheet_spec;
int rows = 0;
if (ssp->dict)
{
struct ccase *c;
int col;
ia->column_cnt = dict_get_var_cnt (ssp->dict);
ia->columns = xcalloc (ia->column_cnt, sizeof (*ia->columns));
for (col = 0; col < ia->column_cnt ; ++col)
{
const struct variable *var = dict_get_var (ssp->dict, col);
ia->columns[col].name = xstrdup (var_get_name (var));
ia->columns[col].contents = NULL;
}
for (; (c = casereader_read (ssp->reader)) != NULL; case_unref (c))
{
rows++;
for (col = 0; col < ia->column_cnt ; ++col)
{
char *ss;
const struct variable *var = dict_get_var (ssp->dict, col);
ia->columns[col].contents = xrealloc (ia->columns[col].contents,
sizeof (struct substring) * rows);
ss = data_out (case_data (c, var), dict_get_encoding (ssp->dict),
var_get_print_format (var));
ia->columns[col].contents[rows - 1] = ss_cstr (ss);
}
if (rows > MAX_PREVIEW_LINES)
{
case_unref (c);
break;
}
}
}
ia->file.line_cnt = rows;
}
static void
reliability_statistics_model_alpha (struct tab_table *tbl,
const struct reliability *rel)
{
const struct variable *wv = rel->wv;
const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : & F_8_0;
const struct cronbach *s = &rel->sc[0];
tab_text (tbl, 0, 0, TAB_CENTER | TAT_TITLE,
_("Cronbach's Alpha"));
tab_text (tbl, 1, 0, TAB_CENTER | TAT_TITLE,
_("N of Items"));
tab_double (tbl, 0, 1, TAB_RIGHT, s->alpha, NULL);
tab_double (tbl, 1, 1, TAB_RIGHT, s->n_items, wfmt);
}
/* Dumps out the values of all the split variables for the case C. */
void
output_split_file_values (const struct dataset *ds, const struct ccase *c)
{
const struct dictionary *dict = dataset_dict (ds);
const struct variable *const *split;
struct tab_table *t;
size_t split_cnt;
int i;
split_cnt = dict_get_split_cnt (dict);
if (split_cnt == 0)
return;
t = tab_create (3, split_cnt + 1);
tab_vline (t, TAL_GAP, 1, 0, split_cnt);
tab_vline (t, TAL_GAP, 2, 0, split_cnt);
tab_text (t, 0, 0, TAB_NONE, _("Variable"));
tab_text (t, 1, 0, TAB_LEFT, _("Value"));
tab_text (t, 2, 0, TAB_LEFT, _("Label"));
split = dict_get_split_vars (dict);
for (i = 0; i < split_cnt; i++)
{
const struct variable *v = split[i];
char *s;
const char *val_lab;
const struct fmt_spec *print = var_get_print_format (v);
tab_text_format (t, 0, i + 1, TAB_LEFT, "%s", var_get_name (v));
s = data_out (case_data (c, v), dict_get_encoding (dict), print);
tab_text_format (t, 1, i + 1, 0, "%.*s", print->w, s);
free (s);
val_lab = var_lookup_value_label (v, case_data (c, v));
if (val_lab)
tab_text (t, 2, i + 1, TAB_LEFT, val_lab);
}
tab_submit (t);
}
static char *
generate_syntax (PsppireDialogAction *a)
{
PsppireDialogActionIndepSamps *act = PSPPIRE_DIALOG_ACTION_INDEP_SAMPS (a);
gchar *text;
GString *str = g_string_new ("T-TEST /VARIABLES=");
psppire_var_view_append_names (PSPPIRE_VAR_VIEW (act->test_vars_tv), 0, str);
g_string_append (str, "\n\t/GROUPS=");
g_string_append (str, var_get_name (act->grp_var));
if (act->group_defn != GROUPS_UNDEF)
{
g_string_append (str, "(");
{
const union value *val =
(act->group_defn == GROUPS_VALUES) ?
&act->grp_val[0] :
&act->cut_point;
struct string strx;
ds_init_empty (&strx);
syntax_gen_value (&strx, val, var_get_width (act->grp_var),
var_get_print_format (act->grp_var));
g_string_append (str, ds_cstr (&strx));
ds_destroy (&strx);
}
if (act->group_defn == GROUPS_VALUES)
{
g_string_append (str, ",");
{
struct string strx;
ds_init_empty (&strx);
syntax_gen_value (&strx, &act->grp_val[1], var_get_width (act->grp_var),
var_get_print_format (act->grp_var));
g_string_append (str, ds_cstr (&strx));
ds_destroy (&strx);
}
}
g_string_append (str, ")");
}
tt_options_dialog_append_syntax (act->opts, str);
g_string_append (str, ".\n");
text = str->str;
g_string_free (str, FALSE);
return text;
}
int
cmd_missing_values (struct lexer *lexer, struct dataset *ds)
{
struct dictionary *dict = dataset_dict (ds);
struct variable **v = NULL;
size_t nv;
bool ok = true;
while (lex_token (lexer) != T_ENDCMD)
{
size_t i;
if (!parse_variables (lexer, dict, &v, &nv, PV_NONE))
goto error;
if (!lex_force_match (lexer, T_LPAREN))
goto error;
for (i = 0; i < nv; i++)
var_clear_missing_values (v[i]);
if (!lex_match (lexer, T_RPAREN))
{
struct missing_values mv;
for (i = 0; i < nv; i++)
if (var_get_type (v[i]) != var_get_type (v[0]))
{
const struct variable *n = var_is_numeric (v[0]) ? v[0] : v[i];
const struct variable *s = var_is_numeric (v[0]) ? v[i] : v[0];
msg (SE, _("Cannot mix numeric variables (e.g. %s) and "
"string variables (e.g. %s) within a single list."),
var_get_name (n), var_get_name (s));
goto error;
}
if (var_is_numeric (v[0]))
{
mv_init (&mv, 0);
while (!lex_match (lexer, T_RPAREN))
{
enum fmt_type type = var_get_print_format (v[0])->type;
double x, y;
bool ok;
if (!parse_num_range (lexer, &x, &y, &type))
goto error;
ok = (x == y
? mv_add_num (&mv, x)
: mv_add_range (&mv, x, y));
if (!ok)
ok = false;
lex_match (lexer, T_COMMA);
}
}
else
{
mv_init (&mv, MV_MAX_STRING);
while (!lex_match (lexer, T_RPAREN))
{
uint8_t value[MV_MAX_STRING];
char *dict_mv;
size_t length;
if (!lex_force_string (lexer))
{
ok = false;
break;
}
dict_mv = recode_string (dict_get_encoding (dict), "UTF-8",
lex_tokcstr (lexer),
ss_length (lex_tokss (lexer)));
length = strlen (dict_mv);
if (length > MV_MAX_STRING)
{
/* XXX truncate graphemes not bytes */
msg (SE, _("Truncating missing value to maximum "
"acceptable length (%d bytes)."),
MV_MAX_STRING);
length = MV_MAX_STRING;
}
memset (value, ' ', MV_MAX_STRING);
memcpy (value, dict_mv, length);
free (dict_mv);
if (!mv_add_str (&mv, value))
ok = false;
lex_get (lexer);
lex_match (lexer, T_COMMA);
}
}
for (i = 0; i < nv; i++)
{
if (mv_is_resizable (&mv, var_get_width (v[i])))
var_set_missing_values (v[i], &mv);
else
{
msg (SE, _("Missing values provided are too long to assign "
"to variable of width %d."),
var_get_width (v[i]));
ok = false;
}
}
mv_destroy (&mv);
}
lex_match (lexer, T_SLASH);
free (v);
v = NULL;
}
free (v);
return ok ? CMD_SUCCESS : CMD_FAILURE;
error:
free (v);
return CMD_FAILURE;
}
/* Opens the CSV file designated by file handle FH for writing cases from
dictionary DICT according to the given OPTS.
No reference to D is retained, so it may be modified or
destroyed at will after this function returns. */
struct casewriter *
csv_writer_open (struct file_handle *fh, const struct dictionary *dict,
const struct csv_writer_options *opts)
{
struct csv_writer *w;
int i;
/* Create and initialize writer. */
w = xmalloc (sizeof *w);
w->fh = fh_ref (fh);
w->lock = NULL;
w->file = NULL;
w->rf = NULL;
w->opts = *opts;
w->encoding = xstrdup (dict_get_encoding (dict));
w->n_csv_vars = dict_get_var_cnt (dict);
w->csv_vars = xnmalloc (w->n_csv_vars, sizeof *w->csv_vars);
for (i = 0; i < w->n_csv_vars; i++)
{
const struct variable *var = dict_get_var (dict, i);
struct csv_var *cv = &w->csv_vars[i];
cv->width = var_get_width (var);
cv->case_index = var_get_case_index (var);
cv->format = *var_get_print_format (var);
if (opts->recode_user_missing)
mv_copy (&cv->missing, var_get_missing_values (var));
else
mv_init (&cv->missing, cv->width);
if (opts->use_value_labels)
cv->val_labs = val_labs_clone (var_get_value_labels (var));
else
cv->val_labs = NULL;
}
/* Open file handle as an exclusive writer. */
/* TRANSLATORS: this fragment will be interpolated into messages in fh_lock()
that identify types of files. */
w->lock = fh_lock (fh, FH_REF_FILE, N_("CSV file"), FH_ACC_WRITE, true);
if (w->lock == NULL)
goto error;
/* Create the file on disk. */
w->rf = replace_file_start (fh_get_file_name (fh), "w", 0666,
&w->file, NULL);
if (w->rf == NULL)
{
msg (ME, _("Error opening `%s' for writing as a system file: %s."),
fh_get_file_name (fh), strerror (errno));
goto error;
}
if (opts->include_var_names)
write_var_names (w, dict);
if (write_error (w))
goto error;
return casewriter_create (dict_get_proto (dict),
&csv_file_casewriter_class, w);
error:
close_writer (w);
return NULL;
}
static void
reliability_statistics_model_split (struct tab_table *tbl,
const struct reliability *rel)
{
const struct variable *wv = rel->wv;
const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : & F_8_0;
tab_text (tbl, 0, 0, TAB_LEFT,
_("Cronbach's Alpha"));
tab_text (tbl, 1, 0, TAB_LEFT,
_("Part 1"));
tab_text (tbl, 2, 0, TAB_LEFT,
_("Value"));
tab_text (tbl, 2, 1, TAB_LEFT,
_("N of Items"));
tab_text (tbl, 1, 2, TAB_LEFT,
_("Part 2"));
tab_text (tbl, 2, 2, TAB_LEFT,
_("Value"));
tab_text (tbl, 2, 3, TAB_LEFT,
_("N of Items"));
tab_text (tbl, 1, 4, TAB_LEFT,
_("Total N of Items"));
tab_text (tbl, 0, 5, TAB_LEFT,
_("Correlation Between Forms"));
tab_text (tbl, 0, 6, TAB_LEFT,
_("Spearman-Brown Coefficient"));
tab_text (tbl, 1, 6, TAB_LEFT,
_("Equal Length"));
tab_text (tbl, 1, 7, TAB_LEFT,
_("Unequal Length"));
tab_text (tbl, 0, 8, TAB_LEFT,
_("Guttman Split-Half Coefficient"));
tab_double (tbl, 3, 0, TAB_RIGHT, rel->sc[1].alpha, NULL);
tab_double (tbl, 3, 2, TAB_RIGHT, rel->sc[2].alpha, NULL);
tab_double (tbl, 3, 1, TAB_RIGHT, rel->sc[1].n_items, wfmt);
tab_double (tbl, 3, 3, TAB_RIGHT, rel->sc[2].n_items, wfmt);
tab_double (tbl, 3, 4, TAB_RIGHT,
rel->sc[1].n_items + rel->sc[2].n_items, wfmt);
{
/* R is the correlation between the two parts */
double r = rel->sc[0].variance_of_sums -
rel->sc[1].variance_of_sums -
rel->sc[2].variance_of_sums ;
/* Guttman Split Half Coefficient */
double g = 2 * r / rel->sc[0].variance_of_sums;
/* Unequal Length Spearman Brown Coefficient, and
intermediate value used in the computation thereof */
double uly, tmp;
r /= sqrt (rel->sc[1].variance_of_sums);
r /= sqrt (rel->sc[2].variance_of_sums);
r /= 2.0;
tab_double (tbl, 3, 5, TAB_RIGHT, r, NULL);
/* Equal length Spearman-Brown Coefficient */
tab_double (tbl, 3, 6, TAB_RIGHT, 2 * r / (1.0 + r), NULL);
tab_double (tbl, 3, 8, TAB_RIGHT, g, NULL);
tmp = (1.0 - r*r) * rel->sc[1].n_items * rel->sc[2].n_items /
pow2 (rel->sc[0].n_items);
uly = sqrt( pow4 (r) + 4 * pow2 (r) * tmp);
uly -= pow2 (r);
uly /= 2 * tmp;
tab_double (tbl, 3, 7, TAB_RIGHT, uly, NULL);
}
}
static void
case_processing_summary (casenumber n_valid, casenumber n_missing,
const struct dictionary *dict)
{
const struct variable *wv = dict_get_weight (dict);
const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : & F_8_0;
casenumber total;
int n_cols = 4;
int n_rows = 4;
int heading_columns = 2;
int heading_rows = 1;
struct tab_table *tbl;
tbl = tab_create (n_cols, n_rows);
tab_headers (tbl, heading_columns, 0, heading_rows, 0);
tab_title (tbl, _("Case Processing Summary"));
/* Vertical lines for the data only */
tab_box (tbl,
-1, -1,
-1, TAL_1,
heading_columns, 0,
n_cols - 1, n_rows - 1);
/* Box around table */
tab_box (tbl,
TAL_2, TAL_2,
-1, -1,
0, 0,
n_cols - 1, n_rows - 1);
tab_hline (tbl, TAL_2, 0, n_cols - 1, heading_rows);
tab_vline (tbl, TAL_2, heading_columns, 0, n_rows - 1);
tab_text (tbl, 0, heading_rows, TAB_LEFT | TAT_TITLE,
_("Cases"));
tab_text (tbl, 1, heading_rows, TAB_LEFT | TAT_TITLE,
_("Valid"));
tab_text (tbl, 1, heading_rows + 1, TAB_LEFT | TAT_TITLE,
_("Excluded"));
tab_text (tbl, 1, heading_rows + 2, TAB_LEFT | TAT_TITLE,
_("Total"));
tab_text (tbl, heading_columns, 0, TAB_CENTER | TAT_TITLE,
_("N"));
tab_text (tbl, heading_columns + 1, 0, TAB_CENTER | TAT_TITLE, _("%"));
total = n_missing + n_valid;
tab_double (tbl, 2, heading_rows, TAB_RIGHT,
n_valid, wfmt);
tab_double (tbl, 2, heading_rows + 1, TAB_RIGHT,
n_missing, wfmt);
tab_double (tbl, 2, heading_rows + 2, TAB_RIGHT,
total, wfmt);
tab_double (tbl, 3, heading_rows, TAB_RIGHT,
100 * n_valid / (double) total, NULL);
tab_double (tbl, 3, heading_rows + 1, TAB_RIGHT,
100 * n_missing / (double) total, NULL);
tab_double (tbl, 3, heading_rows + 2, TAB_RIGHT,
100 * total / (double) total, NULL);
tab_submit (tbl);
}
