/* PSPP - computes sample statistics.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
+ Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
*/
#include <config.h>
-#include <libpspp/message.h>
+
#include <ctype.h>
+#include <gsl/gsl_cdf.h>
#include <stdlib.h>
#include <stdio.h>
-#include <gsl/gsl_cdf.h>
-#include <libpspp/array.h>
-#include <libpspp/alloc.h>
+
#include <data/case.h>
+#include <data/data-out.h>
#include <data/dictionary.h>
-#include <libpspp/hash.h>
-#include <libpspp/pool.h>
+#include <data/format.h>
+#include <data/procedure.h>
+#include <data/value-labels.h>
+#include <data/variable.h>
#include <language/command.h>
-#include <libpspp/compiler.h>
+#include <language/dictionary/split-file.h>
#include <language/lexer/lexer.h>
-#include <libpspp/message.h>
+#include <language/lexer/variable-parser.h>
+#include <libpspp/alloc.h>
+#include <libpspp/array.h>
+#include <libpspp/assertion.h>
+#include <libpspp/compiler.h>
+#include <libpspp/hash.h>
#include <libpspp/magic.h>
+#include <libpspp/message.h>
+#include <libpspp/message.h>
#include <libpspp/misc.h>
-#include <output/output.h>
+#include <libpspp/pool.h>
#include <libpspp/str.h>
+#include <output/output.h>
#include <output/table.h>
-#include <data/value-labels.h>
-#include <data/variable.h>
-#include <procedure.h>
+
+#include "minmax.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
/* (headers) */
-#include <libpspp/debug-print.h>
-
/* (specification)
crosstabs (crs_):
*^tables=custom;
+variables=custom;
- +missing=miss:!table/include/report;
+ missing=miss:!table/include/report;
+write[wr_]=none,cells,all;
+format=fmt:!labels/nolabels/novallabs,
val:!avalue/dvalue,
static inline struct var_range *
get_var_range (struct variable *v)
{
- assert (v != NULL);
- assert (v->aux != NULL);
- return v->aux;
+ return var_get_aux (v);
}
/* Indexes into crosstab.v. */
static int cells[8]; /* Cells requested. */
/* WRITE. */
-static int write; /* One of WR_* that specifies the WRITE style. */
+static int write_style; /* One of WR_* that specifies the WRITE style. */
/* Command parsing info. */
static struct cmd_crosstabs cmd;
static struct pool *pl_tc; /* For table cells. */
static struct pool *pl_col; /* For column data. */
-static int internal_cmd_crosstabs (void);
-static void precalc (void *);
-static bool calc_general (struct ccase *, void *);
-static bool calc_integer (struct ccase *, void *);
-static void postcalc (void *);
+static int internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds);
+static void precalc (const struct ccase *, void *, const struct dataset *);
+static bool calc_general (const struct ccase *, void *, const struct dataset *);
+static bool calc_integer (const struct ccase *, void *, const struct dataset *);
+static bool postcalc (void *, const struct dataset *);
static void submit (struct tab_table *);
static void format_short (char *s, const struct fmt_spec *fp,
/* Parse and execute CROSSTABS, then clean up. */
int
-cmd_crosstabs (void)
+cmd_crosstabs (struct lexer *lexer, struct dataset *ds)
{
- int result = internal_cmd_crosstabs ();
+ int result = internal_cmd_crosstabs (lexer, ds);
free (variables);
pool_destroy (pl_tc);
/* Parses and executes the CROSSTABS procedure. */
static int
-internal_cmd_crosstabs (void)
+internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds)
{
int i;
bool ok;
pl_tc = pool_create ();
pl_col = pool_create ();
- if (!parse_crosstabs (&cmd))
+ if (!parse_crosstabs (lexer, ds, &cmd, NULL))
return CMD_FAILURE;
mode = variables ? INTEGER : GENERAL;
+ cmd.a_write[CRS_WR_CELLS] == 0))
cmd.a_write[CRS_WR_CELLS] = 1;
if (cmd.a_write[CRS_WR_CELLS])
- write = CRS_WR_CELLS;
+ write_style = CRS_WR_CELLS;
else if (cmd.a_write[CRS_WR_ALL])
- write = CRS_WR_ALL;
+ write_style = CRS_WR_ALL;
else
- write = CRS_WR_NONE;
+ write_style = CRS_WR_NONE;
- ok = procedure_with_splits (precalc,
+ ok = procedure_with_splits (ds, precalc,
mode == GENERAL ? calc_general : calc_integer,
postcalc, NULL);
/* Parses the TABLES subcommand. */
static int
-crs_custom_tables (struct cmd_crosstabs *cmd UNUSED)
+crs_custom_tables (struct lexer *lexer, struct dataset *ds, struct cmd_crosstabs *cmd UNUSED, void *aux UNUSED)
{
struct var_set *var_set;
int n_by;
int success = 0;
/* Ensure that this is a TABLES subcommand. */
- if (!lex_match_id ("TABLES")
- && (token != T_ID || dict_lookup_var (default_dict, tokid) == NULL)
- && token != T_ALL)
+ if (!lex_match_id (lexer, "TABLES")
+ && (lex_token (lexer) != T_ID || dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)
+ && lex_token (lexer) != T_ALL)
return 2;
- lex_match ('=');
+ lex_match (lexer, '=');
if (variables != NULL)
var_set = var_set_create_from_array (variables, variables_cnt);
else
- var_set = var_set_create_from_dict (default_dict);
+ var_set = var_set_create_from_dict (dataset_dict (ds));
assert (var_set != NULL);
for (n_by = 0; ;)
{
by = xnrealloc (by, n_by + 1, sizeof *by);
by_nvar = xnrealloc (by_nvar, n_by + 1, sizeof *by_nvar);
- if (!parse_var_set_vars (var_set, &by[n_by], &by_nvar[n_by],
+ if (!parse_var_set_vars (lexer, var_set, &by[n_by], &by_nvar[n_by],
PV_NO_DUPLICATE | PV_NO_SCRATCH))
goto done;
if (xalloc_oversized (nx, by_nvar[n_by]))
nx *= by_nvar[n_by];
n_by++;
- if (!lex_match (T_BY))
+ if (!lex_match (lexer, T_BY))
{
if (n_by < 2)
{
- lex_error (_("expecting BY"));
+ lex_error (lexer, _("expecting BY"));
goto done;
}
else
/* Parses the VARIABLES subcommand. */
static int
-crs_custom_variables (struct cmd_crosstabs *cmd UNUSED)
+crs_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_crosstabs *cmd UNUSED, void *aux UNUSED)
{
if (nxtab)
{
return 0;
}
- lex_match ('=');
+ lex_match (lexer, '=');
for (;;)
{
long min, max;
- if (!parse_variables (default_dict, &variables, &variables_cnt,
+ if (!parse_variables (lexer, dataset_dict (ds),
+ &variables, &variables_cnt,
(PV_APPEND | PV_NUMERIC
| PV_NO_DUPLICATE | PV_NO_SCRATCH)))
return 0;
- if (token != '(')
+ if (lex_token (lexer) != '(')
{
- lex_error ("expecting `('");
+ lex_error (lexer, "expecting `('");
goto lossage;
}
- lex_get ();
+ lex_get (lexer);
- if (!lex_force_int ())
+ if (!lex_force_int (lexer))
goto lossage;
- min = lex_integer ();
- lex_get ();
+ min = lex_integer (lexer);
+ lex_get (lexer);
- lex_match (',');
+ lex_match (lexer, ',');
- if (!lex_force_int ())
+ if (!lex_force_int (lexer))
goto lossage;
- max = lex_integer ();
+ max = lex_integer (lexer);
if (max < min)
{
msg (SE, _("Maximum value (%ld) less than minimum value (%ld)."),
max, min);
goto lossage;
}
- lex_get ();
+ lex_get (lexer);
- if (token != ')')
+ if (lex_token (lexer) != ')')
{
- lex_error ("expecting `)'");
+ lex_error (lexer, "expecting `)'");
goto lossage;
}
- lex_get ();
+ lex_get (lexer);
for (i = orig_nv; i < variables_cnt; i++)
{
var_attach_aux (variables[i], vr, var_dtor_free);
}
- if (token == '/')
+ if (lex_token (lexer) == '/')
break;
}
\f
/* Data file processing. */
-static int compare_table_entry (const void *, const void *, void *);
-static unsigned hash_table_entry (const void *, void *);
+static int compare_table_entry (const void *, const void *, const void *);
+static unsigned hash_table_entry (const void *, const void *);
/* Set up the crosstabulation tables for processing. */
-static void
-precalc (void *aux UNUSED)
+static void
+precalc (const struct ccase *first, void *aux UNUSED, const struct dataset *ds)
{
+ output_split_file_values (ds, first);
if (mode == GENERAL)
{
gen_tab = hsh_create (512, compare_table_entry, hash_table_entry,
n_sorted_tab + 1, sizeof *sorted_tab);
sorted_tab[n_sorted_tab] = NULL;
}
+
}
/* Form crosstabulations for general mode. */
static bool
-calc_general (struct ccase *c, void *aux UNUSED)
+calc_general (const struct ccase *c, void *aux UNUSED, const struct dataset *ds)
{
- int bad_warn = 1;
+ bool bad_warn = true;
+
+ /* Missing values to exclude. */
+ enum mv_class exclude = (cmd.miss == CRS_TABLE ? MV_ANY
+ : cmd.miss == CRS_INCLUDE ? MV_SYSTEM
+ : MV_NEVER);
/* Case weight. */
- double weight = dict_get_case_weight (default_dict, c, &bad_warn);
+ double weight = dict_get_case_weight (dataset_dict (ds), c, &bad_warn);
/* Flattened current table index. */
int t;
assert (x != NULL);
for (j = 0; j < x->nvar; j++)
{
- const union value *v = case_data (c, x->vars[j]->fv);
- const struct missing_values *mv = &x->vars[j]->miss;
- if ((cmd.miss == CRS_TABLE && mv_is_value_missing (mv, v))
- || (cmd.miss == CRS_INCLUDE
- && mv_is_value_system_missing (mv, v)))
+ const union value *v = case_data (c, x->vars[j]);
+ if (var_is_value_missing (x->vars[j], v, exclude))
{
x->missing += weight;
goto next_crosstab;
}
- if (x->vars[j]->type == NUMERIC)
- te->values[j].f = case_num (c, x->vars[j]->fv);
+ if (var_is_numeric (x->vars[j]))
+ te->values[j].f = case_num (c, x->vars[j]);
else
{
- memcpy (te->values[j].s, case_str (c, x->vars[j]->fv),
- x->vars[j]->width);
+ memcpy (te->values[j].s, case_str (c, x->vars[j]),
+ var_get_width (x->vars[j]));
/* Necessary in order to simplify comparisons. */
- memset (&te->values[j].s[x->vars[j]->width], 0,
- sizeof (union value) - x->vars[j]->width);
+ memset (&te->values[j].s[var_get_width (x->vars[j])], 0,
+ sizeof (union value) - var_get_width (x->vars[j]));
}
}
}
}
static bool
-calc_integer (struct ccase *c, void *aux UNUSED)
+calc_integer (const struct ccase *c, void *aux UNUSED, const struct dataset *ds)
{
- int bad_warn = 1;
+ bool bad_warn = true;
/* Case weight. */
- double weight = dict_get_case_weight (default_dict, c, &bad_warn);
+ double weight = dict_get_case_weight (dataset_dict (ds), c, &bad_warn);
/* Flattened current table index. */
int t;
{
struct variable *const v = x->vars[i];
struct var_range *vr = get_var_range (v);
- double value = case_num (c, v->fv);
+ double value = case_num (c, v);
/* Note that the first test also rules out SYSMIS. */
if ((value < vr->min || value >= vr->max)
|| (cmd.miss == CRS_TABLE
- && mv_is_num_user_missing (&v->miss, value)))
+ && var_is_num_missing (v, value, MV_USER)))
{
x->missing += weight;
goto next_crosstab;
{
struct variable *row_var = x->vars[ROW_VAR];
- const int row = case_num (c, row_var->fv) - get_var_range (row_var)->min;
+ const int row = case_num (c, row_var) - get_var_range (row_var)->min;
struct variable *col_var = x->vars[COL_VAR];
- const int col = case_num (c, col_var->fv) - get_var_range (col_var)->min;
+ const int col = case_num (c, col_var) - get_var_range (col_var)->min;
const int col_dim = get_var_range (col_var)->count;
/* Compare the table_entry's at A and B and return a strcmp()-type
result. */
static int
-compare_table_entry (const void *a_, const void *b_, void *foo UNUSED)
+compare_table_entry (const void *a_, const void *b_, const void *aux UNUSED)
{
const struct table_entry *a = a_;
const struct table_entry *b = b_;
int i;
for (i = x->nvar - 1; i >= 0; i--)
- if (x->vars[i]->type == NUMERIC)
+ if (var_is_numeric (x->vars[i]))
{
const double diffnum = a->values[i].f - b->values[i].f;
if (diffnum < 0)
return 1;
}
else
- {
- assert (x->vars[i]->type == ALPHA);
- {
- const int diffstr = strncmp (a->values[i].s, b->values[i].s,
- x->vars[i]->width);
- if (diffstr)
- return diffstr;
- }
- }
+ {
+ const int diffstr = strncmp (a->values[i].s, b->values[i].s,
+ var_get_width (x->vars[i]));
+ if (diffstr)
+ return diffstr;
+ }
}
return 0;
/* Calculate a hash value from table_entry A. */
static unsigned
-hash_table_entry (const void *a_, void *foo UNUSED)
+hash_table_entry (const void *a_, const void *aux UNUSED)
{
const struct table_entry *a = a_;
unsigned long hash;
int *, int *, int *);
static void make_summary_table (void);
-static void
-postcalc (void *aux UNUSED)
+static bool
+postcalc (void *aux UNUSED, const struct dataset *ds UNUSED)
{
if (mode == GENERAL)
{
}
hsh_destroy (gen_tab);
+
+ return true;
}
static void insert_summary (struct tab_table *, int tab_index, double valid);
int cur_tab = 0;
summary = tab_create (7, 3 + nxtab, 1);
- tab_title (summary, 0, _("Summary."));
+ tab_title (summary, _("Summary."));
tab_headers (summary, 1, 0, 3, 0);
tab_joint_text (summary, 1, 0, 6, 0, TAB_CENTER, _("Cases"));
tab_joint_text (summary, 1, 1, 2, 1, TAB_CENTER, _("Valid"));
if (i > 0)
cp = stpcpy (cp, " * ");
- cp = stpcpy (cp,
- x->vars[i]->label ? x->vars[i]->label : x->vars[i]->name);
+ cp = stpcpy (cp, var_to_string (x->vars[i]));
}
tab_text (t, 0, 0, TAB_LEFT, buf);
static int ns_cols, ns_rows;
/* Crosstabulation. */
-static struct crosstab *x;
+static const struct crosstab *x;
/* Number of variables from the crosstabulation to consider. This is
either x->nvar, if pivoting is on, or 2, if pivoting is off. */
/* First header line. */
tab_joint_text (table, nvar - 1, 0, (nvar - 1) + (n_cols - 1), 0,
- TAB_CENTER | TAT_TITLE, x->vars[COL_VAR]->name);
+ TAB_CENTER | TAT_TITLE, var_get_name (x->vars[COL_VAR]));
tab_hline (table, TAL_1, nvar - 1, nvar + n_cols - 2, 1);
for (i = 2; i < nvar; i++)
tab_joint_text (table, nvar - i - 1, 0, nvar - i - 1, 1,
- TAB_RIGHT | TAT_TITLE,
- (x->vars[i]->label
- ? x->vars[i]->label : x->vars[i]->name));
+ TAB_RIGHT | TAT_TITLE, var_to_string (x->vars[i]));
tab_text (table, nvar - 2, 1, TAB_RIGHT | TAT_TITLE,
- x->vars[ROW_VAR]->name);
+ var_get_name (x->vars[ROW_VAR]));
for (i = 0; i < n_cols; i++)
table_value_missing (table, nvar + i - 1, 1, TAB_RIGHT, &cols[i],
x->vars[COL_VAR]);
{
if (i)
cp = stpcpy (cp, " by ");
- cp = stpcpy (cp, x->vars[i]->name);
+ cp = stpcpy (cp, var_get_name (x->vars[i]));
}
else
{
cp = spprintf (cp, "%s by %s for",
- x->vars[0]->name, x->vars[1]->name);
+ var_get_name (x->vars[0]),
+ var_get_name (x->vars[1]));
for (i = 2; i < nvar; i++)
{
char buf[64], *bufp;
if (i > 2)
*cp++ = ',';
*cp++ = ' ';
- cp = stpcpy (cp, x->vars[i]->name);
+ cp = stpcpy (cp, var_get_name (x->vars[i]));
*cp++ = '=';
- format_short (buf, &x->vars[i]->print, &(*pb)->values[i]);
+ format_short (buf, var_get_print_format (x->vars[i]),
+ &(*pb)->values[i]);
for (bufp = buf; isspace ((unsigned char) *bufp); bufp++)
;
cp = stpcpy (cp, bufp);
}
strcpy (cp, "].");
- tab_title (table, 0, title);
+ tab_title (table, "%s", title);
local_free (title);
}
(pe - pb) / n_cols * 3 / 2 * N_CHISQ + 10, 1);
tab_headers (chisq, 1 + (nvar - 2), 0, 1, 0);
- tab_title (chisq, 0, "Chi-square tests.");
+ tab_title (chisq, _("Chi-square tests."));
tab_offset (chisq, nvar - 2, 0);
tab_text (chisq, 0, 0, TAB_LEFT | TAT_TITLE, _("Statistic"));
{
sym = tab_create (6 + (nvar - 2), (pe - pb) / n_cols * 7 + 10, 1);
tab_headers (sym, 2 + (nvar - 2), 0, 1, 0);
- tab_title (sym, 0, "Symmetric measures.");
+ tab_title (sym, _("Symmetric measures."));
tab_offset (sym, nvar - 2, 0);
tab_text (sym, 0, 0, TAB_LEFT | TAT_TITLE, _("Category"));
{
risk = tab_create (4 + (nvar - 2), (pe - pb) / n_cols * 4 + 10, 1);
tab_headers (risk, 1 + nvar - 2, 0, 2, 0);
- tab_title (risk, 0, "Risk estimate.");
+ tab_title (risk, _("Risk estimate."));
tab_offset (risk, nvar - 2, 0);
tab_joint_text (risk, 2, 0, 3, 0, TAB_CENTER | TAT_TITLE | TAT_PRINTF,
{
direct = tab_create (7 + (nvar - 2), (pe - pb) / n_cols * 7 + 10, 1);
tab_headers (direct, 3 + (nvar - 2), 0, 1, 0);
- tab_title (direct, 0, "Directional measures.");
+ tab_title (direct, _("Directional measures."));
tab_offset (direct, nvar - 2, 0);
tab_text (direct, 0, 0, TAB_LEFT | TAT_TITLE, _("Category"));
/* Allocate table space for the matrix. */
if (table && tab_row (table) + (n_rows + 1) * num_cells > tab_nr (table))
tab_realloc (table, -1,
- max (tab_nr (table) + (n_rows + 1) * num_cells,
+ MAX (tab_nr (table) + (n_rows + 1) * num_cells,
tab_nr (table) * (pe - pb) / (te - tb)));
if (mode == GENERAL)
int r;
for (r = 0; r < n_rows; r++)
- if (mv_is_num_user_missing (&x->vars[ROW_VAR]->miss, rows[r].f))
+ if (var_is_num_missing (x->vars[ROW_VAR], rows[r].f, MV_USER))
{
int c;
int c;
for (c = 0; c < n_cols; c++)
- if (mv_is_num_user_missing (&x->vars[COL_VAR]->miss, cols[c].f))
+ if (var_is_num_missing (x->vars[COL_VAR], cols[c].f, MV_USER))
{
int r;
if (t != table)
for (i = 2; i < nvar; i++)
tab_text (t, nvar - i - 1, 0, TAB_RIGHT | TAT_TITLE,
- x->vars[i]->label ? x->vars[i]->label : x->vars[i]->name);
+ var_to_string (x->vars[i]));
tab_box (t, TAL_2, TAL_2, -1, -1, 0, 0, tab_nc (t) - 1, tab_nr (t) - 1);
tab_box (t, -1, -1, -1, TAL_1, tab_l (t), tab_t (t) - 1, tab_nc (t) - 1,
tab_nr (t) - 1);
- tab_box (t, -1, -1, -1, TAL_1 | TAL_SPACING, 0, tab_t (t), tab_l (t) - 1,
+ tab_box (t, -1, -1, -1, TAL_GAP, 0, tab_t (t), tab_l (t) - 1,
tab_nr (t) - 1);
tab_vline (t, TAL_2, tab_l (t), 0, tab_nr (t) - 1);
tab_dim (t, crosstabs_dim);
int i;
/* Width of a numerical column. */
- int c = outp_string_width (d, "0.000000");
+ int c = outp_string_width (d, "0.000000", OUTP_PROPORTIONAL);
if (cmd.miss == CRS_REPORT)
- c += outp_string_width (d, "M");
+ c += outp_string_width (d, "M", OUTP_PROPORTIONAL);
/* Set width for header columns. */
if (t->l != 0)
{
- int w = (d->width - t->vr_tot - c * (t->nc - t->l)) / t->l;
+ size_t i;
+ int w;
+
+ w = d->width - c * (t->nc - t->l);
+ for (i = 0; i <= t->nc; i++)
+ w -= t->wrv[i];
+ w /= t->l;
if (w < d->prop_em_width * 8)
w = d->prop_em_width * 8;
result. WIDTH_ points to an int which is either 0 for a
numeric value or a string width for a string value. */
static int
-compare_value (const void *a_, const void *b_, void *width_)
+compare_value (const void *a_, const void *b_, const void *width_)
{
const union value *a = a_;
const union value *b = b_;
if (mode == GENERAL)
{
- int width = v->width;
+ int width = var_get_width (v);
int i;
*values = xnmalloc (entry_cnt, sizeof **values);
table_value_missing (struct tab_table *table, int c, int r, unsigned char opt,
const union value *v, const struct variable *var)
{
- struct fixed_string s;
+ struct substring s;
+ const struct fmt_spec *print = var_get_print_format (var);
- const char *label = val_labs_find (var->val_labs, *v);
+ const char *label = var_lookup_value_label (var, v);
if (label)
{
tab_text (table, c, r, TAB_LEFT, label);
return;
}
- s.string = tab_alloc (table, var->print.w);
- format_short (s.string, &var->print, v);
+ s.string = tab_alloc (table, print->w);
+ format_short (s.string, print, v);
s.length = strlen (s.string);
- if (cmd.miss == CRS_REPORT && mv_is_num_user_missing (&var->miss, v->f))
+ if (cmd.miss == CRS_REPORT && var_is_num_missing (var, v->f, MV_USER))
s.string[s.length++] = 'M';
while (s.length && *s.string == ' ')
{
}
/* Put VALUE into cell (C,R) of TABLE, suffixed with character
- SUFFIX if nonzero. If MARK_MISSING is nonzero the entry is
+ SUFFIX if nonzero. If MARK_MISSING is true the entry is
additionally suffixed with a letter `M'. */
static void
format_cell_entry (struct tab_table *table, int c, int r, double value,
- char suffix, int mark_missing)
+ char suffix, bool mark_missing)
{
const struct fmt_spec f = {FMT_F, 10, 1};
union value v;
- struct fixed_string s;
+ struct substring s;
s.length = 10;
s.string = tab_alloc (table, 16);
v.f = value;
- data_out (s.string, &f, &v);
+ data_out (&v, &f, s.string);
while (*s.string == ' ')
{
s.length--;
tab_hline (table, TAL_1, -1, n_cols, 0);
for (c = 0; c < n_cols; c++)
{
- int mark_missing = 0;
+ bool mark_missing = false;
double expected_value = row_tot[r] * col_tot[c] / W;
if (cmd.miss == CRS_REPORT
- && (mv_is_num_user_missing (&x->vars[COL_VAR]->miss, cols[c].f)
- || mv_is_num_user_missing (&x->vars[ROW_VAR]->miss,
- rows[r].f)))
- mark_missing = 1;
+ && (var_is_num_missing (x->vars[COL_VAR], cols[c].f, MV_USER)
+ || var_is_num_missing (x->vars[ROW_VAR], rows[r].f,
+ MV_USER)))
+ mark_missing = true;
for (i = 0; i < num_cells; i++)
{
double v;
* (1. - col_tot[c] / W)));
break;
default:
- assert (0);
- abort ();
+ NOT_REACHED ();
}
format_cell_entry (table, c, i, v, suffix, mark_missing);
for (r = 0; r < n_rows; r++)
{
char suffix = 0;
- int mark_missing = 0;
+ bool mark_missing = false;
if (cmd.miss == CRS_REPORT
- && mv_is_num_user_missing (&x->vars[ROW_VAR]->miss, rows[r].f))
- mark_missing = 1;
+ && var_is_num_missing (x->vars[ROW_VAR], rows[r].f, MV_USER))
+ mark_missing = true;
for (i = 0; i < num_cells; i++)
{
v = 0.;
break;
default:
- assert (0);
- abort ();
+ NOT_REACHED ();
}
format_cell_entry (table, n_cols, 0, v, suffix, mark_missing);
for (c = 0; c <= n_cols; c++)
{
double ct = c < n_cols ? col_tot[c] : W;
- int mark_missing = 0;
+ bool mark_missing = false;
char suffix = 0;
int i;
if (cmd.miss == CRS_REPORT && c < n_cols
- && mv_is_num_user_missing (&x->vars[COL_VAR]->miss, cols[c].f))
- mark_missing = 1;
+ && var_is_num_missing (x->vars[COL_VAR], cols[c].f, MV_USER))
+ mark_missing = true;
for (i = 0; i < num_cells; i++)
{
case CRS_CL_ASRESIDUAL:
continue;
default:
- assert (0);
- abort ();
+ NOT_REACHED ();
}
format_cell_entry (table, c, i, v, suffix, mark_missing);
switch (i)
{
case 0:
- if (x->vars[COL_VAR]->type == NUMERIC)
+ if (var_is_numeric (x->vars[COL_VAR]))
sprintf (buf, _("Odds Ratio for %s (%g / %g)"),
- x->vars[COL_VAR]->name, c[0].f, c[1].f);
+ var_get_name (x->vars[COL_VAR]), c[0].f, c[1].f);
else
sprintf (buf, _("Odds Ratio for %s (%.*s / %.*s)"),
- x->vars[COL_VAR]->name,
- x->vars[COL_VAR]->width, c[0].s,
- x->vars[COL_VAR]->width, c[1].s);
+ var_get_name (x->vars[COL_VAR]),
+ var_get_width (x->vars[COL_VAR]), c[0].s,
+ var_get_width (x->vars[COL_VAR]), c[1].s);
break;
case 1:
case 2:
- if (x->vars[ROW_VAR]->type == NUMERIC)
+ if (var_is_numeric (x->vars[ROW_VAR]))
sprintf (buf, _("For cohort %s = %g"),
- x->vars[ROW_VAR]->name, rows[i - 1].f);
+ var_get_name (x->vars[ROW_VAR]), rows[i - 1].f);
else
sprintf (buf, _("For cohort %s = %.*s"),
- x->vars[ROW_VAR]->name,
- x->vars[ROW_VAR]->width, rows[i - 1].s);
+ var_get_name (x->vars[ROW_VAR]),
+ var_get_width (x->vars[ROW_VAR]), rows[i - 1].s);
break;
}
for (; j < 3; j++)
{
- char *string;
+ const char *string;
int k = last[j] = stats_lookup[j][i];
if (k == 0)
string = NULL;
else if (k == 1)
- string = x->vars[0]->name;
+ string = var_get_name (x->vars[0]);
else
- string = x->vars[1]->name;
+ string = var_get_name (x->vars[1]);
tab_text (direct, j, 0, TAB_LEFT | TAT_PRINTF,
gettext (stats_names[j][k]), string);
{
int x;
- if (min (c, d) < min (a, b))
+ if (MIN (c, d) < MIN (a, b))
swap (&a, &c), swap (&b, &d);
- if (min (b, d) < min (a, c))
+ if (MIN (b, d) < MIN (a, c))
swap (&a, &b), swap (&c, &d);
if (b * c < a * d)
{
}
/* Calculate Mantel-Haenszel. */
- if (x->vars[ROW_VAR]->type == NUMERIC && x->vars[COL_VAR]->type == NUMERIC)
+ if (var_is_numeric (x->vars[ROW_VAR]) && var_is_numeric (x->vars[COL_VAR]))
{
double r, ase_0, ase_1;
calc_r ((double *) rows, (double *) cols, &r, &ase_0, &ase_1);
calc_symmetric (double v[N_SYMMETRIC], double ase[N_SYMMETRIC],
double t[N_SYMMETRIC])
{
- int q = min (ns_rows, ns_cols);
+ int q = MIN (ns_rows, ns_cols);
if (q <= 1)
return 0;
struct fmt_spec fmt_subst;
/* Limit to short string width. */
- if (formats[fp->type].cat & FCAT_STRING)
+ if (fmt_is_string (fp->type))
{
fmt_subst = *fp;
assert (fmt_subst.type == FMT_A || fmt_subst.type == FMT_AHEX);
if (fmt_subst.type == FMT_A)
- fmt_subst.w = min (8, fmt_subst.w);
+ fmt_subst.w = MIN (8, fmt_subst.w);
else
- fmt_subst.w = min (16, fmt_subst.w);
+ fmt_subst.w = MIN (16, fmt_subst.w);
fp = &fmt_subst;
}
/* Format. */
- data_out (s, fp, v);
-
+ data_out (v, fp, s);
+
/* Null terminate. */
s[fp->w] = '\0';
}