/* 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, 2011, 2012, 2013 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 <stdlib.h>
#include <stdio.h>
-#include <data/case.h>
-#include <data/casegrouper.h>
-#include <data/casereader.h>
-#include <data/data-out.h>
-#include <data/dictionary.h>
-#include <data/format.h>
-#include <data/procedure.h>
-#include <data/value-labels.h>
-#include <data/variable.h>
-#include <language/command.h>
-#include <language/dictionary/split-file.h>
-#include <language/lexer/lexer.h>
-#include <language/lexer/variable-parser.h>
-#include <libpspp/array.h>
-#include <libpspp/assertion.h>
-#include <libpspp/compiler.h>
-#include <libpspp/hash.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 "minmax.h"
-#include "xalloc.h"
-#include "xsize.h"
+#include "data/case.h"
+#include "data/casegrouper.h"
+#include "data/casereader.h"
+#include "data/data-out.h"
+#include "data/dataset.h"
+#include "data/dictionary.h"
+#include "data/format.h"
+#include "data/value-labels.h"
+#include "data/variable.h"
+#include "language/command.h"
+#include "language/dictionary/split-file.h"
+#include "language/lexer/lexer.h"
+#include "language/lexer/variable-parser.h"
+#include "libpspp/array.h"
+#include "libpspp/assertion.h"
+#include "libpspp/compiler.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/tab.h"
+
+#include "gl/minmax.h"
+#include "gl/xalloc.h"
+#include "gl/xsize.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
+variables=custom;
missing=miss:!table/include/report;
+write[wr_]=none,cells,all;
- +format=fmt:!labels/nolabels/novallabs,
- val:!avalue/dvalue,
+ +format=val:!avalue/dvalue,
indx:!noindex/index,
tabl:!tables/notables,
box:!box/nobox,
/* A crosstabulation of 2 or more variables. */
struct pivot_table
{
+ struct crosstabs_proc *proc;
struct fmt_spec weight_format; /* Format for weight variable. */
double missing; /* Weight of missing cases. */
double total; /* Grand total. */
};
-/* A crosstabulation of exactly 2 variables, conditional on zero
- or more other variables having given values. */
-struct crosstab
- {
- /* Case counts. */
- double missing;
-
- /* Variables. */
- int n_vars; /* Number of variables (at least 2). */
- const struct variable **vars;
- union value *values; /* Values of variables beyond 2. */
-
- /* Data. */
- struct table_entry **entries;
- size_t n_entries;
-
- /* Column values, number of columns. */
- union value *cols;
- int n_cols;
-
- /* Row values, number of rows. */
- union value *rows;
- int n_rows;
-
- /* Number of statistically interesting columns/rows
- (columns/rows with data in them). */
- int ns_cols, ns_rows;
-
- /* Matrix contents. */
- double *mat; /* Matrix proper. */
- double *row_tot; /* Row totals. */
- double *col_tot; /* Column totals. */
- double total; /* Grand total. */
- };
-
/* Integer mode variable info. */
struct var_range
{
+ struct hmap_node hmap_node; /* In struct crosstabs_proc var_ranges map. */
+ const struct variable *var; /* The variable. */
int min; /* Minimum value. */
int max; /* Maximum value + 1. */
int count; /* max - min. */
};
-static inline struct var_range *
-get_var_range (const struct variable *v)
-{
- return var_get_aux (v);
-}
-
struct crosstabs_proc
{
+ const struct dictionary *dict;
enum { INTEGER, GENERAL } mode;
enum mv_class exclude;
bool pivot;
/* Variables specifies on VARIABLES. */
const struct variable **variables;
size_t n_variables;
+ struct hmap var_ranges;
/* TABLES. */
struct pivot_table *pivots;
/* STATISTICS. */
unsigned int statistics; /* Bit k is 1 if statistic k is requested. */
+
+ 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->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;
-}
+const struct var_range *get_var_range (const struct crosstabs_proc *,
+ const struct variable *);
-static void
-free_proc (struct crosstabs_proc *proc UNUSED)
-{
- /* XXX */
-}
-
-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 var_range *range, *next_range;
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;
+ hmap_init (&proc.var_ranges);
+ proc.pivots = NULL;
+ proc.n_pivots = 0;
+ proc.descending = false;
+ proc.weight_format = wv ? *var_get_print_format (wv) : F_8_0;
+
+ if (!parse_crosstabs (lexer, ds, &cmd, &proc))
+ {
+ result = CMD_FAILURE;
+ goto exit;
+ }
+
+ proc.mode = proc.n_variables ? INTEGER : GENERAL;
+
- 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.exclude == MV_NEVER)
{
msg (SE, _("Missing mode REPORT not allowed in general mode. "
"Assuming MISSING=TABLE."));
- proc->mode = MV_ANY;
+ proc.exclude = 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);
+ HMAP_FOR_EACH_SAFE (range, next_range, struct var_range, hmap_node,
+ &proc.var_ranges)
+ {
+ hmap_delete (&proc.var_ranges, &range->hmap_node);
+ free (range);
+ }
+ 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
struct pivot_table *pt = &proc->pivots[proc->n_pivots++];
int j;
+ pt->proc = proc;
pt->weight_format = proc->weight_format;
pt->missing = 0.;
pt->n_vars = n_by;
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++)
{
+ const struct variable *var = proc->variables[i];
struct var_range *vr = xmalloc (sizeof *vr);
+
+ vr->var = var;
vr->min = min;
vr->max = max + 1.;
vr->count = max - min + 1;
- var_attach_aux (proc->variables[i], vr, var_dtor_free);
+ hmap_insert (&proc->var_ranges, &vr->hmap_node,
+ hash_pointer (var, 0));
}
- if (lex_token (lexer) == '/')
+ if (lex_token (lexer) == T_SLASH)
break;
}
\f
/* Data file processing. */
+const struct var_range *
+get_var_range (const struct crosstabs_proc *proc, const struct variable *var)
+{
+ if (!hmap_is_empty (&proc->var_ranges))
+ {
+ const struct var_range *range;
+
+ HMAP_FOR_EACH_IN_BUCKET (range, struct var_range, hmap_node,
+ hash_pointer (var, 0), &proc->var_ranges)
+ if (range->var == var)
+ return range;
+ }
+
+ return NULL;
+}
+
static bool
should_tabulate_case (const struct pivot_table *pt, const struct ccase *c,
enum mv_class exclude)
for (j = 0; j < pt->n_vars; j++)
{
const struct variable *var = pt->vars[j];
- struct var_range *range = get_var_range (var);
+ const struct var_range *range = get_var_range (pt->proc, var);
if (var_is_value_missing (var, case_data (c, var), exclude))
return false;
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);
}
}
- /* XXX clear output and prepare for next split file. */
+ /* Free output and prepare for next split file. */
+ for (pt = &proc->pivots[0]; pt < &proc->pivots[proc->n_pivots]; pt++)
+ {
+ size_t i;
+
+ pt->missing = 0.0;
+
+ /* Free the members that were allocated in this function(and the values
+ owned by the entries.
+
+ The other pointer members are either both allocated and destroyed at a
+ lower level (in output_pivot_table), or both allocated and destroyed
+ at a higher level (in crs_custom_tables and free_proc,
+ respectively). */
+ for (i = 0; i < pt->n_vars; i++)
+ {
+ int width = var_get_width (pt->vars[i]);
+ if (value_needs_init (width))
+ {
+ size_t j;
+
+ for (j = 0; j < pt->n_entries; j++)
+ value_destroy (&pt->entries[j]->values[i], width);
+ }
+ }
+
+ for (i = 0; i < pt->n_entries; i++)
+ free (pt->entries[i]);
+ free (pt->entries);
+ }
}
static void
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)
{
struct string name;
int i;
- summary = tab_create (7, 3 + proc->n_pivots, 1);
+ summary = tab_create (7, 3 + proc->n_pivots);
tab_title (summary, _("Summary."));
tab_headers (summary, 1, 0, 3, 0);
tab_joint_text (summary, 1, 0, 6, 0, TAB_CENTER, _("Cases"));
{
tab_double (summary, i * 2 + 1, 0, TAB_RIGHT, n[i],
&proc->weight_format);
- tab_text (summary, i * 2 + 2, 0, TAB_RIGHT | TAT_PRINTF, "%.1f%%",
- n[i] / n[2] * 100.);
+ tab_text_format (summary, i * 2 + 2, 0, TAB_RIGHT, "%.1f%%",
+ n[i] / n[2] * 100.);
}
tab_next_row (summary);
}
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_table *, struct outp_driver *,
- void *proc);
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_to_string (pt->vars[0]));
+ for (i = 1; i < pt->n_vars; i++)
+ ds_put_format (&vars, " * %s", var_to_string (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);
+ free (pt->cols);
+ 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))))
if (chisq)
{
display_dimensions (proc, &x, chisq, first_difference);
- display_chisq (pt, chisq, &showed_fisher);
+ display_chisq (&x, chisq, &showed_fisher);
}
if (sym)
{
display_dimensions (proc, &x, sym, first_difference);
- display_symmetric (proc, pt, sym);
+ display_symmetric (proc, &x, sym);
}
if (risk)
{
display_dimensions (proc, &x, risk, first_difference);
- display_risk (pt, risk);
+ display_risk (&x, risk);
}
if (direct)
{
display_dimensions (proc, &x, direct, first_difference);
- display_directional (proc, pt, direct);
+ display_directional (proc, &x, direct);
}
- /* XXX Free data in x. */
+ /* Free the parts of x that are not owned by pt. In
+ particular we must not free x.cols, which is the same as
+ pt->cols, which is freed at the end of this function. */
free (x.rows);
+
+ free (x.mat);
+ free (x.row_tot);
+ 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,
- true);
- 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_to_string (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_to_string (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_to_string (x.vars[i]));
}
for (i = 0; i < pt->n_consts; i++)
{
const struct variable *var = pt->const_vars[i];
- ds_put_format (&title, ", %s=", var_get_name (var));
- data_out (&pt->const_values[i], var_get_print_format (var),
- ds_put_uninit (&title, var_get_width (var)));
- /* XXX remove any leading space in what was just inserted. */
+ char *s;
+
+ ds_put_format (&title, ", %s=", var_to_string (var));
+
+ /* Insert the formatted value of VAR without any leading spaces. */
+ s = data_out (&pt->const_values[i], var_get_encoding (var),
+ var_get_print_format (var));
+ ds_put_cstr (&title, s + strspn (s, " "));
+ free (s);
}
ds_put_cstr (&title, " [");
struct tab_table *chisq;
chisq = tab_create (6 + (pt->n_vars - 2),
- pt->n_entries / pt->n_cols * 3 / 2 * N_CHISQ + 10,
- 1);
+ pt->n_entries / pt->n_cols * 3 / 2 * N_CHISQ + 10);
tab_headers (chisq, 1 + (pt->n_vars - 2), 0, 1, 0);
tab_title (chisq, _("Chi-square tests."));
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)"));
- chisq = 0;
+ _("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;
struct tab_table *sym;
sym = tab_create (6 + (pt->n_vars - 2),
- pt->n_entries / pt->n_cols * 7 + 10, 1);
+ pt->n_entries / pt->n_cols * 7 + 10);
tab_headers (sym, 2 + (pt->n_vars - 2), 0, 1, 0);
tab_title (sym, _("Symmetric measures."));
{
struct tab_table *risk;
- risk = tab_create (4 + (pt->n_vars - 2), pt->n_entries / pt->n_cols * 4 + 10,
- 1);
+ risk = tab_create (4 + (pt->n_vars - 2), pt->n_entries / pt->n_cols * 4 + 10);
tab_headers (risk, 1 + pt->n_vars - 2, 0, 2, 0);
tab_title (risk, _("Risk estimate."));
tab_offset (risk, pt->n_vars - 2, 0);
- tab_joint_text (risk, 2, 0, 3, 0, TAB_CENTER | TAT_TITLE | TAT_PRINTF,
- _("95%% Confidence Interval"));
+ tab_joint_text_format (risk, 2, 0, 3, 0, TAB_CENTER | TAT_TITLE,
+ _("95%% Confidence Interval"));
tab_text (risk, 0, 1, TAB_LEFT | TAT_TITLE, _("Statistic"));
tab_text (risk, 1, 1, TAB_RIGHT | TAT_TITLE, _("Value"));
tab_text (risk, 2, 1, TAB_RIGHT | TAT_TITLE, _("Lower"));
struct tab_table *direct;
direct = tab_create (7 + (pt->n_vars - 2),
- pt->n_entries / pt->n_cols * 7 + 10, 1);
+ pt->n_entries / pt->n_cols * 7 + 10);
tab_headers (direct, 3 + (pt->n_vars - 2), 0, 1, 0);
tab_title (direct, _("Directional measures."));
/* 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)
{
int i;
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_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, proc);
- 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_table *t, struct outp_driver *d, void *proc_)
-{
- struct crosstabs_proc *proc = proc_;
- int i;
- /* Width of a numerical column. */
- int c = outp_string_width (d, "0.000000", OUTP_PROPORTIONAL);
- if (proc->exclude == MV_NEVER)
- c += outp_string_width (d, "M", OUTP_PROPORTIONAL);
-
- /* Set width for header columns. */
- if (t->l != 0)
- {
- 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;
-
- if (w > d->prop_em_width * 15)
- w = d->prop_em_width * 15;
-
- for (i = 0; i < t->l; i++)
- t->w[i] = w;
- }
-
- for (i = t->l; i < t->nc; i++)
- t->w[i] = c;
-
- for (i = 0; i < t->nr; i++)
- t->h[i] = tab_natural_height (t, d, i);
+ tab_submit (t);
}
static bool
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
malloc()'d array stored in *VALUES, with the number of values
stored in *VALUE_CNT.
- */
+
+ The caller must eventually free *VALUES, but each pointer in *VALUES points
+ to existing data not owned by *VALUES itself. */
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);
+ const struct var_range *range = get_var_range (pt->proc, var);
union value *values;
size_t i;
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);
}
}
struct tab_table *table, int c, int r, unsigned char opt,
const union value *v, const struct variable *var)
{
- struct substring s;
- const struct fmt_spec *print = var_get_print_format (var);
-
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, print->w);
- data_out (v, print, s.string);
- s.length = print->w;
- if (proc->exclude == MV_NEVER && var_is_num_missing (var, v->f, MV_USER))
- s.string[s.length++] = 'M';
- while (s.length && *s.string == ' ')
+ if (label != NULL)
+ tab_text (table, c, r, TAB_LEFT, label);
+ else
{
- s.length--;
- s.string++;
+ const struct fmt_spec *print = var_get_print_format (var);
+ if (proc->exclude == MV_NEVER && var_is_value_missing (var, v, MV_USER))
+ {
+ char *s = data_out (v, dict_get_encoding (proc->dict), print);
+ tab_text_format (table, c, r, opt, "%sM", s + strspn (s, " "));
+ free (s);
+ }
+ else
+ tab_value (table, c, r, opt, v, var, print);
}
- tab_raw (table, c, r, opt, &s);
}
/* Draws a line across TABLE at the current row to indicate the most
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]);
}
additionally suffixed with a letter `M'. */
static void
format_cell_entry (struct tab_table *table, int c, int r, double value,
- char suffix, bool mark_missing)
+ char suffix, bool mark_missing, const struct dictionary *dict)
{
- const struct fmt_spec f = {FMT_F, 10, 1};
union value v;
- struct substring s;
+ char suffixes[3];
+ int suffix_len;
+ char *s;
- s.length = 10;
- s.string = tab_alloc (table, 16);
v.f = value;
- data_out (&v, &f, s.string);
- while (*s.string == ' ')
- {
- s.length--;
- s.string++;
- }
+ s = data_out (&v, dict_get_encoding (dict), settings_get_format ());
+
+ suffix_len = 0;
if (suffix != 0)
- s.string[s.length++] = suffix;
+ suffixes[suffix_len++] = suffix;
if (mark_missing)
- s.string[s.length++] = 'M';
+ suffixes[suffix_len++] = 'M';
+ suffixes[suffix_len] = '\0';
+
+ tab_text_format (table, c, r, TAB_RIGHT, "%s%s",
+ s + strspn (s, " "), suffixes);
- tab_raw (table, c, r, TAB_RIGHT, &s);
+ 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)
default:
NOT_REACHED ();
}
- format_cell_entry (table, c, i, v, suffix, mark_missing);
+ format_cell_entry (table, c, i, v, suffix, mark_missing, proc->dict);
}
mp++;
NOT_REACHED ();
}
- format_cell_entry (table, pt->n_cols, 0, v, suffix, mark_missing);
+ format_cell_entry (table, pt->n_cols, 0, v, suffix, mark_missing, proc->dict);
tab_next_row (table);
}
}
NOT_REACHED ();
}
- format_cell_entry (table, c, i, v, suffix, mark_missing);
+ format_cell_entry (table, c, i, v, suffix, mark_missing, proc->dict);
}
last_row = i;
}
double chisq_v[N_CHISQ];
double fisher1, fisher2;
int df[N_CHISQ];
- int s = 0;
int i;
calc_chisq (pt, chisq_v, df, &fisher1, &fisher2);
- tab_offset (chisq, pt->n_vars - 2, -1);
+ tab_offset (chisq, pt->n_consts + pt->n_vars - 2, -1);
for (i = 0; i < N_CHISQ; i++)
{
if ((i != 2 && chisq_v[i] == SYSMIS)
|| (i == 2 && fisher1 == SYSMIS))
continue;
- s = 1;
tab_text (chisq, 0, 0, TAB_LEFT, gettext (chisq_stats[i]));
if (i != 2)
somers_d_v, somers_d_ase, somers_d_t))
return;
- tab_offset (sym, pt->n_vars - 2, -1);
+ tab_offset (sym, pt->n_consts + pt->n_vars - 2, -1);
for (i = 0; i < N_SYMMETRIC; i++)
{
if (!calc_risk (pt, risk_v, upper, lower, c))
return;
- tab_offset (risk, pt->n_vars - 2, -1);
+ tab_offset (risk, pt->n_consts + pt->n_vars - 2, -1);
for (i = 0; i < 3; i++)
{
case 0:
if (var_is_numeric (cv))
sprintf (buf, _("Odds Ratio for %s (%g / %g)"),
- var_get_name (cv), c[0].f, c[1].f);
+ var_to_string (cv), c[0].f, c[1].f);
else
sprintf (buf, _("Odds Ratio for %s (%.*s / %.*s)"),
- var_get_name (cv),
+ var_to_string (cv),
cvw, value_str (&c[0], cvw),
cvw, value_str (&c[1], cvw));
break;
case 2:
if (var_is_numeric (rv))
sprintf (buf, _("For cohort %s = %g"),
- var_get_name (rv), pt->rows[i - 1].f);
+ var_to_string (rv), pt->rows[i - 1].f);
else
sprintf (buf, _("For cohort %s = %.*s"),
- var_get_name (rv),
+ var_to_string (rv),
rvw, value_str (&pt->rows[i - 1], rvw));
break;
}
if (!calc_directional (proc, pt, direct_v, direct_ase, direct_t))
return;
- tab_offset (direct, pt->n_vars - 2, -1);
+ tab_offset (direct, pt->n_consts + pt->n_vars - 2, -1);
for (i = 0; i < N_DIRECTIONAL; i++)
{
if (k == 0)
string = NULL;
else if (k == 1)
- string = var_get_name (pt->vars[0]);
+ string = var_to_string (pt->vars[0]);
else
- string = var_get_name (pt->vars[1]);
+ string = var_to_string (pt->vars[1]);
- tab_text (direct, j, 0, TAB_LEFT | TAT_PRINTF,
- gettext (stats_names[j][k]), string);
+ tab_text_format (direct, j, 0, TAB_LEFT,
+ gettext (stats_names[j][k]), string);
}
}
}