struct variable **vars;
size_t n;
size_t scale_idx;
+ size_t summary_idx;
size_t *areas[N_CTATS];
size_t n_areas[N_CTATS];
size_t group_head;
*/
enum pivot_axis_type label_axis[PIVOT_N_AXES];
enum pivot_axis_type clabels_from_axis;
+ enum pivot_axis_type clabels_to_axis;
const struct variable *clabels_example;
struct hmap clabels_values_map;
struct ctables_value **clabels_values;
struct ctables_summary_spec
{
+ /* The calculation to be performed.
+
+ 'function' is the function to calculate. 'weighted' specifies whether
+ to use weighted or unweighted data (for functions that do not support a
+ choice, it must be true). 'calc_area' is the area over which the
+ calculation takes place (for functions that target only an individual
+ cell, it must be 0). For CTSF_PTILE only, 'percentile' is the
+ percentile between 0 and 100 (for other functions it must be 0). */
enum ctables_summary_function function;
bool weighted;
- enum ctables_area_type area;
+ enum ctables_area_type calc_area;
double percentile; /* CTSF_PTILE only. */
- char *label;
+ /* How to display the result of the calculation.
+
+ 'label' is a user-specified label, NULL if the user didn't specify
+ one.
+
+ 'user_area' is usually the same as 'calc_area', but when category labels
+ are rotated from one axis to another it swaps rows and columns.
+
+ 'format' is the format for displaying the output. If
+ 'is_ctables_format' is true, then 'format.type' is one of the special
+ CTEF_* formats instead of the standard ones. */
+ char *label;
+ enum ctables_area_type user_area;
struct fmt_spec format;
bool is_ctables_format; /* Is 'format' one of CTEF_*? */
ctables_summary_label__ (const struct ctables_summary_spec *spec)
{
bool w = spec->weighted;
- enum ctables_area_type a = spec->area;
+ enum ctables_area_type a = spec->user_area;
switch (spec->function)
{
case CTSF_COUNT:
*dst = (struct ctables_summary_spec) {
.function = function,
.weighted = weighted,
- .area = area,
+ .calc_area = area,
+ .user_area = area,
.percentile = percentile,
.label = xstrdup_if_nonnull (label),
.format = (format ? *format
.scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx
: b->scale_idx != SIZE_MAX ? a->n + b->scale_idx
: SIZE_MAX),
+ .summary_idx = (a->summary_idx != SIZE_MAX ? a->summary_idx
+ : b->summary_idx != SIZE_MAX ? a->n + b->summary_idx
+ : SIZE_MAX),
.n = n,
};
for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
struct variable **vars = xmalloc (sizeof *vars);
*vars = a->var;
+ bool is_summary = a->specs[CSV_CELL].n || a->scale;
struct ctables_nest *nest = xmalloc (sizeof *nest);
*nest = (struct ctables_nest) {
.vars = vars,
.n = 1,
.scale_idx = a->scale ? 0 : SIZE_MAX,
+ .summary_idx = is_summary ? 0 : SIZE_MAX,
};
- if (a->specs[CSV_CELL].n || a->scale)
+ if (is_summary)
for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
{
ctables_summary_spec_set_clone (&nest->specs[sv], &a->specs[sv]);
break;
case CTSF_MEAN:
+ case CTSF_SUM:
+ case CTSF_areaPCT_SUM:
+ s->moments = moments1_create (MOMENT_MEAN);
+ break;
+
case CTSF_SEMEAN:
case CTSF_STDDEV:
- case CTSF_SUM:
case CTSF_VARIANCE:
- case CTSF_areaPCT_SUM:
s->moments = moments1_create (MOMENT_VARIANCE);
break;
const struct ctables_summary_spec *ss,
const struct variable *var, const union value *value,
bool is_scale, bool is_scale_missing,
- bool is_missing, bool excluded_missing,
+ bool is_missing, bool is_included,
double d_weight, double e_weight)
{
/* To determine whether a case is included in a given table for a particular
switch (ss->function)
{
case CTSF_TOTALN:
- case CTSF_areaPCT_TOTALN:
s->count += ss->weighted ? d_weight : 1.0;
break;
+ case CTSF_areaPCT_TOTALN:
+ s->count += ss->weighted ? e_weight : 1.0;
+ break;
+
case CTSF_COUNT:
- case CTSF_areaPCT_COUNT:
- if (is_scale || !excluded_missing)
+ if (is_scale || is_included)
s->count += ss->weighted ? d_weight : 1.0;
break;
+ case CTSF_areaPCT_COUNT:
+ if (is_scale || is_included)
+ s->count += ss->weighted ? e_weight : 1.0;
+ break;
+
case CTSF_VALIDN:
- case CTSF_areaPCT_VALIDN:
if (is_scale
? !is_scale_missing
: !is_missing)
s->count += ss->weighted ? d_weight : 1.0;
break;
+ case CTSF_areaPCT_VALIDN:
+ if (is_scale
+ ? !is_scale_missing
+ : !is_missing)
+ s->count += ss->weighted ? e_weight : 1.0;
+ break;
+
case CTSF_areaID:
break;
if (is_scale
? is_scale_missing
: is_missing)
- s->count += ss->weighted ? d_weight : 1.0;
+ s->count += ss->weighted ? e_weight : 1.0;
break;
case CTSF_ECOUNT:
- if (is_scale || !excluded_missing)
+ if (is_scale || is_included)
s->count += e_weight;
break;
case CTSF_STDDEV:
case CTSF_SUM:
case CTSF_VARIANCE:
- case CTSF_areaPCT_SUM:
if (!is_scale_missing)
moments1_add (s->moments, value->f, ss->weighted ? e_weight : 1.0);
break;
+ case CTSF_areaPCT_SUM:
+ if (!is_missing && !is_scale_missing)
+ moments1_add (s->moments, value->f, ss->weighted ? e_weight : 1.0);
+ break;
+
case CTSF_MEDIAN:
case CTSF_MODE:
case CTSF_PTILE:
return s->count;
case CTSF_areaID:
- return cell->areas[ss->area]->sequence;
+ return cell->areas[ss->calc_area]->sequence;
case CTSF_areaPCT_COUNT:
{
- const struct ctables_area *a = cell->areas[ss->area];
+ const struct ctables_area *a = cell->areas[ss->calc_area];
double a_count = ss->weighted ? a->e_count : a->u_count;
return a_count ? s->count / a_count * 100 : SYSMIS;
}
case CTSF_areaPCT_VALIDN:
{
- const struct ctables_area *a = cell->areas[ss->area];
+ const struct ctables_area *a = cell->areas[ss->calc_area];
double a_valid = ss->weighted ? a->e_valid : a->u_valid;
return a_valid ? s->count / a_valid * 100 : SYSMIS;
}
case CTSF_areaPCT_TOTALN:
{
- const struct ctables_area *a = cell->areas[ss->area];
+ const struct ctables_area *a = cell->areas[ss->calc_area];
double a_total = ss->weighted ? a->e_total : a->u_total;
return a_total ? s->count / a_total * 100 : SYSMIS;
}
if (weight == SYSMIS || mean == SYSMIS)
return SYSMIS;
- const struct ctables_area *a = cell->areas[ss->area];
+ const struct ctables_area *a = cell->areas[ss->calc_area];
const struct ctables_sum *sum = &a->sums[ss->sum_var_idx];
double denom = ss->weighted ? sum->e_sum : sum->u_sum;
return denom != 0 ? weight * mean / denom * 100 : SYSMIS;
}
static bool
-is_scale_missing (const struct ctables_summary_spec_set *specs,
- const struct ccase *c)
+is_listwise_missing (const struct ctables_summary_spec_set *specs,
+ const struct ccase *c)
{
- if (!specs->is_scale)
- return false;
-
- if (var_is_num_missing (specs->var, case_num (c, specs->var)))
- return true;
-
for (size_t i = 0; i < specs->n_listwise_vars; i++)
{
const struct variable *var = specs->listwise_vars[i];
static void
ctables_cell_add__ (struct ctables_section *s, const struct ccase *c,
const struct ctables_category *cats[PIVOT_N_AXES][10],
- bool is_missing, bool excluded_missing,
- double d_weight, double e_weight)
+ bool is_included, double d_weight, double e_weight)
{
struct ctables_cell *cell = ctables_cell_insert__ (s, c, cats);
const struct ctables_nest *ss = s->nests[s->table->summary_axis];
const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv];
+ const union value *value = case_data (c, specs->var);
+ bool is_missing = var_is_value_missing (specs->var, value);
+ bool scale_missing = specs->is_scale && (is_missing || is_listwise_missing (specs, c));
- bool scale_missing = is_scale_missing (specs, c);
for (size_t i = 0; i < specs->n; i++)
- ctables_summary_add (&cell->summaries[i], &specs->specs[i],
- specs->var, case_data (c, specs->var), specs->is_scale,
- scale_missing, is_missing, excluded_missing,
+ ctables_summary_add (&cell->summaries[i], &specs->specs[i],
+ specs->var, value, specs->is_scale,
+ scale_missing, is_missing, is_included,
d_weight, e_weight);
for (enum ctables_area_type at = 0; at < N_CTATS; at++)
if (!(cell->omit_areas && (1u << at)))
a->d_total += d_weight;
a->e_total += e_weight;
a->u_total += 1.0;
- if (!excluded_missing)
+ if (is_included)
{
a->d_count += d_weight;
a->e_count += e_weight;
static void
recurse_totals (struct ctables_section *s, const struct ccase *c,
const struct ctables_category *cats[PIVOT_N_AXES][10],
- bool is_missing, bool excluded_missing,
- double d_weight, double e_weight,
+ bool is_included, double d_weight, double e_weight,
enum pivot_axis_type start_axis, size_t start_nest)
{
for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++)
{
const struct ctables_category *save = cats[a][i];
cats[a][i] = total;
- ctables_cell_add__ (s, c, cats, is_missing, excluded_missing,
- d_weight, e_weight);
- recurse_totals (s, c, cats, is_missing, excluded_missing,
- d_weight, e_weight, a, i + 1);
+ ctables_cell_add__ (s, c, cats, is_included, d_weight, e_weight);
+ recurse_totals (s, c, cats, is_included, d_weight, e_weight, a, i + 1);
cats[a][i] = save;
}
}
static void
recurse_subtotals (struct ctables_section *s, const struct ccase *c,
const struct ctables_category *cats[PIVOT_N_AXES][10],
- bool is_missing, bool excluded_missing,
- double d_weight, double e_weight,
+ bool is_included, double d_weight, double e_weight,
enum pivot_axis_type start_axis, size_t start_nest)
{
for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++)
if (save->subtotal)
{
cats[a][i] = save->subtotal;
- ctables_cell_add__ (s, c, cats, is_missing, excluded_missing,
- d_weight, e_weight);
- recurse_subtotals (s, c, cats, is_missing, excluded_missing,
- d_weight, e_weight, a, i + 1);
+ ctables_cell_add__ (s, c, cats, is_included, d_weight, e_weight);
+ recurse_subtotals (s, c, cats, is_included, d_weight, e_weight, a, i + 1);
cats[a][i] = save;
}
}
{
const struct ctables_category *cats[PIVOT_N_AXES][10]; /* XXX */
- /* Does at least one categorical variable have a missing value in an included
- or excluded category? */
- bool is_missing = false;
-
- /* Does at least one categorical variable have a missing value in an excluded
- category? */
- bool excluded_missing = false;
+ bool is_included = true;
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
{
const struct ctables_nest *nest = s->nests[a];
for (size_t i = 0; i < nest->n; i++)
- {
- if (i == nest->scale_idx)
- continue;
-
- const struct variable *var = nest->vars[i];
- const union value *value = case_data (c, var);
-
- bool var_missing = var_is_value_missing (var, value) != 0;
- if (var_missing)
- is_missing = true;
-
- cats[a][i] = ctables_categories_match (
- s->table->categories[var_get_dict_index (var)], value, var);
- if (!cats[a][i])
- {
- if (!var_missing)
- return;
+ if (i != nest->scale_idx)
+ {
+ const struct variable *var = nest->vars[i];
+ const union value *value = case_data (c, var);
- static const struct ctables_category cct_excluded_missing = {
- .type = CCT_EXCLUDED_MISSING,
- .hide = true,
- };
- cats[a][i] = &cct_excluded_missing;
- excluded_missing = true;
- }
+ cats[a][i] = ctables_categories_match (
+ s->table->categories[var_get_dict_index (var)], value, var);
+ if (!cats[a][i])
+ {
+ if (i != nest->summary_idx)
+ return;
+
+ if (!var_is_value_missing (var, value))
+ return;
+
+ static const struct ctables_category cct_excluded_missing = {
+ .type = CCT_EXCLUDED_MISSING,
+ .hide = true,
+ };
+ cats[a][i] = &cct_excluded_missing;
+ is_included = false;
+ }
}
}
- if (!excluded_missing)
+ if (is_included)
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
{
const struct ctables_nest *nest = s->nests[a];
}
}
- ctables_cell_add__ (s, c, cats, is_missing, excluded_missing,
- d_weight, e_weight);
-
- //if (!excluded_missing)
- {
- recurse_totals (s, c, cats, is_missing, excluded_missing,
- d_weight, e_weight, 0, 0);
- recurse_subtotals (s, c, cats, is_missing, excluded_missing,
- d_weight, e_weight, 0, 0);
- }
+ ctables_cell_add__ (s, c, cats, is_included, d_weight, e_weight);
+ recurse_totals (s, c, cats, is_included, d_weight, e_weight, 0, 0);
+ recurse_subtotals (s, c, cats, is_included, d_weight, e_weight, 0, 0);
}
struct merge_item
return as->function > bs->function ? 1 : -1;
else if (as->weighted != bs->weighted)
return as->weighted > bs->weighted ? 1 : -1;
- else if (as->area != bs->area)
- return as->area > bs->area ? 1 : -1;
+ else if (as->calc_area != bs->calc_area)
+ return as->calc_area > bs->calc_area ? 1 : -1;
else if (as->percentile != bs->percentile)
return as->percentile < bs->percentile ? 1 : -1;
for (size_t i = 0; i < nest->n; i++)
hmap_init (&s->occurrences[a][i]);
}
- for (size_t i = 0; i < N_CTATS; i++)
- hmap_init (&s->areas[i]);
+ for (enum ctables_area_type at = 0; at < N_CTATS; at++)
+ hmap_init (&s->areas[at]);
}
}
const struct ctables_summary_spec *ss2 = &pc->specs->specs[i];
if (ss->function == ss2->function
&& ss->weighted == ss2->weighted
- && ss->area == ss2->area
+ && ss->calc_area == ss2->calc_area
&& ss->percentile == ss2->percentile)
{
*format = ss2->format;
if (label_pos == a)
return true;
- t->clabels_from_axis = a;
-
const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS";
const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE";
return (*n)++;
}
+static enum ctables_area_type
+rotate_area (enum ctables_area_type area)
+{
+ return area;
+ switch (area)
+ {
+ case CTAT_TABLE:
+ case CTAT_LAYER:
+ case CTAT_SUBTABLE:
+ return area;
+
+ case CTAT_LAYERROW:
+ return CTAT_LAYERCOL;
+
+ case CTAT_LAYERCOL:
+ return CTAT_LAYERROW;
+
+ case CTAT_ROW:
+ return CTAT_COL;
+
+ case CTAT_COL:
+ return CTAT_ROW;
+ }
+
+ NOT_REACHED ();
+}
+
static void
enumerate_sum_vars (const struct ctables_axis *a,
struct variable ***sum_vars, size_t *n, size_t *allocated)
nest->areas[at] = xmalloc (nest->n * sizeof *nest->areas[at]);
nest->n_areas[at] = 0;
+ enum pivot_axis_type ata, atb;
+ if (at == CTAT_ROW || at == CTAT_LAYERROW)
+ {
+ ata = PIVOT_AXIS_ROW;
+ atb = PIVOT_AXIS_COLUMN;
+ }
+ else if (at == CTAT_COL || at == CTAT_LAYERCOL)
+ {
+ ata = PIVOT_AXIS_COLUMN;
+ atb = PIVOT_AXIS_ROW;
+ }
+
+ if (at == CTAT_LAYER
+ ? a != PIVOT_AXIS_LAYER && t->label_axis[a] == PIVOT_AXIS_LAYER
+ : at == CTAT_LAYERCOL || at == CTAT_LAYERROW
+ ? a == atb && t->label_axis[a] != a
+ : false)
+ {
+ for (size_t k = nest->n - 1; k < nest->n; k--)
+ if (k != nest->scale_idx)
+ {
+ nest->areas[at][nest->n_areas[at]++] = k;
+ break;
+ }
+ continue;
+ }
+
+ if (at == CTAT_LAYER ? a != PIVOT_AXIS_LAYER
+ : at == CTAT_LAYERROW || at == CTAT_LAYERCOL ? a == atb
+ : at == CTAT_TABLE ? true
+ : false)
+ continue;
+
for (size_t k = 0; k < nest->n; k++)
+ if (k != nest->scale_idx)
+ nest->areas[at][nest->n_areas[at]++] = k;
+
+ int n_drop;
+ switch (at)
{
- if (k == nest->scale_idx)
- continue;
+ case CTAT_SUBTABLE:
+#define L PIVOT_AXIS_LAYER
+ n_drop = (t->clabels_from_axis == L ? a != L
+ : t->clabels_to_axis == L ? (t->clabels_from_axis == a ? -1 : a != L)
+ : t->clabels_from_axis == a ? 2
+ : 0);
+#undef L
+ break;
+
+ case CTAT_LAYERROW:
+ case CTAT_LAYERCOL:
+ n_drop = a == ata && t->label_axis[ata] == atb;
+ break;
+
+ case CTAT_ROW:
+ case CTAT_COL:
+ n_drop = (a == ata ? t->label_axis[ata] == atb
+ : a != atb ? 0
+ : t->clabels_from_axis == atb ? -1
+ : t->clabels_to_axis != atb ? 1
+ : 0);
+ break;
+
+ case CTAT_LAYER:
+ case CTAT_TABLE:
+ n_drop = 0;
+ break;
+ }
- switch (at)
+ if (n_drop < 0)
+ {
+ size_t n = nest->n_areas[at];
+ if (n > 1)
{
- case CTAT_TABLE:
- continue;
-
- case CTAT_LAYER:
- if (a != PIVOT_AXIS_LAYER)
- continue;
- break;
-
- case CTAT_SUBTABLE:
- case CTAT_ROW:
- case CTAT_COL:
- if (at == CTAT_SUBTABLE ? a != PIVOT_AXIS_LAYER
- : at == CTAT_ROW ? a == PIVOT_AXIS_COLUMN
- : a == PIVOT_AXIS_ROW)
- {
- if (k == nest->n - 1
- || (nest->scale_idx == nest->n - 1
- && k == nest->n - 2))
- continue;
- }
- break;
-
- case CTAT_LAYERROW:
- if (a == PIVOT_AXIS_COLUMN)
- continue;
- break;
-
- case CTAT_LAYERCOL:
- if (a == PIVOT_AXIS_ROW)
- continue;
- break;
+ nest->areas[at][n - 2] = nest->areas[at][n - 1];
+ nest->n_areas[at]--;
}
-
- nest->areas[at][nest->n_areas[at]++] = k;
+ }
+ else
+ {
+ for (int i = 0; i < n_drop; i++)
+ if (nest->n_areas[at] > 0)
+ nest->n_areas[at]--;
}
}
}
else
{
struct ctables_nest *nest = xmalloc (sizeof *nest);
- *nest = (struct ctables_nest) { .n = 0 };
+ *nest = (struct ctables_nest) {
+ .n = 0,
+ .scale_idx = SIZE_MAX,
+ .summary_idx = SIZE_MAX
+ };
t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 };
/* There's no point in moving labels away from an axis that has no
struct ctables_nest *nest = &stack->nests[i];
if (!nest->specs[CSV_CELL].n)
{
- struct ctables_summary_spec_set *specs = &nest->specs[CSV_CELL];
- specs->specs = xmalloc (sizeof *specs->specs);
- specs->n = 1;
+ struct ctables_summary_spec_set *ss = &nest->specs[CSV_CELL];
+ ss->specs = xmalloc (sizeof *ss->specs);
+ ss->n = 1;
enum ctables_summary_function function
- = specs->is_scale ? CTSF_MEAN : CTSF_COUNT;
+ = ss->is_scale ? CTSF_MEAN : CTSF_COUNT;
- *specs->specs = (struct ctables_summary_spec) {
+ if (!ss->var)
+ {
+ nest->summary_idx = nest->n - 1;
+ ss->var = nest->vars[nest->summary_idx];
+ }
+ *ss->specs = (struct ctables_summary_spec) {
.function = function,
.weighted = true,
- .format = ctables_summary_default_format (function, specs->var),
+ .format = ctables_summary_default_format (function, ss->var),
};
- if (!specs->var)
- specs->var = nest->vars[0];
ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL],
&nest->specs[CSV_CELL]);
ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL],
&nest->specs[CSV_CELL]);
+ if (t->label_axis[PIVOT_AXIS_ROW] == PIVOT_AXIS_COLUMN
+ || t->label_axis[PIVOT_AXIS_COLUMN] == PIVOT_AXIS_ROW)
+ {
+ for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
+ for (size_t i = 0; i < nest->specs[sv].n; i++)
+ {
+ struct ctables_summary_spec *ss = &nest->specs[sv].specs[i];
+ const struct ctables_function_info *cfi =
+ &ctables_function_info[ss->function];
+ if (cfi->is_area)
+ ss->calc_area = rotate_area (ss->calc_area);
+ }
+ }
+
if (t->ctables->smissing_listwise)
{
struct variable **listwise_vars = NULL;
}
hmap_destroy (&s->cells);
- for (size_t i = 0; i < N_CTATS; i++)
- hmap_destroy (&s->areas[i]);
+ for (enum ctables_area_type at = 0; at < N_CTATS; at++)
+ hmap_destroy (&s->areas[at]);
}
static void
for (struct ccase *c = casereader_read (group); c;
case_unref (c), c = casereader_read (group))
{
- double d_weight = dict_get_case_weight (dict, c, &warn_on_invalid);
+ double d_weight = dict_get_rounded_case_weight (dict, c, &warn_on_invalid);
double e_weight = (ct->e_weight
? var_force_valid_weight (ct->e_weight,
case_num (c, ct->e_weight),
sss->specs[sss->n++] = (struct ctables_summary_spec) {
.function = function,
.weighted = weighted,
- .area = area,
+ .calc_area = area,
+ .user_area = area,
.percentile = percentile,
.format = format,
.is_ctables_format = is_ctables_format,
[PIVOT_AXIS_LAYER] = PIVOT_AXIS_LAYER,
},
.clabels_from_axis = PIVOT_AXIS_LAYER,
+ .clabels_to_axis = PIVOT_AXIS_LAYER,
.categories = categories,
.n_categories = n_vars,
.cilevel = 95,
break;
}
- if (t->label_axis[PIVOT_AXIS_ROW] != PIVOT_AXIS_ROW
- && t->label_axis[PIVOT_AXIS_COLUMN] != PIVOT_AXIS_COLUMN)
+ if (t->label_axis[PIVOT_AXIS_ROW] != PIVOT_AXIS_ROW)
{
- msg (SE, _("ROWLABELS and COLLABELS may not both be specified."));
- goto error;
+ t->clabels_from_axis = PIVOT_AXIS_ROW;
+ if (t->label_axis[PIVOT_AXIS_COLUMN] != PIVOT_AXIS_COLUMN)
+ {
+ msg (SE, _("ROWLABELS and COLLABELS may not both be specified."));
+ goto error;
+ }
}
+ else if (t->label_axis[PIVOT_AXIS_COLUMN] != PIVOT_AXIS_COLUMN)
+ t->clabels_from_axis = PIVOT_AXIS_COLUMN;
+ t->clabels_to_axis = t->label_axis[t->clabels_from_axis];
if (!ctables_prepare_table (t))
goto error;