/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2009 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2009, 2010 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 published by
#include <libpspp/array.h>
#include <libpspp/assertion.h>
#include <libpspp/compiler.h>
-#include <libpspp/hash.h>
+#include <libpspp/hash-functions.h>
#include <libpspp/hmap.h>
#include <libpspp/hmapx.h>
#include <libpspp/message.h>
#include <libpspp/misc.h>
#include <libpspp/pool.h>
#include <libpspp/str.h>
-#include <output/output.h>
-#include <output/table.h>
+#include <output/tab.h>
#include "minmax.h"
#include "xalloc.h"
/* STATISTICS. */
unsigned int statistics; /* Bit k is 1 if statistic k is requested. */
- };
-/* Auxiliary data structure for tab_dim. */
-struct crosstabs_dim_aux
- {
- enum mv_class exclude;
+ bool descending; /* True if descending sort order is requested. */
};
-static void
-init_proc (struct crosstabs_proc *proc, struct dataset *ds)
-{
- const struct variable *wv = dict_get_weight (dataset_dict (ds));
- proc->dict = dataset_dict (ds);
- proc->bad_warn = true;
- proc->variables = NULL;
- proc->n_variables = 0;
- proc->pivots = NULL;
- proc->n_pivots = 0;
- proc->weight_format = wv ? *var_get_print_format (wv) : F_8_0;
-}
-
-static void
-free_proc (struct crosstabs_proc *proc)
-{
- struct pivot_table *pt;
-
- free (proc->variables);
- for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
- {
- free (pt->vars);
- free (pt->const_vars);
- /* We must not call value_destroy on const_values because
- it is a wild pointer; it never pointed to anything owned
- by the pivot_table.
-
- The rest of the data was allocated and destroyed at a
- lower level already. */
- }
- free (proc->pivots);
-}
-
-static int internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds,
- struct crosstabs_proc *);
static bool should_tabulate_case (const struct pivot_table *,
const struct ccase *, enum mv_class exclude);
static void tabulate_general_case (struct pivot_table *, const struct ccase *,
static void tabulate_integer_case (struct pivot_table *, const struct ccase *,
double weight);
static void postcalc (struct crosstabs_proc *);
-static void submit (struct crosstabs_proc *, struct pivot_table *,
- struct tab_table *);
+static void submit (struct pivot_table *, struct tab_table *);
-/* Parse and execute CROSSTABS, then clean up. */
+/* Parses and executes the CROSSTABS procedure. */
int
cmd_crosstabs (struct lexer *lexer, struct dataset *ds)
{
+ const struct variable *wv = dict_get_weight (dataset_dict (ds));
struct crosstabs_proc proc;
- int result;
-
- init_proc (&proc, ds);
- result = internal_cmd_crosstabs (lexer, ds, &proc);
- free_proc (&proc);
-
- return result;
-}
-
-/* Parses and executes the CROSSTABS procedure. */
-static int
-internal_cmd_crosstabs (struct lexer *lexer, struct dataset *ds,
- struct crosstabs_proc *proc)
-{
struct casegrouper *grouper;
struct casereader *input, *group;
struct cmd_crosstabs cmd;
struct pivot_table *pt;
+ int result;
bool ok;
int i;
- if (!parse_crosstabs (lexer, ds, &cmd, proc))
- return CMD_FAILURE;
+ proc.dict = dataset_dict (ds);
+ proc.bad_warn = true;
+ proc.variables = NULL;
+ proc.n_variables = 0;
+ proc.pivots = NULL;
+ proc.n_pivots = 0;
+ proc.descending = false;
+ proc.weight_format = wv ? *var_get_print_format (wv) : F_8_0;
- proc->mode = proc->n_variables ? INTEGER : GENERAL;
+ if (!parse_crosstabs (lexer, ds, &cmd, &proc))
+ {
+ result = CMD_FAILURE;
+ goto exit;
+ }
+
+ proc.mode = proc.n_variables ? INTEGER : GENERAL;
+
+
+ proc.descending = cmd.val == CRS_DVALUE;
/* CELLS. */
if (!cmd.sbc_cells)
- proc->cells = 1u << CRS_CL_COUNT;
+ proc.cells = 1u << CRS_CL_COUNT;
else if (cmd.a_cells[CRS_CL_ALL])
- proc->cells = UINT_MAX;
+ proc.cells = UINT_MAX;
else
{
- proc->cells = 0;
+ proc.cells = 0;
for (i = 0; i < CRS_CL_count; i++)
if (cmd.a_cells[i])
- proc->cells |= 1u << i;
- if (proc->cells == 0)
- proc->cells = ((1u << CRS_CL_COUNT)
+ proc.cells |= 1u << i;
+ if (proc.cells == 0)
+ proc.cells = ((1u << CRS_CL_COUNT)
| (1u << CRS_CL_ROW)
| (1u << CRS_CL_COLUMN)
| (1u << CRS_CL_TOTAL));
}
- proc->cells &= ((1u << CRS_CL_count) - 1);
- proc->cells &= ~((1u << CRS_CL_NONE) | (1u << CRS_CL_ALL));
- proc->n_cells = 0;
+ proc.cells &= ((1u << CRS_CL_count) - 1);
+ proc.cells &= ~((1u << CRS_CL_NONE) | (1u << CRS_CL_ALL));
+ proc.n_cells = 0;
for (i = 0; i < CRS_CL_count; i++)
- if (proc->cells & (1u << i))
- proc->a_cells[proc->n_cells++] = i;
+ if (proc.cells & (1u << i))
+ proc.a_cells[proc.n_cells++] = i;
/* STATISTICS. */
if (cmd.a_statistics[CRS_ST_ALL])
- proc->statistics = UINT_MAX;
+ proc.statistics = UINT_MAX;
else if (cmd.sbc_statistics)
{
int i;
- proc->statistics = 0;
+ proc.statistics = 0;
for (i = 0; i < CRS_ST_count; i++)
if (cmd.a_statistics[i])
- proc->statistics |= 1u << i;
- if (proc->statistics == 0)
- proc->statistics |= 1u << CRS_ST_CHISQ;
+ proc.statistics |= 1u << i;
+ if (proc.statistics == 0)
+ proc.statistics |= 1u << CRS_ST_CHISQ;
}
else
- proc->statistics = 0;
+ proc.statistics = 0;
/* MISSING. */
- proc->exclude = (cmd.miss == CRS_TABLE ? MV_ANY
+ proc.exclude = (cmd.miss == CRS_TABLE ? MV_ANY
: cmd.miss == CRS_INCLUDE ? MV_SYSTEM
: MV_NEVER);
- if (proc->mode == GENERAL && proc->mode == MV_NEVER)
+ if (proc.mode == GENERAL && proc.mode == MV_NEVER)
{
msg (SE, _("Missing mode REPORT not allowed in general mode. "
"Assuming MISSING=TABLE."));
- proc->mode = MV_ANY;
+ proc.mode = MV_ANY;
}
/* PIVOT. */
- proc->pivot = cmd.pivot == CRS_PIVOT;
+ proc.pivot = cmd.pivot == CRS_PIVOT;
input = casereader_create_filter_weight (proc_open (ds), dataset_dict (ds),
NULL, NULL);
case_unref (c);
}
+ /* Initialize hash tables. */
+ for (pt = &proc.pivots[0]; pt < &proc.pivots[proc.n_pivots]; pt++)
+ hmap_init (&pt->data);
+
/* Tabulate. */
for (; (c = casereader_read (group)) != NULL; case_unref (c))
- for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
+ for (pt = &proc.pivots[0]; pt < &proc.pivots[proc.n_pivots]; pt++)
{
double weight = dict_get_case_weight (dataset_dict (ds), c,
- &proc->bad_warn);
- if (should_tabulate_case (pt, c, proc->exclude))
+ &proc.bad_warn);
+ if (should_tabulate_case (pt, c, proc.exclude))
{
- if (proc->mode == GENERAL)
+ if (proc.mode == GENERAL)
tabulate_general_case (pt, c, weight);
else
tabulate_integer_case (pt, c, weight);
casereader_destroy (group);
/* Output. */
- postcalc (proc);
+ postcalc (&proc);
}
ok = casegrouper_destroy (grouper);
ok = proc_commit (ds) && ok;
- return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
+ result = ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
+
+exit:
+ free (proc.variables);
+ for (pt = &proc.pivots[0]; pt < &proc.pivots[proc.n_pivots]; pt++)
+ {
+ free (pt->vars);
+ free (pt->const_vars);
+ /* We must not call value_destroy on const_values because
+ it is a wild pointer; it never pointed to anything owned
+ by the pivot_table.
+
+ The rest of the data was allocated and destroyed at a
+ lower level already. */
+ }
+ free (proc.pivots);
+
+ return result;
}
/* Parses the TABLES subcommand. */
/* Ensure that this is a TABLES subcommand. */
if (!lex_match_id (lexer, "TABLES")
&& (lex_token (lexer) != T_ID ||
- dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL)
+ dict_lookup_var (dataset_dict (ds), lex_tokcstr (lexer)) == NULL)
&& lex_token (lexer) != T_ALL)
return 2;
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
if (proc->variables != NULL)
var_set = const_var_set_create_from_array (proc->variables,
{
if (n_by < 2)
{
- lex_error (lexer, _("expecting BY"));
+ lex_force_match (lexer, T_BY);
goto done;
}
else
pt->n_consts = 0;
pt->const_vars = NULL;
pt->const_values = NULL;
- hmap_init (&pt->data);
- pt->entries = NULL;
- pt->n_entries = 0;
for (j = 0; j < n_by; j++)
pt->vars[j] = by[j][by_iter[j]];
return 0;
}
- lex_match (lexer, '=');
+ lex_match (lexer, T_EQUALS);
for (;;)
{
| PV_NO_DUPLICATE | PV_NO_SCRATCH)))
return 0;
- if (lex_token (lexer) != '(')
- {
- lex_error (lexer, "expecting `('");
+ if (!lex_force_match (lexer, T_LPAREN))
goto lossage;
- }
- lex_get (lexer);
if (!lex_force_int (lexer))
goto lossage;
min = lex_integer (lexer);
lex_get (lexer);
- lex_match (lexer, ',');
+ lex_match (lexer, T_COMMA);
if (!lex_force_int (lexer))
goto lossage;
}
lex_get (lexer);
- if (lex_token (lexer) != ')')
- {
- lex_error (lexer, "expecting `)'");
- goto lossage;
- }
- lex_get (lexer);
+ if (!lex_force_match (lexer, T_RPAREN))
+ goto lossage;
for (i = orig_nv; i < proc->n_variables; i++)
{
var_attach_aux (proc->variables[i], vr, var_dtor_free);
}
- if (lex_token (lexer) == '/')
+ if (lex_token (lexer) == T_SLASH)
break;
}
for (j = 0; j < pt->n_vars; j++)
{
const struct variable *var = pt->vars[j];
- int width = var_get_width (var);
- value_init (&te->values[j], width);
- value_copy (&te->values[j], case_data (c, var), width);
+ value_clone (&te->values[j], case_data (c, var), var_get_width (var));
}
hmap_insert (&pt->data, &te->node, hash);
}
int idx0, int idx1);
static int compare_table_entry_3way (const void *ap_, const void *bp_,
const void *pt_);
+static int compare_table_entry_3way_inv (const void *ap_, const void *bp_,
+ const void *pt_);
+
static void enum_var_values (const struct pivot_table *, int var_idx,
- union value **valuesp, int *n_values);
+ union value **valuesp, int *n_values, bool descending);
static void output_pivot_table (struct crosstabs_proc *,
struct pivot_table *);
static void make_pivot_table_subset (struct pivot_table *pt,
hmap_destroy (&pt->data);
sort (pt->entries, pt->n_entries, sizeof *pt->entries,
- compare_table_entry_3way, pt);
+ proc->descending ? compare_table_entry_3way_inv : compare_table_entry_3way,
+ pt);
}
make_summary_table (proc);
return compare_table_entry_var_3way (a, b, pt, COL_VAR);
}
+/* Inverted version of compare_table_entry_3way */
+static int
+compare_table_entry_3way_inv (const void *ap_, const void *bp_, const void *pt_)
+{
+ return -compare_table_entry_3way (ap_, bp_, pt_);
+}
+
static int
find_first_difference (const struct pivot_table *pt, size_t row)
{
}
ds_destroy (&name);
- submit (proc, NULL, summary);
+ submit (NULL, summary);
}
\f
/* Output. */
static void display_risk (struct pivot_table *, struct tab_table *);
static void display_directional (struct crosstabs_proc *, struct pivot_table *,
struct tab_table *);
-static void crosstabs_dim (struct tab_rendering *, void *aux);
-static void crosstabs_dim_free (void *aux);
static void table_value_missing (struct crosstabs_proc *proc,
struct tab_table *table, int c, int r,
unsigned char opt, const union value *v,
static void delete_missing (struct pivot_table *);
static void build_matrix (struct pivot_table *);
-/* Output pivot table beginning at PB and continuing until PE,
- exclusive. For efficiency, *MATP is a pointer to a matrix that can
- hold *MAXROWS entries. */
+/* Output pivot table PT in the context of PROC. */
static void
output_pivot_table (struct crosstabs_proc *proc, struct pivot_table *pt)
{
struct tab_table *direct = NULL; /* Directional measures table. */
size_t row0, row1;
- enum_var_values (pt, COL_VAR, &pt->cols, &pt->n_cols);
+ enum_var_values (pt, COL_VAR, &pt->cols, &pt->n_cols, proc->descending);
+
+ if (pt->n_cols == 0)
+ {
+ struct string vars;
+ int i;
+
+ ds_init_cstr (&vars, var_get_name (pt->vars[0]));
+ for (i = 1; i < pt->n_vars; i++)
+ ds_put_format (&vars, " * %s", var_get_name (pt->vars[i]));
+
+ /* TRANSLATORS: The %s here describes a crosstabulation. It takes the
+ form "var1 * var2 * var3 * ...". */
+ msg (SW, _("Crosstabulation %s contained no non-missing cases."),
+ ds_cstr (&vars));
+
+ ds_destroy (&vars);
+ return;
+ }
if (proc->cells)
table = create_crosstab_table (proc, pt);
make_pivot_table_subset (pt, row0, row1, &x);
/* Find all the row variable values. */
- enum_var_values (&x, ROW_VAR, &x.rows, &x.n_rows);
+ enum_var_values (&x, ROW_VAR, &x.rows, &x.n_rows, proc->descending);
if (size_overflow_p (xtimes (xtimes (x.n_rows, x.n_cols),
sizeof (double))))
free (x.col_tot);
}
- submit (proc, NULL, table);
+ submit (NULL, table);
if (chisq)
{
if (!showed_fisher)
tab_resize (chisq, 4 + (pt->n_vars - 2), -1);
- submit (proc, pt, chisq);
+ submit (pt, chisq);
}
- submit (proc, pt, sym);
- submit (proc, pt, risk);
- submit (proc, pt, direct);
+ submit (pt, sym);
+ submit (pt, risk);
+ submit (pt, direct);
free (pt->cols);
}
struct tab_table *table;
struct string title;
+ struct pivot_table x;
+
int i;
- table = tab_create (pt->n_consts + 1 + pt->n_cols + 1,
- (pt->n_entries / pt->n_cols) * 3 / 2 * proc->n_cells + 10);
- tab_headers (table, pt->n_consts + 1, 0, 2, 0);
+ make_pivot_table_subset (pt, 0, 0, &x);
+
+ table = tab_create (x.n_consts + 1 + x.n_cols + 1,
+ (x.n_entries / x.n_cols) * 3 / 2 * proc->n_cells + 10);
+ tab_headers (table, x.n_consts + 1, 0, 2, 0);
/* First header line. */
- tab_joint_text (table, pt->n_consts + 1, 0,
- (pt->n_consts + 1) + (pt->n_cols - 1), 0,
- TAB_CENTER | TAT_TITLE, var_get_name (pt->vars[COL_VAR]));
+ tab_joint_text (table, x.n_consts + 1, 0,
+ (x.n_consts + 1) + (x.n_cols - 1), 0,
+ TAB_CENTER | TAT_TITLE, var_get_name (x.vars[COL_VAR]));
- tab_hline (table, TAL_1, pt->n_consts + 1,
- pt->n_consts + 2 + pt->n_cols - 2, 1);
+ tab_hline (table, TAL_1, x.n_consts + 1,
+ x.n_consts + 2 + x.n_cols - 2, 1);
/* Second header line. */
- for (i = 2; i < pt->n_consts + 2; i++)
- tab_joint_text (table, pt->n_consts + 2 - i - 1, 0,
- pt->n_consts + 2 - i - 1, 1,
- TAB_RIGHT | TAT_TITLE, var_to_string (pt->vars[i]));
- tab_text (table, pt->n_consts + 2 - 2, 1, TAB_RIGHT | TAT_TITLE,
- var_get_name (pt->vars[ROW_VAR]));
- for (i = 0; i < pt->n_cols; i++)
- table_value_missing (proc, table, pt->n_consts + 2 + i - 1, 1, TAB_RIGHT,
- &pt->cols[i], pt->vars[COL_VAR]);
- tab_text (table, pt->n_consts + 2 + pt->n_cols - 1, 1, TAB_CENTER, _("Total"));
-
- tab_hline (table, TAL_1, 0, pt->n_consts + 2 + pt->n_cols - 1, 2);
- tab_vline (table, TAL_1, pt->n_consts + 2 + pt->n_cols - 1, 0, 1);
+ for (i = 2; i < x.n_consts + 2; i++)
+ tab_joint_text (table, x.n_consts + 2 - i - 1, 0,
+ x.n_consts + 2 - i - 1, 1,
+ TAB_RIGHT | TAT_TITLE, var_to_string (x.vars[i]));
+ tab_text (table, x.n_consts + 2 - 2, 1, TAB_RIGHT | TAT_TITLE,
+ var_get_name (x.vars[ROW_VAR]));
+ for (i = 0; i < x.n_cols; i++)
+ table_value_missing (proc, table, x.n_consts + 2 + i - 1, 1, TAB_RIGHT,
+ &x.cols[i], x.vars[COL_VAR]);
+ tab_text (table, x.n_consts + 2 + x.n_cols - 1, 1, TAB_CENTER, _("Total"));
+
+ tab_hline (table, TAL_1, 0, x.n_consts + 2 + x.n_cols - 1, 2);
+ tab_vline (table, TAL_1, x.n_consts + 2 + x.n_cols - 1, 0, 1);
/* Title. */
ds_init_empty (&title);
- for (i = 0; i < pt->n_consts + 2; i++)
+ for (i = 0; i < x.n_consts + 2; i++)
{
if (i)
ds_put_cstr (&title, " * ");
- ds_put_cstr (&title, var_get_name (pt->vars[i]));
+ ds_put_cstr (&title, var_get_name (x.vars[i]));
}
for (i = 0; i < pt->n_consts; i++)
{
/* Insert the formatted value of the variable, then trim
leading spaces in what was just inserted. */
ofs = ds_length (&title);
- s = data_out (&pt->const_values[i], dict_get_encoding (proc->dict), var_get_print_format (var));
+ s = data_out (&pt->const_values[i], var_get_encoding (var),
+ var_get_print_format (var));
ds_put_cstr (&title, s);
free (s);
ds_remove (&title, ofs, ss_cspan (ds_substr (&title, ofs, SIZE_MAX),
tab_text (chisq, 1, 0, TAB_RIGHT | TAT_TITLE, _("Value"));
tab_text (chisq, 2, 0, TAB_RIGHT | TAT_TITLE, _("df"));
tab_text (chisq, 3, 0, TAB_RIGHT | TAT_TITLE,
- _("Asymp. Sig. (2-sided)"));
- tab_text (chisq, 4, 0, TAB_RIGHT | TAT_TITLE,
- _("Exact Sig. (2-sided)"));
- tab_text (chisq, 5, 0, TAB_RIGHT | TAT_TITLE,
- _("Exact Sig. (1-sided)"));
+ _("Asymp. Sig. (2-tailed)"));
+ tab_text_format (chisq, 4, 0, TAB_RIGHT | TAT_TITLE,
+ _("Exact Sig. (%d-tailed)"), 2);
+ tab_text_format (chisq, 5, 0, TAB_RIGHT | TAT_TITLE,
+ _("Exact Sig. (%d-tailed)"), 1);
tab_offset (chisq, 0, 1);
return chisq;
/* Prepare table T for submission, and submit it. */
static void
-submit (struct crosstabs_proc *proc, struct pivot_table *pt,
- struct tab_table *t)
+submit (struct pivot_table *pt, struct tab_table *t)
{
- struct crosstabs_dim_aux *aux;
int i;
if (t == NULL)
tab_resize (t, -1, 0);
if (tab_nr (t) == tab_t (t))
{
- tab_destroy (t);
+ table_unref (&t->table);
return;
}
tab_offset (t, 0, 0);
tab_nr (t) - 1);
tab_vline (t, TAL_2, tab_l (t), 0, tab_nr (t) - 1);
- aux = xmalloc (sizeof *aux);
- aux->exclude = proc->exclude;
- tab_dim (t, crosstabs_dim, crosstabs_dim_free, aux);
-
tab_submit (t);
}
-/* Sets the widths of all the columns and heights of all the rows in
- table T for driver D. */
-static void
-crosstabs_dim (struct tab_rendering *r, void *aux_)
-{
- const struct tab_table *t = r->table;
- struct outp_driver *d = r->driver;
- struct crosstabs_dim_aux *aux = aux_;
- int i;
-
- /* Width of a numerical column. */
- int c = outp_string_width (d, "0.000000", OUTP_PROPORTIONAL);
- if (aux->exclude == MV_NEVER)
- c += outp_string_width (d, "M", OUTP_PROPORTIONAL);
-
- /* Set width for header columns. */
- if (tab_l (t) != 0)
- {
- size_t i;
- int w;
-
- w = d->width - c * (tab_nc (t) - tab_l (t));
- for (i = 0; i <= tab_nc (t); i++)
- w -= r->wrv[i];
- w /= tab_l (t);
-
- if (w < d->prop_em_width * 8)
- w = d->prop_em_width * 8;
-
- if (w > d->prop_em_width * 15)
- w = d->prop_em_width * 15;
-
- for (i = 0; i < tab_l (t); i++)
- r->w[i] = w;
- }
-
- for (i = tab_l (t); i < tab_nc (t); i++)
- r->w[i] = c;
-
- for (i = 0; i < tab_nr (t); i++)
- r->h[i] = tab_natural_height (r, i);
-}
-
-static void
-crosstabs_dim_free (void *aux_)
-{
- struct crosstabs_dim_aux *aux = aux_;
- free (aux);
-}
-
static bool
find_crosstab (struct pivot_table *pt, size_t *row0p, size_t *row1p)
{
return value_compare_3way (a, b, *width);
}
+/* Inverted version of the above */
+static int
+compare_value_3way_inv (const void *a_, const void *b_, const void *width_)
+{
+ return -compare_value_3way (a_, b_, width_);
+}
+
+
/* Given an array of ENTRY_CNT table_entry structures starting at
ENTRIES, creates a sorted list of the values that the variable
with index VAR_IDX takes on. The values are returned as a
*/
static void
enum_var_values (const struct pivot_table *pt, int var_idx,
- union value **valuesp, int *n_values)
+ union value **valuesp, int *n_values, bool descending)
{
const struct variable *var = pt->vars[var_idx];
struct var_range *range = get_var_range (var);
values[i++] = *iter;
hmapx_destroy (&set);
- sort (values, *n_values, sizeof *values, compare_value_3way, &width);
+ sort (values, *n_values, sizeof *values,
+ descending ? compare_value_3way_inv : compare_value_3way,
+ &width);
}
}
display_dimensions (struct crosstabs_proc *proc, struct pivot_table *pt,
struct tab_table *table, int first_difference)
{
- tab_hline (table, TAL_1, pt->n_vars - first_difference - 1, tab_nc (table) - 1, 0);
+ tab_hline (table, TAL_1, pt->n_consts + pt->n_vars - first_difference - 1, tab_nc (table) - 1, 0);
for (; first_difference >= 2; first_difference--)
- table_value_missing (proc, table, pt->n_vars - first_difference - 1, 0,
+ table_value_missing (proc, table, pt->n_consts + pt->n_vars - first_difference - 1, 0,
TAB_RIGHT, &pt->entries[0]->values[first_difference],
pt->vars[first_difference]);
}
tab_text_format (table, c, r, TAB_RIGHT, "%s%s",
s + strspn (s, " "), suffixes);
+
+ free (s);
}
/* Displays the crosstabulation table. */
double *mp;
for (r = 0; r < pt->n_rows; r++)
- table_value_missing (proc, table, pt->n_vars - 2, r * proc->n_cells,
- TAB_RIGHT, &pt->rows[r], pt->vars[ROW_VAR]);
+ table_value_missing (proc, table, pt->n_consts + pt->n_vars - 2,
+ r * proc->n_cells, TAB_RIGHT, &pt->rows[r],
+ pt->vars[ROW_VAR]);
tab_text (table, pt->n_vars - 2, pt->n_rows * proc->n_cells,
TAB_LEFT, _("Total"));
/* Put in the actual cells. */
mp = pt->mat;
- tab_offset (table, pt->n_vars - 1, -1);
+ tab_offset (table, pt->n_consts + pt->n_vars - 1, -1);
for (r = 0; r < pt->n_rows; r++)
{
if (proc->n_cells > 1)