static GnmValue *
gnumeric_gestep (GnmFuncEvalInfo *ei, GnmValue const * const *argv)
{
gnm_float x = value_get_as_float (argv[0]);
gnm_float y = argv[1] ? value_get_as_float (argv[1]) : 0;
return value_new_int (x >= y);
}
static GnmValue *
gnumeric_hdate_julian (GnmFuncEvalInfo * ei, GnmValue const * const *argv)
{
int year, month, day;
int julian;
gnumeric_hdate_get_date (argv, &year, &month, &day);
julian = hdate_gdate_to_jd (day, month, year);
return value_new_int (julian);
}
static GnmValue *
gnumeric_hdate_year (GnmFuncEvalInfo * ei, GnmValue const * const *argv)
{
int year, month, day;
int hyear, hmonth, hday;
gnumeric_hdate_get_date (argv, &year, &month, &day);
if (0 != hdate_gdate_to_hdate (day, month, year, &hday, &hmonth, &hyear))
return value_new_error_VALUE (ei->pos);
return value_new_int (hyear);
}
static GnmValue *
gnumeric_date2julian (GnmFuncEvalInfo * ei, GnmValue const * const *argv)
{
int year, month, day;
int julian;
GnmValue *val;
val = gnumeric_date_get_date (ei, argv[0], &year, &month, &day);
if (val != NULL)
return val;
julian = hdate_gdate_to_jd (day, month, year);
return value_new_int (julian);
}
static void
thrash_insert (Sheet *sheet)
{
int j;
GnmStyle *style1 = gnm_style_new ();
GnmStyle *style2 = gnm_style_new ();
gnm_style_set_font_bold (style1, TRUE);
gnm_style_set_font_italic (style1, TRUE);
gnm_style_set_font_size (style2, 20.0);
for (j = 0; j < INSERT_HEIGHT; j++) {
GnmRange r;
int i;
for (i = 0; i < INSERT_WIDTH; i++) {
GnmCell *cell;
GnmStyle *setstyle;
r.start.col = i;
r.start.row = j;
r.end = r.start;
if (((i / 31) % 2) == 0)
setstyle = style1;
else
setstyle = style2;
gnm_style_ref (setstyle);
sheet_style_attach (sheet, &r, setstyle);
cell = sheet_cell_fetch (sheet, i, j);
gnm_cell_set_value (cell, value_new_int (i), NULL);
}
r.start.col = 0;
r.start.row = MAX (0, j - 1);
r.end.col = gnm_sheet_get_max_cols (sheet);
r.end.row = MIN (gnm_sheet_get_max_rows (sheet), j + 1);
sheet_style_optimize (sheet, r);
}
gnm_style_unref (style1);
gnm_style_unref (style2);
}
/*
* Figure out whether the format engine in goffice allows negative values
* or (as XL) considers them errors.
*/
gboolean
gnm_datetime_allow_negative (void)
{
static int allow = -1;
if (allow == -1) {
GOFormat *fmt = go_format_new_from_XL ("yyyy-mm-dd");
GnmValue *v = value_new_int (-42);
GODateConventions const *conv =
go_date_conv_from_str ("Lotus:1900");
char *text = format_value (fmt, v, NULL, -1, conv);
allow = (strcmp (text, "1899-11-19") == 0);
value_release (v);
go_format_unref (fmt);
g_free (text);
}
return (gboolean)allow;
}
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;
}
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 GnmExpr const *
parse_subexpr(const psiconv_formula psi_formula)
{
int nrargs=0; /* -1 for variable */
int kind=-1; /* 0 for dat, 1 for operator, 2 for formula, 3 for special,
-1 for unknown */
psiconv_formula psi_form1,psi_form2;
GnmExpr const *expr1=NULL,*expr2=NULL;
switch(psi_formula->type) {
/* Translates values */
case psiconv_formula_dat_float:
case psiconv_formula_dat_int:
case psiconv_formula_dat_string:
case psiconv_formula_dat_cellblock:
case psiconv_formula_dat_vcellblock:
nrargs = 0;
kind = 0;
break;
/* Translates to binary operators */
case psiconv_formula_op_lt:
case psiconv_formula_op_le:
case psiconv_formula_op_gt:
case psiconv_formula_op_ge:
case psiconv_formula_op_ne:
case psiconv_formula_op_eq:
case psiconv_formula_op_add:
case psiconv_formula_op_sub:
case psiconv_formula_op_mul:
case psiconv_formula_op_div:
/* case psiconv_formula_op_pow: */
/* case psiconv_formula_op_and: */
/* case psiconv_formula_op_or: */
/* case psiconv_formula_op_con: */
nrargs = 2;
kind = 1;
break;
/* Translates to unary operators */
case psiconv_formula_op_pos:
case psiconv_formula_op_neg:
case psiconv_formula_op_not:
nrargs = 1;
kind = 1;
break;
/* Specially handled */
case psiconv_formula_dat_cellref:
case psiconv_formula_op_bra:
nrargs = 1;
kind = 3;
break;
/* Should never happen; caught by the default */
/* case psiconv_formula_mark_eof: */
/* case psiconv_formula_mark_opsep: */
/* case psiconv_formula_mark_opend: */
default:
kind = -1;
break;
}
if (kind == -1) {
/* Unknown value */
return NULL;
} else if (kind == 0) {
/* Handling data */
GnmValue *v = NULL;
switch(psi_formula->type) {
case psiconv_formula_dat_float:
v = value_new_float(psi_formula->data.dat_float);
break;
case psiconv_formula_dat_int:
v = value_new_int(psi_formula->data.dat_int);
break;
case psiconv_formula_dat_string:
v = psi_new_string(psi_formula->data.dat_string);
break;
case psiconv_formula_dat_cellblock: {
GnmCellRef cr1, cr2;
p_cellref_init (&cr1,
psi_formula->data.dat_cellblock.first.row.offset,
psi_formula->data.dat_cellblock.first.row.absolute,
psi_formula->data.dat_cellblock.first.column.offset,
psi_formula->data.dat_cellblock.first.column.absolute);
p_cellref_init (&cr2,
psi_formula->data.dat_cellblock.last.row.offset,
psi_formula->data.dat_cellblock.last.row.absolute,
psi_formula->data.dat_cellblock.last.column.offset,
psi_formula->data.dat_cellblock.last.column.absolute);
v = value_new_cellrange (&cr1, &cr2, 1, 1);
break;
}
default:
break;
}
if (!v)
return NULL;
return gnm_expr_new_constant(v);
} else if (kind == 1) {
/* Handling the operators */
if (nrargs >= 1) {
if (!(psi_form1 = psiconv_list_get
(psi_formula->data.fun_operands,0)))
return NULL;
if (!(expr1 = parse_subexpr(psi_form1)))
return NULL;
}
if (nrargs >= 2) {
if (!(psi_form2 = psiconv_list_get
(psi_formula->data.fun_operands,1))) {
gnm_expr_free(expr1);
return NULL;
}
if (!(expr2 = parse_subexpr(psi_form2))) {
gnm_expr_free(expr1);
return NULL;
}
}
switch(psi_formula->type) {
case psiconv_formula_op_lt:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_LT,expr2);
case psiconv_formula_op_le:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_LTE,expr2);
case psiconv_formula_op_gt:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_GT,expr2);
case psiconv_formula_op_ge:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_GTE,expr2);
case psiconv_formula_op_ne:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_NOT_EQUAL,expr2);
case psiconv_formula_op_eq:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_EQUAL,expr2);
case psiconv_formula_op_add:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_ADD,expr2);
case psiconv_formula_op_sub:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_SUB,expr2);
case psiconv_formula_op_mul:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_MULT,expr2);
case psiconv_formula_op_div:
return gnm_expr_new_binary (expr1,GNM_EXPR_OP_DIV,expr2);
case psiconv_formula_op_pos:
return gnm_expr_new_unary (GNM_EXPR_OP_UNARY_PLUS,expr1);
case psiconv_formula_op_neg:
return gnm_expr_new_unary (GNM_EXPR_OP_UNARY_NEG,expr1);
default:
gnm_expr_free(expr1);
gnm_expr_free(expr2);
return NULL;
}
} else if (kind == 3) {
switch(psi_formula->type) {
case psiconv_formula_dat_cellref: {
GnmCellRef cr;
return gnm_expr_new_cellref (p_cellref_init (&cr,
psi_formula->data.dat_cellref.row.offset,
psi_formula->data.dat_cellref.row.absolute,
psi_formula->data.dat_cellref.column.offset,
psi_formula->data.dat_cellref.column.absolute));
}
case psiconv_formula_op_bra:
if (!(psi_form1 = psiconv_list_get
(psi_formula->data.fun_operands,0)))
return NULL;
return parse_subexpr(psi_form1);
default:
break;
}
}
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);
}
static gboolean
analysis_tool_one_mean_test_engine_run (data_analysis_output_t *dao,
analysis_tools_data_one_mean_test_t *info)
{
guint col;
GSList *data = info->base.input;
gboolean first = TRUE;
GnmFunc *fd_mean;
GnmFunc *fd_var;
GnmFunc *fd_sqrt;
GnmFunc *fd_abs;
GnmFunc *fd_tdist;
GnmFunc *fd_iferror;
GnmFunc *fd_count;
fd_count = gnm_func_lookup_or_add_placeholder ("COUNT");
gnm_func_inc_usage (fd_count);
fd_mean = gnm_func_lookup_or_add_placeholder ("AVERAGE");
gnm_func_inc_usage (fd_mean);
fd_var = gnm_func_lookup_or_add_placeholder ("VAR");
gnm_func_inc_usage (fd_var);
fd_sqrt = gnm_func_lookup_or_add_placeholder ("SQRT");
gnm_func_inc_usage (fd_sqrt);
fd_abs = gnm_func_lookup_or_add_placeholder ("ABS");
gnm_func_inc_usage (fd_abs);
fd_tdist = gnm_func_lookup_or_add_placeholder ("TDIST");
gnm_func_inc_usage (fd_tdist);
fd_iferror = gnm_func_lookup_or_add_placeholder ("IFERROR");
gnm_func_inc_usage (fd_iferror);
dao_set_italic (dao, 0, 0, 0, 9);
set_cell_text_col (dao, 0, 0, _("/Student-t Test"
"/N"
"/Observed Mean"
"/Hypothesized Mean"
"/Observed Variance"
"/Test Statistic"
"/df"
"/\xce\xb1"
"/P(T\xe2\x89\xa4t) one-tailed"
"/P(T\xe2\x89\xa4t) two-tailed"));
for (col = 1; data != NULL; data = data->next, col++) {
GnmValue *val_org = value_dup (data->data);
GnmExpr const *expr;
GnmExpr const *expr_org;
GnmExpr const *expr_range_clean;
GnmExpr const *expr_stddev;
GnmExpr const *expr_abs;
/* Note that analysis_tools_write_label may modify val_org */
dao_set_italic (dao, col, 0, col, 0);
analysis_tools_write_label (val_org, dao, &info->base, col, 0, col);
expr_org = gnm_expr_new_constant (val_org);
expr_range_clean = gnm_expr_new_funcall2
(fd_iferror, gnm_expr_copy (expr_org), gnm_expr_new_constant (value_new_string("")));
if (first) {
dao_set_cell_float (dao, col, 3, info->mean);
dao_set_cell_float (dao, col, 7, info->alpha);
first = FALSE;
} else {
dao_set_cell_expr (dao, col, 3, make_cellref (-1,0));
dao_set_cell_expr (dao, col, 7, make_cellref (-1,0));
}
expr = gnm_expr_new_funcall1 (fd_count, expr_org);
dao_set_cell_expr (dao, col, 1, expr);
expr = gnm_expr_new_funcall1 (fd_mean, gnm_expr_copy (expr_range_clean));
dao_set_cell_array_expr (dao, col, 2, expr);
expr = gnm_expr_new_funcall1 (fd_var, expr_range_clean);
dao_set_cell_array_expr (dao, col, 4, expr);
dao_set_cell_expr (dao, col, 6, gnm_expr_new_binary
(make_cellref (0,-5), GNM_EXPR_OP_SUB, gnm_expr_new_constant (value_new_int (1))));
expr_stddev = gnm_expr_new_funcall1
(fd_sqrt, gnm_expr_new_binary (make_cellref (0,-1), GNM_EXPR_OP_DIV, make_cellref (0,-4)));
expr = gnm_expr_new_binary
(gnm_expr_new_binary (make_cellref (0,-3), GNM_EXPR_OP_SUB, make_cellref (0,-2)),
GNM_EXPR_OP_DIV,
expr_stddev);
dao_set_cell_array_expr (dao, col, 5, expr);
expr_abs = gnm_expr_new_funcall1 (fd_abs, make_cellref (0,-3));
expr = gnm_expr_new_funcall3 (fd_tdist, expr_abs, make_cellref (0,-2),
gnm_expr_new_constant (value_new_int (1)));
dao_set_cell_expr (dao, col, 8, expr);
expr_abs = gnm_expr_new_funcall1 (fd_abs, make_cellref (0,-4));
expr = gnm_expr_new_funcall3 (fd_tdist, expr_abs, make_cellref (0,-3),
gnm_expr_new_constant (value_new_int (2)));
dao_set_cell_expr (dao, col, 9, expr);
}
gnm_func_dec_usage (fd_count);
gnm_func_dec_usage (fd_mean);
gnm_func_dec_usage (fd_var);
gnm_func_dec_usage (fd_abs);
gnm_func_dec_usage (fd_sqrt);
gnm_func_dec_usage (fd_tdist);
gnm_func_dec_usage (fd_iferror);
dao_redraw_respan (dao);
return FALSE;
}
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 gboolean
analysis_tool_principal_components_engine_run (data_analysis_output_t *dao,
analysis_tools_data_generic_t *info)
{
int l = g_slist_length (info->input), i;
GSList *inputdata;
GnmFunc *fd_mean;
GnmFunc *fd_var;
GnmFunc *fd_eigen;
GnmFunc *fd_mmult;
GnmFunc *fd_munit;
GnmFunc *fd_sqrt;
GnmFunc *fd_count;
GnmFunc *fd_sum;
GnmFunc *fd_and;
GnmFunc *fd_if;
GnmExpr const *expr;
GnmExpr const *expr_count;
GnmExpr const *expr_munit;
GnmExpr const *expr_and;
int data_points;
GnmExprList *and_args = NULL;
if (!dao_cell_is_visible (dao, l, 9 + 3 * l)) {
dao_set_bold (dao, 0, 0, 0, 0);
dao_set_italic (dao, 0, 0, 0, 0);
dao_set_cell (dao, 0, 0,
_("Principal components analysis has "
"insufficient space."));
return 0;
}
fd_mean = gnm_func_lookup_or_add_placeholder
("AVERAGE", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_mean);
fd_var = gnm_func_lookup_or_add_placeholder
("VAR", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_var);
fd_eigen = gnm_func_lookup_or_add_placeholder
("EIGEN", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_eigen);
fd_mmult = gnm_func_lookup_or_add_placeholder
("MMULT", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_mmult);
fd_munit = gnm_func_lookup_or_add_placeholder
("MUNIT", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_munit);
fd_sqrt = gnm_func_lookup_or_add_placeholder
("SQRT", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_sqrt);
fd_count = gnm_func_lookup_or_add_placeholder
("COUNT", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_count);
fd_sum = gnm_func_lookup_or_add_placeholder
("SUM", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_sum);
fd_and = gnm_func_lookup_or_add_placeholder
("AND", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_and);
fd_if = gnm_func_lookup_or_add_placeholder
("IF", dao->sheet ? dao->sheet->workbook : NULL, FALSE);
gnm_func_ref (fd_if);
dao_set_bold (dao, 0, 0, 0, 0);
dao_set_italic (dao, 0, 0, 0, 11 + 3 * l);
dao_set_format (dao, 0, 0, 0, 0,
_("\"Principal Components Analysis\";"
"[Red]\"Principal Components Analysis is invalid.\""));
dao_set_align (dao, 0, 0, 0, 0,
HALIGN_LEFT, VALIGN_BOTTOM);
dao->offset_row++;
analysis_tool_table (dao, info, _("Covariances:"), "COVAR", TRUE);
dao->offset_row--;
for (i = 1, inputdata = info->input; inputdata != NULL; i++, inputdata = inputdata->next)
analysis_tools_write_label (inputdata->data, dao, info, 0, 9 + 2 * l + i, i);
data_points = value_area_get_width (info->input->data, NULL) *
value_area_get_height (info->input->data, NULL);
for (i = 0; i < l; i++)
and_args = gnm_expr_list_prepend
(and_args,
gnm_expr_new_binary
(gnm_expr_new_constant (value_new_int (data_points)),
GNM_EXPR_OP_EQUAL,
make_cellref (1 + i, 3 + l)));
expr_and = gnm_expr_new_funcall (fd_and, and_args);
dao_set_cell_expr (dao, 0, 0,
gnm_expr_new_funcall3
(fd_if,
expr_and,
gnm_expr_new_constant (value_new_int (1)),
gnm_expr_new_constant (value_new_int (-1))));
dao_set_merge (dao,0,0,2,0);
set_cell_text_col (dao, 0, 3 + l,
_("/Count:"
"/Mean:"
"/Variance:"
"//Eigenvalues:"
"/Eigenvectors:"));
dao_set_cell (dao, 0, 11 + 3 * l, _("Percent of Trace:"));
dao_set_italic (dao, 0, 9 + 2 * l, 1 + l, 9 + 2 * l);
dao_set_percent (dao, 1, 11 + 3 * l, 1 + l, 11 + 3 * l);
for (i = 1, inputdata = info->input; inputdata != NULL; i++, inputdata = inputdata->next) {
expr = gnm_expr_new_constant (value_dup (inputdata->data));
dao_set_cell_expr (dao, i, 3 + l,
gnm_expr_new_funcall1 (fd_count, gnm_expr_copy (expr)));
dao_set_cell_expr (dao, i, 4 + l,
gnm_expr_new_funcall1 (fd_mean, gnm_expr_copy (expr)));
dao_set_cell_expr (dao, i, 5 + l,
gnm_expr_new_funcall1 (fd_var, expr));
}
expr_count = gnm_expr_new_binary (make_cellref (0,-4), GNM_EXPR_OP_DIV,
gnm_expr_new_binary (make_cellref (0,-4), GNM_EXPR_OP_SUB,
gnm_expr_new_constant (value_new_int (1))));
expr = gnm_expr_new_funcall1
(fd_eigen, gnm_expr_new_binary
(expr_count, GNM_EXPR_OP_MULT, make_rangeref (0, - (5 + l), l - 1, - 6)));
dao_set_array_expr (dao, 1, 7 + l, l, l + 1, expr);
for (i = 1; i <= l; i++) {
dao_set_align (dao, i, 9 + 2 * l, i, 9 + 2 * l,
HALIGN_CENTER, VALIGN_BOTTOM);
dao_set_cell_printf (dao, i, 9 + 2 * l, "\xce\xbe%i", i);
dao_set_cell_expr (dao, i, 11 + 3 * l,
gnm_expr_new_binary (make_cellref (0,- 4 - 2 * l),
GNM_EXPR_OP_DIV,
gnm_expr_new_funcall1
(fd_sum,
dao_get_rangeref (dao, 1, 7 + l, l, 7 + l))));
}
expr_munit = gnm_expr_new_funcall1 (fd_munit, gnm_expr_new_constant (value_new_int (l)));
expr = gnm_expr_new_funcall2 (fd_mmult,
gnm_expr_new_binary
(gnm_expr_new_funcall1
(fd_sqrt, gnm_expr_new_binary
(gnm_expr_new_constant (value_new_int (1)),
GNM_EXPR_OP_DIV,
make_rangeref (0, - 5 - l, l - 1, - 5 - l))),
GNM_EXPR_OP_MULT,
gnm_expr_copy (expr_munit)),
make_rangeref (0, - 2 - l, l - 1, - 3));
expr = gnm_expr_new_funcall2 (fd_mmult, expr,
gnm_expr_new_binary
(gnm_expr_new_funcall1
(fd_sqrt, make_rangeref (0, - 3 - l, l - 1, - 3 - l)),
GNM_EXPR_OP_MULT,
expr_munit));
dao_set_array_expr (dao, 1, 10 + 2 * l, l, l, expr);
gnm_func_unref (fd_mean);
gnm_func_unref (fd_var);
gnm_func_unref (fd_eigen);
gnm_func_unref (fd_mmult);
gnm_func_unref (fd_munit);
gnm_func_unref (fd_sqrt);
gnm_func_unref (fd_count);
gnm_func_unref (fd_sum);
gnm_func_unref (fd_and);
gnm_func_unref (fd_if);
dao_redraw_respan (dao);
return 0;
}
static gboolean
analysis_tool_chi_squared_engine_run (data_analysis_output_t *dao,
analysis_tools_data_chi_squared_t *info)
{
GnmExpr const *expr_check;
GnmExpr const *expr_region;
GnmExpr const *expr_statistic;
GnmExpr const *expr_row_ones;
GnmExpr const *expr_col_ones;
GnmExpr const *expr_row;
GnmExpr const *expr_column;
GnmExpr const *expr_expect;
GnmFunc *fd_mmult = analysis_tool_get_function ("MMULT", dao);
GnmFunc *fd_row = analysis_tool_get_function ("ROW", dao);
GnmFunc *fd_column = analysis_tool_get_function ("COLUMN", dao);
GnmFunc *fd_transpose = analysis_tool_get_function ("TRANSPOSE", dao);
GnmFunc *fd_sum = analysis_tool_get_function ("SUM", dao);
GnmFunc *fd_min = analysis_tool_get_function ("MIN", dao);
GnmFunc *fd_offset = analysis_tool_get_function ("OFFSET", dao);
GnmFunc *fd_chiinv = analysis_tool_get_function ("CHIINV", dao);
GnmFunc *fd_chidist = analysis_tool_get_function ("CHIDIST", dao);
char const *label;
char *cc;
label = (info->independence)
/* translator info: The quotation marks in the next strings need to */
/* remain since these are Excel-style format strings */
? _("[>=5]\"Test of Independence\";[<5][Red]\"Invalid Test of Independence\"")
: _("[>=5]\"Test of Homogeneity\";[<5][Red]\"Invalid Test of Homogeneity\"");
dao_set_italic (dao, 0, 1, 0, 4);
set_cell_text_col (dao, 0, 1, _("/Test Statistic"
"/Degrees of Freedom"
"/p-Value"
"/Critical Value"));
cc = g_strdup_printf ("%s = %.2" GNM_FORMAT_f, "\xce\xb1", info->alpha);
dao_set_cell_comment (dao, 0, 4, cc);
g_free (cc);
if (info->labels)
expr_region = gnm_expr_new_funcall5
(fd_offset,
gnm_expr_new_constant (value_dup (info->input)),
gnm_expr_new_constant (value_new_int (1)),
gnm_expr_new_constant (value_new_int (1)),
gnm_expr_new_constant (value_new_int (info->n_r)),
gnm_expr_new_constant (value_new_int (info->n_c)));
else
expr_region = gnm_expr_new_constant (value_dup (info->input));
expr_row = gnm_expr_new_funcall1 (fd_row, gnm_expr_copy (expr_region));
expr_column = gnm_expr_new_funcall1 (fd_column, gnm_expr_copy (expr_region));
expr_col_ones = gnm_expr_new_funcall1 (fd_transpose,
gnm_expr_new_binary (gnm_expr_copy (expr_column),
GNM_EXPR_OP_DIV,
expr_column));
expr_row_ones = gnm_expr_new_funcall1 (fd_transpose,
gnm_expr_new_binary (gnm_expr_copy (expr_row),
GNM_EXPR_OP_DIV,
expr_row));
expr_expect = gnm_expr_new_binary (gnm_expr_new_funcall2
(fd_mmult,
gnm_expr_new_funcall2
(fd_mmult,
gnm_expr_copy (expr_region),
expr_col_ones),
gnm_expr_new_funcall2
(fd_mmult,
expr_row_ones,
gnm_expr_copy (expr_region))),
GNM_EXPR_OP_DIV,
gnm_expr_new_funcall1 (fd_sum, gnm_expr_copy (expr_region)));
expr_check = gnm_expr_new_funcall1 (fd_min, gnm_expr_copy (expr_expect));
dao_set_merge (dao, 0, 0, 1, 0);
dao_set_italic (dao, 0, 0, 0, 0);
dao_set_cell_expr (dao, 0, 0, expr_check);
dao_set_format (dao, 0, 0, 0, 0, label);
dao_set_align (dao, 0, 0, 0, 0, GNM_HALIGN_CENTER, GNM_VALIGN_BOTTOM);
expr_statistic = gnm_expr_new_funcall1 (fd_sum,
gnm_expr_new_binary
(gnm_expr_new_binary (gnm_expr_new_binary
(gnm_expr_copy (expr_region),
GNM_EXPR_OP_SUB,
gnm_expr_copy (expr_expect)),
GNM_EXPR_OP_EXP,
gnm_expr_new_constant (value_new_int (2))),
GNM_EXPR_OP_DIV,
gnm_expr_copy (expr_expect)));
dao_set_cell_array_expr (dao, 1, 1, expr_statistic);
dao_set_cell_int (dao, 1, 2, (info->n_r - 1)*(info->n_c - 1));
dao_set_cell_expr(dao, 1, 3, gnm_expr_new_funcall2
(fd_chidist, make_cellref (0,-2), make_cellref (0,-1)));
dao_set_cell_expr(dao, 1, 4, gnm_expr_new_funcall2
(fd_chiinv,
gnm_expr_new_constant (value_new_float (info->alpha)),
make_cellref (0,-2)));
gnm_func_unref (fd_mmult);
gnm_func_unref (fd_row);
gnm_func_unref (fd_column);
gnm_func_unref (fd_transpose);
gnm_func_unref (fd_sum);
gnm_func_unref (fd_min);
gnm_func_unref (fd_offset);
gnm_func_unref (fd_chiinv);
gnm_func_unref (fd_chidist);
gnm_expr_free (expr_expect);
gnm_expr_free (expr_region);
dao_redraw_respan (dao);
return FALSE;
}
static inline GnmExpr const *
make_int (int n)
{
return gnm_expr_new_constant (value_new_int (n));
}
static gboolean
analysis_tool_frequency_engine_run (data_analysis_output_t *dao,
analysis_tools_data_frequency_t *info)
{
gint i_limit, col;
GSList *l;
GnmFunc *fd_sum;
GnmFunc *fd_if;
GnmFunc *fd_index;
GnmFunc *fd_isblank;
GnmFunc *fd_rows = NULL;
GnmFunc *fd_columns = NULL;
GnmFunc *fd_exact = NULL;
fd_sum = gnm_func_lookup_or_add_placeholder ("SUM");
gnm_func_ref (fd_sum);
fd_if = gnm_func_lookup_or_add_placeholder ("IF");
gnm_func_ref (fd_if);
fd_index = gnm_func_lookup_or_add_placeholder ("INDEX");
gnm_func_ref (fd_index);
fd_isblank = gnm_func_lookup_or_add_placeholder ("ISBLANK");
gnm_func_ref (fd_isblank);
if (info->exact) {
fd_exact = gnm_func_lookup_or_add_placeholder ("EXACT");
gnm_func_ref (fd_exact);
}
if (info->percentage) {
fd_rows = gnm_func_lookup_or_add_placeholder ("ROWS");
gnm_func_ref (fd_rows);
fd_columns = gnm_func_lookup_or_add_placeholder ("COLUMNS");
gnm_func_ref (fd_columns);
}
/* General Info */
dao_set_italic (dao, 0, 0, 0, 1);
set_cell_text_col (dao, 0, 0, _("/Frequency Table"
"/Category"));
/* Setting up the categories */
if (info->predetermined) {
int row = 2, i, j, i_h_limit, i_w_limit;
GnmExpr const *expr_bin;
GnmRange range;
range_init_value (&range, info->bin);
i_h_limit = range_height (&range);
i_w_limit = range_width (&range);
i_limit = i_h_limit * i_w_limit;
expr_bin = gnm_expr_new_constant (info->bin);
for (i = 1; i <= i_h_limit; i++)
for (j = 1; j <= i_w_limit; j++) {
GnmExpr const *expr_index;
expr_index = gnm_expr_new_funcall3
(fd_index,
gnm_expr_copy (expr_bin),
gnm_expr_new_constant (value_new_int (i)),
gnm_expr_new_constant (value_new_int (j)));
dao_set_cell_expr (dao, 0, row++,
gnm_expr_new_funcall3
(fd_if,
gnm_expr_new_funcall1
(fd_isblank,
gnm_expr_copy (expr_index)),
gnm_expr_new_constant (value_new_string ("")),
expr_index));
}
gnm_expr_free (expr_bin);
} else {
i_limit = info->n;
}
for (l = info->base.input, col = 1; l; col++, l = l->next) {
GnmValue *val = value_dup ((GnmValue *)l->data);
GnmValue *val_c = NULL;
GnmExpr const *expr_count;
GnmExpr const *expr_data;
GnmExpr const *expr_if;
int i, row = 2;
dao_set_italic (dao, col, 1, col, 1);
if (info->base.labels) {
val_c = value_dup (val);
switch (info->base.group_by) {
case GROUPED_BY_ROW:
val->v_range.cell.a.col++;
break;
default:
val->v_range.cell.a.row++;
break;
}
dao_set_cell_expr (dao, col, 1,
gnm_expr_new_funcall1 (fd_index,
gnm_expr_new_constant (val_c)));
} else {
char const *format;
switch (info->base.group_by) {
case GROUPED_BY_ROW:
format = _("Row %d");
break;
case GROUPED_BY_COL:
format = _("Column %d");
break;
default:
format = _("Area %d");
break;
}
dao_set_cell_printf (dao, col, 1, format, col);
}
expr_data = gnm_expr_new_constant (val);
if (info->exact)
expr_if = gnm_expr_new_funcall2
(fd_exact, gnm_expr_copy (expr_data),
make_cellref (- col, 0));
else
expr_if = gnm_expr_new_binary
(gnm_expr_copy (expr_data),
GNM_EXPR_OP_EQUAL, make_cellref (- col, 0));
expr_count = gnm_expr_new_funcall1 (fd_sum,
gnm_expr_new_funcall3
(fd_if, expr_if,
gnm_expr_new_constant (value_new_int (1)),
gnm_expr_new_constant (value_new_int (0))));
if (info->percentage) {
dao_set_format (dao, col, 2, col, i_limit + 2, "0.0%");
expr_count = gnm_expr_new_binary (expr_count,
GNM_EXPR_OP_DIV,
gnm_expr_new_binary
(gnm_expr_new_funcall1
(fd_rows, gnm_expr_copy (expr_data)),
GNM_EXPR_OP_MULT,
gnm_expr_new_funcall1
(fd_columns, expr_data)));
} else
gnm_expr_free (expr_data);
for (i = 0; i < i_limit; i++, row++)
dao_set_cell_array_expr (dao, col, row, gnm_expr_copy (expr_count));
gnm_expr_free (expr_count);
}
gnm_func_unref (fd_if);
gnm_func_unref (fd_sum);
gnm_func_unref (fd_index);
gnm_func_unref (fd_isblank);
if (fd_rows != NULL)
gnm_func_unref (fd_rows);
if (fd_columns != NULL)
gnm_func_unref (fd_columns);
if (fd_exact != NULL)
gnm_func_unref (fd_exact);
/* Create Chart if requested */
if (info->chart != NO_CHART) {
SheetObject *so;
GogGraph *graph;
GogChart *chart;
GogPlot *plot;
GogSeries *series;
GOData *cats;
GOData *values;
int ct;
graph = g_object_new (GOG_TYPE_GRAPH, NULL);
chart = GOG_CHART (gog_object_add_by_name (
GOG_OBJECT (graph), "Chart", NULL));
plot = gog_plot_new_by_name ("GogBarColPlot");
if (info->chart == BAR_CHART)
go_object_toggle (plot, "horizontal");
gog_object_add_by_name (GOG_OBJECT (chart),
"Plot", GOG_OBJECT (plot));
cats = dao_go_data_vector (dao, 0, 2,
0, 2 + i_limit);
for (ct = 1; ct < col; ct ++) {
g_object_ref (cats);
values = dao_go_data_vector (dao, ct, 2,
ct, 2 + i_limit);
series = gog_plot_new_series (plot);
gog_series_set_dim (series, 0, cats, NULL);
gog_series_set_dim (series, 1, values, NULL);
}
g_object_unref (cats);
so = sheet_object_graph_new (graph);
g_object_unref (graph);
dao_set_sheet_object (dao, 0, 1, so);
}
dao_redraw_respan (dao);
return FALSE;
}
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;
}