#undef S
};
+enum ctables_domain_type
+ {
+ /* Within a section, where stacked variables divide one section from
+ another. */
+ CTDT_TABLE, /* All layers of a whole section. */
+ CTDT_LAYER, /* One layer within a section. */
+ CTDT_LAYERROW, /* Row in one layer within a section. */
+ CTDT_LAYERCOL, /* Column in one layer within a section. */
+
+ /* Within a subtable, where a subtable pairs an innermost row variable with
+ an innermost column variable within a single layer. */
+ CTDT_SUBTABLE, /* Whole subtable. */
+ CTDT_ROW, /* Row within a subtable. */
+ CTDT_COL, /* Column within a subtable. */
+#define N_CTDTS 7
+ };
+
+struct ctables_domain
+ {
+ struct hmap_node node;
+
+ const struct ctables_freq *example;
+
+ double valid;
+ double missing;
+ };
+
+struct ctables_freq
+ {
+ /* In struct ctables's 'ft' hmap. Indexed by all the values in all the
+ axes (except the scalar variable, if any). */
+ struct hmap_node node;
+
+ /* The domains that contains this cell. */
+ struct ctables_domain *domains[N_CTDTS];
+
+ struct
+ {
+ size_t vaa_idx;
+ union value *values;
+ int leaf;
+ }
+ axes[PIVOT_N_AXES];
+
+ union ctables_summary *summaries;
+ };
+
struct ctables
{
struct pivot_table_look *look;
{
struct variable **vars;
size_t n;
+ size_t scale_idx;
+ size_t *domains[N_CTDTS];
+ size_t n_domains[N_CTDTS];
struct ctables_summary_spec *summaries;
size_t n_summaries;
struct var_array2 vaas[PIVOT_N_AXES];
enum pivot_axis_type summary_axis;
struct hmap ft;
+ struct hmap domains[N_CTDTS];
enum pivot_axis_type slabels_position;
bool slabels_visible;
struct ctables_chisq *chisq;
struct ctables_pairwise *pairwise;
-
};
struct ctables_var
};
};
+static const struct ctables_cat_value *ctables_categories_match (
+ const struct ctables_categories *, const union value *,
+ const struct variable *);
+
static void
ctables_cat_value_uninit (struct ctables_cat_value *cv)
{
NOT_REACHED ();
vaa.vas[vaa.n++] = (struct var_array) {
.vars = vars,
+ .scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx
+ : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx
+ : SIZE_MAX),
.n = n,
.summaries = summary_src->summaries,
.n_summaries = summary_src->n_summaries,
{
case CTAO_VAR:
assert (!a->var.is_mrset);
+
+ struct variable **vars = xmalloc (sizeof *vars);
+ *vars = a->var.var;
+
struct var_array *va = xmalloc (sizeof *va);
- if (a->scale)
- *va = (struct var_array) { .n = 0 };
- else
- {
- struct variable **vars = xmalloc (sizeof *vars);
- *vars = a->var.var;
- enum pivot_axis_type *axes = xmalloc (sizeof *axes);
- *axes = axis_type;
- *va = (struct var_array) { .vars = vars, .n = 1 };
- }
+ *va = (struct var_array) {
+ .vars = vars,
+ .n = 1,
+ .scale_idx = a->scale ? 0 : SIZE_MAX,
+ };
if (a->n_summaries || a->scale)
{
va->summaries = a->summaries;
}
static double
-ctables_summary_value (union ctables_summary *s,
+ctables_summary_value (const struct ctables_freq *f,
+ union ctables_summary *s,
const struct ctables_summary_spec *ss)
{
switch (ss->function)
case CTSF_ECOUNT:
return s->valid;
+ case CTSF_SUBTABLEPCT_COUNT:
+ return f->domains[CTDT_SUBTABLE]->valid ? s->valid / f->domains[CTDT_SUBTABLE]->valid * 100 : SYSMIS;
+
case CTSF_ROWPCT_COUNT:
+ return f->domains[CTDT_ROW]->valid ? s->valid / f->domains[CTDT_ROW]->valid * 100 : SYSMIS;
+
case CTSF_COLPCT_COUNT:
+ return f->domains[CTDT_COL]->valid ? s->valid / f->domains[CTDT_COL]->valid * 100 : SYSMIS;
+
case CTSF_TABLEPCT_COUNT:
- case CTSF_SUBTABLEPCT_COUNT:
+ return f->domains[CTDT_TABLE]->valid ? s->valid / f->domains[CTDT_TABLE]->valid * 100 : SYSMIS;
+
case CTSF_LAYERPCT_COUNT:
+ return f->domains[CTDT_LAYER]->valid ? s->valid / f->domains[CTDT_LAYER]->valid * 100 : SYSMIS;
+
case CTSF_LAYERROWPCT_COUNT:
+ return f->domains[CTDT_LAYERROW]->valid ? s->valid / f->domains[CTDT_LAYERROW]->valid * 100 : SYSMIS;
+
case CTSF_LAYERCOLPCT_COUNT:
+ return f->domains[CTDT_LAYERCOL]->valid ? s->valid / f->domains[CTDT_LAYERCOL]->valid * 100 : SYSMIS;
+
case CTSF_ROWPCT_VALIDN:
case CTSF_COLPCT_VALIDN:
case CTSF_TABLEPCT_VALIDN:
NOT_REACHED ();
}
-struct ctables_freq
- {
- struct hmap_node node; /* Element in hash table. */
-
- struct
- {
- size_t vaa_idx;
- union value *values;
- int leaf;
- }
- axes[PIVOT_N_AXES];
-
- union ctables_summary *summaries;
- };
-
-#if 0
-static struct ctables_freq *
-ctables_freq_create (struct ctables_freqtab *ft)
-{
- struct ctables_freq *f = xmalloc (sizeof *f + ft->vars.n * sizeof *f->values);
- f->summaries = xmalloc (ft->n_summaries * sizeof *f->summaries);
- for (size_t i = 0; i < ft->n_summaries; i++)
- ctables_summary_init (&f->summaries[i], &ft->summaries[i]);
- return f;
-}
-
-static void
-ctables_freq_add (struct ctables_freqtab *ft, struct ctables_freq *f,
- const struct variable *var, const union value *value,
- double weight)
-{
- for (size_t i = 0; i < ft->n_summaries; i++)
- ctables_summary_add (&f->summaries[i], &ft->summaries[i],
- var, value, weight);
-}
-#endif
-
struct ctables_freq_sort_aux
{
const struct ctables_table *t;
const struct var_array *va = &aux->t->vaas[aux->a].vas[a_idx];
for (size_t i = 0; i < va->n; i++)
- {
- int cmp = value_compare_3way (&a->axes[aux->a].values[i],
- &b->axes[aux->a].values[i],
- var_get_width (va->vars[i]));
- if (cmp)
+ if (i != va->scale_idx)
+ {
+ const struct variable *var = va->vars[i];
+ const union value *val_a = &a->axes[aux->a].values[i];
+ const union value *val_b = &b->axes[aux->a].values[i];
+ int cmp = value_compare_3way (val_a, val_b, var_get_width (var));
+ if (!cmp)
+ continue;
+
+ const struct ctables_categories *cats = aux->t->categories[var_get_dict_index (var)];
+ if (cats && cats->n_values)
+ {
+ const struct ctables_cat_value *a_cv = ctables_categories_match (cats, val_a, var);
+ const struct ctables_cat_value *b_cv = ctables_categories_match (cats, val_b, var);
+ assert (a_cv && b_cv);
+ return (a_cv == b_cv ? cmp
+ : a_cv > b_cv ? 1
+ : -1);
+ }
+
return cmp;
- }
+ }
return 0;
}
Fill the table entry using the indexes from before.
*/
+static struct ctables_domain *
+ctables_domain_insert (struct ctables_table *t, struct ctables_freq *f,
+ enum ctables_domain_type domain)
+{
+ size_t hash = 0;
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ {
+ size_t idx = f->axes[a].vaa_idx;
+ const struct var_array *va = &t->vaas[a].vas[idx];
+ hash = hash_int (idx, hash);
+ for (size_t i = 0; i < va->n_domains[domain]; i++)
+ {
+ size_t v_idx = va->domains[domain][i];
+ hash = value_hash (&f->axes[a].values[v_idx],
+ var_get_width (va->vars[v_idx]), hash);
+ }
+ }
+
+ struct ctables_domain *d;
+ HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &t->domains[domain])
+ {
+ const struct ctables_freq *df = d->example;
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ {
+ size_t idx = f->axes[a].vaa_idx;
+ if (idx != df->axes[a].vaa_idx)
+ goto not_equal;
+
+ const struct var_array *va = &t->vaas[a].vas[idx];
+ for (size_t i = 0; i < va->n_domains[domain]; i++)
+ {
+ size_t v_idx = va->domains[domain][i];
+ if (!value_equal (&df->axes[a].values[v_idx],
+ &f->axes[a].values[v_idx],
+ var_get_width (va->vars[v_idx])))
+ goto not_equal;
+ }
+ }
+ return d;
+
+ not_equal: ;
+ }
+
+ d = xmalloc (sizeof *d);
+ *d = (struct ctables_domain) { .example = f };
+ hmap_insert (&t->domains[domain], &d->node, hash);
+ return d;
+}
+
+static const struct ctables_cat_value *
+ctables_categories_match (const struct ctables_categories *cats,
+ const union value *v, const struct variable *var)
+{
+ const struct ctables_cat_value *othernm = NULL;
+ for (size_t i = cats->n_values; i-- > 0; )
+ {
+ const struct ctables_cat_value *cv = &cats->values[i];
+ switch (cv->type)
+ {
+ case CCVT_NUMBER:
+ if (cv->number == v->f)
+ return cv;
+ break;
+
+ case CCVT_STRING:
+ NOT_REACHED ();
+
+ case CCVT_RANGE:
+ if ((cv->range[0] == -DBL_MAX || v->f >= cv->range[0])
+ && (cv->range[1] == DBL_MAX || v->f <= cv->range[1]))
+ return cv;
+ break;
+
+ case CCVT_MISSING:
+ if (var_is_value_missing (var, v))
+ return cv;
+ break;
+
+ case CCVT_OTHERNM:
+ if (!othernm)
+ othernm = cv;
+ break;
+
+ case CCVT_SUBTOTAL:
+ case CCVT_HSUBTOTAL:
+ break;
+ }
+ }
+
+ return var_is_value_missing (var, v) ? NULL : othernm;
+}
+
static void
ctables_freqtab_insert (struct ctables_table *t,
const struct ccase *c,
};
const struct var_array *ss = &t->vaas[t->summary_axis].vas[ix[t->summary_axis]];
+ for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
+ {
+ const struct var_array *va = &t->vaas[a].vas[ix[a]];
+ for (size_t i = 0; i < va->n; i++)
+ {
+ if (i == va->scale_idx)
+ continue;
+
+ const struct ctables_categories *cats = t->categories[var_get_dict_index (va->vars[i])];
+ if (!cats || !cats->n_values)
+ continue;
+
+ if (!ctables_categories_match (cats, case_data (c, va->vars[i]), va->vars[i]))
+ return;
+ }
+ }
+
size_t hash = 0;
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
{
const struct var_array *va = &t->vaas[a].vas[ix[a]];
hash = hash_int (ix[a], hash);
for (size_t i = 0; i < va->n; i++)
- hash = value_hash (case_data (c, va->vars[i]),
- var_get_width (va->vars[i]), hash);
+ if (i != va->scale_idx)
+ hash = value_hash (case_data (c, va->vars[i]),
+ var_get_width (va->vars[i]), hash);
}
struct ctables_freq *f;
if (f->axes[a].vaa_idx != ix[a])
goto not_equal;
for (size_t i = 0; i < va->n; i++)
- if (!value_equal (case_data (c, va->vars[i]),
- &f->axes[a].values[i],
- var_get_width (va->vars[i])))
- goto not_equal;
+ if (i != va->scale_idx
+ && !value_equal (case_data (c, va->vars[i]),
+ &f->axes[a].values[i],
+ var_get_width (va->vars[i])))
+ goto not_equal;
}
goto summarize;
f->summaries = xmalloc (ss->n_summaries * sizeof *f->summaries);
for (size_t i = 0; i < ss->n_summaries; i++)
ctables_summary_init (&f->summaries[i], &ss->summaries[i]);
+ for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+ f->domains[dt] = ctables_domain_insert (t, f, dt);
hmap_insert (&t->ft, &f->node, hash);
summarize:
for (size_t i = 0; i < ss->n_summaries; i++)
ctables_summary_add (&f->summaries[i], &ss->summaries[i], ss->summary_var,
case_data (c, ss->summary_var), weight);
+ for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+ f->domains[dt]->valid += weight;
}
static bool
struct ctables_table *t = ct->tables[i];
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
if (t->axes[a])
- t->vaas[a] = enumerate_fts (a, t->axes[a]);
+ {
+ t->vaas[a] = enumerate_fts (a, t->axes[a]);
+
+ for (size_t j = 0; j < t->vaas[a].n; j++)
+ {
+ struct var_array *va = &t->vaas[a].vas[j];
+ for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+ {
+ va->domains[dt] = xmalloc (va->n * sizeof *va->domains[dt]);
+ va->n_domains[dt] = 0;
+
+ for (size_t k = 0; k < va->n; k++)
+ {
+ if (k == va->scale_idx)
+ continue;
+
+ switch (dt)
+ {
+ case CTDT_TABLE:
+ continue;
+
+ case CTDT_LAYER:
+ if (a != PIVOT_AXIS_LAYER)
+ continue;
+ break;
+
+ case CTDT_SUBTABLE:
+ case CTDT_ROW:
+ case CTDT_COL:
+ if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER
+ : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN
+ : a == PIVOT_AXIS_ROW)
+ {
+ if (k == va->n - 1
+ || (va->scale_idx == va->n - 1
+ && k == va->n - 2))
+ continue;
+ }
+ break;
+
+ case CTDT_LAYERROW:
+ if (a == PIVOT_AXIS_COLUMN)
+ continue;
+ break;
+
+ case CTDT_LAYERCOL:
+ if (a == PIVOT_AXIS_ROW)
+ continue;
+ break;
+ }
+
+ va->domains[dt][va->n_domains[dt]++] = k;
+ }
+ }
+ }
+ }
else
{
struct var_array *va = xmalloc (sizeof *va);
dataset_dict (ds),
NULL, NULL);
bool warn_on_invalid = true;
+ double total_weight = 0;
for (struct ccase *c = casereader_read (input); c;
case_unref (c), c = casereader_read (input))
{
double weight = dict_get_case_weight (dataset_dict (ds), c,
&warn_on_invalid);
+ total_weight += weight;
for (size_t i = 0; i < ct->n_tables; i++)
{
{
struct ctables_table *t = ct->tables[i];
- struct pivot_table *pt = pivot_table_create (N_("Custom Tables"));
+ struct pivot_table *pt = pivot_table_create__ (
+ (t->title
+ ? pivot_value_new_user_text (t->title, SIZE_MAX)
+ : pivot_value_new_text (N_("Custom Tables"))),
+ NULL);
+ if (t->caption)
+ pivot_table_set_caption (
+ pt, pivot_value_new_user_text (t->caption, SIZE_MAX));
+ if (t->corner)
+ pivot_table_set_caption (
+ pt, pivot_value_new_user_text (t->corner, SIZE_MAX));
+
pivot_table_set_look (pt, ct->look);
struct pivot_dimension *d[PIVOT_N_AXES];
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
if (prev->axes[a].vaa_idx == f->axes[a].vaa_idx)
{
for (; n_common < va->n; n_common++)
- if (!value_equal (&prev->axes[a].values[n_common],
- &f->axes[a].values[n_common],
- var_get_type (va->vars[n_common])))
+ if (n_common != va->scale_idx
+ && !value_equal (&prev->axes[a].values[n_common],
+ &f->axes[a].values[n_common],
+ var_get_type (va->vars[n_common])))
break;
}
else
{
struct pivot_category *parent = k > 0 ? groups[k - 1] : top;
- struct pivot_value *label = pivot_value_new_var_value (
- va->vars[k], &f->axes[a].values[k]);
-
+ struct pivot_value *label
+ = (k != va->scale_idx
+ ? pivot_value_new_var_value (va->vars[k],
+ &f->axes[a].values[k])
+ : NULL);
if (k == va->n - 1)
{
if (a == t->summary_axis)
{
- parent = pivot_category_create_group__ (parent, label);
+ if (label)
+ parent = pivot_category_create_group__ (parent, label);
for (size_t m = 0; m < va->n_summaries; m++)
{
int leaf = pivot_category_create_leaf (
}
}
else
- prev_leaf = pivot_category_create_leaf (parent, label);
+ {
+ /* This assertion is true as long as the summary axis
+ is the axis where the summaries are displayed. */
+ assert (label);
+
+ prev_leaf = pivot_category_create_leaf (parent, label);
+ }
break;
}
- parent = pivot_category_create_group__ (parent, label);
+ if (label)
+ parent = pivot_category_create_group__ (parent, label);
enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (va->vars[k + 1])];
if (vlabel != CTVL_NONE)
dindexes[n_dindexes++] = leaf;
}
- double value = ctables_summary_value (&f->summaries[j], &ss->summaries[j]);
- pivot_table_put (pt, dindexes, n_dindexes,
- pivot_value_new_number (value));
+ double d = ctables_summary_value (f, &f->summaries[j], &ss->summaries[j]);
+ struct pivot_value *value = pivot_value_new_number (d);
+ value->numeric.format = ss->summaries[j].format;
+ pivot_table_put (pt, dindexes, n_dindexes, value);
}
}
.n_categories = dict_get_n_vars (dataset_dict (ds)),
.cilevel = 95,
};
+ for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+ hmap_init (&t->domains[dt]);
ct->tables[ct->n_tables++] = t;
lex_match (lexer, T_EQUALS);
projects / pspp / blobdiff