X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Froc.c;h=724bc523a3beef42df39ca5b801da5918f88d398;hb=dfd1972f7bcb550a4fc3b05dbe7e71d12334b0a7;hp=e6251b36b38ff79c495931e1b805f4489df3c992;hpb=8f07df1b704439ced3bb6715da86f71866cca41f;p=pspp-builds.git diff --git a/src/language/stats/roc.c b/src/language/stats/roc.c index e6251b36..724bc523 100644 --- a/src/language/stats/roc.c +++ b/src/language/stats/roc.c @@ -16,28 +16,26 @@ #include -#include "roc.h" -#include -#include -#include -#include +#include #include #include #include #include #include -#include +#include #include - - +#include +#include +#include +#include #include +#include +#include +#include +#include #include -#include - -#include -#include #include "gettext.h" #define _(msgid) gettext (msgid) @@ -47,8 +45,9 @@ struct cmd_roc { size_t n_vars; const struct variable **vars; + const struct dictionary *dict; - struct variable *state_var ; + const struct variable *state_var ; union value state_value; /* Plot the roc curve */ @@ -66,6 +65,11 @@ struct cmd_roc bool invert ; /* True iff a smaller test result variable indicates a positive result */ + + double pos; + double neg; + double pos_weighted; + double neg_weighted; }; static int run_roc (struct dataset *ds, struct cmd_roc *roc); @@ -86,29 +90,33 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) roc.ci = 95; roc.bi_neg_exp = false; roc.invert = false; + roc.pos = roc.pos_weighted = 0; + roc.neg = roc.neg_weighted = 0; + roc.dict = dataset_dict (ds); if (!parse_variables_const (lexer, dict, &roc.vars, &roc.n_vars, PV_APPEND | PV_NO_DUPLICATE | PV_NUMERIC)) - return 2; + goto error; if ( ! lex_force_match (lexer, T_BY)) { - return 2; + goto error; } roc.state_var = parse_variable (lexer, dict); if ( !lex_force_match (lexer, '(')) { - return 2; + 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)); if ( !lex_force_match (lexer, ')')) { - return 2; + goto error; } @@ -131,7 +139,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) else { lex_error (lexer, NULL); - return 2; + goto error; } } } @@ -155,7 +163,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) else { lex_error (lexer, NULL); - return 2; + goto error; } } else if (lex_match_id (lexer, "PRINT")) @@ -174,7 +182,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) else { lex_error (lexer, NULL); - return 2; + goto error; } } } @@ -197,7 +205,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) else { lex_error (lexer, NULL); - return 2; + goto error; } lex_force_match (lexer, ')'); } @@ -215,7 +223,7 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) else { lex_error (lexer, NULL); - return 2; + goto error; } lex_force_match (lexer, ')'); } @@ -241,14 +249,14 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) else { lex_error (lexer, NULL); - return 2; + goto error; } lex_force_match (lexer, ')'); } else { lex_error (lexer, NULL); - return 2; + goto error; } } } @@ -259,9 +267,17 @@ cmd_roc (struct lexer *lexer, struct dataset *ds) } } - run_roc (ds, &roc); + if ( ! run_roc (ds, &roc)) + goto error; - return 1; + value_destroy (&roc.state_value, var_get_width (roc.state_var)); + free (roc.vars); + return CMD_SUCCESS; + + error: + value_destroy (&roc.state_value, var_get_width (roc.state_var)); + free (roc.vars); + return CMD_FAILURE; } @@ -310,14 +326,36 @@ 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 + roc->{pos,neg}_weighted counts. + */ static bool match_positives (const struct ccase *c, void *aux) { struct cmd_roc *roc = aux; + const struct variable *wv = dict_get_weight (roc->dict); + const double weight = wv ? case_data (c, wv)->f : 1.0; - return 0 == value_compare_3way (case_data (c, roc->state_var), - &roc->state_value, - var_get_width (roc->state_var)); + const bool positive = + ( 0 == value_compare_3way (case_data (c, roc->state_var), &roc->state_value, + var_get_width (roc->state_var))); + + if ( positive ) + { + roc->pos++; + roc->pos_weighted += weight; + } + else + { + roc->neg++; + roc->neg_weighted += weight; + } + + return positive; } @@ -325,16 +363,20 @@ 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 + standard error values */ struct roc_state { - double auc; + double auc; /* Area under the curve */ - double n1; - double n2; + double n1; /* total weight of positives */ + double n2; /* total weight of negatives */ - double q1hat; + /* intermediates for standard error */ + double q1hat; double q2hat; + /* intermediates for cutpoints */ struct casewriter *cutpoint_wtr; struct casereader *cutpoint_rdr; double prev_result; @@ -342,15 +384,15 @@ struct roc_state double max; }; - - -#define CUTPOINT 0 -#define TP 1 -#define FN 2 -#define TN 3 -#define FP 4 - - +/* + 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 + "positive". + WEIGHT is the value of a single count. + */ static struct casereader * accumulate_counts (struct casereader *cutpoint_rdr, double result, double weight, @@ -364,11 +406,12 @@ accumulate_counts (struct casereader *cutpoint_rdr, struct ccase *cpc; double prev_cp = SYSMIS; - for ( ; (cpc = casereader_read (r) ); case_unref (cpc)) { struct ccase *new_case; - const double cp = case_data_idx (cpc, CUTPOINT)->f; + const double cp = case_data_idx (cpc, ROC_CUTPOINT)->f; + + assert (cp != SYSMIS); /* We don't want duplicates here */ if ( cp == prev_cp ) @@ -377,13 +420,9 @@ accumulate_counts (struct casereader *cutpoint_rdr, new_case = case_clone (cpc); if ( pos_cond (result, cp)) - { - case_data_rw_idx (new_case, true_index)->f += weight; - } + case_data_rw_idx (new_case, true_index)->f += weight; else - { - case_data_rw_idx (new_case, false_index)->f += weight; - } + case_data_rw_idx (new_case, false_index)->f += weight; prev_cp = cp; @@ -398,7 +437,21 @@ accumulate_counts (struct casereader *cutpoint_rdr, static void output_roc (struct roc_state *rs, const struct cmd_roc *roc); +/* + This function does 3 things: + + 1. Counts the number of cases which are equal to every other case in READER, + and those cases for which the relationship between it and every other case + satifies PRED (normally either > or <). VAR is variable defining a case's value + for this purpose. + 2. Counts the number of true and false cases in reader, and populates + 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 * process_group (const struct variable *var, struct casereader *reader, bool (*pred) (double, double), @@ -407,10 +460,10 @@ process_group (const struct variable *var, struct casereader *reader, struct casereader **cutpoint_rdr, bool (*pos_cond) (double, double), int true_index, - int false_index - ) + int false_index) { const struct variable *w = dict_get_weight (dict); + struct casereader *r1 = casereader_create_distinct (sort_execute_1var (reader, var), var, w); @@ -479,6 +532,12 @@ process_group (const struct variable *var, struct casereader *reader, return casewriter_make_reader (wtr); } +/* 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_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 */ + static bool gt (double d1, double d2) { @@ -498,6 +557,14 @@ lt (double d1, double d2) return d1 < d2; } + +/* + Return a casereader with width 3, + populated with cases based upon READER. + The cases will have the values: + (N, number of cases equal to N, number of cases greater than N) + As a side effect, update RS->n1 with the number of positive cases. +*/ static struct casereader * process_positive_group (const struct variable *var, struct casereader *reader, const struct dictionary *dict, @@ -506,10 +573,16 @@ process_positive_group (const struct variable *var, struct casereader *reader, return process_group (var, reader, gt, dict, &rs->n1, &rs->cutpoint_rdr, ge, - TP, FN); + ROC_TP, ROC_FN); } - +/* + Return a casereader with width 3, + populated with cases based upon READER. + The cases will have the values: + (N, number of cases equal to N, number of cases less than N) + As a side effect, update RS->n2 with the number of negative cases. +*/ static struct casereader * process_negative_group (const struct variable *var, struct casereader *reader, const struct dictionary *dict, @@ -518,7 +591,7 @@ process_negative_group (const struct variable *var, struct casereader *reader, return process_group (var, reader, lt, dict, &rs->n2, &rs->cutpoint_rdr, lt, - TN, FP); + ROC_TN, ROC_FP); } @@ -529,18 +602,23 @@ append_cutpoint (struct casewriter *writer, double cutpoint) { struct ccase *cc = case_create (casewriter_get_proto (writer)); - case_data_rw_idx (cc, CUTPOINT)->f = cutpoint; - case_data_rw_idx (cc, TP)->f = 0; - case_data_rw_idx (cc, FN)->f = 0; - case_data_rw_idx (cc, TN)->f = 0; - case_data_rw_idx (cc, FP)->f = 0; - + case_data_rw_idx (cc, ROC_CUTPOINT)->f = cutpoint; + case_data_rw_idx (cc, ROC_TP)->f = 0; + case_data_rw_idx (cc, ROC_FN)->f = 0; + case_data_rw_idx (cc, ROC_TN)->f = 0; + case_data_rw_idx (cc, ROC_FP)->f = 0; casewriter_write (writer, cc); } -/* Prepare the cutpoints */ +/* + 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. + However on exit from this function, only ROC_CUTPOINT entries will be set to their final + value. The other entries will be initialised to zero. +*/ static void prepare_cutpoints (struct cmd_roc *roc, struct roc_state *rs, struct casereader *input) { @@ -550,13 +628,13 @@ prepare_cutpoints (struct cmd_roc *roc, struct roc_state *rs, struct casereader struct caseproto *proto = caseproto_create (); struct subcase ordering; - subcase_init (&ordering, CUTPOINT, 0, SC_ASCEND); + subcase_init (&ordering, ROC_CUTPOINT, 0, SC_ASCEND); proto = caseproto_add_width (proto, 0); /* cutpoint */ - proto = caseproto_add_width (proto, 0); /* TP */ - proto = caseproto_add_width (proto, 0); /* FN */ - proto = caseproto_add_width (proto, 0); /* TN */ - proto = caseproto_add_width (proto, 0); /* FP */ + proto = caseproto_add_width (proto, 0); /* ROC_TP */ + proto = caseproto_add_width (proto, 0); /* ROC_FN */ + proto = caseproto_add_width (proto, 0); /* ROC_TN */ + proto = caseproto_add_width (proto, 0); /* ROC_FP */ for (i = 0 ; i < roc->n_vars; ++i) { @@ -570,7 +648,11 @@ prepare_cutpoints (struct cmd_roc *roc, struct roc_state *rs, struct casereader { for (i = 0 ; i < roc->n_vars; ++i) { - const double result = case_data (c, roc->vars[i])->f; + 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)) + continue; minimize (&rs[i].min, result); maximize (&rs[i].max, result); @@ -598,14 +680,12 @@ prepare_cutpoints (struct cmd_roc *roc, struct roc_state *rs, struct casereader } static void -do_roc (struct cmd_roc *roc, struct casereader *input, struct dictionary *dict) +do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict) { int i; struct roc_state *rs = xcalloc (roc->n_vars, sizeof *rs); - struct casewriter *neg_wtr = autopaging_writer_create (casereader_get_proto (input)); - struct casereader *negatives = NULL; struct casereader *positives = NULL; @@ -614,8 +694,26 @@ do_roc (struct cmd_roc *roc, struct casereader *input, struct dictionary *dict) struct subcase up_ordering; struct subcase down_ordering; + struct casewriter *neg_wtr = NULL; + + struct casereader *input = casereader_create_filter_missing (reader, + roc->vars, roc->n_vars, + roc->exclude, + NULL, + NULL); + + input = casereader_create_filter_missing (input, + &roc->state_var, 1, + roc->exclude, + NULL, + NULL); + + neg_wtr = autopaging_writer_create (casereader_get_proto (input)); + prepare_cutpoints (roc, rs, input); + + /* Separate the positive actual state cases from the negative ones */ positives = casereader_create_filter_func (input, match_positives, @@ -648,6 +746,7 @@ do_roc (struct cmd_roc *roc, struct casereader *input, struct dictionary *dict) struct casereader *neg ; struct casereader *pos = casereader_clone (positives); + struct casereader *n_pos = process_positive_group (var, pos, dict, &rs[i]); @@ -660,6 +759,8 @@ do_roc (struct cmd_roc *roc, struct casereader *input, struct dictionary *dict) n_neg = process_negative_group (var, neg, dict, &rs[i]); + + /* Merge the n_pos and n_neg casereaders */ w = sort_create_writer (&up_ordering, n_proto); for ( ; (cpos = casereader_read (n_pos) ); case_unref (cpos)) { @@ -674,12 +775,12 @@ do_roc (struct cmd_roc *roc, struct casereader *input, struct dictionary *dict) const double jneg = case_data_idx (cneg, VALUE)->f; case_data_rw_idx (nc, VALUE)->f = jneg; - case_data_rw_idx (nc, N_EQ)->f = 0; + case_data_rw_idx (nc, N_POS_EQ)->f = 0; - case_data_rw_idx (nc, N_PRED)->f = SYSMIS; + case_data_rw_idx (nc, N_POS_GT)->f = SYSMIS; - *case_data_rw_idx (nc, 3) = *case_data_idx (cneg, N_EQ); - *case_data_rw_idx (nc, 4) = *case_data_idx (cneg, N_PRED); + *case_data_rw_idx (nc, N_NEG_EQ) = *case_data_idx (cneg, N_EQ); + *case_data_rw_idx (nc, N_NEG_LT) = *case_data_idx (cneg, N_PRED); casewriter_write (w, nc); @@ -689,29 +790,35 @@ do_roc (struct cmd_roc *roc, struct casereader *input, struct dictionary *dict) } case_data_rw_idx (pos_case, VALUE)->f = jpos; - *case_data_rw_idx (pos_case, N_EQ) = *case_data_idx (cpos, N_EQ); - *case_data_rw_idx (pos_case, N_PRED) = *case_data_idx (cpos, N_PRED); - case_data_rw_idx (pos_case, 3)->f = 0; - case_data_rw_idx (pos_case, 4)->f = SYSMIS; + *case_data_rw_idx (pos_case, N_POS_EQ) = *case_data_idx (cpos, N_EQ); + *case_data_rw_idx (pos_case, N_POS_GT) = *case_data_idx (cpos, N_PRED); + case_data_rw_idx (pos_case, N_NEG_EQ)->f = 0; + case_data_rw_idx (pos_case, N_NEG_LT)->f = SYSMIS; casewriter_write (w, pos_case); } +/* These aren't used anymore */ +#undef N_EQ +#undef N_PRED + r = casewriter_make_reader (w); + /* Propagate the N_POS_GT values from the positive cases + to the negative ones */ { double prev_pos_gt = rs[i].n1; w = sort_create_writer (&down_ordering, n_proto); for ( ; (c = casereader_read (r) ); case_unref (c)) { - double n_pos_gt = case_data_idx (c, N_PRED)->f; + double n_pos_gt = case_data_idx (c, N_POS_GT)->f; struct ccase *nc = case_clone (c); if ( n_pos_gt == SYSMIS) { n_pos_gt = prev_pos_gt; - case_data_rw_idx (nc, N_PRED)->f = n_pos_gt; + case_data_rw_idx (nc, N_POS_GT)->f = n_pos_gt; } casewriter_write (w, nc); @@ -721,19 +828,21 @@ do_roc (struct cmd_roc *roc, struct casereader *input, struct dictionary *dict) r = casewriter_make_reader (w); } + /* Propagate the N_NEG_LT values from the negative cases + to the positive ones */ { double prev_neg_lt = rs[i].n2; w = sort_create_writer (&up_ordering, n_proto); for ( ; (c = casereader_read (r) ); case_unref (c)) { - double n_neg_lt = case_data_idx (c, 4)->f; + double n_neg_lt = case_data_idx (c, N_NEG_LT)->f; struct ccase *nc = case_clone (c); if ( n_neg_lt == SYSMIS) { n_neg_lt = prev_neg_lt; - case_data_rw_idx (nc, 4)->f = n_neg_lt; + case_data_rw_idx (nc, N_NEG_LT)->f = n_neg_lt; } casewriter_write (w, nc); @@ -750,23 +859,23 @@ do_roc (struct cmd_roc *roc, struct casereader *input, struct dictionary *dict) const struct ccase *next_case = casereader_peek (r, 0); const double j = case_data_idx (c, VALUE)->f; - double n_pos_eq = case_data_idx (c, N_EQ)->f; - double n_pos_gt = case_data_idx (c, N_PRED)->f; - double n_neg_eq = case_data_idx (c, 3)->f; - double n_neg_lt = case_data_idx (c, 4)->f; + double n_pos_eq = case_data_idx (c, N_POS_EQ)->f; + double n_pos_gt = case_data_idx (c, N_POS_GT)->f; + double n_neg_eq = case_data_idx (c, N_NEG_EQ)->f; + double n_neg_lt = case_data_idx (c, N_NEG_LT)->f; if ( prev_case && j == case_data_idx (prev_case, VALUE)->f) { - if ( 0 == case_data_idx (c, N_EQ)->f) + if ( 0 == case_data_idx (c, N_POS_EQ)->f) { - n_pos_eq = case_data_idx (prev_case, N_EQ)->f; - n_pos_gt = case_data_idx (prev_case, N_PRED)->f; + n_pos_eq = case_data_idx (prev_case, N_POS_EQ)->f; + n_pos_gt = case_data_idx (prev_case, N_POS_GT)->f; } - if ( 0 == case_data_idx (c, 3)->f) + if ( 0 == case_data_idx (c, N_NEG_EQ)->f) { - n_neg_eq = case_data_idx (prev_case, 3)->f; - n_neg_lt = case_data_idx (prev_case, 4)->f; + n_neg_eq = case_data_idx (prev_case, N_NEG_EQ)->f; + n_neg_lt = case_data_idx (prev_case, N_NEG_LT)->f; } } @@ -817,7 +926,7 @@ show_auc (struct roc_state *rs, const struct cmd_roc *roc) 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, 0); + struct tab_table *tbl = tab_create (n_cols, n_rows); if ( roc->n_vars > 1) tab_title (tbl, _("Area Under the Curve")); @@ -826,7 +935,6 @@ show_auc (struct roc_state *rs, const struct cmd_roc *roc) tab_headers (tbl, n_cols - n_fields, 0, 1, 0); - tab_dim (tbl, tab_natural_dimensions, NULL); tab_text (tbl, n_cols - n_fields, 1, TAT_TITLE, _("Area")); @@ -847,9 +955,9 @@ show_auc (struct roc_state *rs, const struct cmd_roc *roc) 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 (tbl, n_cols - 2, 0, 4, 0, - TAT_TITLE | TAB_CENTER | TAT_PRINTF, - _("Asymp. %g%% Confidence Interval"), roc->ci); + 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); } @@ -912,14 +1020,12 @@ 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, 0); + struct tab_table *tbl = tab_create (n_cols, n_rows); tab_title (tbl, _("Case Summary")); tab_headers (tbl, 1, 0, 2, 0); - tab_dim (tbl, tab_natural_dimensions, NULL); - tab_box (tbl, TAL_2, TAL_2, -1, -1, @@ -948,13 +1054,11 @@ show_summary (const struct cmd_roc *roc) tab_text (tbl, 0, 3, TAB_LEFT, _("Negative")); -#if 0 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); -#endif tab_submit (tbl); } @@ -972,7 +1076,7 @@ show_coords (struct roc_state *rs, const struct cmd_roc *roc) for (i = 0; i < roc->n_vars; ++i) n_rows += casereader_count_cases (rs[i].cutpoint_rdr); - tbl = tab_create (n_cols, n_rows, 0); + tbl = tab_create (n_cols, n_rows); if ( roc->n_vars > 1) tab_title (tbl, _("Coordinates of the Curve")); @@ -982,8 +1086,6 @@ show_coords (struct roc_state *rs, const struct cmd_roc *roc) tab_headers (tbl, 1, 0, 1, 0); - tab_dim (tbl, tab_natural_dimensions, NULL); - tab_hline (tbl, TAL_2, 0, n_cols - 1, 1); if ( roc->n_vars > 1) @@ -1018,21 +1120,21 @@ show_coords (struct roc_state *rs, const struct cmd_roc *roc) for (; (cc = casereader_read (r)) != NULL; case_unref (cc), x++) { - const double se = case_data_idx (cc, TP)->f / + const double se = case_data_idx (cc, ROC_TP)->f / ( - case_data_idx (cc, TP)->f + case_data_idx (cc, ROC_TP)->f + - case_data_idx (cc, FN)->f + case_data_idx (cc, ROC_FN)->f ); - const double sp = case_data_idx (cc, TN)->f / + const double sp = case_data_idx (cc, ROC_TN)->f / ( - case_data_idx (cc, TN)->f + case_data_idx (cc, ROC_TN)->f + - case_data_idx (cc, FP)->f + case_data_idx (cc, ROC_FP)->f ); - tab_double (tbl, n_cols - 3, x, 0, case_data_idx (cc, CUTPOINT)->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); @@ -1046,68 +1148,25 @@ show_coords (struct roc_state *rs, const struct cmd_roc *roc) } -static void -draw_roc (struct roc_state *rs, const struct cmd_roc *roc) -{ - int i; - - struct chart *roc_chart = chart_create (); - - chart_write_title (roc_chart, _("ROC Curve")); - chart_write_xlabel (roc_chart, _("1 - Specificity")); - chart_write_ylabel (roc_chart, _("Sensitivity")); - - chart_write_xscale (roc_chart, 0, 1, 5); - chart_write_yscale (roc_chart, 0, 1, 5); - - if ( roc->reference ) - { - chart_line (roc_chart, 1.0, 0, - 0.0, 1.0, - CHART_DIM_X); - } - - for (i = 0; i < roc->n_vars; ++i) - { - struct ccase *cc; - struct casereader *r = casereader_clone (rs[i].cutpoint_rdr); - - chart_vector_start (roc_chart, var_get_name (roc->vars[i])); - for (; (cc = casereader_read (r)) != NULL; - case_unref (cc)) - { - double se = case_data_idx (cc, TP)->f; - double sp = case_data_idx (cc, TN)->f; - - se /= case_data_idx (cc, FN)->f + - case_data_idx (cc, TP)->f ; - - sp /= case_data_idx (cc, TN)->f + - case_data_idx (cc, FP)->f ; - - chart_vector (roc_chart, 1 - sp, se); - } - chart_vector_end (roc_chart); - casereader_destroy (r); - } - - chart_write_legend (roc_chart); - - chart_submit (roc_chart); -} - - static void output_roc (struct roc_state *rs, const struct cmd_roc *roc) { show_summary (roc); if ( roc->curve ) - draw_roc (rs, roc); + { + struct roc_chart *rc; + size_t i; + + rc = roc_chart_create (roc->reference); + for (i = 0; i < roc->n_vars; i++) + roc_chart_add_var (rc, var_get_name (roc->vars[i]), + rs[i].cutpoint_rdr); + roc_chart_submit (rc); + } show_auc (rs, roc); - if ( roc->print_coords ) show_coords (rs, roc); }