const struct variable *clabels_example;
struct hmap clabels_values_map;
- union value *clabels_values;
+ struct ctables_value **clabels_values;
size_t n_clabels_values;
enum pivot_axis_type slabels_axis;
case CTSF_LAYERPCT_SUM:
case CTSF_LAYERROWPCT_SUM:
case CTSF_LAYERCOLPCT_SUM:
- moments1_add (s->moments, value->f, weight);
+ if (!var_is_value_missing (var, value))
+ moments1_add (s->moments, value->f, weight);
break;
case CTSF_MEDIAN:
}
}
+static void
+recurse_subtotals (struct ctables_table *t, const struct ccase *c,
+ size_t ix[PIVOT_N_AXES],
+ const struct ctables_category *cats[PIVOT_N_AXES][10],
+ double 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_nest *nest = &t->stacks[a].nests[ix[a]];
+ for (size_t i = start_nest; i < nest->n; i++)
+ {
+ if (i == nest->scale_idx)
+ continue;
+
+ const struct ctables_category *save = cats[a][i];
+ if (save->subtotal)
+ {
+ cats[a][i] = save->subtotal;
+ ctables_cell_add__ (t, c, ix, cats, weight);
+ recurse_subtotals (t, c, ix, cats, weight, a, i + 1);
+ cats[a][i] = save;
+ }
+ }
+ start_nest = 0;
+ }
+}
+
static void
ctables_cell_insert (struct ctables_table *t,
const struct ccase *c,
ctables_cell_add__ (t, c, ix, cats, weight);
recurse_totals (t, c, ix, cats, weight, 0, 0);
-
- for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
- {
- const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
- for (size_t i = 0; i < nest->n; i++)
- {
- if (i == nest->scale_idx)
- continue;
-
- const struct ctables_category *save = cats[a][i];
- if (save->subtotal)
- {
- cats[a][i] = save->subtotal;
- ctables_cell_add__ (t, c, ix, cats, weight);
- cats[a][i] = save;
- }
- }
- }
+ recurse_subtotals (t, c, ix, cats, weight, 0, 0);
}
struct merge_item
pivot_table_set_caption (
pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
- bool summary_dimension = t->summary_axis != t->slabels_axis;
+ bool summary_dimension = (t->summary_axis != t->slabels_axis
+ || (!t->slabels_visible
+ && t->summary_specs.n > 1));
if (summary_dimension)
{
struct pivot_dimension *d = pivot_dimension_create (
- pt, t->slabels_axis, N_("Summaries"));
+ pt, t->slabels_axis, N_("Statistics"));
const struct ctables_summary_spec_set *specs = &t->summary_specs;
+ if (!t->slabels_visible)
+ d->hide_all_labels = true;
for (size_t i = 0; i < specs->n; i++)
pivot_category_create_leaf (
d->root, pivot_value_new_text (specs->specs[i].label));
const struct ctables_categories *c = t->categories[var_get_dict_index (var)];
for (size_t i = 0; i < t->n_clabels_values; i++)
{
- const union value *value = &t->clabels_values[i];
- const struct ctables_category *cat = ctables_categories_match (c, value, var);
- if (!cat)
- {
- pivot_category_create_leaf (d->root, pivot_value_new_integer (value->f)); /* XXX */
- continue;
- }
+ const struct ctables_value *value = t->clabels_values[i];
+ const struct ctables_category *cat = ctables_categories_match (c, &value->value, var);
+ assert (cat != NULL);
pivot_category_create_leaf (d->root, ctables_category_create_label (
- cat, t->clabels_example, value));
+ cat, t->clabels_example, &value->value));
}
}
if (new_subtable)
{
n_levels = 0;
- printf ("%s levels:", pivot_axis_type_to_string (a));
for (size_t k = 0; k < nest->n; k++)
{
enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])];
if (vlabel != CTVL_NONE)
{
- printf (" var(%s)", var_get_name (nest->vars[k]));
levels[n_levels++] = (struct ctables_level) {
.type = CTL_VAR,
.var_idx = k,
if (nest->scale_idx != k
&& (k != nest->n - 1 || t->label_axis[a] == a))
{
- printf (" category(%s)", var_get_name (nest->vars[k]));
levels[n_levels++] = (struct ctables_level) {
.type = CTL_CATEGORY,
.var_idx = k,
}
}
- if (a == t->slabels_axis && a == t->summary_axis)
+ if (!summary_dimension && a == t->slabels_axis)
{
- printf (" summary");
levels[n_levels++] = (struct ctables_level) {
.type = CTL_SUMMARY,
.var_idx = SIZE_MAX,
};
}
- printf ("\n");
}
size_t n_common = 0;
if (level->type == CTL_CATEGORY)
{
size_t var_idx = level->var_idx;
- if (prev->axes[a].cvs[var_idx].category
- != cell->axes[a].cvs[var_idx].category)
- {
- break;
- }
- else if (!value_equal (&prev->axes[a].cvs[var_idx].value,
- &cell->axes[a].cvs[var_idx].value,
- var_get_type (nest->vars[var_idx])))
- {
- break;
- }
+ const struct ctables_category *c = cell->axes[a].cvs[var_idx].category;
+ if (prev->axes[a].cvs[var_idx].category != c)
+ break;
+ else if (c->type != CCT_SUBTOTAL
+ && c->type != CCT_HSUBTOTAL
+ && c->type != CCT_TOTAL
+ && !value_equal (&prev->axes[a].cvs[var_idx].value,
+ &cell->axes[a].cvs[var_idx].value,
+ var_get_type (nest->vars[var_idx])))
+ break;
}
}
}
const struct variable *var = clabels_nest->vars[clabels_nest->n - 1];
const union value *value = &cell->axes[t->clabels_from_axis].cvs[clabels_nest->n - 1].value;
const struct ctables_value *ctv = ctables_value_find (t, value, var_get_width (var));
-
- printf ("leaf=%d\n", ctv ? ctv->leaf : 0);
- dindexes[n_dindexes++] = ctv ? ctv->leaf : 0; /* XXX */
- //dindexes[n_dindexes++] = 0;
+ assert (ctv != NULL);
+ dindexes[n_dindexes++] = ctv->leaf;
}
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
for (size_t i = 0; i < stack->n; i++)
{
const struct ctables_nest *nest = &stack->nests[i];
- const struct variable *v = nest->vars[nest->n - 1];
- int width = var_get_width (v);
- const union value *value = case_data (c, v);
+ const struct variable *var = nest->vars[nest->n - 1];
+ int width = var_get_width (var);
+ const union value *value = case_data (c, var);
+
+ if (var_is_numeric (var) && value->f == SYSMIS)
+ continue;
+
+ if (!ctables_categories_match (t->categories [var_get_dict_index (var)],
+ value, var))
+ continue;
+
unsigned int hash = value_hash (value, width, 0);
struct ctables_value *clv = ctables_value_find__ (t, value, width, hash);
static int
compare_clabels_values_3way (const void *a_, const void *b_, const void *width_)
{
- const union value *a = a_;
- const union value *b = b_;
+ const struct ctables_value *const *ap = a_;
+ const struct ctables_value *const *bp = b_;
+ const struct ctables_value *a = *ap;
+ const struct ctables_value *b = *bp;
const int *width = width_;
- return value_compare_3way (a, b, *width);
+ return value_compare_3way (&a->value, &b->value, *width);
}
static void
struct ctables_value *clv;
size_t i = 0;
HMAP_FOR_EACH (clv, struct ctables_value, node, &t->clabels_values_map)
- {
- clv->leaf = i;
- t->clabels_values[i] = clv->value;
- i++;
- }
+ t->clabels_values[i++] = clv;
t->n_clabels_values = n;
assert (i == n);
sort (t->clabels_values, n, sizeof *t->clabels_values,
compare_clabels_values_3way, &width);
+
+ for (size_t i = 0; i < n; i++)
+ t->clabels_values[i]->leaf = i;
}
static bool