X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Froc.c;h=eb2430a2541efc29e52e1101b0e7ff1e631d1ee1;hb=edcf839b61451c61f3ea9eb62b38b09872bd9793;hp=22e4acb6fa161621ea2748eb5c33268a7b04e7b0;hpb=691c25e36fd1ee722dd35419d6110e3876b99f9c;p=pspp diff --git a/src/language/stats/roc.c b/src/language/stats/roc.c index 22e4acb6fa..eb2430a254 100644 --- a/src/language/stats/roc.c +++ b/src/language/stats/roc.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 2009, 2010 Free Software Foundation, Inc. + Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -16,27 +16,27 @@ #include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "language/stats/roc.h" #include +#include "data/casegrouper.h" +#include "data/casereader.h" +#include "data/casewriter.h" +#include "data/dataset.h" +#include "data/dictionary.h" +#include "data/format.h" +#include "data/subcase.h" +#include "language/command.h" +#include "language/lexer/lexer.h" +#include "language/lexer/value-parser.h" +#include "language/lexer/variable-parser.h" +#include "libpspp/misc.h" +#include "math/sort.h" +#include "output/chart-item.h" +#include "output/charts/roc-chart.h" +#include "output/pivot-table.h" + #include "gettext.h" #define _(msgid) gettext (msgid) #define N_(msgid) msgid @@ -49,6 +49,7 @@ struct cmd_roc const struct variable *state_var; union value state_value; + size_t state_var_width; /* Plot the roc curve */ bool curve; @@ -94,6 +95,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) roc.neg = roc.neg_weighted = 0; roc.dict = dataset_dict (ds); roc.state_var = NULL; + roc.state_var_width = -1; lex_match (lexer, T_SLASH); if (!parse_variables_const (lexer, dict, &roc.vars, &roc.n_vars, @@ -106,14 +108,19 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) } roc.state_var = parse_variable (lexer, dict); + if (! roc.state_var) + { + goto error; + } if ( !lex_force_match (lexer, T_LPAREN)) { goto error; } - value_init (&roc.state_value, var_get_width (roc.state_var)); - parse_value (lexer, &roc.state_value, var_get_width (roc.state_var)); + roc.state_var_width = var_get_width (roc.state_var); + value_init (&roc.state_value, roc.state_var_width); + parse_value (lexer, &roc.state_value, roc.state_var); if ( !lex_force_match (lexer, T_RPAREN)) @@ -121,7 +128,6 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) goto error; } - while (lex_token (lexer) != T_ENDCMD) { lex_match (lexer, T_SLASH); @@ -154,8 +160,10 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) if (lex_match (lexer, T_LPAREN)) { roc.reference = true; - lex_force_match_id (lexer, "REFERENCE"); - lex_force_match (lexer, T_RPAREN); + if (! lex_force_match_id (lexer, "REFERENCE")) + goto error; + if (! lex_force_match (lexer, T_RPAREN)) + goto error; } } else if (lex_match_id (lexer, "NONE")) @@ -195,7 +203,8 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) { if (lex_match_id (lexer, "CUTOFF")) { - lex_force_match (lexer, T_LPAREN); + if (! lex_force_match (lexer, T_LPAREN)) + goto error; if (lex_match_id (lexer, "INCLUDE")) { roc.exclude = MV_SYSTEM; @@ -209,11 +218,13 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) lex_error (lexer, NULL); goto error; } - lex_force_match (lexer, T_RPAREN); + if (! lex_force_match (lexer, T_RPAREN)) + goto error; } else if (lex_match_id (lexer, "TESTPOS")) { - lex_force_match (lexer, T_LPAREN); + if (! lex_force_match (lexer, T_LPAREN)) + goto error; if (lex_match_id (lexer, "LARGE")) { roc.invert = false; @@ -227,19 +238,24 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) lex_error (lexer, NULL); goto error; } - lex_force_match (lexer, T_RPAREN); + if (! lex_force_match (lexer, T_RPAREN)) + goto error; } else if (lex_match_id (lexer, "CI")) { - lex_force_match (lexer, T_LPAREN); - lex_force_num (lexer); + if (!lex_force_match (lexer, T_LPAREN)) + goto error; + if (! lex_force_num (lexer)) + goto error; roc.ci = lex_number (lexer); lex_get (lexer); - lex_force_match (lexer, T_RPAREN); + if (!lex_force_match (lexer, T_RPAREN)) + goto error; } else if (lex_match_id (lexer, "DISTRIBUTION")) { - lex_force_match (lexer, T_LPAREN); + if (!lex_force_match (lexer, T_LPAREN)) + goto error; if (lex_match_id (lexer, "FREE")) { roc.bi_neg_exp = false; @@ -253,7 +269,8 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) lex_error (lexer, NULL); goto error; } - lex_force_match (lexer, T_RPAREN); + if (!lex_force_match (lexer, T_RPAREN)) + goto error; } else { @@ -269,16 +286,17 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) } } - if ( ! run_roc (ds, &roc)) + if ( ! run_roc (ds, &roc)) goto error; - value_destroy (&roc.state_value, var_get_width (roc.state_var)); + if ( roc.state_var) + value_destroy (&roc.state_value, roc.state_var_width); free (roc.vars); return CMD_SUCCESS; error: if ( roc.state_var) - value_destroy (&roc.state_value, var_get_width (roc.state_var)); + value_destroy (&roc.state_value, roc.state_var_width); free (roc.vars); return CMD_FAILURE; } @@ -330,10 +348,10 @@ dump_casereader (struct casereader *reader) #endif -/* +/* Return true iff the state variable indicates that C has positive actual state. - As a side effect, this function also accumulates the roc->{pos,neg} and + As a side effect, this function also accumulates the roc->{pos,neg} and roc->{pos,neg}_weighted counts. */ static bool @@ -366,7 +384,7 @@ match_positives (const struct ccase *c, void *aux) #define N_EQ 1 #define N_PRED 2 -/* Some intermediate state for calculating the cutpoints and the +/* Some intermediate state for calculating the cutpoints and the standard error values */ struct roc_state { @@ -376,7 +394,7 @@ struct roc_state double n2; /* total weight of negatives */ /* intermediates for standard error */ - double q1hat; + double q1hat; double q2hat; /* intermediates for cutpoints */ @@ -387,18 +405,18 @@ struct roc_state double max; }; -/* +/* Return a new casereader based upon CUTPOINT_RDR. The number of "positive" cases are placed into the position TRUE_INDEX, and the number of "negative" cases into FALSE_INDEX. - POS_COND and RESULT determine the semantics of what is + POS_COND and RESULT determine the semantics of what is "positive". WEIGHT is the value of a single count. */ static struct casereader * accumulate_counts (struct casereader *input, - double result, double weight, + double result, double weight, bool (*pos_cond) (double, double), int true_index, int false_index) { @@ -451,7 +469,7 @@ static void output_roc (struct roc_state *rs, const struct cmd_roc *roc); CUTPOINT_RDR accordingly. TRUE_INDEX and FALSE_INDEX are the indices which receive these values. POS_COND is the condition defining true and false. - + 3. CC is filled with the cumulative weight of all cases of READER. */ static struct casereader * @@ -459,7 +477,7 @@ process_group (const struct variable *var, struct casereader *reader, bool (*pred) (double, double), const struct dictionary *dict, double *cc, - struct casereader **cutpoint_rdr, + struct casereader **cutpoint_rdr, bool (*pos_cond) (double, double), int true_index, int false_index) @@ -471,7 +489,7 @@ process_group (const struct variable *var, struct casereader *reader, const int weight_idx = w ? var_get_case_index (w) : caseproto_get_n_widths (casereader_get_proto (r1)) - 1; - + struct ccase *c1; struct casereader *rclone = casereader_clone (r1); @@ -482,7 +500,7 @@ process_group (const struct variable *var, struct casereader *reader, proto = caseproto_add_width (proto, 0); proto = caseproto_add_width (proto, 0); - wtr = autopaging_writer_create (proto); + wtr = autopaging_writer_create (proto); *cc = 0; @@ -528,7 +546,7 @@ process_group (const struct variable *var, struct casereader *reader, casereader_destroy (r2); } - + casereader_destroy (r1); casereader_destroy (rclone); @@ -539,7 +557,7 @@ process_group (const struct variable *var, struct casereader *reader, /* Some more indeces into case data */ #define N_POS_EQ 1 /* number of positive cases with values equal to n */ -#define N_POS_GT 2 /* number of postive cases with values greater than n */ +#define N_POS_GT 2 /* number of positive cases with values greater than n */ #define N_NEG_EQ 3 /* number of negative cases with values equal to n */ #define N_NEG_LT 4 /* number of negative cases with values less than n */ @@ -617,7 +635,7 @@ append_cutpoint (struct casewriter *writer, double cutpoint) } -/* +/* Create and initialise the rs[x].cutpoint_rdr casereaders. That is, the readers will be created with width 5, ready to take the values (cutpoint, ROC_TP, ROC_FN, ROC_TN, ROC_FP), and the reader will be populated with its final number of cases. @@ -658,7 +676,7 @@ prepare_cutpoints (struct cmd_roc *roc, struct roc_state *rs, struct casereader { for (i = 0 ; i < roc->n_vars; ++i) { - const union value *v = case_data (c, roc->vars[i]); + const union value *v = case_data (c, roc->vars[i]); const double result = v->f; if ( mv_is_value_missing (var_get_missing_values (roc->vars[i]), v, roc->exclude)) @@ -724,7 +742,7 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict) /* Separate the positive actual state cases from the negative ones */ - positives = + positives = casereader_create_filter_func (input, match_positives, NULL, @@ -732,7 +750,7 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict) neg_wtr); n_proto = caseproto_create (); - + n_proto = caseproto_add_width (n_proto, 0); n_proto = caseproto_add_width (n_proto, 0); n_proto = caseproto_add_width (n_proto, 0); @@ -831,7 +849,7 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict) n_pos_gt = prev_pos_gt; case_data_rw_idx (nc, N_POS_GT)->f = n_pos_gt; } - + casewriter_write (w, nc); prev_pos_gt = n_pos_gt; } @@ -856,7 +874,7 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict) n_neg_lt = prev_neg_lt; case_data_rw_idx (nc, N_NEG_LT)->f = n_neg_lt; } - + casewriter_write (w, nc); prev_neg_lt = n_neg_lt; } @@ -910,8 +928,8 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict) casereader_destroy (r); case_unref (prev_case); - rs[i].auc /= rs[i].n1 * rs[i].n2; - if ( roc->invert ) + rs[i].auc /= rs[i].n1 * rs[i].n2; + if ( roc->invert ) rs[i].auc = 1 - rs[i].auc; if ( roc->bi_neg_exp ) @@ -935,7 +953,7 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict) subcase_destroy (&down_ordering); output_roc (rs, roc); - + for (i = 0 ; i < roc->n_vars; ++i) casereader_destroy (rs[i].cutpoint_rdr); @@ -945,229 +963,161 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict) static void show_auc (struct roc_state *rs, const struct cmd_roc *roc) { - int i; - const int n_fields = roc->print_se ? 5 : 1; - const int n_cols = roc->n_vars > 1 ? n_fields + 1: n_fields; - const int n_rows = 2 + roc->n_vars; - struct tab_table *tbl = tab_create (n_cols, n_rows); + struct pivot_table *table = pivot_table_create (N_("Area Under the Curve")); - if ( roc->n_vars > 1) - tab_title (tbl, _("Area Under the Curve")); - else - tab_title (tbl, _("Area Under the Curve (%s)"), var_to_string (roc->vars[0])); - - tab_headers (tbl, n_cols - n_fields, 0, 1, 0); - - - tab_text (tbl, n_cols - n_fields, 1, TAT_TITLE, _("Area")); - - tab_hline (tbl, TAL_2, 0, n_cols - 1, 2); - - tab_box (tbl, - TAL_2, TAL_2, - -1, TAL_1, - 0, 0, - n_cols - 1, - n_rows - 1); - - if ( roc->print_se ) + struct pivot_dimension *statistics = pivot_dimension_create ( + table, PIVOT_AXIS_COLUMN, N_("Statistics"), + N_("Area"), PIVOT_RC_OTHER); + if (roc->print_se) { - tab_text (tbl, n_cols - 4, 1, TAT_TITLE, _("Std. Error")); - tab_text (tbl, n_cols - 3, 1, TAT_TITLE, _("Asymptotic Sig.")); - - tab_text (tbl, n_cols - 2, 1, TAT_TITLE, _("Lower Bound")); - tab_text (tbl, n_cols - 1, 1, TAT_TITLE, _("Upper Bound")); - - tab_joint_text_format (tbl, n_cols - 2, 0, 4, 0, - TAT_TITLE | TAB_CENTER, - _("Asymp. %g%% Confidence Interval"), roc->ci); - tab_vline (tbl, 0, n_cols - 1, 0, 0); - tab_hline (tbl, TAL_1, n_cols - 2, n_cols - 1, 1); + pivot_category_create_leaves ( + statistics->root, + N_("Std. Error"), PIVOT_RC_OTHER, + N_("Asymptotic Sig."), PIVOT_RC_SIGNIFICANCE); + struct pivot_category *interval = pivot_category_create_group__ ( + statistics->root, + pivot_value_new_text_format (N_("Asymp. %g%% Confidence Interval"), + roc->ci)); + pivot_category_create_leaves (interval, + N_("Lower Bound"), PIVOT_RC_OTHER, + N_("Upper Bound"), PIVOT_RC_OTHER); } - if ( roc->n_vars > 1) - tab_text (tbl, 0, 1, TAT_TITLE, _("Variable under test")); + struct pivot_dimension *variables = pivot_dimension_create ( + table, PIVOT_AXIS_ROW, N_("Variable under test")); + variables->root->show_label = true; - if ( roc->n_vars > 1) - tab_vline (tbl, TAL_2, 1, 0, n_rows - 1); - - - for ( i = 0 ; i < roc->n_vars ; ++i ) + for (size_t i = 0 ; i < roc->n_vars ; ++i ) { - tab_text (tbl, 0, 2 + i, TAT_TITLE, var_to_string (roc->vars[i])); + int var_idx = pivot_category_create_leaf ( + variables->root, pivot_value_new_variable (roc->vars[i])); - tab_double (tbl, n_cols - n_fields, 2 + i, 0, rs[i].auc, NULL); + pivot_table_put2 (table, 0, var_idx, pivot_value_new_number (rs[i].auc)); if ( roc->print_se ) { - double se ; - const double sd_0_5 = sqrt ((rs[i].n1 + rs[i].n2 + 1) / - (12 * rs[i].n1 * rs[i].n2)); - double ci ; - double yy ; - - se = rs[i].auc * (1 - rs[i].auc) + (rs[i].n1 - 1) * (rs[i].q1hat - pow2 (rs[i].auc)) + - (rs[i].n2 - 1) * (rs[i].q2hat - pow2 (rs[i].auc)); - + double se = (rs[i].auc * (1 - rs[i].auc) + + (rs[i].n1 - 1) * (rs[i].q1hat - pow2 (rs[i].auc)) + + (rs[i].n2 - 1) * (rs[i].q2hat - pow2 (rs[i].auc))); se /= rs[i].n1 * rs[i].n2; - se = sqrt (se); - tab_double (tbl, n_cols - 4, 2 + i, 0, - se, - NULL); - - ci = 1 - roc->ci / 100.0; - yy = gsl_cdf_gaussian_Qinv (ci, se) ; - - tab_double (tbl, n_cols - 2, 2 + i, 0, - rs[i].auc - yy, - NULL); - - tab_double (tbl, n_cols - 1, 2 + i, 0, - rs[i].auc + yy, - NULL); - - tab_double (tbl, n_cols - 3, 2 + i, 0, - 2.0 * gsl_cdf_ugaussian_Q (fabs ((rs[i].auc - 0.5 ) / sd_0_5)), - NULL); + double ci = 1 - roc->ci / 100.0; + double yy = gsl_cdf_gaussian_Qinv (ci, se); + + double sd_0_5 = sqrt ((rs[i].n1 + rs[i].n2 + 1) / + (12 * rs[i].n1 * rs[i].n2)); + double sig = 2.0 * gsl_cdf_ugaussian_Q (fabs ((rs[i].auc - 0.5) + / sd_0_5)); + double entries[] = { se, sig, rs[i].auc - yy, rs[i].auc + yy }; + for (size_t i = 0; i < sizeof entries / sizeof *entries; i++) + pivot_table_put2 (table, i + 1, var_idx, + pivot_value_new_number (entries[i])); } } - tab_submit (tbl); + pivot_table_submit (table); } static void show_summary (const struct cmd_roc *roc) { - const int n_cols = 3; - const int n_rows = 4; - struct tab_table *tbl = tab_create (n_cols, n_rows); - - tab_title (tbl, _("Case Summary")); - - tab_headers (tbl, 1, 0, 2, 0); - - tab_box (tbl, - TAL_2, TAL_2, - -1, -1, - 0, 0, - n_cols - 1, - n_rows - 1); - - tab_hline (tbl, TAL_2, 0, n_cols - 1, 2); - tab_vline (tbl, TAL_2, 1, 0, n_rows - 1); - - - tab_hline (tbl, TAL_2, 1, n_cols - 1, 1); - tab_vline (tbl, TAL_1, 2, 1, n_rows - 1); - - - tab_text (tbl, 0, 1, TAT_TITLE | TAB_LEFT, var_to_string (roc->state_var)); - tab_text (tbl, 1, 1, TAT_TITLE, _("Unweighted")); - tab_text (tbl, 2, 1, TAT_TITLE, _("Weighted")); + struct pivot_table *table = pivot_table_create (N_("Case Summary")); - tab_joint_text (tbl, 1, 0, 2, 0, - TAT_TITLE | TAB_CENTER, - _("Valid N (listwise)")); + struct pivot_dimension *statistics = pivot_dimension_create ( + table, PIVOT_AXIS_COLUMN, N_("Valid N (listwise)"), + N_("Unweighted"), PIVOT_RC_INTEGER, + N_("Weighted"), PIVOT_RC_OTHER); + statistics->root->show_label = true; + struct pivot_dimension *cases = pivot_dimension_create__ ( + table, PIVOT_AXIS_ROW, pivot_value_new_variable (roc->state_var)); + cases->root->show_label = true; + pivot_category_create_leaves (cases->root, N_("Positive"), N_("Negative")); - tab_text (tbl, 0, 2, TAB_LEFT, _("Positive")); - tab_text (tbl, 0, 3, TAB_LEFT, _("Negative")); - - - tab_double (tbl, 1, 2, 0, roc->pos, &F_8_0); - tab_double (tbl, 1, 3, 0, roc->neg, &F_8_0); - - tab_double (tbl, 2, 2, 0, roc->pos_weighted, 0); - tab_double (tbl, 2, 3, 0, roc->neg_weighted, 0); - - tab_submit (tbl); + struct entry + { + int stat_idx; + int case_idx; + double x; + } + entries[] = { + { 0, 0, roc->pos }, + { 0, 1, roc->neg }, + { 1, 0, roc->pos_weighted }, + { 1, 1, roc->neg_weighted }, + }; + for (size_t i = 0; i < sizeof entries / sizeof *entries; i++) + { + const struct entry *e = &entries[i]; + pivot_table_put2 (table, e->stat_idx, e->case_idx, + pivot_value_new_number (e->x)); + } + pivot_table_submit (table); } - static void show_coords (struct roc_state *rs, const struct cmd_roc *roc) { - int x = 1; - int i; - const int n_cols = roc->n_vars > 1 ? 4 : 3; - int n_rows = 1; - struct tab_table *tbl ; - - for (i = 0; i < roc->n_vars; ++i) - n_rows += casereader_count_cases (rs[i].cutpoint_rdr); - - tbl = tab_create (n_cols, n_rows); - - if ( roc->n_vars > 1) - tab_title (tbl, _("Coordinates of the Curve")); - else - tab_title (tbl, _("Coordinates of the Curve (%s)"), var_to_string (roc->vars[0])); - - - tab_headers (tbl, 1, 0, 1, 0); - - tab_hline (tbl, TAL_2, 0, n_cols - 1, 1); + struct pivot_table *table = pivot_table_create ( + N_("Coordinates of the Curve")); + table->omit_empty = true; - if ( roc->n_vars > 1) - tab_text (tbl, 0, 0, TAT_TITLE, _("Test variable")); + pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"), + N_("Positive if greater than or equal to"), + N_("Sensitivity"), N_("1 - Specificity")); - tab_text (tbl, n_cols - 3, 0, TAT_TITLE, _("Positive if greater than or equal to")); - tab_text (tbl, n_cols - 2, 0, TAT_TITLE, _("Sensitivity")); - tab_text (tbl, n_cols - 1, 0, TAT_TITLE, _("1 - Specificity")); + struct pivot_dimension *coordinates = pivot_dimension_create ( + table, PIVOT_AXIS_ROW, N_("Coordinates")); + coordinates->hide_all_labels = true; - tab_box (tbl, - TAL_2, TAL_2, - -1, TAL_1, - 0, 0, - n_cols - 1, - n_rows - 1); + struct pivot_dimension *variables = pivot_dimension_create ( + table, PIVOT_AXIS_ROW, N_("Test variable")); + variables->root->show_label = true; - if ( roc->n_vars > 1) - tab_vline (tbl, TAL_2, 1, 0, n_rows - 1); - for (i = 0; i < roc->n_vars; ++i) + int n_coords = 0; + for (size_t i = 0; i < roc->n_vars; ++i) { - struct ccase *cc; struct casereader *r = casereader_clone (rs[i].cutpoint_rdr); - if ( roc->n_vars > 1) - tab_text (tbl, 0, x, TAT_TITLE, var_to_string (roc->vars[i])); - - if ( i > 0) - tab_hline (tbl, TAL_1, 0, n_cols - 1, x); + int var_idx = pivot_category_create_leaf ( + variables->root, pivot_value_new_variable (roc->vars[i])); - - for (; (cc = casereader_read (r)) != NULL; - case_unref (cc), x++) + struct ccase *cc; + int coord_idx = 0; + for (; (cc = casereader_read (r)) != NULL; case_unref (cc)) { const double se = case_data_idx (cc, ROC_TP)->f / - ( - case_data_idx (cc, ROC_TP)->f - + - case_data_idx (cc, ROC_FN)->f - ); + (case_data_idx (cc, ROC_TP)->f + case_data_idx (cc, ROC_FN)->f); const double sp = case_data_idx (cc, ROC_TN)->f / - ( - case_data_idx (cc, ROC_TN)->f - + - case_data_idx (cc, ROC_FP)->f - ); - - tab_double (tbl, n_cols - 3, x, 0, case_data_idx (cc, ROC_CUTPOINT)->f, - var_get_print_format (roc->vars[i])); - - tab_double (tbl, n_cols - 2, x, 0, se, NULL); - tab_double (tbl, n_cols - 1, x, 0, 1 - sp, NULL); + (case_data_idx (cc, ROC_TN)->f + case_data_idx (cc, ROC_FP)->f); + + pivot_table_put3 ( + table, 0, coord_idx, var_idx, + pivot_value_new_var_value (roc->vars[i], + case_data_idx (cc, ROC_CUTPOINT))); + + pivot_table_put3 (table, 1, coord_idx, var_idx, + pivot_value_new_number (se)); + pivot_table_put3 (table, 2, coord_idx, var_idx, + pivot_value_new_number (1 - sp)); + coord_idx++; } + if (coord_idx > n_coords) + n_coords = coord_idx; + casereader_destroy (r); } - tab_submit (tbl); + for (size_t i = 0; i < n_coords; i++) + pivot_category_create_leaf (coordinates->root, + pivot_value_new_integer (i + 1)); + + pivot_table_submit (table); }