static GnmValue *
gnumeric_not (GnmFuncEvalInfo *ei, GnmValue const * const *argv)
{
gboolean err, val = value_get_as_bool (argv [0], &err);
if (err)
return value_new_error (ei->pos, _("Type Mismatch"));
return value_new_bool (!val);
}
static GnmValue *
gnumeric_and (GnmFuncEvalInfo *ei, int argc, GnmExprConstPtr const *argv)
{
int result = -1;
/* Yes, AND is actually strict. */
GnmValue *v = function_iterate_argument_values
(ei->pos, callback_function_and, &result,
argc, argv, TRUE, CELL_ITER_IGNORE_BLANK);
if (v != NULL)
return v;
/* See if there was any value worth using */
if (result == -1)
return value_new_error_VALUE (ei->pos);
return value_new_bool (result);
}
static GnmValue *
value_new_from_psi_cell(const psiconv_sheet_cell psi_cell)
{
switch (psi_cell->type) {
case psiconv_cell_int :
return value_new_int(psi_cell->data.dat_int);
case psiconv_cell_float :
return value_new_float(psi_cell->data.dat_float);
case psiconv_cell_string :
return psi_new_string(psi_cell->data.dat_string);
case psiconv_cell_bool :
return value_new_bool(psi_cell->data.dat_bool);
case psiconv_cell_blank :
return value_new_empty();
case psiconv_cell_error :
/* TODO: value_new_error */
return value_new_empty();
default :
/* TODO: value_new_error */
return value_new_empty();
}
return NULL;
}
G_MODULE_EXPORT void
paradox_file_open (GOFileOpener const *fo, GOIOContext *io_context,
WorkbookView *wb_view, GsfInput *input)
{
Workbook *wb;
pxdoc_t *pxdoc;
pxhead_t *pxh;
pxfield_t *pxf;
char *data;
char *name;
Sheet *sheet;
GnmCell *cell;
GnmValue *val = NULL;
GOErrorInfo *open_error = NULL;
guint row, i, j, offset;
#ifdef PX_MEMORY_DEBUGGING
PX_mp_init ();
#endif
#ifdef PX_MEMORY_DEBUGGING
pxdoc = PX_new2 (gn_errorhandler, PX_mp_malloc, PX_mp_realloc, PX_mp_free);
#else
pxdoc = PX_new2 (gn_errorhandler, gn_malloc, gn_realloc, gn_free);
#endif
if (PX_open_gsf (pxdoc, input) < 0) {
go_io_error_info_set (io_context, go_error_info_new_str_with_details (
_("Error while opening Paradox file."),
open_error));
return;
}
pxh = pxdoc->px_head;
PX_set_targetencoding (pxdoc, "UTF-8");
wb = wb_view_get_workbook (wb_view);
name = workbook_sheet_get_free_name (wb, pxh->px_tablename, FALSE, TRUE);
sheet = sheet_new (wb, name, 256, 65536);
g_free (name);
workbook_sheet_attach (wb, sheet);
pxf = pxh->px_fields;
for (i = 0 ; i < (guint) pxh->px_numfields; i++) {
char str[30], *str2;
char ctypes[26] = {'?',
'A', 'D', 'S', 'I', '$', 'N', '?', '?',
'L', '?', '?', 'M', 'B', 'F', 'O', 'G',
'?', '?', '?', 'T', '@', '+', '#', 'Y',
};
cell = sheet_cell_fetch (sheet, i, 0);
if (pxf->px_ftype == pxfBCD)
snprintf (str, 30, "%s,%c,%d", pxf->px_fname, ctypes[(int)pxf->px_ftype], pxf->px_fdc);
else
snprintf (str, 30, "%s,%c,%d", pxf->px_fname, ctypes[(int)pxf->px_ftype], pxf->px_flen);
#if PXLIB_MAJOR_VERSION == 0 && (PXLIB_MINOR_VERION < 3 || (PXLIB_MAJOR_VERSION == 3 && PXLIB_MICRO_VERSION == 0))
/* Convert the field names to utf-8. This is actually in pxlib
* responsibility, but hasn't been implemented yet. For the mean time
* we *misuse* PX_get_data_alpha()
*/
PX_get_data_alpha (pxdoc, str, strlen (str), &str2);
gnm_cell_set_text (cell, str2);
pxdoc->free (pxdoc, str2);
#else
gnm_cell_set_text (cell, str);
#endif
pxf++;
}
{
GnmRange r;
GnmStyle *bold = gnm_style_new ();
gnm_style_set_font_bold (bold, TRUE);
sheet_style_apply_range (sheet,
range_init (&r, 0, 0, pxh->px_numfields-1, 0), bold);
}
if ((data = (char *) pxdoc->malloc (pxdoc, pxh->px_recordsize, _("Could not allocate memory for record."))) == NULL) {
go_io_error_info_set (io_context, go_error_info_new_str_with_details (
_("Error while opening Paradox file."),
open_error));
return;
}
row = 1;
for (j = 0; j < (guint)pxh->px_numrecords; j++) {
pxdatablockinfo_t pxdbinfo;
int isdeleted = 0;
if (NULL != PX_get_record2 (pxdoc, j, data, &isdeleted, &pxdbinfo)) {
offset = 0;
pxf = pxh->px_fields;
for (i = 0; i < (guint) pxh->px_numfields ; i++) {
cell = sheet_cell_fetch (sheet, i, row);
val = NULL;
switch (pxf->px_ftype) {
case pxfAlpha: {
char *value;
if (0 < PX_get_data_alpha (pxdoc, &data[offset], pxf->px_flen, &value)) {
val = value_new_string_nocopy (value);
/* value_set_fmt (val, field->fmt); */
}
break;
}
case pxfShort: {
short int value;
if (0 < PX_get_data_short (pxdoc, &data[offset], pxf->px_flen, &value)) {
val = value_new_int (value);
}
break;
}
case pxfAutoInc:
case pxfLong: {
long value;
if (0 < PX_get_data_long (pxdoc, &data[offset], pxf->px_flen, &value)) {
val = value_new_int (value);
}
break;
}
case pxfCurrency:
case pxfNumber: {
double value;
if (0 < PX_get_data_double (pxdoc, &data[offset], pxf->px_flen, &value)) {
val = value_new_float (value);
if (pxf->px_ftype == pxfCurrency)
value_set_fmt (val, go_format_default_money ());
}
break;
}
case pxfTimestamp: {
double value;
if (0 < PX_get_data_double (pxdoc, &data[offset], pxf->px_flen, &value)) {
value = value / 86400000.0;
/* 693594 = number of days up to 31.12.1899 */
value -= 693594;
val = value_new_float (value);
value_set_fmt (val, go_format_default_date_time ());
}
break;
}
case pxfLogical: {
char value;
if (0 < PX_get_data_byte (pxdoc, &data[offset], pxf->px_flen, &value)) {
val = value_new_bool (value ? TRUE : FALSE);
}
break;
}
case pxfDate: {
long value;
int year, month, day;
GDate *date;
if (0 < PX_get_data_long (pxdoc, &data[offset], pxf->px_flen, &value)) {
PX_SdnToGregorian (value+1721425, &year, &month, &day);
date = g_date_new_dmy (day, month, year);
val = value_new_int (go_date_g_to_serial (date, NULL));
value_set_fmt (val, go_format_default_date ());
g_date_free (date);
}
break;
}
case pxfTime: {
long value;
if (0 < PX_get_data_long (pxdoc, &data[offset], pxf->px_flen, &value)) {
val = value_new_float (value/86400000.0);
value_set_fmt (val, go_format_default_time ());
}
break;
}
case pxfBCD: {
char *value;
if (0 < PX_get_data_bcd (pxdoc, &data[offset], pxf->px_fdc, &value)) {
val = value_new_string_nocopy (value);
}
break;
}
case pxfMemoBLOb: {
char *value;
int size, mod_nr;
if (0 < PX_get_data_blob (pxdoc, &data[offset], pxf->px_flen, &mod_nr, &size, &value)) {
val = value_new_string_nocopy (value);
}
break;
}
default:
val = value_new_string_nocopy (
g_strdup_printf (_("Field type %d is not supported."), pxf->px_ftype));
}
if (val)
gnm_cell_set_value (cell, val);
offset += pxf->px_flen;
pxf++;
}
if (pxh->px_filetype == pxfFileTypPrimIndex) {
short int value;
cell = sheet_cell_fetch (sheet, i++, row);
if (0 < PX_get_data_short (pxdoc, &data[offset], 2, &value)) {
val = value_new_int (value);
gnm_cell_set_value (cell, val);
}
offset += 2;
cell = sheet_cell_fetch (sheet, i++, row);
if (0 < PX_get_data_short (pxdoc, &data[offset], 2, &value)) {
val = value_new_int (value);
gnm_cell_set_value (cell, val);
}
offset += 2;
cell = sheet_cell_fetch (sheet, i++, row);
if (0 < PX_get_data_short (pxdoc, &data[offset], 2, &value)) {
val = value_new_int (value);
gnm_cell_set_value (cell, val);
}
cell = sheet_cell_fetch (sheet, i++, row);
val = value_new_int (pxdbinfo.number);
gnm_cell_set_value (cell, val);
}
}
row++;
}
pxdoc->free (pxdoc, data);
PX_close (pxdoc);
PX_delete (pxdoc);
sheet_flag_recompute_spans (sheet);
}
/*
* Raturns FALSE on EOF.
*/
static gboolean
dif_parse_data (DifInputContext *ctxt)
{
gboolean too_many_rows = FALSE, too_many_columns = FALSE;
gint row = -1, col = 0;
gint val_type;
GnmCell *cell;
gchar *msg;
while (1) {
if (!dif_get_line (ctxt))
return FALSE;
val_type = atoi (ctxt->line);
if (val_type == 0) {
gchar const *comma = strchr (ctxt->line, ',');
if (comma == NULL)
go_io_warning (ctxt->io_context,
_("Syntax error at line %d. Ignoring."),
ctxt->line_no);
else if (col > gnm_sheet_get_max_cols (ctxt->sheet)) {
too_many_columns = TRUE;
break;
} else {
gnm_float num = gnm_strto (comma+1, NULL);
GnmValue *v = NULL;
if (!dif_get_line (ctxt))
return FALSE;
if (0 == strcmp (ctxt->line, "V")) { /* V value */
v = value_new_float (num);
} else if (0 == strcmp (ctxt->line, "NA")) { /* NA not available res must be O */
v = value_new_error_NA (NULL);
} else if (0 == strcmp (ctxt->line, "TRUE")) { /* TRUE bool T res must be 1 */
v = value_new_bool (TRUE);
} else if (0 == strcmp (ctxt->line, "FALSE")) { /* FALSE bool F res must be O */
v = value_new_bool (TRUE);
} else if (0 == strcmp (ctxt->line, "ERROR")) { /* ERROR err res must be O */
go_io_warning (ctxt->io_context,
_("Unknown value type '%s' at line %d. Ignoring."),
ctxt->line, ctxt->line_no);
}
if (NULL != v) {
cell = sheet_cell_fetch (ctxt->sheet, col, row);
gnm_cell_set_value (cell, v);
}
col++;
}
} else if (val_type == 1) {
if (!dif_get_line (ctxt))
return FALSE;
if (col > gnm_sheet_get_max_cols (ctxt->sheet)) {
too_many_columns = TRUE;
continue;
}
cell = sheet_cell_fetch (ctxt->sheet, col, row);
if (ctxt->line_len >= 2 &&
ctxt->line[0] == '"' && ctxt->line[ctxt->line_len - 1] == '"') {
ctxt->line[ctxt->line_len - 1] = '\0';
gnm_cell_set_text (cell, ctxt->line + 1);
} else
gnm_cell_set_text (cell, ctxt->line);
col++;
} else if (val_type == -1) {
if (!dif_get_line (ctxt))
return FALSE;
if (strcmp (ctxt->line, "BOT") == 0) {
col = 0;
row++;
if (row > gnm_sheet_get_max_rows (ctxt->sheet)) {
too_many_rows = TRUE;
break;
}
} else if (strcmp (ctxt->line, "EOD") == 0) {
break;
} else {
msg = g_strdup_printf (
_("Unknown data value \"%s\" at line %d. Ignoring."),
ctxt->line, ctxt->line_no);
g_warning ("%s", msg);
g_free (msg);
}
} else {
msg = g_strdup_printf (
_("Unknown value type %d at line %d. Ignoring."),
val_type, ctxt->line_no);
g_warning ("%s", msg);
g_free (msg);
(void) dif_get_line (ctxt);
}
}
if (too_many_rows) {
g_warning (_("DIF file has more than the maximum number of rows %d. "
"Ignoring remaining rows."), gnm_sheet_get_max_rows (ctxt->sheet));
}
if (too_many_columns) {
g_warning (_("DIF file has more than the maximum number of columns %d. "
"Ignoring remaining columns."), gnm_sheet_get_max_cols (ctxt->sheet));
}
return TRUE;
}
static GODataCache *
build_cache(void)
{
Workbook *wb;
Sheet *sheet;
GODataCache *cache;
GnmRange *range;
int row, col, numRows = 60, numCols = 5;
wb = workbook_new();
sheet = workbook_sheet_add (wb, -1, 1024, 1024);
for (row = 0; row < numRows; row++) {
for (col = 0; col < numCols; col++) {
GnmCell * tempCell = sheet_cell_create(sheet, col, row);
GnmValue * tempVal;
if (col == 0) {
if (row%4 == 0) {
tempVal = value_new_string_nocopy((char *)"A");
} else if (row%4 == 1) {
tempVal = value_new_string_nocopy((char *)"B");
} else if (row%4 == 2) {
tempVal = value_new_string_nocopy((char *)"C");
} else {
tempVal = value_new_string_nocopy((char *)"D");
}
} else if (col == 1) {
tempVal = value_new_int(row);
} else if (col == 2) {
if (row%5 == 0) {
tempVal = value_new_float(14.4);
} else if (row%5 == 1) {
tempVal = value_new_float(18.8);
} else if (row%5 == 2) {
tempVal = value_new_float(7.6);
} else if (row%5 == 3) {
tempVal = value_new_float(3.3);
} else {
tempVal = value_new_float(11.6);
}
} else if (col == 3) {
tempVal = value_new_int(row % 10);
} else if (col == 4) {
if (row == 0) {
GnmEvalPos *pos = g_new(GnmEvalPos, 1);
pos = eval_pos_init(pos, sheet, col, row);
tempVal = value_new_error_DIV0(pos);
} else if (row == 1) {
GnmEvalPos *pos = g_new(GnmEvalPos, 1);
pos = eval_pos_init(pos, sheet, col, row);
tempVal = value_new_error_NA(pos);
} else if (row == 2) {
GnmEvalPos *pos = g_new(GnmEvalPos, 1);
pos = eval_pos_init(pos, sheet, col, row);
tempVal = value_new_error_REF(pos);
} else if (row == 3) {
tempVal = value_new_bool(TRUE);
} else if (row == 4) {
tempVal = value_new_bool(FALSE);
} else if (row == 5) {
tempVal = value_new_empty();
} else {
if (row%5 == 1) {
tempVal = value_new_string_nocopy((char *)"a");
} else if (row%5 == 2) {
tempVal = value_new_string_nocopy((char *)"b");
} else if (row%5 == 3) {
tempVal = value_new_string_nocopy((char *)"c");
} else if (row%5 == 4) {
tempVal = value_new_string_nocopy((char *)"d");
} else {
tempVal = value_new_string_nocopy((char *)"e");
}
}
}
sheet_cell_set_value(tempCell, tempVal);
}
}
cache = g_object_new(GO_DATA_CACHE_TYPE, NULL);
range = g_new(GnmRange, 1);
range = range_init(range, 0, 0, numCols - 1, numRows - 1);
go_data_cache_build_cache(cache, sheet, range);
g_object_unref (wb);
return cache;
}
static GnmValue *
gnumeric_false (GnmFuncEvalInfo *ei, GnmValue const * const *args)
{
return value_new_bool (FALSE);
}
static GnmValue *
gnumeric_true (GnmFuncEvalInfo *ei, GnmValue const * const *args)
{
return value_new_bool (TRUE);
}
static GnmValue *
new_gnm_value_from_xloper (const XLOPER*x)
{
GnmValue * g = NULL;
if (NULL != x) {
switch (x->xltype & xltypeType) {
case xltypeNum:
g = value_new_float (x->val.num);
break;
case xltypeStr: {
char *o = NULL;
const char *s = x->val.str;
if (NULL != s) {
guint m = ((unsigned char)s[0]) + 1U;
o = g_new (char, m);
g_strlcpy (o, s + 1, m);
}
g = value_new_string_nocopy (o);
break;
}
case xltypeBool:
g = value_new_bool (x->val.boolean);
break;
case xltypeRef:
unsupported_xloper_type (x);
break;
case xltypeErr:
g = value_new_error_std (NULL, gnm_value_error_from_xloper (x));
break;
case xltypeFlow:
unsupported_xloper_type (x);
break;
case xltypeMulti: {
guint m = x->val.array.columns;
guint n = x->val.array.rows;
if (m > 0 && n > 0) {
guint i;
g = value_new_array_empty (m,n);
for (i = 0; i < m; ++i) {
guint j;
for (j = 0; j < n; ++j) {
g->v_array.vals[i][j] =
new_gnm_value_from_xloper (x->val.array.lparray + i + j * m);
}
}
} else {
g = value_new_error_std (NULL, GNM_ERROR_VALUE);
}
break;
}
case xltypeMissing:
break;
case xltypeNil:
g = value_new_empty ();
break;
case xltypeSRef:
unsupported_xloper_type (x);
break;
case xltypeInt:
g = value_new_int (x->val.w);
break;
default:
unsupported_xloper_type (x);
}
} else {
static gboolean
analysis_tool_wilcoxon_mann_whitney_engine_run (data_analysis_output_t *dao,
analysis_tools_data_generic_b_t *info)
{
GnmFunc *fd_count;
GnmFunc *fd_sum;
GnmFunc *fd_rows;
GnmFunc *fd_rank_avg;
GnmFunc *fd_rank;
GnmFunc *fd_min;
GnmFunc *fd_normdist;
GnmFunc *fd_sqrt;
GnmFunc *fd_if;
GnmFunc *fd_isblank;
GnmExpr const *expr_total;
GnmExpr const *expr_pop_1;
GnmExpr const *expr_pop_2;
GnmExpr const *expr_u;
GnmExpr const *expr_count_total;
GnmValue *val_1 = value_dup (info->range_1);
GnmValue *val_2 = value_dup (info->range_2);
Workbook *wb = dao->sheet ? dao->sheet->workbook : NULL;
fd_count = gnm_func_lookup_or_add_placeholder ("COUNT");
gnm_func_ref (fd_count);
fd_sum = gnm_func_lookup_or_add_placeholder ("SUM");
gnm_func_ref (fd_sum);
fd_rows = gnm_func_lookup_or_add_placeholder ("ROWS");
gnm_func_ref (fd_rows);
fd_rank_avg = gnm_func_lookup_or_add_placeholder ("RANK.AVG");
gnm_func_ref (fd_rank_avg);
fd_rank = gnm_func_lookup_or_add_placeholder ("RANK");
gnm_func_ref (fd_rank);
fd_min = gnm_func_lookup_or_add_placeholder ("MIN");
gnm_func_ref (fd_min);
fd_normdist = gnm_func_lookup_or_add_placeholder ("NORMDIST");
gnm_func_ref (fd_normdist);
fd_sqrt = gnm_func_lookup_or_add_placeholder ("SQRT");
gnm_func_ref (fd_sqrt);
fd_if = gnm_func_lookup_or_add_placeholder ("IF");
gnm_func_ref (fd_if);
fd_isblank = gnm_func_lookup_or_add_placeholder ("ISBLANK");
gnm_func_ref (fd_isblank);
dao_set_italic (dao, 0, 0, 0, 8);
dao_set_italic (dao, 0, 1, 3, 1);
dao_set_merge (dao, 0, 0, 3, 0);
dao_set_cell (dao, 0, 0, _("Wilcoxon-Mann-Whitney Test"));
set_cell_text_col (dao, 0, 2, _("/Rank-Sum"
"/N"
"/U"
"/Ties"
"/Statistic"
"/U-Statistic"
"/p-Value"));
dao_set_cell (dao, 3, 1, _("Total"));
/* Label */
analysis_tools_write_label_ftest (val_1, dao, 1, 1, info->labels, 1);
analysis_tools_write_label_ftest (val_2, dao, 2, 1, info->labels, 2);
expr_total = analysis_tool_combine_area (val_1, val_2, wb);
expr_pop_1 = gnm_expr_new_constant (val_1);
expr_pop_2 = gnm_expr_new_constant (val_2);
/* =sum(if(isblank(region1),0,rank.avg(region1,combined_regions,1))) */
dao_set_cell_array_expr (dao, 1, 2,
gnm_expr_new_funcall1
(fd_sum,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_funcall1
(fd_isblank,
gnm_expr_copy (expr_pop_1)),
gnm_expr_new_constant (value_new_int (0)),
gnm_expr_new_funcall3
(fd_rank_avg,
gnm_expr_copy (expr_pop_1),
gnm_expr_copy (expr_total),
gnm_expr_new_constant (value_new_int (1))))));
dao_set_cell_array_expr (dao, 2, 2,
gnm_expr_new_funcall1
(fd_sum,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_funcall1
(fd_isblank,
gnm_expr_copy (expr_pop_2)),
gnm_expr_new_constant (value_new_int (0)),
gnm_expr_new_funcall3
(fd_rank_avg,
gnm_expr_copy (expr_pop_2),
gnm_expr_copy (expr_total),
gnm_expr_new_constant (value_new_int (1))))));
expr_count_total = gnm_expr_new_funcall1
(fd_count, gnm_expr_copy (expr_total));
dao_set_cell_expr (dao, 3, 2,
gnm_expr_new_binary
(gnm_expr_new_binary
(gnm_expr_copy (expr_count_total),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(gnm_expr_copy (expr_count_total),
GNM_EXPR_OP_ADD,
gnm_expr_new_constant (value_new_int (1)))),
GNM_EXPR_OP_DIV,
gnm_expr_new_constant (value_new_int (2))));
dao_set_cell_expr (dao, 1, 3,
gnm_expr_new_funcall1
(fd_count,
expr_pop_1));
dao_set_cell_expr (dao, 2, 3,
gnm_expr_new_funcall1
(fd_count,
expr_pop_2));
dao_set_cell_expr (dao, 3, 3,
gnm_expr_new_funcall1
(fd_count,
gnm_expr_copy (expr_total)));
expr_u = gnm_expr_new_binary
(make_cellref (0,- 2), GNM_EXPR_OP_SUB,
gnm_expr_new_binary
(gnm_expr_new_binary
(make_cellref (0,- 1),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(make_cellref (0,- 1),
GNM_EXPR_OP_ADD,
gnm_expr_new_constant (value_new_int (1)))),
GNM_EXPR_OP_DIV,
gnm_expr_new_constant (value_new_int (2))));
dao_set_cell_expr (dao, 1, 4, gnm_expr_copy (expr_u));
dao_set_cell_expr (dao, 2, 4, expr_u);
dao_set_cell_expr (dao, 3, 4,
gnm_expr_new_binary
(make_cellref (-2,-1),
GNM_EXPR_OP_MULT,
make_cellref (-1,-1)));
dao_set_cell_array_expr (dao, 1, 5,
gnm_expr_new_funcall1
(fd_sum,
gnm_expr_new_binary
(gnm_expr_new_funcall2
(fd_rank_avg,
gnm_expr_copy (expr_total),
gnm_expr_copy (expr_total)),
GNM_EXPR_OP_SUB,
gnm_expr_new_funcall2
(fd_rank,
gnm_expr_copy (expr_total),
gnm_expr_copy (expr_total)))));
if (dao_cell_is_visible (dao, 2, 4)) {
GnmExpr const *expr_prod;
GnmExpr const *expr_sqrt;
GnmExpr const *expr_normdist;
expr_prod = gnm_expr_new_binary
(make_cellref (0,-5),
GNM_EXPR_OP_MULT,
make_cellref (1,-5));
expr_sqrt = gnm_expr_new_funcall1
(fd_sqrt,
gnm_expr_new_binary
(gnm_expr_new_binary
(gnm_expr_copy(expr_prod),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(gnm_expr_new_binary
(make_cellref (0,-5),
GNM_EXPR_OP_ADD,
make_cellref (1,-5)),
GNM_EXPR_OP_ADD,
gnm_expr_new_constant (value_new_int (1)))),
GNM_EXPR_OP_DIV,
gnm_expr_new_constant (value_new_int (12))));
expr_normdist = gnm_expr_new_funcall4
(fd_normdist,
make_cellref (0,-1),
gnm_expr_new_binary
(expr_prod,
GNM_EXPR_OP_DIV,
gnm_expr_new_constant (value_new_int (2))),
expr_sqrt,
gnm_expr_new_constant (value_new_bool (TRUE)));
dao_set_cell_expr (dao, 1, 6,
gnm_expr_new_funcall2
(fd_min,
make_cellref (0,-4),
make_cellref (1,-4)));
dao_set_cell_expr (dao, 1, 7,
gnm_expr_new_funcall2
(fd_min,
make_cellref (0,-3),
make_cellref (1,-3)));
dao_set_cell_expr (dao, 1, 8,
gnm_expr_new_binary
(gnm_expr_new_constant (value_new_int (2)),
GNM_EXPR_OP_MULT,
expr_normdist));
dao_set_cell_comment (dao, 1, 8,
_("This p-value is calculated using a\n"
"normal approximation, so it is\n"
"only valid for large samples of\n"
"at least 15 observations in each\n"
"population, and few if any ties."));
} else {
dao_set_cell_na (dao, 1, 6);
dao_set_cell_comment (dao, 1, 6,
_("Since there is insufficient space\n"
"for the third column of output,\n"
"this value is not calculated."));
dao_set_cell_na (dao, 1, 7);
dao_set_cell_comment (dao, 1, 7,
_("Since there is insufficient space\n"
"for the third column of output,\n"
"this value is not calculated."));
dao_set_cell_na (dao, 1, 8);
dao_set_cell_comment (dao, 1, 8,
_("Since there is insufficient space\n"
"for the third column of output,\n"
"this value is not calculated."));
}
gnm_expr_free (expr_count_total);
gnm_expr_free (expr_total);
gnm_func_unref (fd_count);
gnm_func_unref (fd_sum);
gnm_func_unref (fd_rows);
gnm_func_unref (fd_rank_avg);
gnm_func_unref (fd_rank);
gnm_func_unref (fd_min);
gnm_func_unref (fd_normdist);
gnm_func_unref (fd_sqrt);
gnm_func_unref (fd_if);
gnm_func_unref (fd_isblank);
dao_redraw_respan (dao);
return 0;
}
static gboolean
analysis_tool_signed_rank_test_engine_run (data_analysis_output_t *dao,
analysis_tools_data_sign_test_t *info)
{
guint col;
GSList *data = info->base.input;
gboolean first = TRUE;
GnmExpr const *expr;
GnmExpr const *expr_isnumber;
GnmExpr const *expr_diff;
GnmExpr const *expr_expect;
GnmExpr const *expr_var;
GnmExpr const *expr_abs;
GnmExpr const *expr_big;
GnmFunc *fd_median = analysis_tool_get_function ("MEDIAN", dao);
GnmFunc *fd_if = analysis_tool_get_function ("IF", dao);
GnmFunc *fd_sum = analysis_tool_get_function ("SUM", dao);
GnmFunc *fd_min = analysis_tool_get_function ("MIN", dao);
GnmFunc *fd_normdist = analysis_tool_get_function ("NORMDIST", dao);
GnmFunc *fd_isnumber = analysis_tool_get_function ("ISNUMBER", dao);
GnmFunc *fd_iferror = analysis_tool_get_function ("IFERROR", dao);
GnmFunc *fd_rank = analysis_tool_get_function ("RANK.AVG", dao);
GnmFunc *fd_abs = analysis_tool_get_function ("ABS", dao);
GnmFunc *fd_sqrt = analysis_tool_get_function ("SQRT", dao);
GnmFunc *fd_max = analysis_tool_get_function ("MAX", dao);
dao_set_italic (dao, 0, 0, 0, 9);
set_cell_text_col (dao, 0, 0, _("/Wilcoxon Signed Rank Test"
"/Median"
"/Predicted Median"
"/N"
"/S\xe2\x88\x92"
"/S+"
"/Test Statistic"
"/\xce\xb1"
"/P(T\xe2\x89\xa4t) one-tailed"
"/P(T\xe2\x89\xa4t) two-tailed"));
for (col = 0; data != NULL; data = data->next, col++) {
GnmValue *val_org = value_dup (data->data);
GnmExpr const *expr_org;
/* Note that analysis_tools_write_label may modify val_org */
dao_set_italic (dao, col + 1, 0, col+1, 0);
analysis_tools_write_label (val_org, dao, &info->base, col + 1, 0, col + 1);
expr_org = gnm_expr_new_constant (val_org);
if (first) {
dao_set_cell_float (dao, col + 1, 2, info->median);
dao_set_cell_float (dao, col + 1, 7, info->alpha);
first = FALSE;
} else {
dao_set_cell_expr (dao, col + 1, 2, make_cellref (-1,0));
dao_set_cell_expr (dao, col + 1, 7, make_cellref (-1,0));
}
expr_isnumber = gnm_expr_new_funcall3
(fd_if, gnm_expr_new_funcall1
(fd_isnumber, gnm_expr_copy (expr_org)),
make_int (1),
make_int (0));
expr = gnm_expr_new_funcall1
(fd_median,
gnm_expr_copy (expr_org));
dao_set_cell_expr (dao, col + 1, 1, expr);
expr_diff = gnm_expr_new_binary
(gnm_expr_copy (expr_org), GNM_EXPR_OP_SUB, make_cellref (0,-2));
expr_abs = gnm_expr_new_funcall1
(fd_abs, gnm_expr_copy (expr_diff));
expr_big = gnm_expr_new_binary
(gnm_expr_new_funcall1
(fd_max, gnm_expr_copy (expr_abs)),
GNM_EXPR_OP_ADD,
make_int (1));
expr = gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_funcall1
(fd_isnumber, gnm_expr_copy (expr_org)),
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(gnm_expr_copy (expr_org),
GNM_EXPR_OP_EQUAL,
make_cellref (0,-2)),
gnm_expr_copy (expr_big),
expr_abs),
expr_big);
expr = gnm_expr_new_funcall3
(fd_rank,
gnm_expr_new_unary (GNM_EXPR_OP_UNARY_NEG,
expr_diff),
expr,
make_int (1));
dao_set_cell_array_expr
(dao, col + 1, 4,
gnm_expr_new_funcall1
(fd_sum,
gnm_expr_new_binary
(gnm_expr_copy (expr_isnumber),
GNM_EXPR_OP_MULT,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(gnm_expr_copy (expr_org),
GNM_EXPR_OP_LT,
make_cellref (0,-2)),
expr,
make_int (0)))));
expr = gnm_expr_new_funcall1
(fd_sum, gnm_expr_new_binary
(expr_isnumber, GNM_EXPR_OP_MULT,
gnm_expr_new_funcall2
(fd_iferror, gnm_expr_new_funcall3
(fd_if, gnm_expr_new_binary (expr_org,
GNM_EXPR_OP_NOT_EQUAL, make_cellref (0,-1)),
make_int (1),
make_int (0)),
make_int (0))));
dao_set_cell_array_expr (dao, col + 1, 3, expr);
dao_set_cell_expr (dao, col + 1, 5,
gnm_expr_new_binary
(gnm_expr_new_binary
(gnm_expr_new_binary
(make_cellref (0,-2),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(make_cellref (0,-2),
GNM_EXPR_OP_ADD,
make_int (1))),
GNM_EXPR_OP_DIV,
make_int (2)),
GNM_EXPR_OP_SUB,
make_cellref (0,-1)));
dao_set_cell_expr (dao, col + 1, 6,
gnm_expr_new_funcall2
(fd_min, make_cellref (0,-1), make_cellref (0,-2)));
expr_expect = gnm_expr_new_binary
(gnm_expr_new_binary
(make_cellref (0,-5),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(make_cellref (0,-5),
GNM_EXPR_OP_ADD,
make_int (1))),
GNM_EXPR_OP_DIV,
make_int (4));
expr_var = gnm_expr_new_binary
(gnm_expr_new_binary
(gnm_expr_copy (expr_expect),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(gnm_expr_new_binary
(make_int (2),
GNM_EXPR_OP_MULT,
make_cellref (0,-5)),
GNM_EXPR_OP_ADD,
make_int (1))),
GNM_EXPR_OP_DIV,
make_int (6));
expr = gnm_expr_new_funcall4
(fd_normdist, gnm_expr_new_binary
(make_cellref (0,-2),
GNM_EXPR_OP_ADD,
make_float (0.5)),
expr_expect,
gnm_expr_new_funcall1 (fd_sqrt, expr_var),
gnm_expr_new_constant (value_new_bool (TRUE)));
dao_set_cell_expr (dao, col + 1, 8,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(make_cellref (0,-5),
GNM_EXPR_OP_LT,
make_int (12)),
gnm_expr_new_constant (value_new_error_NA (NULL)),
expr));
dao_set_cell_comment (dao, col + 1, 8,
_("This p-value is calculated by a normal approximation.\n"
"It is only valid if the sample size is at least 12."));
expr = gnm_expr_new_binary (make_int (2),
GNM_EXPR_OP_MULT, make_cellref (0,-1));
dao_set_cell_expr (dao, col + 1, 9, expr);
}
gnm_func_unref (fd_median);
gnm_func_unref (fd_if);
gnm_func_unref (fd_min);
gnm_func_unref (fd_sum);
gnm_func_unref (fd_normdist);
gnm_func_unref (fd_isnumber);
gnm_func_unref (fd_iferror);
gnm_func_unref (fd_rank);
gnm_func_unref (fd_abs);
gnm_func_unref (fd_sqrt);
gnm_func_unref (fd_max);
dao_redraw_respan (dao);
return FALSE;
}
static gboolean
analysis_tool_signed_rank_test_two_engine_run (data_analysis_output_t *dao,
analysis_tools_data_sign_test_two_t *info)
{
GnmValue *val_1;
GnmValue *val_2;
GnmExpr const *expr_1;
GnmExpr const *expr_2;
GnmExpr const *expr;
GnmExpr const *expr_diff;
GnmExpr const *expr_diff_pred;
GnmExpr const *expr_isnumber_1;
GnmExpr const *expr_isnumber_2;
GnmExpr const *expr_isnumber;
GnmExpr const *expr_expect;
GnmExpr const *expr_var;
GnmExpr const *expr_abs;
GnmExpr const *expr_big;
GnmFunc *fd_median = analysis_tool_get_function ("MEDIAN", dao);
GnmFunc *fd_if = analysis_tool_get_function ("IF", dao);
GnmFunc *fd_sum = analysis_tool_get_function ("SUM", dao);
GnmFunc *fd_min = analysis_tool_get_function ("MIN", dao);
GnmFunc *fd_normdist = analysis_tool_get_function ("NORMDIST", dao);
GnmFunc *fd_isnumber = analysis_tool_get_function ("ISNUMBER", dao);
GnmFunc *fd_iferror = analysis_tool_get_function ("IFERROR", dao);
GnmFunc *fd_rank = analysis_tool_get_function ("RANK.AVG", dao);
GnmFunc *fd_abs = analysis_tool_get_function ("ABS", dao);
GnmFunc *fd_sqrt = analysis_tool_get_function ("SQRT", dao);
GnmFunc *fd_max = analysis_tool_get_function ("MAX", dao);
dao_set_italic (dao, 0, 0, 0, 10);
set_cell_text_col (dao, 0, 0, _("/Wilcoxon Signed Rank Test"
"/Median"
"/Observed Median Difference"
"/Predicted Median Difference"
"/N"
"/S\xe2\x88\x92"
"/S+"
"/Test Statistic"
"/\xce\xb1"
"/P(T\xe2\x89\xa4t) one-tailed"
"/P(T\xe2\x89\xa4t) two-tailed"));
val_1 = value_dup (info->base.range_1);
val_2 = value_dup (info->base.range_2);
/* Labels */
dao_set_italic (dao, 1, 0, 2, 0);
analysis_tools_write_label_ftest (val_1, dao, 1, 0,
info->base.labels, 1);
analysis_tools_write_label_ftest (val_2, dao, 2, 0,
info->base.labels, 2);
expr_1 = gnm_expr_new_constant (value_dup (val_1));
expr_2 = gnm_expr_new_constant (value_dup (val_2));
dao_set_cell_float (dao, 1, 3, info->median);
dao_set_cell_float (dao, 1, 8, info->base.alpha);
expr_isnumber_1 = gnm_expr_new_funcall3
(fd_if, gnm_expr_new_funcall1
(fd_isnumber, gnm_expr_copy (expr_1)),
make_int (1),
make_int (0));
expr_isnumber_2 = gnm_expr_new_funcall3
(fd_if, gnm_expr_new_funcall1
(fd_isnumber, gnm_expr_copy (expr_2)),
make_int (1),
make_int (0));
expr_isnumber = gnm_expr_new_binary
(expr_isnumber_1,
GNM_EXPR_OP_MULT,
expr_isnumber_2);
expr = gnm_expr_new_funcall1
(fd_median,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(gnm_expr_copy (expr_isnumber),
GNM_EXPR_OP_EQUAL,
make_int (1)),
gnm_expr_copy (expr_1),
gnm_expr_new_constant (value_new_string(""))));
dao_set_cell_array_expr (dao, 1, 1, expr);
expr = gnm_expr_new_funcall1
(fd_median,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(gnm_expr_copy (expr_isnumber),
GNM_EXPR_OP_EQUAL,
make_int (1)),
gnm_expr_copy (expr_2),
gnm_expr_new_constant (value_new_string(""))));
dao_set_cell_array_expr (dao, 2, 1, expr);
expr_diff = gnm_expr_new_binary (gnm_expr_copy (expr_1),
GNM_EXPR_OP_SUB,
gnm_expr_copy (expr_2));
dao_set_cell_array_expr
(dao, 1, 2,
gnm_expr_new_funcall1
(fd_median,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(gnm_expr_copy (expr_isnumber),
GNM_EXPR_OP_EQUAL,
make_int (1)),
gnm_expr_copy (expr_diff),
gnm_expr_new_constant (value_new_string("")))));
expr = gnm_expr_new_funcall1
(fd_sum, gnm_expr_new_binary
(gnm_expr_copy (expr_isnumber),
GNM_EXPR_OP_MULT,
gnm_expr_new_funcall2
(fd_iferror, gnm_expr_new_funcall3
(fd_if, gnm_expr_new_binary
(gnm_expr_copy (expr_diff),
GNM_EXPR_OP_NOT_EQUAL, make_cellref (0,-2)),
make_int (1),
make_int (0)),
make_int (0))));
dao_set_cell_array_expr (dao, 1, 4, expr);
expr_diff_pred = gnm_expr_new_binary
(gnm_expr_copy (expr_diff),
GNM_EXPR_OP_SUB,
make_cellref (0,-2));
expr_abs = gnm_expr_new_funcall1
(fd_abs, gnm_expr_copy (expr_diff_pred));
expr_big = gnm_expr_new_binary
(gnm_expr_new_funcall1
(fd_max, gnm_expr_copy (expr_abs)),
GNM_EXPR_OP_ADD,
make_int (1));
expr = gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_funcall1
(fd_isnumber, expr_1),
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_funcall1
(fd_isnumber, expr_2),
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(gnm_expr_copy (expr_diff),
GNM_EXPR_OP_EQUAL,
make_cellref (0,-2)),
gnm_expr_copy (expr_big),
expr_abs),
gnm_expr_copy (expr_big)),
expr_big);
expr = gnm_expr_new_funcall3
(fd_rank,
gnm_expr_new_unary (GNM_EXPR_OP_UNARY_NEG,
expr_diff_pred),
expr,
make_int (1));
expr = gnm_expr_new_funcall1
(fd_sum,
gnm_expr_new_binary
(expr_isnumber,
GNM_EXPR_OP_MULT,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(expr_diff,
GNM_EXPR_OP_LT,
make_cellref (0,-2)),
expr,
make_int (0))));
dao_set_cell_array_expr (dao, 1, 5, expr);
dao_set_cell_expr (dao, 1, 6,
gnm_expr_new_binary
(gnm_expr_new_binary
(gnm_expr_new_binary
(make_cellref (0,-2),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(make_cellref (0,-2),
GNM_EXPR_OP_ADD,
make_int (1))),
GNM_EXPR_OP_DIV,
make_int (2)),
GNM_EXPR_OP_SUB,
make_cellref (0,-1)));
dao_set_cell_expr
(dao, 1, 7,
gnm_expr_new_funcall2
(fd_min, make_cellref (0,-1), make_cellref (0,-2)));
expr_expect = gnm_expr_new_binary
(gnm_expr_new_binary
(make_cellref (0,-5),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(make_cellref (0,-5),
GNM_EXPR_OP_ADD,
make_int (1))),
GNM_EXPR_OP_DIV,
make_int (4));
expr_var = gnm_expr_new_binary
(gnm_expr_new_binary
(gnm_expr_copy (expr_expect),
GNM_EXPR_OP_MULT,
gnm_expr_new_binary
(gnm_expr_new_binary
(make_int (2),
GNM_EXPR_OP_MULT,
make_cellref (0,-5)),
GNM_EXPR_OP_ADD,
make_int (1))),
GNM_EXPR_OP_DIV,
make_int (6));
expr = gnm_expr_new_funcall4
(fd_normdist, gnm_expr_new_binary
(make_cellref (0,-2),
GNM_EXPR_OP_ADD,
make_float (0.5)),
expr_expect,
gnm_expr_new_funcall1 (fd_sqrt, expr_var),
gnm_expr_new_constant (value_new_bool (TRUE)));
dao_set_cell_expr (dao, 1, 9,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_binary
(make_cellref (0,-5),
GNM_EXPR_OP_LT,
make_int (12)),
gnm_expr_new_constant (value_new_error_NA (NULL)),
expr));
dao_set_cell_comment
(dao, 1, 9,
_("This p-value is calculated by a normal approximation.\n"
"It is only valid if the sample size is at least 12."));
expr = gnm_expr_new_binary (make_int (2),
GNM_EXPR_OP_MULT, make_cellref (0,-1));
dao_set_cell_array_expr (dao, 1, 10, expr);
gnm_func_unref (fd_median);
gnm_func_unref (fd_if);
gnm_func_unref (fd_min);
gnm_func_unref (fd_sum);
gnm_func_unref (fd_normdist);
gnm_func_unref (fd_isnumber);
gnm_func_unref (fd_iferror);
gnm_func_unref (fd_rank);
gnm_func_unref (fd_abs);
gnm_func_unref (fd_sqrt);
gnm_func_unref (fd_max);
value_release (val_1);
value_release (val_2);
dao_redraw_respan (dao);
return FALSE;
}