axes[PIVOT_N_AXES];
union ctables_summary *summaries;
-
- //char *name;
};
struct ctables
return false;
struct substring name = lex_tokss (lexer);
+ if (ss_ends_with_case (name, ss_cstr (".LCL"))
+ || ss_ends_with_case (name, ss_cstr (".UCL"))
+ || ss_ends_with_case (name, ss_cstr (".SE")))
+ {
+ lex_error (lexer, _("Support for LCL, UCL, and SE summary functions "
+ "is not yet implemented."));
+ return false;
+ }
+
bool u = ss_match_byte (&name, 'U') || ss_match_byte (&name, 'u');
bool e = !u && (ss_match_byte (&name, 'E') || ss_match_byte (&name, 'e'));
static struct ctables_axis *ctables_axis_parse_stack (
struct ctables_axis_parse_ctx *);
-
static struct ctables_axis *
ctables_axis_parse_primary (struct ctables_axis_parse_ctx *ctx)
{
if (!lex_force_id (ctx->lexer))
return NULL;
+ if (lex_tokcstr (ctx->lexer)[0] == '$')
+ {
+ lex_error (ctx->lexer,
+ _("Multiple response set support not implemented."));
+ return NULL;
+ }
+
int start_ofs = lex_ofs (ctx->lexer);
struct variable *var = parse_variable (ctx->lexer, ctx->dict);
if (!var)
}
else if (!c->n_cats && lex_match_id (lexer, "KEY"))
{
+ int start_ofs = lex_ofs (lexer) - 1;
lex_match (lexer, T_EQUALS);
if (lex_match_id (lexer, "VALUE"))
cat.type = CCT_VALUE;
bool UNUSED b = lex_force_match (lexer, T_LPAREN);
goto error;
}
+
+ lex_ofs_error (lexer, start_ofs, lex_ofs (lexer) - 1,
+ _("Data-dependent sorting is not implemented."));
+ goto error;
}
}
else if (!c->n_cats && lex_match_id (lexer, "MISSING"))
double ovalid;
double ovalue;
};
-
- /* XXX multiple response */
};
static void
static void
ctables_summary_add (union ctables_summary *s,
const struct ctables_summary_spec *ss,
- const struct variable *var, const union value *value,
- bool is_scale, bool is_scale_missing,
+ const union value *value,
bool is_missing, bool is_included,
double weight)
{
/* To determine whether a case is included in a given table for a particular
- kind of summary, consider the following charts for each variable in the
- table. Only if "yes" appears for every variable for the summary is the
- case counted.
+ kind of summary, consider the following charts for the variable being
+ summarized. Only if "yes" appears is the case counted.
- Categorical variables: VALIDN COUNT TOTALN
+ Categorical variables: VALIDN other TOTALN
Valid values in included categories yes yes yes
Missing values in included categories --- yes yes
Missing values in excluded categories --- --- yes
Valid values in excluded categories --- --- ---
- Scale variables: VALIDN COUNT TOTALN
+ Scale variables: VALIDN other TOTALN
Valid value yes yes yes
Missing value --- yes yes
Missing values include both user- and system-missing. (The system-missing
value is always in an excluded category.)
+
+ One way to interpret the above table is that scale variables are like
+ categorical variables in which all values are in included categories.
*/
switch (ss->function)
{
case CTSF_TOTALN:
- s->count += weight;
- break;
-
case CTSF_areaPCT_TOTALN:
s->count += weight;
break;
case CTSF_COUNT:
- if (is_scale || is_included)
- s->count += weight;
- break;
-
case CTSF_areaPCT_COUNT:
- if (is_scale || is_included)
+ if (is_included)
s->count += weight;
break;
case CTSF_VALIDN:
- if (is_scale
- ? !is_scale_missing
- : !is_missing)
- s->count += weight;
- break;
-
case CTSF_areaPCT_VALIDN:
- if (is_scale
- ? !is_scale_missing
- : !is_missing)
+ if (!is_missing)
s->count += weight;
break;
break;
case CTSF_MISSING:
- if (is_scale
- ? is_scale_missing
- : is_missing)
+ if (is_missing)
s->count += weight;
break;
case CTSF_MAXIMUM:
case CTSF_MINIMUM:
case CTSF_RANGE:
- if (!is_scale_missing)
+ if (!is_missing)
{
- assert (!var_is_alpha (var)); /* XXX? */
if (s->min == SYSMIS || value->f < s->min)
s->min = value->f;
if (s->max == SYSMIS || value->f > s->max)
case CTSF_STDDEV:
case CTSF_SUM:
case CTSF_VARIANCE:
- if (!is_scale_missing)
+ if (!is_missing)
moments1_add (s->moments, value->f, weight);
break;
case CTSF_areaPCT_SUM:
- if (!is_missing && !is_scale_missing)
+ if (!is_missing)
moments1_add (s->moments, value->f, weight);
break;
case CTSF_MEDIAN:
case CTSF_MODE:
case CTSF_PTILE:
- if (!is_scale_missing)
+ if (!is_missing)
{
s->ovalid += weight;
return 0;
}
-/* Algorithm:
-
- For each row:
- For each ctables_table:
- For each combination of row vars:
- For each combination of column vars:
- For each combination of layer vars:
- Add entry
- Make a table of row values:
- Sort entries by row values
- Assign a 0-based index to each actual value
- Construct a dimension
- Make a table of column values
- Make a table of layer values
- For each entry:
- Fill the table entry using the indexes from before.
- */
-
static struct ctables_area *
ctables_area_insert (struct ctables_section *s, struct ctables_cell *cell,
enum ctables_area_type area)
static struct ctables_cell *
ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c,
- const struct ctables_category *cats[PIVOT_N_AXES][10])
+ const struct ctables_category **cats[PIVOT_N_AXES])
{
size_t hash = 0;
enum ctables_summary_variant sv = CSV_CELL;
cell->sv = sv;
cell->omit_areas = 0;
cell->postcompute = false;
- //struct string name = DS_EMPTY_INITIALIZER;
for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
{
const struct ctables_nest *nest = s->nests[a];
|| cat->type == CCT_SUBTOTAL
|| cat->type == CCT_POSTCOMPUTE)
{
- /* XXX these should be more encompassing I think.*/
-
switch (a)
{
case PIVOT_AXIS_COLUMN:
cell->axes[a].cvs[i].category = cat;
value_clone (&cell->axes[a].cvs[i].value, value, var_get_width (var));
-
-#if 0
- if (i != nest->scale_idx)
- {
- if (!ds_is_empty (&name))
- ds_put_cstr (&name, ", ");
- char *value_s = data_out (value, var_get_encoding (var),
- var_get_print_format (var),
- settings_get_fmt_settings ());
- if (cat->type == CCT_TOTAL
- || cat->type == CCT_SUBTOTAL
- || cat->type == CCT_POSTCOMPUTE)
- ds_put_format (&name, "%s=total", var_get_name (var));
- else
- ds_put_format (&name, "%s=%s", var_get_name (var),
- value_s + strspn (value_s, " "));
- free (value_s);
- }
-#endif
}
}
- //cell->name = ds_steal_cstr (&name);
const struct ctables_nest *ss = s->nests[s->table->summary_axis];
const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv];
static void
ctables_cell_add__ (struct ctables_section *s, const struct ccase *c,
- const struct ctables_category *cats[PIVOT_N_AXES][10],
+ const struct ctables_category **cats[PIVOT_N_AXES],
bool is_included, double weight[N_CTWS])
{
struct ctables_cell *cell = ctables_cell_insert__ (s, c, cats);
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 is_scale_missing
+ = is_missing || (specs->is_scale && is_listwise_missing (specs, c));
for (size_t i = 0; i < specs->n; i++)
- ctables_summary_add (&cell->summaries[i], &specs->specs[i],
- specs->var, value, specs->is_scale,
- scale_missing, is_missing, is_included,
+ ctables_summary_add (&cell->summaries[i], &specs->specs[i], value,
+ is_scale_missing, is_included,
weight[specs->specs[i].weighting]);
for (enum ctables_area_type at = 0; at < N_CTATS; at++)
if (!(cell->omit_areas && (1u << at)))
{
add_weight (a->valid, weight);
- for (size_t i = 0; i < s->table->n_sum_vars; i++)
- {
- /* XXX listwise_missing??? */
- const struct variable *var = s->table->sum_vars[i];
- double addend = case_num (c, var);
- if (!var_is_num_missing (var, addend))
- {
- struct ctables_sum *sum = &a->sums[i];
+ if (!is_scale_missing)
+ for (size_t i = 0; i < s->table->n_sum_vars; i++)
+ {
+ const struct variable *var = s->table->sum_vars[i];
+ double addend = case_num (c, var);
+ if (!var_is_num_missing (var, addend))
for (enum ctables_weighting wt = 0; wt < N_CTWS; wt++)
- sum->sum[wt] += addend * weight[wt];
- }
- }
+ a->sums[i].sum[wt] += addend * weight[wt];
+ }
}
}
}
static void
recurse_totals (struct ctables_section *s, const struct ccase *c,
- const struct ctables_category *cats[PIVOT_N_AXES][10],
+ const struct ctables_category **cats[PIVOT_N_AXES],
bool is_included, double weight[N_CTWS],
enum pivot_axis_type start_axis, size_t start_nest)
{
static void
recurse_subtotals (struct ctables_section *s, const struct ccase *c,
- const struct ctables_category *cats[PIVOT_N_AXES][10],
+ const struct ctables_category **cats[PIVOT_N_AXES],
bool is_included, double weight[N_CTWS],
enum pivot_axis_type start_axis, size_t start_nest)
{
ctables_cell_insert (struct ctables_section *s, const struct ccase *c,
double weight[N_CTWS])
{
- const struct ctables_category *cats[PIVOT_N_AXES][10]; /* XXX */
+ const struct ctables_category *layer_cats[s->nests[PIVOT_AXIS_LAYER]->n];
+ const struct ctables_category *row_cats[s->nests[PIVOT_AXIS_ROW]->n];
+ const struct ctables_category *column_cats[s->nests[PIVOT_AXIS_COLUMN]->n];
+ const struct ctables_category **cats[PIVOT_N_AXES] =
+ {
+ [PIVOT_AXIS_LAYER] = layer_cats,
+ [PIVOT_AXIS_ROW] = row_cats,
+ [PIVOT_AXIS_COLUMN] = column_cats,
+ };
bool is_included = true;
struct ctables_cell_sort_aux aux = { .nest = nest, .a = a };
sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux);
-#if 0
- if (a == PIVOT_AXIS_ROW)
- {
- size_t ids[N_CTATS];
- memset (ids, 0, sizeof ids);
- for (size_t j = 0; j < n_sorted; j++)
- {
- struct ctables_cell *cell = sorted[j];
- for (enum ctables_area_type at = 0; at < N_CTATS; at++)
- {
- struct ctables_area *area = cell->areas[at];
- if (!area->sequence)
- area->sequence = ++ids[at];
- }
- }
- }
-#endif
-
-#if 0
- for (size_t j = 0; j < n_sorted; j++)
- {
- printf ("%s (%s): %f/%f = %.1f%%\n", sorted[j]->name, sorted[j]->contributes_to_areas ? "y" : "n", sorted[j]->summaries[0].count, sorted[j]->areas[CTAT_COL]->e_count, sorted[j]->summaries[0].count / sorted[j]->areas[CTAT_COL]->e_count * 100.0);
- }
- printf ("\n");
-#endif
-
struct ctables_level
{
enum ctables_level_type
}
free (items);
-#if 0
- for (size_t j = 0; j < merged->n; j++)
- printf ("%s\n", ctables_summary_function_name (merged->specs[j].function));
-
- for (size_t j = 0; j < stack->n; j++)
- {
- const struct ctables_nest *nest = &stack->nests[j];
- for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++)
- {
- const struct ctables_summary_spec_set *specs = &nest->specs[sv];
- for (size_t k = 0; k < specs->n; k++)
- printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function),
- specs->specs[k].axis_idx);
- printf ("\n");
- }
- }
-#endif
-
size_t allocated_sum_vars = 0;
enumerate_sum_vars (t->axes[t->summary_axis],
&t->sum_vars, &t->n_sum_vars, &allocated_sum_vars);
static void
ctables_section_recurse_add_empty_categories (
struct ctables_section *s,
- const struct ctables_category *cats[PIVOT_N_AXES][10], struct ccase *c,
+ const struct ctables_category **cats[PIVOT_N_AXES], struct ccase *c,
enum pivot_axis_type a, size_t a_idx)
{
if (a >= PIVOT_N_AXES)
if (!show_empty)
return;
- const struct ctables_category *cats[PIVOT_N_AXES][10]; /* XXX */
+ const struct ctables_category *layer_cats[s->nests[PIVOT_AXIS_LAYER]->n];
+ const struct ctables_category *row_cats[s->nests[PIVOT_AXIS_ROW]->n];
+ const struct ctables_category *column_cats[s->nests[PIVOT_AXIS_COLUMN]->n];
+ const struct ctables_category **cats[PIVOT_N_AXES] =
+ {
+ [PIVOT_AXIS_LAYER] = layer_cats,
+ [PIVOT_AXIS_ROW] = row_cats,
+ [PIVOT_AXIS_COLUMN] = column_cats,
+ };
struct ccase *c = case_create (dict_get_proto (s->table->ctables->dict));
ctables_section_recurse_add_empty_categories (s, cats, c, 0, 0);
case_unref (c);
}
else if (lex_match_id (lexer, "SIGTEST"))
{
+ int start_ofs = lex_ofs (lexer) - 1;
if (!t->chisq)
{
t->chisq = xmalloc (sizeof *t->chisq);
}
while (lex_token (lexer) != T_SLASH
&& lex_token (lexer) != T_ENDCMD);
+
+ lex_ofs_error (lexer, start_ofs, lex_ofs (lexer) - 1,
+ _("Support for SIGTEST not yet implemented."));
+ goto error;
}
else if (lex_match_id (lexer, "COMPARETEST"))
{
+ int start_ofs = lex_ofs (lexer);
if (!t->pairwise)
{
t->pairwise = xmalloc (sizeof *t->pairwise);
}
while (lex_token (lexer) != T_SLASH
&& lex_token (lexer) != T_ENDCMD);
+
+ lex_ofs_error (lexer, start_ofs, lex_ofs (lexer) - 1,
+ _("Support for COMPARETEST not yet implemented."));
+ goto error;
}
else
{
projects / pspp / blobdiff