#include <output/output.h>
#include <output/table.h>
+#include "minmax.h"
+
#include "gettext.h"
#define _(msgid) gettext (msgid)
#define N_(msgid) msgid
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))
+ if ((cmd.miss == CRS_TABLE && var_is_value_missing (x->vars[j], v))
|| (cmd.miss == CRS_INCLUDE
- && mv_is_value_system_missing (mv, v)))
+ && var_is_value_system_missing (x->vars[j], v)))
{
x->missing += weight;
goto next_crosstab;
}
- if (x->vars[j]->type == NUMERIC)
+ if (var_is_numeric (x->vars[j]))
te->values[j].f = case_num (c, x->vars[j]->fv);
else
{
memcpy (te->values[j].s, case_str (c, x->vars[j]->fv),
- x->vars[j]->width);
+ 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]));
}
}
}
/* 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)))
+ || (cmd.miss == CRS_TABLE && var_is_num_user_missing (v, value)))
{
x->missing += weight;
goto next_crosstab;
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;
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);
/* 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);
/* 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_user_missing (x->vars[ROW_VAR], rows[r].f))
{
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_user_missing (x->vars[COL_VAR], cols[c].f))
{
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);
if (mode == GENERAL)
{
- int width = v->width;
+ int width = var_get_width (v);
int i;
*values = xnmalloc (entry_cnt, sizeof **values);
const union value *v, const struct variable *var)
{
struct substring s;
+ const struct fmt_spec *print = var_get_print_format (var);
const char *label = val_labs_find (var->val_labs, *v);
if (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_user_missing (var, v->f))
s.string[s.length++] = 'M';
while (s.length && *s.string == ' ')
{
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)))
+ && (var_is_num_user_missing (x->vars[COL_VAR], cols[c].f)
+ || var_is_num_user_missing (x->vars[ROW_VAR], rows[r].f)))
mark_missing = true;
for (i = 0; i < num_cells; i++)
{
bool mark_missing = false;
if (cmd.miss == CRS_REPORT
- && mv_is_num_user_missing (&x->vars[ROW_VAR]->miss, rows[r].f))
+ && var_is_num_user_missing (x->vars[ROW_VAR], rows[r].f))
mark_missing = true;
for (i = 0; i < num_cells; i++)
int i;
if (cmd.miss == CRS_REPORT && c < n_cols
- && mv_is_num_user_missing (&x->vars[COL_VAR]->miss, cols[c].f))
+ && var_is_num_user_missing (x->vars[COL_VAR], cols[c].f))
mark_missing = true;
for (i = 0; i < num_cells; i++)
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;
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;
}