struct
{
- size_t stack_idx;
+ size_t nest_idx;
struct ctables_cell_value
{
const struct ctables_category *category;
{
struct hmap_node node;
union value value;
+ int leaf;
};
struct ctables_table
}
}
-static double UNUSED
+static double
ctables_summary_value (const struct ctables_cell *cell,
union ctables_summary *s,
const struct ctables_summary_spec *ss)
const struct ctables_cell *a = *ap;
const struct ctables_cell *b = *bp;
- size_t a_idx = a->axes[aux->a].stack_idx;
- size_t b_idx = b->axes[aux->a].stack_idx;
+ size_t a_idx = a->axes[aux->a].nest_idx;
+ size_t b_idx = b->axes[aux->a].nest_idx;
if (a_idx != b_idx)
return a_idx < b_idx ? -1 : 1;
size_t hash = 0;
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
{
- size_t idx = cell->axes[a].stack_idx;
+ size_t idx = cell->axes[a].nest_idx;
const struct ctables_nest *nest = &t->stacks[a].nests[idx];
hash = hash_int (idx, hash);
for (size_t i = 0; i < nest->n_domains[domain]; i++)
const struct ctables_cell *df = d->example;
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
{
- size_t idx = cell->axes[a].stack_idx;
- if (idx != df->axes[a].stack_idx)
+ size_t idx = cell->axes[a].nest_idx;
+ if (idx != df->axes[a].nest_idx)
goto not_equal;
const struct ctables_nest *nest = &t->stacks[a].nests[idx];
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
{
const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
- if (cell->axes[a].stack_idx != ix[a])
+ if (cell->axes[a].nest_idx != ix[a])
goto not_equal;
for (size_t i = 0; i < nest->n; i++)
if (i != nest->scale_idx
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
{
const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
- cell->axes[a].stack_idx = ix[a];
+ cell->axes[a].nest_idx = ix[a];
cell->axes[a].cvs = (nest->n
? xnmalloc (nest->n, sizeof *cell->axes[a].cvs)
: NULL);
: pivot_value_new_var_value (var, value));
}
+static struct ctables_value *
+ctables_value_find__ (struct ctables_table *t, const union value *value,
+ int width, unsigned int hash)
+{
+ struct ctables_value *clv;
+ HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node,
+ hash, &t->clabels_values_map)
+ if (value_equal (value, &clv->value, width))
+ return clv;
+ return NULL;
+}
+
+static struct ctables_value *
+ctables_value_find (struct ctables_table *t,
+ const union value *value, int width)
+{
+ return ctables_value_find__ (t, value, width,
+ value_hash (value, width, 0));
+}
+
static void
-ctables_table_output_different_axis (struct ctables *ct, struct ctables_table *t)
+ctables_table_output (struct ctables *ct, struct ctables_table *t)
{
struct pivot_table *pt = pivot_table_create__ (
(t->title
pivot_table_set_caption (
pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
- if (t->summary_axis != t->slabels_axis)
+ bool summary_dimension = t->summary_axis != t->slabels_axis;
+ if (summary_dimension)
{
struct pivot_dimension *d = pivot_dimension_create (
pt, t->slabels_axis, N_("Summaries"));
d->root, pivot_value_new_text (specs->specs[i].label));
}
- if (t->clabels_example)
+ bool categories_dimension = t->clabels_example != NULL;
+ if (categories_dimension)
{
struct pivot_dimension *d = pivot_dimension_create (
pt, t->label_axis[t->clabels_from_axis],
const struct ctables_category *cat = ctables_categories_match (c, value, var);
if (!cat)
{
- /* XXX probably missing */
+ pivot_category_create_leaf (d->root, pivot_value_new_integer (value->f)); /* XXX */
continue;
}
pivot_category_create_leaf (d->root, ctables_category_create_label (
{
struct ctables_cell *cell = sorted[j];
struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL;
- const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].stack_idx];
+ const struct ctables_nest *nest = &t->stacks[a].nests[cell->axes[a].nest_idx];
- bool new_subtable = !prev || prev->axes[a].stack_idx != cell->axes[a].stack_idx;
+ bool new_subtable = !prev || prev->axes[a].nest_idx != cell->axes[a].nest_idx;
if (new_subtable)
{
n_levels = 0;
{
const struct ctables_summary_spec_set *specs = &t->summary_specs;
for (size_t m = 0; m < specs->n; m++)
- pivot_category_create_leaf (
- parent, pivot_value_new_text (specs->specs[m].label));
+ {
+ int leaf = pivot_category_create_leaf (
+ parent, pivot_value_new_text (specs->specs[m].label));
+ if (!m)
+ prev_leaf = leaf;
+ }
}
else
{
NOT_REACHED ();
if (k == n_levels - 1)
- pivot_category_create_leaf (parent, label);
+ prev_leaf = pivot_category_create_leaf (parent, label);
else
groups[k] = pivot_category_create_group__ (parent, label);
}
free (sorted);
free (groups);
}
+
+ struct ctables_cell *cell;
+ HMAP_FOR_EACH (cell, struct ctables_cell, node, &t->cells)
+ {
+ if (cell->hide)
+ continue;
+
+ const struct ctables_nest *specs_nest = &t->stacks[t->summary_axis].nests[cell->axes[t->summary_axis].nest_idx];
+ const struct ctables_summary_spec_set *specs = &specs_nest->specs[cell->sv];
+ for (size_t j = 0; j < specs->n; j++)
+ {
+ size_t dindexes[5];
+ size_t n_dindexes = 0;
+
+ if (summary_dimension)
+ dindexes[n_dindexes++] = specs->specs[j].axis_idx;
+
+ if (categories_dimension)
+ {
+ const struct ctables_nest *clabels_nest = &t->stacks[t->clabels_from_axis].nests[cell->axes[t->clabels_from_axis].nest_idx];
+ 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;
+ }
+
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ if (d[a])
+ {
+ int leaf = cell->axes[a].leaf;
+ if (a == t->summary_axis && !summary_dimension)
+ leaf += j;
+ dindexes[n_dindexes++] = leaf;
+ }
+
+ double d = ctables_summary_value (cell, &cell->summaries[j], &specs->specs[j]);
+ struct pivot_value *value = pivot_value_new_number (d);
+ value->numeric.format = specs->specs[j].format;
+ pivot_table_put (pt, dindexes, n_dindexes, value);
+ }
+ }
+
pivot_table_submit (pt);
}
const union value *value = case_data (c, v);
unsigned int hash = value_hash (value, width, 0);
- struct ctables_value *clv;
- HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node, hash,
- &t->clabels_values_map)
- if (value_equal (value, &clv->value, width))
- goto next_stack;
-
- clv = xmalloc (sizeof *clv);
- value_clone (&clv->value, value, width);
- hmap_insert (&t->clabels_values_map, &clv->node, hash);
-
- next_stack: ;
+ struct ctables_value *clv = ctables_value_find__ (t, value, width, hash);
+ if (!clv)
+ {
+ clv = xmalloc (sizeof *clv);
+ value_clone (&clv->value, value, width);
+ hmap_insert (&t->clabels_values_map, &clv->node, hash);
+ }
}
}
size_t n = hmap_count (&t->clabels_values_map);
t->clabels_values = xnmalloc (n, sizeof *t->clabels_values);
- const struct ctables_value *clv;
+ struct ctables_value *clv;
size_t i = 0;
HMAP_FOR_EACH (clv, struct ctables_value, node, &t->clabels_values_map)
- t->clabels_values[i++] = clv->value;
+ {
+ clv->leaf = i;
+ t->clabels_values[i] = clv->value;
+ i++;
+ }
t->n_clabels_values = n;
assert (i == n);
if (t->clabels_example)
ctables_sort_clabels_values (t);
- ctables_table_output_different_axis (ct, ct->tables[i]);
+ ctables_table_output (ct, ct->tables[i]);
}
return proc_commit (ds);
}