X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fexamine.q;h=988ef77934280907bf5943344b0635cb761db19f;hb=1c4b7cfcec922cf6d1e92a607f23f00d26e7324e;hp=14981e884e0469ae3c2ab080904684cc13ca7608;hpb=2322678e8fddbbf158b01b2720db2636404bba3b;p=pspp diff --git a/src/language/stats/examine.q b/src/language/stats/examine.q index 14981e884e..988ef77934 100644 --- a/src/language/stats/examine.q +++ b/src/language/stats/examine.q @@ -19,51 +19,56 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include + #include -#include "message.h" +#include +#include #include #include -#include -#include "alloc.h" -#include "str.h" -#include "case.h" -#include "dictionary.h" -#include "command.h" -#include "compiler.h" -#include "lexer.h" -#include "message.h" -#include "magic.h" -#include "misc.h" -#include "table.h" -#include "manager.h" -#include "value-labels.h" -#include "variable.h" -#include "procedure.h" -#include "hash.h" -#include "casefile.h" -#include "factor-stats.h" -#include "moments.h" -#include "percentiles.h" -#include "box-whisker.h" -#include "cartesian.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 "minmax.h" #include "gettext.h" #define _(msgid) gettext (msgid) #define N_(msgid) msgid /* (headers) */ -#include "chart.h" -#include "plot-hist.h" -#include "plot-chart.h" +#include +#include +#include /* (specification) "EXAMINE" (xmn_): *^variables=custom; +total=custom; +nototal=custom; - +missing=miss:pairwise/!listwise, - rep:report/!noreport, - incl:include/!exclude; + missing=miss:pairwise/!listwise, + rep:report/!noreport, + incl:include/!exclude; +compare=cmp:variables/!groups; +percentiles=custom; +id=var; @@ -107,40 +112,40 @@ static struct factor *factors=0; static struct metrics *totals=0; /* Parse the clause specifying the factors */ -static int examine_parse_independent_vars(struct cmd_examine *cmd); +static int examine_parse_independent_vars (struct lexer *lexer, const struct dictionary *dict, struct cmd_examine *cmd); /* Output functions */ -static void show_summary(struct variable **dependent_var, int n_dep_var, +static void show_summary (struct variable **dependent_var, int n_dep_var, const struct factor *f); -static void show_extremes(struct variable **dependent_var, +static void show_extremes (struct variable **dependent_var, int n_dep_var, const struct factor *factor, int n_extremities); -static void show_descriptives(struct variable **dependent_var, +static void show_descriptives (struct variable **dependent_var, int n_dep_var, struct factor *factor); -static void show_percentiles(struct variable **dependent_var, +static void show_percentiles (struct variable **dependent_var, int n_dep_var, struct factor *factor); -void np_plot(const struct metrics *m, const char *factorname); +void np_plot (const struct metrics *m, const char *factorname); -void box_plot_group(const struct factor *fctr, +void box_plot_group (const struct factor *fctr, const struct variable **vars, int n_vars, const struct variable *id ) ; -void box_plot_variables(const struct factor *fctr, +void box_plot_variables (const struct factor *fctr, const struct variable **vars, int n_vars, const struct variable *id ); @@ -148,18 +153,19 @@ void box_plot_variables(const struct factor *fctr, /* Per Split function */ -static bool run_examine(const struct casefile *cf, void *cmd_); +static bool run_examine (const struct ccase *, + const struct casefile *cf, void *cmd_, const struct dataset *); -static void output_examine(void); +static void output_examine (void); -void factor_calc(struct ccase *c, int case_no, +void factor_calc (struct ccase *c, int case_no, double weight, int case_missing); /* Represent a factor as a string, so it can be printed in a human readable fashion */ -const char * factor_to_string(const struct factor *fctr, +const char * factor_to_string (const struct factor *fctr, struct factor_statistics *fs, const struct variable *var); @@ -167,14 +173,14 @@ const char * factor_to_string(const struct factor *fctr, /* Represent a factor as a string, so it can be printed in a human readable fashion, but sacrificing some readablility for the sake of brevity */ -const char *factor_to_string_concise(const struct factor *fctr, +const char *factor_to_string_concise (const struct factor *fctr, struct factor_statistics *fs); /* Function to use for testing for missing values */ -static is_missing_func *value_is_missing; +static var_is_missing_func *value_is_missing; /* PERCENTILES */ @@ -187,21 +193,24 @@ static short sbc_percentile; int -cmd_examine(void) +cmd_examine (struct lexer *lexer, struct dataset *ds) { bool ok; - subc_list_double_create(&percentile_list); + subc_list_double_create (&percentile_list); percentile_algorithm = PC_HAVERAGE; - if ( !parse_examine(&cmd) ) - return CMD_FAILURE; + if ( !parse_examine (lexer, ds, &cmd, NULL) ) + { + subc_list_double_destroy (&percentile_list); + return CMD_FAILURE; + } /* If /MISSING=INCLUDE is set, then user missing values are ignored */ if (cmd.incl == XMN_INCLUDE ) - value_is_missing = mv_is_value_system_missing; + value_is_missing = var_is_value_system_missing; else - value_is_missing = mv_is_value_missing; + value_is_missing = var_is_value_missing; if ( cmd.st_n == SYSMIS ) cmd.st_n = 5; @@ -213,16 +222,16 @@ cmd_examine(void) quartiles are calculated */ if ( cmd.a_statistics[XMN_ST_DESCRIPTIVES] ) { - subc_list_double_push(&percentile_list, 25); - subc_list_double_push(&percentile_list, 50); - subc_list_double_push(&percentile_list, 75); + subc_list_double_push (&percentile_list, 25); + subc_list_double_push (&percentile_list, 50); + subc_list_double_push (&percentile_list, 75); } - ok = multipass_procedure_with_splits (run_examine, &cmd); + ok = multipass_procedure_with_splits (ds, run_examine, &cmd); if ( totals ) { - free( totals ); + free ( totals ); } if ( dependent_vars ) @@ -242,7 +251,7 @@ cmd_examine(void) factors = 0; } - subc_list_double_destroy(&percentile_list); + subc_list_double_destroy (&percentile_list); return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE; }; @@ -251,46 +260,53 @@ cmd_examine(void) /* Show all the appropriate tables */ static void -output_examine(void) +output_examine (void) { struct factor *fctr; /* Show totals if appropriate */ if ( ! cmd.sbc_nototal || factors == 0 ) { - show_summary(dependent_vars, n_dependent_vars, 0); + show_summary (dependent_vars, n_dependent_vars, 0); if ( cmd.sbc_statistics ) { if ( cmd.a_statistics[XMN_ST_EXTREME]) - show_extremes(dependent_vars, n_dependent_vars, 0, cmd.st_n); + show_extremes (dependent_vars, n_dependent_vars, 0, cmd.st_n); if ( cmd.a_statistics[XMN_ST_DESCRIPTIVES]) - show_descriptives(dependent_vars, n_dependent_vars, 0); + show_descriptives (dependent_vars, n_dependent_vars, 0); } if ( sbc_percentile ) - show_percentiles(dependent_vars, n_dependent_vars, 0); + show_percentiles (dependent_vars, n_dependent_vars, 0); if ( cmd.sbc_plot) { int v; + if ( cmd.a_plot[XMN_PLT_STEMLEAF] ) + msg (SW, _ ("%s is not currently supported."), "STEMLEAF"); + + if ( cmd.a_plot[XMN_PLT_SPREADLEVEL] ) + msg (SW, _ ("%s is not currently supported."), "SPREADLEVEL"); + if ( cmd.a_plot[XMN_PLT_NPPLOT] ) { for ( v = 0 ; v < n_dependent_vars; ++v ) - np_plot(&totals[v], var_to_string(dependent_vars[v])); + np_plot (&totals[v], var_to_string (dependent_vars[v])); } if ( cmd.a_plot[XMN_PLT_BOXPLOT] ) { if ( cmd.cmp == XMN_GROUPS ) { - box_plot_group(0, dependent_vars, n_dependent_vars, - cmd.v_id); + box_plot_group (0, (const struct variable **) dependent_vars, + n_dependent_vars, cmd.v_id); } else - box_plot_variables(0, dependent_vars, n_dependent_vars, - cmd.v_id); + box_plot_variables (0, + (const struct variable **) dependent_vars, + n_dependent_vars, cmd.v_id); } if ( cmd.a_plot[XMN_PLT_HISTOGRAM] ) @@ -303,8 +319,8 @@ output_examine(void) normal.mean = totals[v].mean; normal.stddev = totals[v].stddev; - histogram_plot(totals[v].histogram, - var_to_string(dependent_vars[v]), + histogram_plot (totals[v].histogram, + var_to_string (dependent_vars[v]), &normal, 0); } } @@ -318,19 +334,19 @@ output_examine(void) fctr = factors; while ( fctr ) { - show_summary(dependent_vars, n_dependent_vars, fctr); + show_summary (dependent_vars, n_dependent_vars, fctr); if ( cmd.sbc_statistics ) { if ( cmd.a_statistics[XMN_ST_EXTREME]) - show_extremes(dependent_vars, n_dependent_vars, fctr, cmd.st_n); + show_extremes (dependent_vars, n_dependent_vars, fctr, cmd.st_n); if ( cmd.a_statistics[XMN_ST_DESCRIPTIVES]) - show_descriptives(dependent_vars, n_dependent_vars, fctr); + show_descriptives (dependent_vars, n_dependent_vars, fctr); } if ( sbc_percentile ) - show_percentiles(dependent_vars, n_dependent_vars, fctr); + show_percentiles (dependent_vars, n_dependent_vars, fctr); if ( cmd.sbc_plot) @@ -342,11 +358,13 @@ output_examine(void) if ( cmd.a_plot[XMN_PLT_BOXPLOT] ) { if ( cmd.cmp == XMN_VARIABLES ) - box_plot_variables(fctr, dependent_vars, n_dependent_vars, - cmd.v_id); + box_plot_variables (fctr, + (const struct variable **) dependent_vars, + n_dependent_vars, cmd.v_id); else - box_plot_group(fctr, dependent_vars, n_dependent_vars, - cmd.v_id); + box_plot_group (fctr, + (const struct variable **) dependent_vars, + n_dependent_vars, cmd.v_id); } for ( v = 0 ; v < n_dependent_vars; ++v ) @@ -354,10 +372,10 @@ output_examine(void) for ( fs = fctr->fs ; *fs ; ++fs ) { - const char *s = factor_to_string(fctr, *fs, dependent_vars[v]); + const char *s = factor_to_string (fctr, *fs, dependent_vars[v]); if ( cmd.a_plot[XMN_PLT_NPPLOT] ) - np_plot(&(*fs)->m[v], s); + np_plot (& (*fs)->m[v], s); if ( cmd.a_plot[XMN_PLT_HISTOGRAM] ) { @@ -367,7 +385,7 @@ output_examine(void) normal.mean = (*fs)->m[v].mean; normal.stddev = (*fs)->m[v].stddev; - histogram_plot((*fs)->m[v].histogram, + histogram_plot ((*fs)->m[v].histogram, s, &normal, 0); } @@ -386,27 +404,27 @@ output_examine(void) /* Create a hash table of percentiles and their values from the list of percentiles */ static struct hsh_table * -list_to_ptile_hash(const subc_list_double *l) +list_to_ptile_hash (const subc_list_double *l) { int i; struct hsh_table *h ; - h = hsh_create(subc_list_double_count(l), + h = hsh_create (subc_list_double_count (l), (hsh_compare_func *) ptile_compare, (hsh_hash_func *) ptile_hash, (hsh_free_func *) free, 0); - for ( i = 0 ; i < subc_list_double_count(l) ; ++i ) + for ( i = 0 ; i < subc_list_double_count (l) ; ++i ) { struct percentile *p = xmalloc (sizeof *p); - p->p = subc_list_double_at(l,i); + p->p = subc_list_double_at (l,i); p->v = SYSMIS; - hsh_insert(h, p); + hsh_insert (h, p); } @@ -416,54 +434,55 @@ list_to_ptile_hash(const subc_list_double *l) /* Parse the PERCENTILES subcommand */ static int -xmn_custom_percentiles(struct cmd_examine *p UNUSED) +xmn_custom_percentiles (struct lexer *lexer, struct dataset *ds UNUSED, + struct cmd_examine *p UNUSED, void *aux UNUSED) { sbc_percentile = 1; - lex_match('='); + lex_match (lexer, '='); - lex_match('('); + lex_match (lexer, '('); - while ( lex_is_number() ) + while ( lex_is_number (lexer) ) { - subc_list_double_push(&percentile_list,lex_number()); + subc_list_double_push (&percentile_list, lex_number (lexer)); - lex_get(); + lex_get (lexer); - lex_match(',') ; + lex_match (lexer, ',') ; } - lex_match(')'); + lex_match (lexer, ')'); - lex_match('='); + lex_match (lexer, '='); - if ( lex_match_id("HAVERAGE")) + if ( lex_match_id (lexer, "HAVERAGE")) percentile_algorithm = PC_HAVERAGE; - else if ( lex_match_id("WAVERAGE")) + else if ( lex_match_id (lexer, "WAVERAGE")) percentile_algorithm = PC_WAVERAGE; - else if ( lex_match_id("ROUND")) + else if ( lex_match_id (lexer, "ROUND")) percentile_algorithm = PC_ROUND; - else if ( lex_match_id("EMPIRICAL")) + else if ( lex_match_id (lexer, "EMPIRICAL")) percentile_algorithm = PC_EMPIRICAL; - else if ( lex_match_id("AEMPIRICAL")) + else if ( lex_match_id (lexer, "AEMPIRICAL")) percentile_algorithm = PC_AEMPIRICAL; - else if ( lex_match_id("NONE")) + else if ( lex_match_id (lexer, "NONE")) percentile_algorithm = PC_NONE; - if ( 0 == subc_list_double_count(&percentile_list)) + if ( 0 == subc_list_double_count (&percentile_list)) { - subc_list_double_push(&percentile_list, 5); - subc_list_double_push(&percentile_list, 10); - subc_list_double_push(&percentile_list, 25); - subc_list_double_push(&percentile_list, 50); - subc_list_double_push(&percentile_list, 75); - subc_list_double_push(&percentile_list, 90); - subc_list_double_push(&percentile_list, 95); + subc_list_double_push (&percentile_list, 5); + subc_list_double_push (&percentile_list, 10); + subc_list_double_push (&percentile_list, 25); + subc_list_double_push (&percentile_list, 50); + subc_list_double_push (&percentile_list, 75); + subc_list_double_push (&percentile_list, 90); + subc_list_double_push (&percentile_list, 95); } return 1; @@ -471,11 +490,11 @@ xmn_custom_percentiles(struct cmd_examine *p UNUSED) /* TOTAL and NOTOTAL are simple, mutually exclusive flags */ static int -xmn_custom_total(struct cmd_examine *p) +xmn_custom_total (struct lexer *lexer UNUSED, struct dataset *ds UNUSED, struct cmd_examine *p, void *aux UNUSED) { if ( p->sbc_nototal ) { - msg (SE, _("%s and %s are mutually exclusive"),"TOTAL","NOTOTAL"); + msg (SE, _ ("%s and %s are mutually exclusive"),"TOTAL","NOTOTAL"); return 0; } @@ -483,11 +502,12 @@ xmn_custom_total(struct cmd_examine *p) } static int -xmn_custom_nototal(struct cmd_examine *p) +xmn_custom_nototal (struct lexer *lexer UNUSED, struct dataset *ds UNUSED, + struct cmd_examine *p, void *aux UNUSED) { if ( p->sbc_total ) { - msg (SE, _("%s and %s are mutually exclusive"),"TOTAL","NOTOTAL"); + msg (SE, _ ("%s and %s are mutually exclusive"),"TOTAL","NOTOTAL"); return 0; } @@ -499,31 +519,32 @@ xmn_custom_nototal(struct cmd_examine *p) /* Parser for the variables sub command Returns 1 on success */ static int -xmn_custom_variables(struct cmd_examine *cmd ) +xmn_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_examine *cmd, void *aux UNUSED) { - lex_match('='); + const struct dictionary *dict = dataset_dict (ds); + lex_match (lexer, '='); - if ((token != T_ID || dict_lookup_var (default_dict, tokid) == NULL) - && token != T_ALL) + if ( (lex_token (lexer) != T_ID || dict_lookup_var (dict, lex_tokid (lexer)) == NULL) + && lex_token (lexer) != T_ALL) { return 2; } - if (!parse_variables (default_dict, &dependent_vars, &n_dependent_vars, + if (!parse_variables (lexer, dict, &dependent_vars, &n_dependent_vars, PV_NO_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH) ) { free (dependent_vars); return 0; } - assert(n_dependent_vars); + assert (n_dependent_vars); totals = xnmalloc (n_dependent_vars, sizeof *totals); - if ( lex_match(T_BY)) + if ( lex_match (lexer, T_BY)) { int success ; - success = examine_parse_independent_vars(cmd); + success = examine_parse_independent_vars (lexer, dict, cmd); if ( success != 1 ) { free (dependent_vars); free (totals) ; @@ -538,40 +559,40 @@ xmn_custom_variables(struct cmd_examine *cmd ) /* Parse the clause specifying the factors */ static int -examine_parse_independent_vars(struct cmd_examine *cmd) +examine_parse_independent_vars (struct lexer *lexer, const struct dictionary *dict, struct cmd_examine *cmd) { int success; struct factor *sf = xmalloc (sizeof *sf); - if ((token != T_ID || dict_lookup_var (default_dict, tokid) == NULL) - && token != T_ALL) + if ( (lex_token (lexer) != T_ID || dict_lookup_var (dict, lex_tokid (lexer)) == NULL) + && lex_token (lexer) != T_ALL) { free ( sf ) ; return 2; } - sf->indep_var[0] = parse_variable(); + sf->indep_var[0] = parse_variable (lexer, dict); sf->indep_var[1] = 0; - if ( token == T_BY ) + if ( lex_token (lexer) == T_BY ) { - lex_match(T_BY); + lex_match (lexer, T_BY); - if ((token != T_ID || dict_lookup_var (default_dict, tokid) == NULL) - && token != T_ALL) + if ( (lex_token (lexer) != T_ID || dict_lookup_var (dict, lex_tokid (lexer)) == NULL) + && lex_token (lexer) != T_ALL) { free ( sf ) ; return 2; } - sf->indep_var[1] = parse_variable(); + sf->indep_var[1] = parse_variable (lexer, dict); } - sf->fstats = hsh_create(4, + sf->fstats = hsh_create (4, (hsh_compare_func *) factor_statistics_compare, (hsh_hash_func *) factor_statistics_hash, (hsh_free_func *) factor_statistics_free, @@ -580,12 +601,12 @@ examine_parse_independent_vars(struct cmd_examine *cmd) sf->next = factors; factors = sf; - lex_match(','); + lex_match (lexer, ','); - if ( token == '.' || token == '/' ) + if ( lex_token (lexer) == '.' || lex_token (lexer) == '/' ) return 1; - success = examine_parse_independent_vars(cmd); + success = examine_parse_independent_vars (lexer, dict, cmd); if ( success != 1 ) free ( sf ) ; @@ -596,27 +617,27 @@ examine_parse_independent_vars(struct cmd_examine *cmd) -void populate_percentiles(struct tab_table *tbl, int col, int row, +void populate_percentiles (struct tab_table *tbl, int col, int row, const struct metrics *m); -void populate_descriptives(struct tab_table *t, int col, int row, +void populate_descriptives (struct tab_table *t, int col, int row, const struct metrics *fs); -void populate_extremes(struct tab_table *t, int col, int row, int n, +void populate_extremes (struct tab_table *t, int col, int row, int n, const struct metrics *m); -void populate_summary(struct tab_table *t, int col, int row, +void populate_summary (struct tab_table *t, int col, int row, const struct metrics *m); -static int bad_weight_warn = 1; +static bool bad_weight_warn = true; /* Perform calculations for the sub factors */ void -factor_calc(struct ccase *c, int case_no, double weight, int case_missing) +factor_calc (struct ccase *c, int case_no, double weight, int case_missing) { size_t v; struct factor *fctr = factors; @@ -626,28 +647,28 @@ factor_calc(struct ccase *c, int case_no, double weight, int case_missing) struct factor_statistics **foo ; union value indep_vals[2] ; - indep_vals[0] = * case_data(c, fctr->indep_var[0]->fv); + indep_vals[0] = * case_data (c, fctr->indep_var[0]->fv); if ( fctr->indep_var[1] ) - indep_vals[1] = * case_data(c, fctr->indep_var[1]->fv); + indep_vals[1] = * case_data (c, fctr->indep_var[1]->fv); else indep_vals[1].f = SYSMIS; - assert(fctr->fstats); + assert (fctr->fstats); foo = ( struct factor_statistics ** ) - hsh_probe(fctr->fstats, (void *) &indep_vals); + hsh_probe (fctr->fstats, (void *) &indep_vals); if ( !*foo ) { - *foo = create_factor_statistics(n_dependent_vars, + *foo = create_factor_statistics (n_dependent_vars, &indep_vals[0], &indep_vals[1]); for ( v = 0 ; v < n_dependent_vars ; ++v ) { - metrics_precalc( &(*foo)->m[v] ); + metrics_precalc ( & (*foo)->m[v] ); } } @@ -657,10 +678,10 @@ factor_calc(struct ccase *c, int case_no, double weight, int case_missing) const struct variable *var = dependent_vars[v]; const union value *val = case_data (c, var->fv); - if ( value_is_missing (&var->miss, val) || case_missing ) + if ( value_is_missing (var, val) || case_missing ) val = 0; - metrics_calc( &(*foo)->m[v], val, weight, case_no); + metrics_calc ( & (*foo)->m[v], val, weight, case_no); } @@ -671,42 +692,46 @@ factor_calc(struct ccase *c, int case_no, double weight, int case_missing) } static bool -run_examine(const struct casefile *cf, void *cmd_ ) +run_examine (const struct ccase *first, const struct casefile *cf, + void *cmd_, const struct dataset *ds) { + struct dictionary *dict = dataset_dict (ds); struct casereader *r; struct ccase c; int v; const struct cmd_examine *cmd = (struct cmd_examine *) cmd_; + struct factor *fctr; + + output_split_file_values (ds, first); + /* Make sure we haven't got rubbish left over from a previous split */ - struct factor *fctr = factors; + fctr = factors; while (fctr) { struct factor *next = fctr->next; - hsh_clear(fctr->fstats); + hsh_clear (fctr->fstats); fctr->fs = 0; fctr = next; } - - for ( v = 0 ; v < n_dependent_vars ; ++v ) - metrics_precalc(&totals[v]); + metrics_precalc (&totals[v]); - for(r = casefile_get_reader (cf); + for (r = casefile_get_reader (cf, NULL); casereader_read (r, &c) ; case_destroy (&c) ) { int case_missing=0; - const int case_no = casereader_cnum(r); + const int case_no = casereader_cnum (r); const double weight = - dict_get_case_weight(default_dict, &c, &bad_weight_warn); + dict_get_case_weight (dict, &c, &bad_weight_warn); if ( cmd->miss == XMN_LISTWISE ) { @@ -715,7 +740,7 @@ run_examine(const struct casefile *cf, void *cmd_ ) const struct variable *var = dependent_vars[v]; const union value *val = case_data (&c, var->fv); - if ( value_is_missing(&var->miss, val)) + if ( value_is_missing (var, val)) case_missing = 1; } @@ -726,14 +751,14 @@ run_examine(const struct casefile *cf, void *cmd_ ) const struct variable *var = dependent_vars[v]; const union value *val = case_data (&c, var->fv); - if ( value_is_missing(&var->miss, val) || case_missing ) + if ( value_is_missing (var, val) || case_missing ) val = 0; - metrics_calc(&totals[v], val, weight, case_no); + metrics_calc (&totals[v], val, weight, case_no); } - factor_calc(&c, case_no, weight, case_missing); + factor_calc (&c, case_no, weight, case_missing); } @@ -746,22 +771,22 @@ run_examine(const struct casefile *cf, void *cmd_ ) struct hsh_iterator hi; struct factor_statistics *fs; - for ( fs = hsh_first(fctr->fstats, &hi); + for ( fs = hsh_first (fctr->fstats, &hi); fs != 0 ; - fs = hsh_next(fctr->fstats, &hi)) + fs = hsh_next (fctr->fstats, &hi)) { - fs->m[v].ptile_hash = list_to_ptile_hash(&percentile_list); + fs->m[v].ptile_hash = list_to_ptile_hash (&percentile_list); fs->m[v].ptile_alg = percentile_algorithm; - metrics_postcalc(&fs->m[v]); + metrics_postcalc (&fs->m[v]); } fctr = fctr->next; } - totals[v].ptile_hash = list_to_ptile_hash(&percentile_list); + totals[v].ptile_hash = list_to_ptile_hash (&percentile_list); totals[v].ptile_alg = percentile_algorithm; - metrics_postcalc(&totals[v]); + metrics_postcalc (&totals[v]); } @@ -780,31 +805,31 @@ run_examine(const struct casefile *cf, void *cmd_ ) union value *val0; union value *val1; - idh0 = hsh_create(4, (hsh_compare_func *) compare_values, - (hsh_hash_func *) hash_value, + idh0 = hsh_create (4, (hsh_compare_func *) compare_values, + (hsh_hash_func *) hash_value, 0,0); - idh1 = hsh_create(4, (hsh_compare_func *) compare_values, - (hsh_hash_func *) hash_value, + idh1 = hsh_create (4, (hsh_compare_func *) compare_values, + (hsh_hash_func *) hash_value, 0,0); - for ( fs = hsh_first(fctr->fstats, &hi); + for ( fs = hsh_first (fctr->fstats, &hi); fs != 0 ; - fs = hsh_next(fctr->fstats, &hi)) + fs = hsh_next (fctr->fstats, &hi)) { - hsh_insert(idh0,(void *) &fs->id[0]); - hsh_insert(idh1,(void *) &fs->id[1]); + hsh_insert (idh0, (void *) &fs->id[0]); + hsh_insert (idh1, (void *) &fs->id[1]); } /* Ensure that the factors combination is complete */ - for ( val0 = hsh_first(idh0, &hi0); + for ( val0 = hsh_first (idh0, &hi0); val0 != 0 ; - val0 = hsh_next(idh0, &hi0)) + val0 = hsh_next (idh0, &hi0)) { - for ( val1 = hsh_first(idh1, &hi1); + for ( val1 = hsh_first (idh1, &hi1); val1 != 0 ; - val1 = hsh_next(idh1, &hi1)) + val1 = hsh_next (idh1, &hi1)) { struct factor_statistics **ffs; union value key[2]; @@ -812,27 +837,27 @@ run_examine(const struct casefile *cf, void *cmd_ ) key[1] = *val1; ffs = (struct factor_statistics **) - hsh_probe(fctr->fstats, (void *) &key ); + hsh_probe (fctr->fstats, (void *) &key ); if ( !*ffs ) { size_t i; - (*ffs) = create_factor_statistics (n_dependent_vars, + (*ffs) = create_factor_statistics (n_dependent_vars, &key[0], &key[1]); for ( i = 0 ; i < n_dependent_vars ; ++i ) - metrics_precalc( &(*ffs)->m[i]); + metrics_precalc ( & (*ffs)->m[i]); } } } - hsh_destroy(idh0); - hsh_destroy(idh1); + hsh_destroy (idh0); + hsh_destroy (idh1); - fctr->fs = (struct factor_statistics **) hsh_sort_copy(fctr->fstats); + fctr->fs = (struct factor_statistics **) hsh_sort_copy (fctr->fstats); fctr = fctr->next; } - output_examine(); + output_examine (); if ( totals ) @@ -840,7 +865,7 @@ run_examine(const struct casefile *cf, void *cmd_ ) size_t i; for ( i = 0 ; i < n_dependent_vars ; ++i ) { - metrics_destroy(&totals[i]); + metrics_destroy (&totals[i]); } } @@ -849,14 +874,14 @@ run_examine(const struct casefile *cf, void *cmd_ ) static void -show_summary(struct variable **dependent_var, int n_dep_var, +show_summary (struct variable **dependent_var, int n_dep_var, const struct factor *fctr) { static const char *subtitle[]= { - N_("Valid"), - N_("Missing"), - N_("Total") + N_ ("Valid"), + N_ ("Missing"), + N_ ("Total") }; int i; @@ -871,7 +896,7 @@ show_summary(struct variable **dependent_var, int n_dep_var, if ( fctr ) { heading_columns = 2; - n_factors = hsh_count(fctr->fstats); + n_factors = hsh_count (fctr->fstats); n_rows = n_dep_var * n_factors ; if ( fctr->indep_var[1] ) @@ -914,13 +939,13 @@ show_summary(struct variable **dependent_var, int n_dep_var, tab_vline (tbl, TAL_2, heading_columns, 0, n_rows - 1); - tab_title (tbl, 0, _("Case Processing Summary")); + tab_title (tbl, _ ("Case Processing Summary")); - tab_joint_text(tbl, heading_columns, 0, + tab_joint_text (tbl, heading_columns, 0, n_cols -1, 0, TAB_CENTER | TAT_TITLE, - _("Cases")); + _ ("Cases")); /* Remove lines ... */ tab_box (tbl, @@ -932,12 +957,12 @@ show_summary(struct variable **dependent_var, int n_dep_var, for ( i = 0 ; i < 3 ; ++i ) { tab_text (tbl, heading_columns + i*2 , 2, TAB_CENTER | TAT_TITLE, - _("N")); + _ ("N")); tab_text (tbl, heading_columns + i*2 + 1, 2, TAB_CENTER | TAT_TITLE, - _("Percent")); + _ ("Percent")); - tab_joint_text(tbl, heading_columns + i*2 , 1, + tab_joint_text (tbl, heading_columns + i*2 , 1, heading_columns + i*2 + 1, 1, TAB_CENTER | TAT_TITLE, subtitle[i]); @@ -954,12 +979,12 @@ show_summary(struct variable **dependent_var, int n_dep_var, if ( fctr ) { tab_text (tbl, 1, heading_rows - 1, TAB_CENTER | TAT_TITLE, - var_to_string(fctr->indep_var[0])); + var_to_string (fctr->indep_var[0])); if ( fctr->indep_var[1] ) { tab_text (tbl, 2, heading_rows - 1, TAB_CENTER | TAT_TITLE, - var_to_string(fctr->indep_var[1])); + var_to_string (fctr->indep_var[1])); } } @@ -969,21 +994,21 @@ show_summary(struct variable **dependent_var, int n_dep_var, { int n_factors = 1; if ( fctr ) - n_factors = hsh_count(fctr->fstats); + n_factors = hsh_count (fctr->fstats); if ( i > 0 ) - tab_hline(tbl, TAL_1, 0, n_cols -1 , i * n_factors + heading_rows); + tab_hline (tbl, TAL_1, 0, n_cols -1 , i * n_factors + heading_rows); tab_text (tbl, 0, i * n_factors + heading_rows, TAB_LEFT | TAT_TITLE, - var_to_string(dependent_var[i]) + var_to_string (dependent_var[i]) ); if ( !fctr ) - populate_summary(tbl, heading_columns, + populate_summary (tbl, heading_columns, (i * n_factors) + heading_rows, &totals[i]); @@ -997,19 +1022,19 @@ show_summary(struct variable **dependent_var, int n_dep_var, { static union value prev; - if ( 0 != compare_values(&prev, &(*fs)->id[0], - fctr->indep_var[0]->width)) + if ( 0 != compare_values (&prev, & (*fs)->id[0], + var_get_width (fctr->indep_var[0]))) { tab_text (tbl, 1, (i * n_factors ) + count + heading_rows, TAB_LEFT | TAT_TITLE, - value_to_string(&(*fs)->id[0], fctr->indep_var[0]) + value_to_string (& (*fs)->id[0], fctr->indep_var[0]) ); if (fctr->indep_var[1] && count > 0 ) - tab_hline(tbl, TAL_1, 1, n_cols - 1, + tab_hline (tbl, TAL_1, 1, n_cols - 1, (i * n_factors ) + count + heading_rows); } @@ -1023,13 +1048,13 @@ show_summary(struct variable **dependent_var, int n_dep_var, (i * n_factors ) + count + heading_rows, TAB_LEFT | TAT_TITLE, - value_to_string(&(*fs)->id[1], fctr->indep_var[1]) + value_to_string (& (*fs)->id[1], fctr->indep_var[1]) ); - populate_summary(tbl, heading_columns, + populate_summary (tbl, heading_columns, (i * n_factors) + count + heading_rows, - &(*fs)->m[i]); + & (*fs)->m[i]); count++ ; fs++; @@ -1042,15 +1067,15 @@ show_summary(struct variable **dependent_var, int n_dep_var, void -populate_summary(struct tab_table *t, int col, int row, +populate_summary (struct tab_table *t, int col, int row, const struct metrics *m) { const double total = m->n + m->n_missing ; - tab_float(t, col + 0, row + 0, TAB_RIGHT, m->n, 8, 0); - tab_float(t, col + 2, row + 0, TAB_RIGHT, m->n_missing, 8, 0); - tab_float(t, col + 4, row + 0, TAB_RIGHT, total, 8, 0); + tab_float (t, col + 0, row + 0, TAB_RIGHT, m->n, 8, 0); + tab_float (t, col + 2, row + 0, TAB_RIGHT, m->n_missing, 8, 0); + tab_float (t, col + 4, row + 0, TAB_RIGHT, total, 8, 0); if ( total > 0 ) { @@ -1073,7 +1098,7 @@ populate_summary(struct tab_table *t, int col, int row, static void -show_extremes(struct variable **dependent_var, int n_dep_var, +show_extremes (struct variable **dependent_var, int n_dep_var, const struct factor *fctr, int n_extremities) { int i; @@ -1088,7 +1113,7 @@ show_extremes(struct variable **dependent_var, int n_dep_var, if ( fctr ) { heading_columns = 2; - n_factors = hsh_count(fctr->fstats); + n_factors = hsh_count (fctr->fstats); n_rows = n_dep_var * 2 * n_extremities * n_factors; @@ -1120,7 +1145,7 @@ show_extremes(struct variable **dependent_var, int n_dep_var, tab_hline (tbl, TAL_2, 0, n_cols - 1, heading_rows ); - tab_title (tbl, 0, _("Extreme Values")); + tab_title (tbl, _ ("Extreme Values")); tab_vline (tbl, TAL_2, n_cols - 2, 0, n_rows -1); tab_vline (tbl, TAL_1, n_cols - 1, 0, n_rows -1); @@ -1128,32 +1153,32 @@ show_extremes(struct variable **dependent_var, int n_dep_var, if ( fctr ) { tab_text (tbl, 1, heading_rows - 1, TAB_CENTER | TAT_TITLE, - var_to_string(fctr->indep_var[0])); + var_to_string (fctr->indep_var[0])); if ( fctr->indep_var[1] ) tab_text (tbl, 2, heading_rows - 1, TAB_CENTER | TAT_TITLE, - var_to_string(fctr->indep_var[1])); + var_to_string (fctr->indep_var[1])); } - tab_text (tbl, n_cols - 1, 0, TAB_CENTER | TAT_TITLE, _("Value")); - tab_text (tbl, n_cols - 2, 0, TAB_CENTER | TAT_TITLE, _("Case Number")); + tab_text (tbl, n_cols - 1, 0, TAB_CENTER | TAT_TITLE, _ ("Value")); + tab_text (tbl, n_cols - 2, 0, TAB_CENTER | TAT_TITLE, _ ("Case Number")); for ( i = 0 ; i < n_dep_var ; ++i ) { if ( i > 0 ) - tab_hline(tbl, TAL_1, 0, n_cols -1 , + tab_hline (tbl, TAL_1, 0, n_cols -1 , i * 2 * n_extremities * n_factors + heading_rows); tab_text (tbl, 0, i * 2 * n_extremities * n_factors + heading_rows, TAB_LEFT | TAT_TITLE, - var_to_string(dependent_var[i]) + var_to_string (dependent_var[i]) ); if ( !fctr ) - populate_extremes(tbl, heading_columns - 2, + populate_extremes (tbl, heading_columns - 2, i * 2 * n_extremities * n_factors + heading_rows, n_extremities, &totals[i]); @@ -1167,11 +1192,11 @@ show_extremes(struct variable **dependent_var, int n_dep_var, static union value prev ; const int row = heading_rows + ( 2 * n_extremities ) * - ( ( i * n_factors ) + count ); + ( ( i * n_factors ) + count ); - if ( 0 != compare_values(&prev, &(*fs)->id[0], - fctr->indep_var[0]->width)) + if ( 0 != compare_values (&prev, & (*fs)->id[0], + var_get_width (fctr->indep_var[0]))) { if ( count > 0 ) @@ -1180,24 +1205,24 @@ show_extremes(struct variable **dependent_var, int n_dep_var, tab_text (tbl, 1, row, TAB_LEFT | TAT_TITLE, - value_to_string(&(*fs)->id[0], fctr->indep_var[0]) + value_to_string (& (*fs)->id[0], fctr->indep_var[0]) ); } prev = (*fs)->id[0]; if (fctr->indep_var[1] && count > 0 ) - tab_hline(tbl, TAL_1, 2, n_cols - 1, row); + tab_hline (tbl, TAL_1, 2, n_cols - 1, row); if ( fctr->indep_var[1]) tab_text (tbl, 2, row, TAB_LEFT | TAT_TITLE, - value_to_string(&(*fs)->id[1], fctr->indep_var[1]) + value_to_string (& (*fs)->id[1], fctr->indep_var[1]) ); - populate_extremes(tbl, heading_columns - 2, + populate_extremes (tbl, heading_columns - 2, row, n_extremities, - &(*fs)->m[i]); + & (*fs)->m[i]); count++ ; fs++; @@ -1205,43 +1230,43 @@ show_extremes(struct variable **dependent_var, int n_dep_var, } } - tab_submit(tbl); + tab_submit (tbl); } /* Fill in the extremities table */ void -populate_extremes(struct tab_table *t, +populate_extremes (struct tab_table *t, int col, int row, int n, const struct metrics *m) { int extremity; int idx=0; - tab_text(t, col, row, + tab_text (t, col, row, TAB_RIGHT | TAT_TITLE , - _("Highest") + _ ("Highest") ); - tab_text(t, col, row + n , + tab_text (t, col, row + n , TAB_RIGHT | TAT_TITLE , - _("Lowest") + _ ("Lowest") ); - tab_hline(t, TAL_1, col, col + 3, row + n ); + tab_hline (t, TAL_1, col, col + 3, row + n ); for (extremity = 0; extremity < n ; ++extremity ) { /* Highest */ - tab_float(t, col + 1, row + extremity, + tab_float (t, col + 1, row + extremity, TAB_RIGHT, extremity + 1, 8, 0); /* Lowest */ - tab_float(t, col + 1, row + extremity + n, + tab_float (t, col + 1, row + extremity + n, TAB_RIGHT, extremity + 1, 8, 0); @@ -1261,11 +1286,11 @@ populate_extremes(struct tab_table *t, if ( extremity + j >= n ) break ; - tab_float(t, col + 3, row + extremity + j + n, + tab_float (t, col + 3, row + extremity + j + n, TAB_RIGHT, wv->v.f, 8, 2); - tab_float(t, col + 2, row + extremity + j + n, + tab_float (t, col + 2, row + extremity + j + n, TAB_RIGHT, cn->num, 8, 0); @@ -1290,11 +1315,11 @@ populate_extremes(struct tab_table *t, if ( extremity + j >= n ) break ; - tab_float(t, col + 3, row + extremity + j, + tab_float (t, col + 3, row + extremity + j, TAB_RIGHT, wv->v.f, 8, 2); - tab_float(t, col + 2, row + extremity + j, + tab_float (t, col + 2, row + extremity + j, TAB_RIGHT, cn->num, 8, 0); @@ -1310,7 +1335,7 @@ populate_extremes(struct tab_table *t, /* Show the descriptives table */ void -show_descriptives(struct variable **dependent_var, +show_descriptives (struct variable **dependent_var, int n_dep_var, struct factor *fctr) { @@ -1329,7 +1354,7 @@ show_descriptives(struct variable **dependent_var, if ( fctr ) { heading_columns = 4; - n_factors = hsh_count(fctr->fstats); + n_factors = hsh_count (fctr->fstats); n_rows = n_dep_var * n_stat_rows * n_factors; @@ -1366,10 +1391,10 @@ show_descriptives(struct variable **dependent_var, tab_vline (tbl, TAL_2, n_cols - 2, 0, n_rows - 1); tab_vline (tbl, TAL_1, n_cols - 1, 0, n_rows - 1); - tab_text (tbl, n_cols - 2, 0, TAB_CENTER | TAT_TITLE, _("Statistic")); - tab_text (tbl, n_cols - 1, 0, TAB_CENTER | TAT_TITLE, _("Std. Error")); + tab_text (tbl, n_cols - 2, 0, TAB_CENTER | TAT_TITLE, _ ("Statistic")); + tab_text (tbl, n_cols - 1, 0, TAB_CENTER | TAT_TITLE, _ ("Std. Error")); - tab_title (tbl, 0, _("Descriptives")); + tab_title (tbl, _ ("Descriptives")); for ( i = 0 ; i < n_dep_var ; ++i ) @@ -1377,12 +1402,12 @@ show_descriptives(struct variable **dependent_var, const int row = heading_rows + i * n_stat_rows * n_factors ; if ( i > 0 ) - tab_hline(tbl, TAL_1, 0, n_cols - 1, row ); + tab_hline (tbl, TAL_1, 0, n_cols - 1, row ); tab_text (tbl, 0, i * n_stat_rows * n_factors + heading_rows, TAB_LEFT | TAT_TITLE, - var_to_string(dependent_var[i]) + var_to_string (dependent_var[i]) ); @@ -1392,24 +1417,24 @@ show_descriptives(struct variable **dependent_var, int count = 0; tab_text (tbl, 1, heading_rows - 1, TAB_CENTER | TAT_TITLE, - var_to_string(fctr->indep_var[0])); + var_to_string (fctr->indep_var[0])); if ( fctr->indep_var[1]) tab_text (tbl, 2, heading_rows - 1, TAB_CENTER | TAT_TITLE, - var_to_string(fctr->indep_var[1])); + var_to_string (fctr->indep_var[1])); - while( *fs ) + while ( *fs ) { static union value prev ; const int row = heading_rows + n_stat_rows * - ( ( i * n_factors ) + count ); + ( ( i * n_factors ) + count ); - if ( 0 != compare_values(&prev, &(*fs)->id[0], - fctr->indep_var[0]->width)) + if ( 0 != compare_values (&prev, & (*fs)->id[0], + var_get_width (fctr->indep_var[0]))) { if ( count > 0 ) @@ -1418,23 +1443,23 @@ show_descriptives(struct variable **dependent_var, tab_text (tbl, 1, row, TAB_LEFT | TAT_TITLE, - value_to_string(&(*fs)->id[0], fctr->indep_var[0]) + value_to_string (& (*fs)->id[0], fctr->indep_var[0]) ); } prev = (*fs)->id[0]; if (fctr->indep_var[1] && count > 0 ) - tab_hline(tbl, TAL_1, 2, n_cols - 1, row); + tab_hline (tbl, TAL_1, 2, n_cols - 1, row); if ( fctr->indep_var[1]) tab_text (tbl, 2, row, TAB_LEFT | TAT_TITLE, - value_to_string(&(*fs)->id[1], fctr->indep_var[1]) + value_to_string (& (*fs)->id[1], fctr->indep_var[1]) ); - populate_descriptives(tbl, heading_columns - 2, - row, &(*fs)->m[i]); + populate_descriptives (tbl, heading_columns - 2, + row, & (*fs)->m[i]); count++ ; fs++; @@ -1445,13 +1470,13 @@ show_descriptives(struct variable **dependent_var, else { - populate_descriptives(tbl, heading_columns - 2, + populate_descriptives (tbl, heading_columns - 2, i * n_stat_rows * n_factors + heading_rows, &totals[i]); } } - tab_submit(tbl); + tab_submit (tbl); } @@ -1460,18 +1485,18 @@ show_descriptives(struct variable **dependent_var, /* Fill in the descriptives data */ void -populate_descriptives(struct tab_table *tbl, int col, int row, +populate_descriptives (struct tab_table *tbl, int col, int row, const struct metrics *m) { - const double t = gsl_cdf_tdist_Qinv(1 - cmd.n_cinterval[0]/100.0/2.0, \ + const double t = gsl_cdf_tdist_Qinv (1 - cmd.n_cinterval[0]/100.0/2.0, \ m->n -1); tab_text (tbl, col, row, TAB_LEFT | TAT_TITLE, - _("Mean")); + _ ("Mean")); tab_float (tbl, col + 2, row, @@ -1489,13 +1514,13 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 1, TAB_LEFT | TAT_TITLE | TAT_PRINTF, - _("%g%% Confidence Interval for Mean"), cmd.n_cinterval[0]); + _ ("%g%% Confidence Interval for Mean"), cmd.n_cinterval[0]); tab_text (tbl, col + 1, row + 1, TAB_LEFT | TAT_TITLE, - _("Lower Bound")); + _ ("Lower Bound")); tab_float (tbl, col + 2, row + 1, @@ -1506,7 +1531,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col + 1, row + 2, TAB_LEFT | TAT_TITLE, - _("Upper Bound")); + _ ("Upper Bound")); tab_float (tbl, col + 2, @@ -1518,7 +1543,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 3, TAB_LEFT | TAT_TITLE | TAT_PRINTF, - _("5%% Trimmed Mean")); + _ ("5%% Trimmed Mean")); tab_float (tbl, col + 2, row + 3, @@ -1529,15 +1554,15 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 4, TAB_LEFT | TAT_TITLE, - _("Median")); + _ ("Median")); { struct percentile *p; double d = 50; - p = hsh_find(m->ptile_hash, &d); + p = hsh_find (m->ptile_hash, &d); - assert(p); + assert (p); tab_float (tbl, col + 2, @@ -1551,7 +1576,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 5, TAB_LEFT | TAT_TITLE, - _("Variance")); + _ ("Variance")); tab_float (tbl, col + 2, row + 5, @@ -1563,7 +1588,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 6, TAB_LEFT | TAT_TITLE, - _("Std. Deviation")); + _ ("Std. Deviation")); tab_float (tbl, col + 2, @@ -1576,7 +1601,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 7, TAB_LEFT | TAT_TITLE, - _("Minimum")); + _ ("Minimum")); tab_float (tbl, col + 2, row + 7, @@ -1587,7 +1612,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 8, TAB_LEFT | TAT_TITLE, - _("Maximum")); + _ ("Maximum")); tab_float (tbl, col + 2, row + 8, @@ -1599,7 +1624,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 9, TAB_LEFT | TAT_TITLE, - _("Range")); + _ ("Range")); tab_float (tbl, col + 2, @@ -1611,20 +1636,20 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 10, TAB_LEFT | TAT_TITLE, - _("Interquartile Range")); + _ ("Interquartile Range")); { struct percentile *p1; struct percentile *p2; double d = 75; - p1 = hsh_find(m->ptile_hash, &d); + p1 = hsh_find (m->ptile_hash, &d); d = 25; - p2 = hsh_find(m->ptile_hash, &d); + p2 = hsh_find (m->ptile_hash, &d); - assert(p1); - assert(p2); + assert (p1); + assert (p2); tab_float (tbl, col + 2, row + 10, @@ -1638,7 +1663,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_text (tbl, col, row + 11, TAB_LEFT | TAT_TITLE, - _("Skewness")); + _ ("Skewness")); tab_float (tbl, col + 2, @@ -1651,14 +1676,14 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_float (tbl, col + 3, row + 11, TAB_CENTER, - calc_seskew(m->n), + calc_seskew (m->n), 8,3); tab_text (tbl, col, row + 12, TAB_LEFT | TAT_TITLE, - _("Kurtosis")); + _ ("Kurtosis")); tab_float (tbl, col + 2, @@ -1671,7 +1696,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, tab_float (tbl, col + 3, row + 12, TAB_CENTER, - calc_sekurt(m->n), + calc_sekurt (m->n), 8,3); @@ -1680,7 +1705,7 @@ populate_descriptives(struct tab_table *tbl, int col, int row, void -box_plot_variables(const struct factor *fctr, +box_plot_variables (const struct factor *fctr, const struct variable **vars, int n_vars, const struct variable *id) { @@ -1690,7 +1715,7 @@ box_plot_variables(const struct factor *fctr, if ( ! fctr ) { - box_plot_group(fctr, vars, n_vars, id); + box_plot_group (fctr, vars, n_vars, id); return; } @@ -1698,18 +1723,18 @@ box_plot_variables(const struct factor *fctr, { double y_min = DBL_MAX; double y_max = -DBL_MAX; - struct chart *ch = chart_create(); - const char *s = factor_to_string(fctr, *fs, 0 ); + struct chart *ch = chart_create (); + const char *s = factor_to_string (fctr, *fs, 0 ); - chart_write_title(ch, s); + chart_write_title (ch, s); for ( i = 0 ; i < n_vars ; ++i ) { - y_max = max(y_max, (*fs)->m[i].max); - y_min = min(y_min, (*fs)->m[i].min); + y_max = MAX (y_max, (*fs)->m[i].max); + y_min = MIN (y_min, (*fs)->m[i].min); } - boxplot_draw_yscale(ch, y_max, y_min); + boxplot_draw_yscale (ch, y_max, y_min); for ( i = 0 ; i < n_vars ; ++i ) { @@ -1720,15 +1745,15 @@ box_plot_variables(const struct factor *fctr, const double box_centre = ( i * 2 + 1) * box_width + ch->data_left; - boxplot_draw_boxplot(ch, + boxplot_draw_boxplot (ch, box_centre, box_width, - &(*fs)->m[i], - var_to_string(vars[i])); + & (*fs)->m[i], + var_to_string (vars[i])); } - chart_submit(ch); + chart_submit (ch); } } @@ -1739,7 +1764,7 @@ box_plot_variables(const struct factor *fctr, each dependent variable has its own plot. */ void -box_plot_group(const struct factor *fctr, +box_plot_group (const struct factor *fctr, const struct variable **vars, int n_vars, const struct variable *id UNUSED) @@ -1752,9 +1777,9 @@ box_plot_group(const struct factor *fctr, struct factor_statistics **fs ; struct chart *ch; - ch = chart_create(); + ch = chart_create (); - boxplot_draw_yscale(ch, totals[i].max, totals[i].min); + boxplot_draw_yscale (ch, totals[i].max, totals[i].min); if ( fctr ) { @@ -1763,13 +1788,13 @@ box_plot_group(const struct factor *fctr, for ( fs = fctr->fs ; *fs ; ++fs ) ++n_factors; - chart_write_title(ch, _("Boxplot of %s vs. %s"), - var_to_string(vars[i]), var_to_string(fctr->indep_var[0]) ); + chart_write_title (ch, _ ("Boxplot of %s vs. %s"), + var_to_string (vars[i]), var_to_string (fctr->indep_var[0]) ); for ( fs = fctr->fs ; *fs ; ++fs ) { - const char *s = factor_to_string_concise(fctr, *fs); + const char *s = factor_to_string_concise (fctr, *fs); const double box_width = (ch->data_right - ch->data_left) / (n_factors * 2.0 ) ; @@ -1777,9 +1802,9 @@ box_plot_group(const struct factor *fctr, const double box_centre = ( f++ * 2 + 1) * box_width + ch->data_left; - boxplot_draw_boxplot(ch, + boxplot_draw_boxplot (ch, box_centre, box_width, - &(*fs)->m[i], + & (*fs)->m[i], s); } } @@ -1788,16 +1813,16 @@ box_plot_group(const struct factor *fctr, const double box_width = (ch->data_right - ch->data_left) / 3.0; const double box_centre = (ch->data_right + ch->data_left) / 2.0; - chart_write_title(ch, _("Boxplot")); + chart_write_title (ch, _ ("Boxplot")); - boxplot_draw_boxplot(ch, + boxplot_draw_boxplot (ch, box_centre, box_width, &totals[i], - var_to_string(vars[i]) ); + var_to_string (vars[i]) ); } - chart_submit(ch); + chart_submit (ch); } } @@ -1805,7 +1830,7 @@ box_plot_group(const struct factor *fctr, /* Plot the normal and detrended normal plots for m Label the plots with factorname */ void -np_plot(const struct metrics *m, const char *factorname) +np_plot (const struct metrics *m, const char *factorname) { int i; double yfirst=0, ylast=0; @@ -1824,21 +1849,21 @@ np_plot(const struct metrics *m, const char *factorname) if ( m->n_data == 0 ) return ; - np_chart = chart_create(); - dnp_chart = chart_create(); + np_chart = chart_create (); + dnp_chart = chart_create (); if ( !np_chart || ! dnp_chart ) return ; - chart_write_title(np_chart, _("Normal Q-Q Plot of %s"), factorname); - chart_write_xlabel(np_chart, _("Observed Value")); - chart_write_ylabel(np_chart, _("Expected Normal")); + chart_write_title (np_chart, _ ("Normal Q-Q Plot of %s"), factorname); + chart_write_xlabel (np_chart, _ ("Observed Value")); + chart_write_ylabel (np_chart, _ ("Expected Normal")); - chart_write_title(dnp_chart, _("Detrended Normal Q-Q Plot of %s"), + chart_write_title (dnp_chart, _ ("Detrended Normal Q-Q Plot of %s"), factorname); - chart_write_xlabel(dnp_chart, _("Observed Value")); - chart_write_ylabel(dnp_chart, _("Dev from Normal")); + chart_write_xlabel (dnp_chart, _ ("Observed Value")); + chart_write_ylabel (dnp_chart, _ ("Dev from Normal")); yfirst = gsl_cdf_ugaussian_Pinv (m->wvp[0]->rank / ( m->n + 1)); ylast = gsl_cdf_ugaussian_Pinv (m->wvp[m->n_data-1]->rank / ( m->n + 1)); @@ -1847,17 +1872,17 @@ np_plot(const struct metrics *m, const char *factorname) { /* Need to make sure that both the scatter plot and the ideal fit into the plot */ - double x_lower = min(m->min, (yfirst - intercept) / slope) ; - double x_upper = max(m->max, (ylast - intercept) / slope) ; + double x_lower = MIN (m->min, (yfirst - intercept) / slope) ; + double x_upper = MAX (m->max, (ylast - intercept) / slope) ; double slack = (x_upper - x_lower) * 0.05 ; - chart_write_xscale(np_chart, x_lower - slack, x_upper + slack, 5); + chart_write_xscale (np_chart, x_lower - slack, x_upper + slack, 5); - chart_write_xscale(dnp_chart, m->min, m->max, 5); + chart_write_xscale (dnp_chart, m->min, m->max, 5); } - chart_write_yscale(np_chart, yfirst, ylast, 5); + chart_write_yscale (np_chart, yfirst, ylast, 5); { /* We have to cache the detrended data, beacause we need to @@ -1869,26 +1894,26 @@ np_plot(const struct metrics *m, const char *factorname) { const double ns = gsl_cdf_ugaussian_Pinv (m->wvp[i]->rank / ( m->n + 1)); - chart_datum(np_chart, 0, m->wvp[i]->v.f, ns); + chart_datum (np_chart, 0, m->wvp[i]->v.f, ns); d_data[i] = (m->wvp[i]->v.f - m->mean) / m->stddev - ns; if ( d_data[i] < d_min ) d_min = d_data[i]; if ( d_data[i] > d_max ) d_max = d_data[i]; } - chart_write_yscale(dnp_chart, d_min, d_max, 5); + chart_write_yscale (dnp_chart, d_min, d_max, 5); for ( i = 0 ; i < m->n_data; ++i ) - chart_datum(dnp_chart, 0, m->wvp[i]->v.f, d_data[i]); + chart_datum (dnp_chart, 0, m->wvp[i]->v.f, d_data[i]); - free(d_data); + free (d_data); } - chart_line(np_chart, slope, intercept, yfirst, ylast , CHART_DIM_Y); - chart_line(dnp_chart, 0, 0, m->min, m->max , CHART_DIM_X); + chart_line (np_chart, slope, intercept, yfirst, ylast , CHART_DIM_Y); + chart_line (dnp_chart, 0, 0, m->min, m->max , CHART_DIM_X); - chart_submit(np_chart); - chart_submit(dnp_chart); + chart_submit (np_chart); + chart_submit (dnp_chart); } @@ -1896,7 +1921,7 @@ np_plot(const struct metrics *m, const char *factorname) /* Show the percentiles */ void -show_percentiles(struct variable **dependent_var, +show_percentiles (struct variable **dependent_var, int n_dep_var, struct factor *fctr) { @@ -1918,7 +1943,7 @@ show_percentiles(struct variable **dependent_var, { struct factor_statistics **fs = fctr->fs ; n_heading_columns = 3; - n_factors = hsh_count(fctr->fstats); + n_factors = hsh_count (fctr->fstats); ptiles = (*fs)->m[0].ptile_hash; @@ -1933,7 +1958,7 @@ show_percentiles(struct variable **dependent_var, ptiles = totals[0].ptile_hash; } - n_ptiles = hsh_count(ptiles); + n_ptiles = hsh_count (ptiles); n_rows = n_heading_rows + n_dep_var * n_stat_rows * n_factors; @@ -1957,7 +1982,7 @@ show_percentiles(struct variable **dependent_var, tab_vline (tbl, TAL_2, n_heading_columns, 0, n_rows - 1); - tab_title (tbl, 0, _("Percentiles")); + tab_title (tbl, _ ("Percentiles")); tab_hline (tbl, TAL_1, n_heading_columns, n_cols - 1, 1 ); @@ -1976,21 +2001,21 @@ show_percentiles(struct variable **dependent_var, n_heading_columns, n_heading_rows - 1, n_cols - 1, n_rows - 1); - tab_joint_text(tbl, n_heading_columns + 1, 0, + tab_joint_text (tbl, n_heading_columns + 1, 0, n_cols - 1 , 0, TAB_CENTER | TAT_TITLE , - _("Percentiles")); + _ ("Percentiles")); { /* Put in the percentile break points as headings */ - struct percentile **p = (struct percentile **) hsh_sort(ptiles); + struct percentile **p = (struct percentile **) hsh_sort (ptiles); i = 0; while ( (*p) ) { - tab_float(tbl, n_heading_columns + i++ , 1, + tab_float (tbl, n_heading_columns + i++ , 1, TAB_CENTER, (*p)->p, 8, 0); @@ -2005,12 +2030,12 @@ show_percentiles(struct variable **dependent_var, const int row = n_heading_rows + i * n_stat_rows * n_factors ; if ( i > 0 ) - tab_hline(tbl, TAL_1, 0, n_cols - 1, row ); + tab_hline (tbl, TAL_1, 0, n_cols - 1, row ); tab_text (tbl, 0, i * n_stat_rows * n_factors + n_heading_rows, TAB_LEFT | TAT_TITLE, - var_to_string(dependent_var[i]) + var_to_string (dependent_var[i]) ); if ( fctr ) @@ -2020,24 +2045,24 @@ show_percentiles(struct variable **dependent_var, tab_text (tbl, 1, n_heading_rows - 1, TAB_CENTER | TAT_TITLE, - var_to_string(fctr->indep_var[0])); + var_to_string (fctr->indep_var[0])); if ( fctr->indep_var[1]) tab_text (tbl, 2, n_heading_rows - 1, TAB_CENTER | TAT_TITLE, - var_to_string(fctr->indep_var[1])); + var_to_string (fctr->indep_var[1])); - while( *fs ) + while ( *fs ) { static union value prev ; const int row = n_heading_rows + n_stat_rows * - ( ( i * n_factors ) + count ); + ( ( i * n_factors ) + count ); - if ( 0 != compare_values(&prev, &(*fs)->id[0], - fctr->indep_var[0]->width)) + if ( 0 != compare_values (&prev, & (*fs)->id[0], + var_get_width (fctr->indep_var[0]))) { if ( count > 0 ) @@ -2046,7 +2071,7 @@ show_percentiles(struct variable **dependent_var, tab_text (tbl, 1, row, TAB_LEFT | TAT_TITLE, - value_to_string(&(*fs)->id[0], fctr->indep_var[0]) + value_to_string (& (*fs)->id[0], fctr->indep_var[0]) ); @@ -2055,17 +2080,17 @@ show_percentiles(struct variable **dependent_var, prev = (*fs)->id[0]; if (fctr->indep_var[1] && count > 0 ) - tab_hline(tbl, TAL_1, 2, n_cols - 1, row); + tab_hline (tbl, TAL_1, 2, n_cols - 1, row); if ( fctr->indep_var[1]) tab_text (tbl, 2, row, TAB_LEFT | TAT_TITLE, - value_to_string(&(*fs)->id[1], fctr->indep_var[1]) + value_to_string (& (*fs)->id[1], fctr->indep_var[1]) ); - populate_percentiles(tbl, n_heading_columns - 1, - row, &(*fs)->m[i]); + populate_percentiles (tbl, n_heading_columns - 1, + row, & (*fs)->m[i]); count++ ; @@ -2076,7 +2101,7 @@ show_percentiles(struct variable **dependent_var, } else { - populate_percentiles(tbl, n_heading_columns - 1, + populate_percentiles (tbl, n_heading_columns - 1, i * n_stat_rows * n_factors + n_heading_rows, &totals[i]); } @@ -2085,7 +2110,7 @@ show_percentiles(struct variable **dependent_var, } - tab_submit(tbl); + tab_submit (tbl); } @@ -2094,17 +2119,17 @@ show_percentiles(struct variable **dependent_var, void -populate_percentiles(struct tab_table *tbl, int col, int row, +populate_percentiles (struct tab_table *tbl, int col, int row, const struct metrics *m) { int i; - struct percentile **p = (struct percentile **) hsh_sort(m->ptile_hash); + struct percentile **p = (struct percentile **) hsh_sort (m->ptile_hash); tab_text (tbl, col, row + 1, TAB_LEFT | TAT_TITLE, - _("Tukey\'s Hinges") + _ ("Tukey\'s Hinges") ); tab_text (tbl, @@ -2117,21 +2142,21 @@ populate_percentiles(struct tab_table *tbl, int col, int row, i = 0; while ( (*p) ) { - tab_float(tbl, col + i + 1 , row, + tab_float (tbl, col + i + 1 , row, TAB_CENTER, - (*p)->v, 8, 2); + (*p)->v, 8, 2); if ( (*p)->p == 25 ) - tab_float(tbl, col + i + 1 , row + 1, + tab_float (tbl, col + i + 1 , row + 1, TAB_CENTER, m->hinge[0], 8, 2); if ( (*p)->p == 50 ) - tab_float(tbl, col + i + 1 , row + 1, + tab_float (tbl, col + i + 1 , row + 1, TAB_CENTER, m->hinge[1], 8, 2); if ( (*p)->p == 75 ) - tab_float(tbl, col + i + 1 , row + 1, + tab_float (tbl, col + i + 1 , row + 1, TAB_CENTER, m->hinge[2], 8, 2); @@ -2146,7 +2171,7 @@ populate_percentiles(struct tab_table *tbl, int col, int row, const char * -factor_to_string(const struct factor *fctr, +factor_to_string (const struct factor *fctr, struct factor_statistics *fs, const struct variable *var) { @@ -2154,30 +2179,30 @@ factor_to_string(const struct factor *fctr, static char buf1[100]; char buf2[100]; - strcpy(buf1,""); + strcpy (buf1,""); if (var) - sprintf(buf1, "%s (",var_to_string(var) ); + sprintf (buf1, "%s (",var_to_string (var) ); - snprintf(buf2, 100, "%s = %s", - var_to_string(fctr->indep_var[0]), - value_to_string(&fs->id[0],fctr->indep_var[0])); + snprintf (buf2, 100, "%s = %s", + var_to_string (fctr->indep_var[0]), + value_to_string (&fs->id[0],fctr->indep_var[0])); - strcat(buf1, buf2); + strcat (buf1, buf2); if ( fctr->indep_var[1] ) { - sprintf(buf2, "; %s = %s)", - var_to_string(fctr->indep_var[1]), - value_to_string(&fs->id[1], + sprintf (buf2, "; %s = %s)", + var_to_string (fctr->indep_var[1]), + value_to_string (&fs->id[1], fctr->indep_var[1])); - strcat(buf1, buf2); + strcat (buf1, buf2); } else { if ( var ) - strcat(buf1, ")"); + strcat (buf1, ")"); } return buf1; @@ -2186,7 +2211,7 @@ factor_to_string(const struct factor *fctr, const char * -factor_to_string_concise(const struct factor *fctr, +factor_to_string_concise (const struct factor *fctr, struct factor_statistics *fs) { @@ -2195,13 +2220,13 @@ factor_to_string_concise(const struct factor *fctr, char buf2[100]; - snprintf(buf, 100, "%s", - value_to_string(&fs->id[0], fctr->indep_var[0])); + snprintf (buf, 100, "%s", + value_to_string (&fs->id[0], fctr->indep_var[0])); if ( fctr->indep_var[1] ) { - sprintf(buf2, ",%s)", value_to_string(&fs->id[1], fctr->indep_var[1]) ); - strcat(buf, buf2); + sprintf (buf2, ",%s)", value_to_string (&fs->id[1], fctr->indep_var[1]) ); + strcat (buf, buf2); }