Fixes part of bug #15911.
+Thu Dec 7 15:22:38 WST 2006 John Darrington <john@darrington.wattle.id.au>
+
+ * variable.c variable.h (value_dup): New function.
+
Mon Dec 4 22:20:17 2006 Ben Pfaff <blp@gnu.org>
Start converting struct variable to an opaque. In this phase, we
Mon Dec 4 22:20:17 2006 Ben Pfaff <blp@gnu.org>
Start converting struct variable to an opaque. In this phase, we
+/* Duplicate a value.
+ The caller is responsible for freeing the returned value
+*/
+union value *
+value_dup (const union value *val, int width)
+{
+ size_t bytes = MAX(width, sizeof *val);
+
+ union value *v = xmalloc (bytes);
+ memcpy (v, val, bytes);
+ return v;
+}
+
+
+
/* Compares A and B, which both have the given WIDTH, and returns
a strcmp()-type result. */
int
/* Compares A and B, which both have the given WIDTH, and returns
a strcmp()-type result. */
int
int width_to_bytes(int width);
int width_to_bytes(int width);
+union value * value_dup (const union value *val, int width);
+
+Thu Dec 7 15:26:25 WST 2006 John Darrington <john@darrington.wattle.id.au>
+
+ * examine.q: Allocated the categorical values for the dependent and
+ independent variables, on the heap. Hence they can be of any width.
+
Wed Dec 6 21:14:26 2006 Ben Pfaff <blp@gnu.org>
* regression.q (reg_inserted): Compare variable pointers instead
Wed Dec 6 21:14:26 2006 Ben Pfaff <blp@gnu.org>
* regression.q (reg_inserted): Compare variable pointers instead
/* PSPP - EXAMINE data for normality . -*-c-*-
Copyright (C) 2004 Free Software Foundation, Inc.
/* PSPP - EXAMINE data for normality . -*-c-*-
Copyright (C) 2004 Free Software Foundation, Inc.
-Author: John Darrington 2004
+Author: John Darrington 2004, 2006
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
static size_t n_dependent_vars;
static size_t n_dependent_vars;
{
/* The independent variable */
struct variable *indep_var[2];
{
/* The independent variable */
struct variable *indep_var[2];
};
/* Linked list of factors */
};
/* Linked list of factors */
-static struct factor *factors=0;
+static struct factor *factors = 0;
-static struct metrics *totals=0;
+static struct metrics *totals = 0;
/* Parse the clause specifying the factors */
static int examine_parse_independent_vars (struct lexer *lexer, const struct dictionary *dict, struct cmd_examine *cmd);
/* Parse the clause specifying the factors */
static int examine_parse_independent_vars (struct lexer *lexer, const struct dictionary *dict, struct cmd_examine *cmd);
-static void show_summary (struct variable **dependent_var, int n_dep_var,
+static void show_summary (struct variable **dependent_var, int n_dep_var,
-static void show_extremes (struct variable **dependent_var,
- int n_dep_var,
+static void show_extremes (struct variable **dependent_var,
+ int n_dep_var,
const struct factor *factor,
int n_extremities);
const struct factor *factor,
int n_extremities);
-static void show_descriptives (struct variable **dependent_var,
- int n_dep_var,
+static void show_descriptives (struct variable **dependent_var,
+ int n_dep_var,
-static void show_percentiles (struct variable **dependent_var,
- int n_dep_var,
+static void show_percentiles (struct variable **dependent_var,
+ int n_dep_var,
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
) ;
const struct variable **vars, int n_vars,
const struct variable *id
) ;
-void box_plot_variables (const struct factor *fctr,
- const struct variable **vars, int n_vars,
+void box_plot_variables (const struct factor *fctr,
+ const struct variable **vars, int n_vars,
const struct variable *id
);
const struct variable *id
);
static void output_examine (void);
static void output_examine (void);
-void factor_calc (struct ccase *c, int case_no,
- double weight, int case_missing);
+void factor_calc (const 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 */
/* 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,
- struct factor_statistics *fs,
- const struct variable *var);
+const char * factor_to_string (const struct factor *fctr,
+ const struct factor_statistics *fs,
+ const struct variable *var);
/* 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 */
/* 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);
struct factor_statistics *fs);
}
/* If /MISSING=INCLUDE is set, then user missing values are ignored */
}
/* If /MISSING=INCLUDE is set, then user missing values are ignored */
- if (cmd.incl == XMN_INCLUDE )
+ if (cmd.incl == XMN_INCLUDE )
value_is_missing = var_is_value_system_missing;
else
value_is_missing = var_is_value_missing;
value_is_missing = var_is_value_system_missing;
else
value_is_missing = var_is_value_missing;
- if ( cmd.st_n == SYSMIS )
+ if ( cmd.st_n == SYSMIS )
- if ( ! cmd.sbc_cinterval)
+ if ( ! cmd.sbc_cinterval)
cmd.n_cinterval[0] = 95.0;
cmd.n_cinterval[0] = 95.0;
- /* If descriptives have been requested, make sure the
+ /* If descriptives have been requested, make sure the
quartiles are calculated */
if ( cmd.a_statistics[XMN_ST_DESCRIPTIVES] )
{
quartiles are calculated */
if ( cmd.a_statistics[XMN_ST_DESCRIPTIVES] )
{
ok = multipass_procedure_with_splits (ds, run_examine, &cmd);
ok = multipass_procedure_with_splits (ds, run_examine, &cmd);
-
- if ( dependent_vars )
+
+ if ( dependent_vars )
free (dependent_vars);
{
struct factor *f = factors ;
free (dependent_vars);
{
struct factor *f = factors ;
{
show_summary (dependent_vars, n_dependent_vars, 0);
{
show_summary (dependent_vars, n_dependent_vars, 0);
- if ( cmd.sbc_statistics )
+ if ( cmd.sbc_statistics )
- if ( cmd.a_statistics[XMN_ST_EXTREME])
+ 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])
+ if ( cmd.a_statistics[XMN_ST_DESCRIPTIVES])
show_descriptives (dependent_vars, n_dependent_vars, 0);
}
show_descriptives (dependent_vars, n_dependent_vars, 0);
}
show_percentiles (dependent_vars, n_dependent_vars, 0);
show_percentiles (dependent_vars, n_dependent_vars, 0);
- if ( cmd.a_plot[XMN_PLT_STEMLEAF] )
+ if ( cmd.a_plot[XMN_PLT_STEMLEAF] )
msg (SW, _ ("%s is not currently supported."), "STEMLEAF");
msg (SW, _ ("%s is not currently supported."), "STEMLEAF");
- if ( cmd.a_plot[XMN_PLT_SPREADLEVEL] )
+ if ( cmd.a_plot[XMN_PLT_SPREADLEVEL] )
msg (SW, _ ("%s is not currently supported."), "SPREADLEVEL");
msg (SW, _ ("%s is not currently supported."), "SPREADLEVEL");
- if ( cmd.a_plot[XMN_PLT_NPPLOT] )
+ if ( cmd.a_plot[XMN_PLT_NPPLOT] )
- for ( v = 0 ; v < n_dependent_vars; ++v )
+ 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.a_plot[XMN_PLT_BOXPLOT] )
- if ( cmd.cmp == XMN_GROUPS )
+ if ( cmd.cmp == XMN_GROUPS )
{
box_plot_group (0, (const struct variable **) dependent_vars,
n_dependent_vars, cmd.v_id);
{
box_plot_group (0, (const struct variable **) dependent_vars,
n_dependent_vars, cmd.v_id);
n_dependent_vars, cmd.v_id);
}
n_dependent_vars, cmd.v_id);
}
- if ( cmd.a_plot[XMN_PLT_HISTOGRAM] )
+ if ( cmd.a_plot[XMN_PLT_HISTOGRAM] )
- for ( v = 0 ; v < n_dependent_vars; ++v )
+ for ( v = 0 ; v < n_dependent_vars; ++v )
{
struct normal_curve normal;
normal.N = totals[v].n;
normal.mean = totals[v].mean;
normal.stddev = totals[v].stddev;
{
struct normal_curve normal;
normal.N = totals[v].n;
normal.mean = totals[v].mean;
normal.stddev = totals[v].stddev;
-
- histogram_plot (totals[v].histogram,
+
+ histogram_plot (totals[v].histogram,
var_to_string (dependent_vars[v]),
&normal, 0);
}
var_to_string (dependent_vars[v]),
&normal, 0);
}
/* Show grouped statistics as appropriate */
fctr = factors;
/* Show grouped statistics as appropriate */
fctr = factors;
{
show_summary (dependent_vars, n_dependent_vars, fctr);
{
show_summary (dependent_vars, n_dependent_vars, fctr);
- if ( cmd.sbc_statistics )
+ if ( cmd.sbc_statistics )
- if ( cmd.a_statistics[XMN_ST_EXTREME])
+ 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])
+ if ( cmd.a_statistics[XMN_ST_DESCRIPTIVES])
show_descriptives (dependent_vars, n_dependent_vars, fctr);
}
show_descriptives (dependent_vars, n_dependent_vars, fctr);
}
show_percentiles (dependent_vars, n_dependent_vars, fctr);
show_percentiles (dependent_vars, n_dependent_vars, fctr);
if ( cmd.a_plot[XMN_PLT_BOXPLOT] )
{
if ( cmd.a_plot[XMN_PLT_BOXPLOT] )
{
- if ( cmd.cmp == XMN_VARIABLES )
+ if ( cmd.cmp == XMN_VARIABLES )
box_plot_variables (fctr,
(const struct variable **) dependent_vars,
n_dependent_vars, cmd.v_id);
box_plot_variables (fctr,
(const struct variable **) dependent_vars,
n_dependent_vars, cmd.v_id);
for ( v = 0 ; v < n_dependent_vars; ++v )
{
for ( v = 0 ; v < n_dependent_vars; ++v )
{
- for ( fs = fctr->fs ; *fs ; ++fs )
+ 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] )
+ 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] )
+ if ( cmd.a_plot[XMN_PLT_HISTOGRAM] )
{
struct normal_curve normal;
normal.N = (*fs)->m[v].n;
normal.mean = (*fs)->m[v].mean;
normal.stddev = (*fs)->m[v].stddev;
{
struct normal_curve normal;
normal.N = (*fs)->m[v].n;
normal.mean = (*fs)->m[v].mean;
normal.stddev = (*fs)->m[v].stddev;
-
- histogram_plot ((*fs)->m[v].histogram,
+
+ histogram_plot ((*fs)->m[v].histogram,
} /* for ( fs .... */
} /* for ( v = 0 ..... */
} /* for ( fs .... */
} /* for ( v = 0 ..... */
list_to_ptile_hash (const subc_list_double *l)
{
int i;
list_to_ptile_hash (const subc_list_double *l)
{
int i;
-
- struct hsh_table *h ;
- h = hsh_create (subc_list_double_count (l),
+ struct hsh_table *h ;
+
+ h = hsh_create (subc_list_double_count (l),
(hsh_compare_func *) ptile_compare,
(hsh_compare_func *) ptile_compare,
- (hsh_hash_func *) ptile_hash,
+ (hsh_hash_func *) ptile_hash,
(hsh_free_func *) free,
0);
(hsh_free_func *) free,
0);
for ( i = 0 ; i < subc_list_double_count (l) ; ++i )
{
struct percentile *p = xmalloc (sizeof *p);
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->v = SYSMIS;
p->p = subc_list_double_at (l,i);
p->v = SYSMIS;
/* Parse the PERCENTILES subcommand */
static int
/* Parse the PERCENTILES subcommand */
static int
-xmn_custom_percentiles (struct lexer *lexer, struct dataset *ds UNUSED,
+xmn_custom_percentiles (struct lexer *lexer, struct dataset *ds UNUSED,
struct cmd_examine *p UNUSED, void *aux UNUSED)
{
sbc_percentile = 1;
struct cmd_examine *p UNUSED, void *aux UNUSED)
{
sbc_percentile = 1;
- while ( lex_is_number (lexer) )
+ while ( lex_is_number (lexer) )
{
subc_list_double_push (&percentile_list, lex_number (lexer));
{
subc_list_double_push (&percentile_list, lex_number (lexer));
lex_match (lexer, '=');
if ( lex_match_id (lexer, "HAVERAGE"))
lex_match (lexer, '=');
if ( lex_match_id (lexer, "HAVERAGE"))
- percentile_algorithm = PC_HAVERAGE;
+ percentile_algorithm = PC_HAVERAGE;
else if ( lex_match_id (lexer, "WAVERAGE"))
else if ( lex_match_id (lexer, "WAVERAGE"))
- percentile_algorithm = PC_WAVERAGE;
+ percentile_algorithm = PC_WAVERAGE;
else if ( lex_match_id (lexer, "ROUND"))
percentile_algorithm = PC_ROUND;
else if ( lex_match_id (lexer, "ROUND"))
percentile_algorithm = PC_ROUND;
percentile_algorithm = PC_EMPIRICAL;
else if ( lex_match_id (lexer, "AEMPIRICAL"))
percentile_algorithm = PC_EMPIRICAL;
else if ( lex_match_id (lexer, "AEMPIRICAL"))
- percentile_algorithm = PC_AEMPIRICAL;
+ percentile_algorithm = PC_AEMPIRICAL;
else if ( lex_match_id (lexer, "NONE"))
else if ( lex_match_id (lexer, "NONE"))
- percentile_algorithm = PC_NONE;
+ percentile_algorithm = PC_NONE;
if ( 0 == subc_list_double_count (&percentile_list))
if ( 0 == subc_list_double_count (&percentile_list))
static int
xmn_custom_total (struct lexer *lexer UNUSED, struct dataset *ds UNUSED, struct cmd_examine *p, void *aux UNUSED)
{
static int
xmn_custom_total (struct lexer *lexer UNUSED, struct dataset *ds UNUSED, struct cmd_examine *p, void *aux UNUSED)
{
{
msg (SE, _ ("%s and %s are mutually exclusive"),"TOTAL","NOTOTAL");
return 0;
{
msg (SE, _ ("%s and %s are mutually exclusive"),"TOTAL","NOTOTAL");
return 0;
-xmn_custom_nototal (struct lexer *lexer UNUSED, struct dataset *ds UNUSED,
+xmn_custom_nototal (struct lexer *lexer UNUSED, struct dataset *ds UNUSED,
struct cmd_examine *p, void *aux UNUSED)
{
struct cmd_examine *p, void *aux UNUSED)
{
{
msg (SE, _ ("%s and %s are mutually exclusive"),"TOTAL","NOTOTAL");
return 0;
{
msg (SE, _ ("%s and %s are mutually exclusive"),"TOTAL","NOTOTAL");
return 0;
-/* Parser for the variables sub command
+/* Parser for the variables sub command
Returns 1 on success */
static int
xmn_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_examine *cmd, void *aux UNUSED)
Returns 1 on success */
static int
xmn_custom_variables (struct lexer *lexer, struct dataset *ds, struct cmd_examine *cmd, void *aux UNUSED)
if (!parse_variables (lexer, dict, &dependent_vars, &n_dependent_vars,
PV_NO_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH) )
{
if (!parse_variables (lexer, dict, &dependent_vars, &n_dependent_vars,
PV_NO_DUPLICATE | PV_NUMERIC | PV_NO_SCRATCH) )
{
if ( lex_match (lexer, T_BY))
{
if ( lex_match (lexer, T_BY))
{
success = examine_parse_independent_vars (lexer, dict, cmd);
if ( success != 1 ) {
free (dependent_vars);
success = examine_parse_independent_vars (lexer, dict, cmd);
if ( success != 1 ) {
free (dependent_vars);
sf->indep_var[0] = parse_variable (lexer, dict);
sf->indep_var[1] = 0;
sf->indep_var[0] = parse_variable (lexer, dict);
sf->indep_var[1] = 0;
- if ( lex_token (lexer) == T_BY )
+ if ( lex_token (lexer) == T_BY )
{
lex_match (lexer, T_BY);
{
lex_match (lexer, T_BY);
sf->next = factors;
factors = sf;
sf->next = factors;
factors = sf;
- if ( lex_token (lexer) == '.' || lex_token (lexer) == '/' )
+ if ( lex_token (lexer) == '.' || lex_token (lexer) == '/' )
return 1;
success = examine_parse_independent_vars (lexer, dict, cmd);
return 1;
success = examine_parse_independent_vars (lexer, dict, cmd);
-
- if ( success != 1 )
- free ( sf ) ;
+
+ if ( success != 1 )
+ free ( sf ) ;
-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);
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);
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,
const struct metrics *m);
void populate_summary (struct tab_table *t, int col, int row,
/* Perform calculations for the sub factors */
void
/* Perform calculations for the sub factors */
void
-factor_calc (struct ccase *c, int case_no, double weight, int case_missing)
+factor_calc (const struct ccase *c, int case_no, double weight,
+ int case_missing)
{
size_t v;
struct factor *fctr = factors;
{
size_t v;
struct factor *fctr = factors;
{
struct factor_statistics **foo ;
{
struct factor_statistics **foo ;
- union value indep_vals[2] ;
+ union value *indep_vals[2] ;
- indep_vals[0] = * case_data (c, fctr->indep_var[0]->fv);
+ indep_vals[0] = value_dup (
+ case_data (c, fctr->indep_var[0]->fv),
+ var_get_width (fctr->indep_var[0])
+ );
- if ( fctr->indep_var[1] )
- indep_vals[1] = * case_data (c, fctr->indep_var[1]->fv);
+ if ( fctr->indep_var[1] )
+ indep_vals[1] = value_dup (
+ case_data (c, fctr->indep_var[1]->fv),
+ var_get_width (fctr->indep_var[1])
+ );
- indep_vals[1].f = SYSMIS;
+ {
+ const union value sm = {SYSMIS};
+ indep_vals[1] = value_dup (&sm, 0);
+ }
- foo = ( struct factor_statistics ** )
+ foo = ( struct factor_statistics ** )
hsh_probe (fctr->fstats, (void *) &indep_vals);
hsh_probe (fctr->fstats, (void *) &indep_vals);
- *foo = create_factor_statistics (n_dependent_vars,
- &indep_vals[0],
- &indep_vals[1]);
+ *foo = create_factor_statistics (n_dependent_vars,
+ indep_vals[0],
+ indep_vals[1]);
- for ( v = 0 ; v < n_dependent_vars ; ++v )
+ for ( v = 0 ; v < n_dependent_vars ; ++v )
{
metrics_precalc ( & (*foo)->m[v] );
}
}
{
metrics_precalc ( & (*foo)->m[v] );
}
}
+ else
+ {
+ free (indep_vals[0]);
+ free (indep_vals[1]);
+ }
- for ( v = 0 ; v < n_dependent_vars ; ++v )
+ for ( v = 0 ; v < n_dependent_vars ; ++v )
{
const struct variable *var = dependent_vars[v];
{
const struct variable *var = dependent_vars[v];
- const union value *val = case_data (c, var->fv);
+ union value *val = value_dup (
+ case_data (c, var->fv),
+ var_get_width (var)
+ );
+
+ if ( value_is_missing (var, val) || case_missing )
+ {
+ free (val);
+ continue;
+ }
- 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);
-static bool
-run_examine (const struct ccase *first, const struct casefile *cf,
+static bool
+run_examine (const struct ccase *first, const struct casefile *cf,
void *cmd_, const struct dataset *ds)
{
struct dictionary *dict = dataset_dict (ds);
void *cmd_, const struct dataset *ds)
{
struct dictionary *dict = dataset_dict (ds);
output_split_file_values (ds, first);
output_split_file_values (ds, first);
- /* Make sure we haven't got rubbish left over from a
+ /* Make sure we haven't got rubbish left over from a
previous split */
fctr = factors;
previous split */
fctr = factors;
{
struct factor *next = fctr->next;
{
struct factor *next = fctr->next;
- for ( v = 0 ; v < n_dependent_vars ; ++v )
+ for ( v = 0 ; v < n_dependent_vars ; ++v )
metrics_precalc (&totals[v]);
for (r = casefile_get_reader (cf, NULL);
casereader_read (r, &c) ;
metrics_precalc (&totals[v]);
for (r = casefile_get_reader (cf, NULL);
casereader_read (r, &c) ;
{
int case_missing=0;
const int case_no = casereader_cnum (r);
{
int case_missing=0;
const int case_no = casereader_cnum (r);
dict_get_case_weight (dict, &c, &bad_weight_warn);
dict_get_case_weight (dict, &c, &bad_weight_warn);
- if ( cmd->miss == XMN_LISTWISE )
+ if ( cmd->miss == XMN_LISTWISE )
- for ( v = 0 ; v < n_dependent_vars ; ++v )
+ for ( v = 0 ; v < n_dependent_vars ; ++v )
{
const struct variable *var = dependent_vars[v];
{
const struct variable *var = dependent_vars[v];
- const union value *val = case_data (&c, var->fv);
+ union value *val = value_dup (
+ case_data (&c, var->fv),
+ var_get_width (var)
+ );
if ( value_is_missing (var, val))
case_missing = 1;
if ( value_is_missing (var, val))
case_missing = 1;
- for ( v = 0 ; v < n_dependent_vars ; ++v )
+ for ( v = 0 ; v < n_dependent_vars ; ++v )
{
const struct variable *var = dependent_vars[v];
{
const struct variable *var = dependent_vars[v];
- const union value *val = case_data (&c, var->fv);
+ union value *val = value_dup (
+ case_data (&c, var->fv),
+ var_get_width (var)
+ );
- if ( value_is_missing (var, val) || case_missing )
- val = 0;
+ if ( value_is_missing (var, val) || case_missing )
+ {
+ free (val) ;
+ continue ;
+ }
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);
for ( v = 0 ; v < n_dependent_vars ; ++v)
{
fctr = factors;
for ( v = 0 ; v < n_dependent_vars ; ++v)
{
fctr = factors;
{
struct hsh_iterator hi;
struct factor_statistics *fs;
{
struct hsh_iterator hi;
struct factor_statistics *fs;
fs != 0 ;
fs = hsh_next (fctr->fstats, &hi))
{
fs != 0 ;
fs = hsh_next (fctr->fstats, &hi))
{
fs->m[v].ptile_hash = list_to_ptile_hash (&percentile_list);
fs->m[v].ptile_alg = percentile_algorithm;
metrics_postcalc (&fs->m[v]);
fs->m[v].ptile_hash = list_to_ptile_hash (&percentile_list);
fs->m[v].ptile_alg = percentile_algorithm;
metrics_postcalc (&fs->m[v]);
/* Make sure that the combination of factors are complete */
fctr = factors;
/* Make sure that the combination of factors are complete */
fctr = factors;
{
struct hsh_iterator hi;
struct hsh_iterator hi0;
{
struct hsh_iterator hi;
struct hsh_iterator hi0;
struct hsh_table *idh1=0;
union value *val0;
union value *val1;
struct hsh_table *idh1=0;
union value *val0;
union value *val1;
idh0 = hsh_create (4, (hsh_compare_func *) compare_values,
(hsh_hash_func *) hash_value,
0,0);
idh0 = hsh_create (4, (hsh_compare_func *) compare_values,
(hsh_hash_func *) hash_value,
0,0);
union value key[2];
key[0] = *val0;
key[1] = *val1;
union value key[2];
key[0] = *val0;
key[1] = *val1;
-
- ffs = (struct factor_statistics **)
+
+ ffs = (struct factor_statistics **)
hsh_probe (fctr->fstats, (void *) &key );
if ( !*ffs ) {
size_t i;
(*ffs) = create_factor_statistics (n_dependent_vars,
&key[0], &key[1]);
hsh_probe (fctr->fstats, (void *) &key );
if ( !*ffs ) {
size_t i;
(*ffs) = create_factor_statistics (n_dependent_vars,
&key[0], &key[1]);
- for ( i = 0 ; i < n_dependent_vars ; ++i )
+ for ( i = 0 ; i < n_dependent_vars ; ++i )
metrics_precalc ( & (*ffs)->m[i]);
}
}
metrics_precalc ( & (*ffs)->m[i]);
}
}
- for ( i = 0 ; i < n_dependent_vars ; ++i )
+ for ( i = 0 ; i < n_dependent_vars ; ++i )
{
metrics_destroy (&totals[i]);
}
{
metrics_destroy (&totals[i]);
}
-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[]=
const struct factor *fctr)
{
static const char *subtitle[]=
tab_headers (tbl, heading_columns, 0, heading_rows, 0);
tab_dim (tbl, tab_natural_dimensions);
tab_headers (tbl, heading_columns, 0, heading_rows, 0);
tab_dim (tbl, tab_natural_dimensions);
TAL_2, TAL_2,
-1, -1,
0, 0,
n_cols - 1, n_rows - 1);
/* Vertical lines for the data only */
TAL_2, TAL_2,
-1, -1,
0, 0,
n_cols - 1, n_rows - 1);
/* Vertical lines for the data only */
-1, -1,
-1, TAL_1,
heading_columns, 0,
-1, -1,
-1, TAL_1,
heading_columns, 0,
tab_title (tbl, _ ("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"));
/* Remove lines ... */
n_cols -1, 0,
TAB_CENTER | TAT_TITLE,
_ ("Cases"));
/* Remove lines ... */
-1, -1,
TAL_0, TAL_0,
heading_columns, 0,
n_cols - 1, 0);
-1, -1,
TAL_0, TAL_0,
heading_columns, 0,
n_cols - 1, 0);
- for ( i = 0 ; i < 3 ; ++i )
+ for ( i = 0 ; i < 3 ; ++i )
- tab_text (tbl, heading_columns + i*2 , 2, TAB_CENTER | TAT_TITLE,
+ tab_text (tbl, heading_columns + i*2 , 2, TAB_CENTER | TAT_TITLE,
- tab_text (tbl, heading_columns + i*2 + 1, 2, TAB_CENTER | TAT_TITLE,
+ tab_text (tbl, heading_columns + i*2 + 1, 2, TAB_CENTER | TAT_TITLE,
_ ("Percent"));
tab_joint_text (tbl, heading_columns + i*2 , 1,
_ ("Percent"));
tab_joint_text (tbl, heading_columns + i*2 , 1,
/* Titles for the independent variables */
/* Titles for the independent variables */
- tab_text (tbl, 1, heading_rows - 1, TAB_CENTER | TAT_TITLE,
+ 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] )
+ if ( fctr->indep_var[1] )
- tab_text (tbl, 2, heading_rows - 1, TAB_CENTER | TAT_TITLE,
+ 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]));
}
- for ( i = 0 ; i < n_dep_var ; ++i )
+ for ( i = 0 ; i < n_dep_var ; ++i )
n_factors = hsh_count (fctr->fstats);
n_factors = hsh_count (fctr->fstats);
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);
0, i * n_factors + heading_rows,
0, i * n_factors + heading_rows,
var_to_string (dependent_var[i])
);
var_to_string (dependent_var[i])
);
- if ( !fctr )
- populate_summary (tbl, heading_columns,
+ if ( !fctr )
+ populate_summary (tbl, heading_columns,
(i * n_factors) + heading_rows,
&totals[i]);
(i * n_factors) + heading_rows,
&totals[i]);
{
struct factor_statistics **fs = fctr->fs;
int count = 0 ;
{
struct factor_statistics **fs = fctr->fs;
int count = 0 ;
+ const union value *prev = NULL;
- static union value prev;
-
- if ( 0 != compare_values (&prev, & (*fs)->id[0],
- var_get_width (fctr->indep_var[0])))
+ if ( !prev ||
+ 0 != compare_values (prev, (*fs)->id[0],
+ var_get_width (fctr->indep_var[0])))
- (i * n_factors ) + count +
+ (i * n_factors ) + count +
- TAB_LEFT | TAT_TITLE,
- value_to_string (& (*fs)->id[0], fctr->indep_var[0])
+ TAB_LEFT | TAT_TITLE,
+ 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,
+ if (fctr->indep_var[1] && count > 0 )
+ tab_hline (tbl, TAL_1, 1, n_cols - 1,
(i * n_factors ) + count + heading_rows);
}
(i * n_factors ) + count + heading_rows);
}
- if ( fctr->indep_var[1])
- tab_text (tbl,
+ if ( fctr->indep_var[1])
+ tab_text (tbl,
- (i * n_factors ) + count +
+ (i * n_factors ) + count +
- TAB_LEFT | TAT_TITLE,
- value_to_string (& (*fs)->id[1], fctr->indep_var[1])
+ TAB_LEFT | TAT_TITLE,
+ value_to_string ((*fs)->id[1], fctr->indep_var[1])
- populate_summary (tbl, heading_columns,
- (i * n_factors) + count
+ populate_summary (tbl, heading_columns,
+ (i * n_factors) + count
+ heading_rows,
& (*fs)->m[i]);
+ heading_rows,
& (*fs)->m[i]);
populate_summary (struct tab_table *t, int col, int row,
const struct metrics *m)
{
populate_summary (struct tab_table *t, int col, int row,
const struct metrics *m)
{
- const double total = m->n + m->n_missing ;
+ 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 + 0, row + 0, TAB_RIGHT, m->n, 8, 0);
tab_float (t, col + 2, row + 0, TAB_RIGHT, m->n_missing, 8, 0);
- tab_text (t, col + 1, row + 0, TAB_RIGHT | TAT_PRINTF, "%2.0f%%",
+ tab_text (t, col + 1, row + 0, TAB_RIGHT | TAT_PRINTF, "%2.0f%%",
- tab_text (t, col + 3, row + 0, TAB_RIGHT | TAT_PRINTF, "%2.0f%%",
+ tab_text (t, col + 3, row + 0, TAB_RIGHT | TAT_PRINTF, "%2.0f%%",
100.0 * m->n_missing / total );
/* This seems a bit pointless !!! */
100.0 * m->n_missing / total );
/* This seems a bit pointless !!! */
- tab_text (t, col + 5, row + 0, TAB_RIGHT | TAT_PRINTF, "%2.0f%%",
+ tab_text (t, col + 5, row + 0, TAB_RIGHT | TAT_PRINTF, "%2.0f%%",
100.0 * total / total );
}
100.0 * total / total );
}
-static void
-show_extremes (struct variable **dependent_var, int n_dep_var,
+static void
+show_extremes (struct variable **dependent_var, int n_dep_var,
const struct factor *fctr, int n_extremities)
{
int i;
const struct factor *fctr, int n_extremities)
{
int i;
tab_headers (tbl, heading_columns, 0, heading_rows, 0);
tab_dim (tbl, tab_natural_dimensions);
tab_headers (tbl, heading_columns, 0, heading_rows, 0);
tab_dim (tbl, tab_natural_dimensions);
/* Outline the box, No internal lines*/
/* Outline the box, No internal lines*/
TAL_2, TAL_2,
-1, -1,
0, 0,
TAL_2, TAL_2,
-1, -1,
0, 0,
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_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, 1, heading_rows - 1, TAB_CENTER | TAT_TITLE,
+ 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,
+ if ( fctr->indep_var[1] )
+ tab_text (tbl, 2, heading_rows - 1, TAB_CENTER | TAT_TITLE,
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"));
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"));
- for ( i = 0 ; i < n_dep_var ; ++i )
+ for ( i = 0 ; i < n_dep_var ; ++i )
- if ( i > 0 )
- tab_hline (tbl, TAL_1, 0, n_cols -1 ,
+ if ( i > 0 )
+ tab_hline (tbl, TAL_1, 0, n_cols -1 ,
i * 2 * n_extremities * n_factors + heading_rows);
i * 2 * n_extremities * n_factors + heading_rows);
tab_text (tbl, 0,
i * 2 * n_extremities * n_factors + heading_rows,
tab_text (tbl, 0,
i * 2 * n_extremities * n_factors + heading_rows,
var_to_string (dependent_var[i])
);
var_to_string (dependent_var[i])
);
- if ( !fctr )
- populate_extremes (tbl, heading_columns - 2,
+ if ( !fctr )
+ populate_extremes (tbl, heading_columns - 2,
i * 2 * n_extremities * n_factors + heading_rows,
n_extremities, &totals[i]);
i * 2 * n_extremities * n_factors + heading_rows,
n_extremities, &totals[i]);
{
struct factor_statistics **fs = fctr->fs;
int count = 0 ;
{
struct factor_statistics **fs = fctr->fs;
int count = 0 ;
+ const union value *prev = NULL;
- static union value prev ;
-
- const int row = heading_rows + ( 2 * n_extremities ) *
+ const int row = heading_rows + ( 2 * n_extremities ) *
( ( i * n_factors ) + count );
( ( i * n_factors ) + count );
- if ( 0 != compare_values (&prev, & (*fs)->id[0],
+ if ( !prev || 0 != compare_values (prev, (*fs)->id[0],
var_get_width (fctr->indep_var[0])))
{
var_get_width (fctr->indep_var[0])))
{
tab_hline (tbl, TAL_1, 1, n_cols - 1, row);
tab_hline (tbl, TAL_1, 1, n_cols - 1, row);
- TAB_LEFT | TAT_TITLE,
- value_to_string (& (*fs)->id[0], fctr->indep_var[0])
+ TAB_LEFT | TAT_TITLE,
+ value_to_string ((*fs)->id[0], fctr->indep_var[0])
);
}
prev = (*fs)->id[0];
);
}
prev = (*fs)->id[0];
- if (fctr->indep_var[1] && count > 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])
+ if ( fctr->indep_var[1])
- TAB_LEFT | TAT_TITLE,
- value_to_string (& (*fs)->id[1], fctr->indep_var[1])
+ TAB_LEFT | TAT_TITLE,
+ 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]);
row, n_extremities,
& (*fs)->m[i]);
/* Fill in the extremities table */
/* Fill in the extremities table */
-void
-populate_extremes (struct tab_table *t,
+void
+populate_extremes (struct tab_table *t,
int col, int row, int n, const struct metrics *m)
{
int extremity;
int col, int row, int n, const struct metrics *m)
{
int extremity;
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 )
+
+ for (extremity = 0; extremity < n ; ++extremity )
{
/* Highest */
tab_float (t, col + 1, row + extremity,
{
/* Highest */
tab_float (t, col + 1, row + extremity,
- for (idx = 0, extremity = 0; extremity < n && idx < m->n_data ; ++idx )
+ for (idx = 0, extremity = 0; extremity < n && idx < m->n_data ; ++idx )
{
int j;
const struct weighted_value *wv = m->wvp[idx];
struct case_node *cn = wv->case_nos;
{
int j;
const struct weighted_value *wv = m->wvp[idx];
struct case_node *cn = wv->case_nos;
for (j = 0 ; j < wv->w ; ++j )
{
for (j = 0 ; j < wv->w ; ++j )
{
- if ( extremity + j >= n )
+ if ( extremity + j >= n )
break ;
tab_float (t, col + 3, row + extremity + j + n,
break ;
tab_float (t, col + 3, row + extremity + j + n,
TAB_RIGHT,
cn->num, 8, 0);
TAB_RIGHT,
cn->num, 8, 0);
- for (idx = m->n_data - 1, extremity = 0; extremity < n && idx >= 0; --idx )
+ for (idx = m->n_data - 1, extremity = 0; extremity < n && idx >= 0; --idx )
{
int j;
const struct weighted_value *wv = m->wvp[idx];
{
int j;
const struct weighted_value *wv = m->wvp[idx];
for (j = 0 ; j < wv->w ; ++j )
{
for (j = 0 ; j < wv->w ; ++j )
{
- if ( extremity + j >= n )
+ if ( extremity + j >= n )
break ;
tab_float (t, col + 3, row + extremity + j,
break ;
tab_float (t, col + 3, row + extremity + j,
TAB_RIGHT,
cn->num, 8, 0);
TAB_RIGHT,
cn->num, 8, 0);
/* Show the descriptives table */
void
/* Show the descriptives table */
void
-show_descriptives (struct variable **dependent_var,
- int n_dep_var,
+show_descriptives (struct variable **dependent_var,
+ int n_dep_var,
struct factor *fctr)
{
int i;
struct factor *fctr)
{
int i;
tab_dim (tbl, tab_natural_dimensions);
/* Outline the box and have no internal lines*/
tab_dim (tbl, tab_natural_dimensions);
/* Outline the box and have no internal lines*/
TAL_2, TAL_2,
-1, -1,
0, 0,
TAL_2, TAL_2,
-1, -1,
0, 0,
tab_title (tbl, _ ("Descriptives"));
tab_title (tbl, _ ("Descriptives"));
- for ( i = 0 ; i < n_dep_var ; ++i )
+ for ( i = 0 ; i < n_dep_var ; ++i )
{
const int row = heading_rows + i * n_stat_rows * n_factors ;
{
const int row = heading_rows + i * n_stat_rows * n_factors ;
tab_text (tbl, 0,
i * n_stat_rows * n_factors + heading_rows,
tab_text (tbl, 0,
i * n_stat_rows * n_factors + heading_rows,
var_to_string (dependent_var[i])
);
if ( fctr )
{
var_to_string (dependent_var[i])
);
if ( fctr )
{
+ const union value *prev = NULL;
+
struct factor_statistics **fs = fctr->fs;
int count = 0;
struct factor_statistics **fs = fctr->fs;
int count = 0;
- tab_text (tbl, 1, heading_rows - 1, TAB_CENTER | TAT_TITLE,
+ tab_text (tbl, 1, heading_rows - 1, TAB_CENTER | TAT_TITLE,
var_to_string (fctr->indep_var[0]));
if ( fctr->indep_var[1])
var_to_string (fctr->indep_var[0]));
if ( fctr->indep_var[1])
- tab_text (tbl, 2, heading_rows - 1, TAB_CENTER | TAT_TITLE,
+ 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]));
-
- static union value prev ;
-
- const int row = heading_rows + n_stat_rows *
+ const int row = heading_rows + n_stat_rows *
( ( i * n_factors ) + count );
( ( i * n_factors ) + count );
- if ( 0 != compare_values (&prev, & (*fs)->id[0],
+ if ( !prev || 0 != compare_values (prev, (*fs)->id[0],
var_get_width (fctr->indep_var[0])))
{
var_get_width (fctr->indep_var[0])))
{
tab_hline (tbl, TAL_1, 1, n_cols - 1, row);
tab_hline (tbl, TAL_1, 1, n_cols - 1, row);
- TAB_LEFT | TAT_TITLE,
- value_to_string (& (*fs)->id[0], fctr->indep_var[0])
+ TAB_LEFT | TAT_TITLE,
+ value_to_string ((*fs)->id[0], fctr->indep_var[0])
);
}
prev = (*fs)->id[0];
);
}
prev = (*fs)->id[0];
- if (fctr->indep_var[1] && count > 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])
+ if ( fctr->indep_var[1])
- TAB_LEFT | TAT_TITLE,
- value_to_string (& (*fs)->id[1], fctr->indep_var[1])
+ TAB_LEFT | TAT_TITLE,
+ value_to_string ((*fs)->id[1], fctr->indep_var[1])
- populate_descriptives (tbl, heading_columns - 2,
+ populate_descriptives (tbl, heading_columns - 2,
-
- populate_descriptives (tbl, heading_columns - 2,
+
+ populate_descriptives (tbl, heading_columns - 2,
i * n_stat_rows * n_factors + heading_rows,
&totals[i]);
}
i * n_stat_rows * n_factors + heading_rows,
&totals[i]);
}
/* Fill in the descriptives data */
void
/* 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 struct metrics *m)
{
row,
TAB_LEFT | TAT_TITLE,
_ ("Mean"));
row,
TAB_LEFT | TAT_TITLE,
_ ("Mean"));
TAB_CENTER,
m->mean,
8,2);
TAB_CENTER,
m->mean,
8,2);
tab_float (tbl, col + 3,
row,
TAB_CENTER,
m->se_mean,
8,3);
tab_float (tbl, col + 3,
row,
TAB_CENTER,
m->se_mean,
8,3);
row + 1,
TAB_LEFT | TAT_TITLE | TAT_PRINTF,
_ ("%g%% Confidence Interval for Mean"), cmd.n_cinterval[0]);
row + 1,
TAB_LEFT | TAT_TITLE | TAT_PRINTF,
_ ("%g%% Confidence Interval for Mean"), cmd.n_cinterval[0]);
- tab_text (tbl, col + 1,
+ tab_text (tbl, col + 1,
row + 1,
TAB_LEFT | TAT_TITLE,
_ ("Lower Bound"));
row + 1,
TAB_LEFT | TAT_TITLE,
_ ("Lower Bound"));
tab_float (tbl, col + 2,
row + 1,
TAB_CENTER,
tab_float (tbl, col + 2,
row + 1,
TAB_CENTER,
- m->mean - t * m->se_mean,
+ m->mean - t * m->se_mean,
- tab_text (tbl, col + 1,
+ tab_text (tbl, col + 1,
row + 2,
TAB_LEFT | TAT_TITLE,
_ ("Upper Bound"));
row + 2,
TAB_LEFT | TAT_TITLE,
_ ("Upper Bound"));
tab_float (tbl, col + 2,
row + 2,
TAB_CENTER,
tab_float (tbl, col + 2,
row + 2,
TAB_CENTER,
- m->mean + t * m->se_mean,
+ m->mean + t * m->se_mean,
row + 3,
TAB_LEFT | TAT_TITLE | TAT_PRINTF,
_ ("5%% Trimmed Mean"));
row + 3,
TAB_LEFT | TAT_TITLE | TAT_PRINTF,
_ ("5%% Trimmed Mean"));
- tab_float (tbl, col + 2,
+ tab_float (tbl, col + 2,
row + 3,
TAB_CENTER,
m->trimmed_mean,
8,2);
row + 3,
TAB_CENTER,
m->trimmed_mean,
8,2);
row + 4,
TAB_LEFT | TAT_TITLE,
_ ("Median"));
row + 4,
TAB_LEFT | TAT_TITLE,
_ ("Median"));
{
struct percentile *p;
double d = 50;
{
struct percentile *p;
double d = 50;
p = hsh_find (m->ptile_hash, &d);
p = hsh_find (m->ptile_hash, &d);
- tab_float (tbl, col + 2,
+ tab_float (tbl, col + 2,
row + 4,
TAB_CENTER,
p->v,
8, 2);
}
row + 4,
TAB_CENTER,
p->v,
8, 2);
}
row + 5,
TAB_LEFT | TAT_TITLE,
_ ("Variance"));
row + 5,
TAB_LEFT | TAT_TITLE,
_ ("Variance"));
row + 6,
TAB_LEFT | TAT_TITLE,
_ ("Std. Deviation"));
row + 6,
TAB_LEFT | TAT_TITLE,
_ ("Std. Deviation"));
row + 7,
TAB_LEFT | TAT_TITLE,
_ ("Minimum"));
row + 7,
TAB_LEFT | TAT_TITLE,
_ ("Minimum"));
row + 8,
TAB_LEFT | TAT_TITLE,
_ ("Maximum"));
row + 8,
TAB_LEFT | TAT_TITLE,
_ ("Maximum"));
row + 9,
TAB_LEFT | TAT_TITLE,
_ ("Range"));
row + 9,
TAB_LEFT | TAT_TITLE,
_ ("Range"));
row + 10,
TAB_LEFT | TAT_TITLE,
_ ("Interquartile Range"));
row + 10,
TAB_LEFT | TAT_TITLE,
_ ("Interquartile Range"));
assert (p1);
assert (p2);
assert (p1);
assert (p2);
- tab_float (tbl, col + 2,
+ tab_float (tbl, col + 2,
row + 10,
TAB_CENTER,
p1->v - p2->v,
row + 10,
TAB_CENTER,
p1->v - p2->v,
row + 11,
TAB_LEFT | TAT_TITLE,
_ ("Skewness"));
row + 11,
TAB_LEFT | TAT_TITLE,
_ ("Skewness"));
row + 12,
TAB_LEFT | TAT_TITLE,
_ ("Kurtosis"));
row + 12,
TAB_LEFT | TAT_TITLE,
_ ("Kurtosis"));
-box_plot_variables (const struct factor *fctr,
- const struct variable **vars, int n_vars,
+box_plot_variables (const struct factor *fctr,
+ const struct variable **vars, int n_vars,
const struct variable *id)
{
int i;
struct factor_statistics **fs ;
const struct variable *id)
{
int i;
struct factor_statistics **fs ;
{
box_plot_group (fctr, vars, n_vars, id);
return;
}
{
box_plot_group (fctr, vars, n_vars, id);
return;
}
- for ( fs = fctr->fs ; *fs ; ++fs )
+ for ( fs = fctr->fs ; *fs ; ++fs )
{
double y_min = DBL_MAX;
double y_max = -DBL_MAX;
{
double y_min = DBL_MAX;
double y_max = -DBL_MAX;
chart_write_title (ch, s);
chart_write_title (ch, s);
- for ( i = 0 ; i < n_vars ; ++i )
+ 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 )
+
+ for ( i = 0 ; i < n_vars ; ++i )
- const double box_width = (ch->data_right - ch->data_left)
+ const double box_width = (ch->data_right - ch->data_left)
- const double box_centre = ( i * 2 + 1) * box_width
+ const double box_centre = ( i * 2 + 1) * box_width
boxplot_draw_boxplot (ch,
box_centre, box_width,
& (*fs)->m[i],
boxplot_draw_boxplot (ch,
box_centre, box_width,
& (*fs)->m[i],
each dependent variable has its own plot.
*/
void
each dependent variable has its own plot.
*/
void
-box_plot_group (const struct factor *fctr,
- const struct variable **vars,
+box_plot_group (const struct factor *fctr,
+ const struct variable **vars,
int n_vars,
const struct variable *id UNUSED)
{
int i;
int n_vars,
const struct variable *id UNUSED)
{
int i;
- for ( i = 0 ; i < n_vars ; ++i )
+ for ( i = 0 ; i < n_vars ; ++i )
{
struct factor_statistics **fs ;
struct chart *ch;
{
struct factor_statistics **fs ;
struct chart *ch;
boxplot_draw_yscale (ch, totals[i].max, totals[i].min);
boxplot_draw_yscale (ch, totals[i].max, totals[i].min);
{
int n_factors = 0;
int f=0;
{
int n_factors = 0;
int f=0;
- for ( fs = fctr->fs ; *fs ; ++fs )
+ for ( fs = fctr->fs ; *fs ; ++fs )
- chart_write_title (ch, _ ("Boxplot of %s vs. %s"),
+ chart_write_title (ch, _ ("Boxplot of %s vs. %s"),
var_to_string (vars[i]), var_to_string (fctr->indep_var[0]) );
var_to_string (vars[i]), var_to_string (fctr->indep_var[0]) );
- for ( fs = fctr->fs ; *fs ; ++fs )
+ 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)
+ const double box_width = (ch->data_right - ch->data_left)
- const double box_centre = ( f++ * 2 + 1) * box_width
+ const double box_centre = ( f++ * 2 + 1) * box_width
boxplot_draw_boxplot (ch,
box_centre, box_width,
& (*fs)->m[i],
boxplot_draw_boxplot (ch,
box_centre, box_width,
& (*fs)->m[i],
chart_write_title (ch, _ ("Boxplot"));
boxplot_draw_boxplot (ch,
chart_write_title (ch, _ ("Boxplot"));
boxplot_draw_boxplot (ch,
&totals[i],
var_to_string (vars[i]) );
&totals[i],
var_to_string (vars[i]) );
const double intercept = - m->mean / m->stddev;
/* Cowardly refuse to plot an empty data set */
const double intercept = - m->mean / m->stddev;
/* Cowardly refuse to plot an empty data set */
- if ( m->n_data == 0 )
- return ;
+ 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 )
+ if ( !np_chart || ! dnp_chart )
return ;
chart_write_title (np_chart, _ ("Normal Q-Q Plot of %s"), factorname);
return ;
chart_write_title (np_chart, _ ("Normal Q-Q Plot of %s"), factorname);
chart_write_ylabel (np_chart, _ ("Expected Normal"));
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"));
factorname);
chart_write_xlabel (dnp_chart, _ ("Observed Value"));
chart_write_ylabel (dnp_chart, _ ("Dev from Normal"));
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
+ /* We have to cache the detrended data, beacause we need to
find its limits before we can plot it */
double *d_data = xnmalloc (m->n_data, sizeof *d_data);
double d_max = -DBL_MAX;
double d_min = DBL_MAX;
find its limits before we can plot it */
double *d_data = xnmalloc (m->n_data, sizeof *d_data);
double d_max = -DBL_MAX;
double d_min = DBL_MAX;
- for ( i = 0 ; i < m->n_data; ++i )
+ for ( i = 0 ; i < m->n_data; ++i )
{
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);
d_data[i] = (m->wvp[i]->v.f - m->mean) / m->stddev - ns;
{
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);
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);
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);
- for ( i = 0 ; i < m->n_data; ++i )
+ for ( i = 0 ; i < m->n_data; ++i )
chart_datum (dnp_chart, 0, m->wvp[i]->v.f, d_data[i]);
free (d_data);
chart_datum (dnp_chart, 0, m->wvp[i]->v.f, d_data[i]);
free (d_data);
/* Show the percentiles */
void
/* Show the percentiles */
void
-show_percentiles (struct variable **dependent_var,
- int n_dep_var,
+show_percentiles (struct variable **dependent_var,
+ int n_dep_var,
struct factor *fctr)
{
struct tab_table *tbl;
int i;
struct factor *fctr)
{
struct tab_table *tbl;
int i;
int n_cols, n_rows;
int n_factors;
int n_cols, n_rows;
int n_factors;
- struct factor_statistics **fs = fctr->fs ;
+ struct factor_statistics **fs = fctr->fs ;
n_heading_columns = 3;
n_factors = hsh_count (fctr->fstats);
n_heading_columns = 3;
n_factors = hsh_count (fctr->fstats);
n_rows = n_heading_rows + n_dep_var * n_stat_rows * n_factors;
n_rows = n_heading_rows + n_dep_var * n_stat_rows * n_factors;
- n_cols = n_heading_columns + n_ptiles ;
+ n_cols = n_heading_columns + n_ptiles ;
tbl = tab_create (n_cols, n_rows, 0);
tbl = tab_create (n_cols, n_rows, 0);
tab_dim (tbl, tab_natural_dimensions);
/* Outline the box and have no internal lines*/
tab_dim (tbl, tab_natural_dimensions);
/* Outline the box and have no internal lines*/
TAL_2, TAL_2,
-1, -1,
0, 0,
TAL_2, TAL_2,
-1, -1,
0, 0,
tab_hline (tbl, TAL_1, n_heading_columns, n_cols - 1, 1 );
tab_hline (tbl, TAL_1, n_heading_columns, n_cols - 1, 1 );
-1, -1,
-1, TAL_1,
0, n_heading_rows,
n_heading_columns - 1, n_rows - 1);
-1, -1,
-1, TAL_1,
0, n_heading_rows,
n_heading_columns - 1, n_rows - 1);
-1, -1,
-1, TAL_1,
n_heading_columns, n_heading_rows - 1,
-1, -1,
-1, TAL_1,
n_heading_columns, n_heading_rows - 1,
struct percentile **p = (struct percentile **) hsh_sort (ptiles);
i = 0;
struct percentile **p = (struct percentile **) hsh_sort (ptiles);
i = 0;
- tab_float (tbl, n_heading_columns + i++ , 1,
+ tab_float (tbl, n_heading_columns + i++ , 1,
TAB_CENTER,
(*p)->p, 8, 0);
TAB_CENTER,
(*p)->p, 8, 0);
- for ( i = 0 ; i < n_dep_var ; ++i )
+ for ( i = 0 ; i < n_dep_var ; ++i )
{
const int n_stat_rows = 2;
const int row = n_heading_rows + i * n_stat_rows * n_factors ;
{
const int n_stat_rows = 2;
const int row = n_heading_rows + i * n_stat_rows * n_factors ;
tab_text (tbl, 0,
i * n_stat_rows * n_factors + n_heading_rows,
tab_text (tbl, 0,
i * n_stat_rows * n_factors + n_heading_rows,
var_to_string (dependent_var[i])
);
if ( fctr )
{
var_to_string (dependent_var[i])
);
if ( fctr )
{
+ const union value *prev = NULL ;
struct factor_statistics **fs = fctr->fs;
int count = 0;
struct factor_statistics **fs = fctr->fs;
int count = 0;
- tab_text (tbl, 1, n_heading_rows - 1,
- TAB_CENTER | TAT_TITLE,
+ tab_text (tbl, 1, n_heading_rows - 1,
+ TAB_CENTER | TAT_TITLE,
var_to_string (fctr->indep_var[0]));
if ( fctr->indep_var[1])
var_to_string (fctr->indep_var[0]));
if ( fctr->indep_var[1])
- tab_text (tbl, 2, n_heading_rows - 1, TAB_CENTER | TAT_TITLE,
+ 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]));
-
- static union value prev ;
-
- const int row = n_heading_rows + n_stat_rows *
+ 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],
+ if ( !prev || 0 != compare_values (prev, (*fs)->id[0],
var_get_width (fctr->indep_var[0])))
{
var_get_width (fctr->indep_var[0])))
{
tab_hline (tbl, TAL_1, 1, n_cols - 1, row);
tab_hline (tbl, TAL_1, 1, n_cols - 1, row);
- TAB_LEFT | TAT_TITLE,
- value_to_string (& (*fs)->id[0], fctr->indep_var[0])
+ TAB_LEFT | TAT_TITLE,
+ value_to_string ((*fs)->id[0], fctr->indep_var[0])
- if (fctr->indep_var[1] && count > 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])
+ if ( fctr->indep_var[1])
- TAB_LEFT | TAT_TITLE,
- value_to_string (& (*fs)->id[1], fctr->indep_var[1])
+ TAB_LEFT | TAT_TITLE,
+ value_to_string ((*fs)->id[1], fctr->indep_var[1])
- populate_percentiles (tbl, n_heading_columns - 1,
+ populate_percentiles (tbl, n_heading_columns - 1,
- 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]);
}
i * n_stat_rows * n_factors + n_heading_rows,
&totals[i]);
}
-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);
const struct metrics *m)
{
int i;
struct percentile **p = (struct percentile **) hsh_sort (m->ptile_hash);
- tab_text (tbl,
- col, row,
- TAB_LEFT | TAT_TITLE,
+ tab_text (tbl,
+ col, row,
+ TAB_LEFT | TAT_TITLE,
ptile_alg_desc[m->ptile_alg]
);
i = 0;
ptile_alg_desc[m->ptile_alg]
);
i = 0;
- tab_float (tbl, col + i + 1 , row,
+ tab_float (tbl, col + i + 1 , row,
TAB_CENTER,
(*p)->v, 8, 2);
TAB_CENTER,
(*p)->v, 8, 2);
- if ( (*p)->p == 25 )
- tab_float (tbl, col + i + 1 , row + 1,
+ if ( (*p)->p == 25 )
+ tab_float (tbl, col + i + 1 , row + 1,
TAB_CENTER,
m->hinge[0], 8, 2);
TAB_CENTER,
m->hinge[0], 8, 2);
- if ( (*p)->p == 50 )
- tab_float (tbl, col + i + 1 , row + 1,
+ if ( (*p)->p == 50 )
+ tab_float (tbl, col + i + 1 , row + 1,
TAB_CENTER,
m->hinge[1], 8, 2);
TAB_CENTER,
m->hinge[1], 8, 2);
- if ( (*p)->p == 75 )
- tab_float (tbl, col + i + 1 , row + 1,
+ if ( (*p)->p == 75 )
+ tab_float (tbl, col + i + 1 , row + 1,
TAB_CENTER,
m->hinge[2], 8, 2);
TAB_CENTER,
m->hinge[2], 8, 2);
-factor_to_string (const struct factor *fctr,
- struct factor_statistics *fs,
- const struct variable *var)
+factor_to_string (const struct factor *fctr,
+ const struct factor_statistics *fs,
+ const struct variable *var)
if (var)
sprintf (buf1, "%s (",var_to_string (var) );
if (var)
sprintf (buf1, "%s (",var_to_string (var) );
snprintf (buf2, 100, "%s = %s",
var_to_string (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]));
-
+ value_to_string (fs->id[0], fctr->indep_var[0]));
+
-
- if ( fctr->indep_var[1] )
+
+ if ( fctr->indep_var[1] )
{
sprintf (buf2, "; %s = %s)",
var_to_string (fctr->indep_var[1]),
{
sprintf (buf2, "; %s = %s)",
var_to_string (fctr->indep_var[1]),
- value_to_string (&fs->id[1],
+ value_to_string (fs->id[1],
fctr->indep_var[1]));
strcat (buf1, buf2);
}
else
{
fctr->indep_var[1]));
strcat (buf1, buf2);
}
else
{
-factor_to_string_concise (const struct factor *fctr,
+factor_to_string_concise (const struct factor *fctr,
struct factor_statistics *fs)
{
struct factor_statistics *fs)
{
char buf2[100];
snprintf (buf, 100, "%s",
char buf2[100];
snprintf (buf, 100, "%s",
- value_to_string (&fs->id[0], fctr->indep_var[0]));
-
- if ( fctr->indep_var[1] )
+ 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]) );
+ sprintf (buf2, ",%s)", value_to_string (fs->id[1], fctr->indep_var[1]) );
+Thu Dec 7 15:27:49 WST 2006 John Darrington <john@darrington.wattle.id.au>
+
+ * factor-stats.c factor-stats.h: Changed independent values to
+ be pointers rather than copies.
+
Wed Dec 6 21:14:59 2006 Ben Pfaff <blp@gnu.org>
* coefficient.c: (pspp_coeff_get_value) Compare variable pointers
Wed Dec 6 21:14:59 2006 Ben Pfaff <blp@gnu.org>
* coefficient.c: (pspp_coeff_get_value) Compare variable pointers
If val is null, then treat it as MISSING
*/
void
If val is null, then treat it as MISSING
*/
void
-metrics_calc(struct metrics *fs, const union value *val,
- double weight, int case_no)
+metrics_calc (struct metrics *fs, const union value *val,
+ double weight, int case_no)
{
struct weighted_value **wv;
double x;
{
struct weighted_value **wv;
double x;
{
fs->n_missing += weight;
return ;
{
fs->n_missing += weight;
return ;
wv = (struct weighted_value **) hsh_probe (fs->ordered_data,(void *) val );
wv = (struct weighted_value **) hsh_probe (fs->ordered_data,(void *) val );
- /* If this value has already been seen, then simply
+ /* If this value has already been seen, then simply
increase its weight and push a new case number */
struct case_node *cn;
assert( (*wv)->v.f == val->f );
increase its weight and push a new case number */
struct case_node *cn;
assert( (*wv)->v.f == val->f );
cn = xmalloc ( sizeof *cn);
cn->next = (*wv)->case_nos ;
cn = xmalloc ( sizeof *cn);
cn->next = (*wv)->case_nos ;
*wv = weighted_value_create();
(*wv)->v = *val;
(*wv)->w = weight;
*wv = weighted_value_create();
(*wv)->v = *val;
(*wv)->w = weight;
cn = xmalloc (sizeof *cn);
cn->next=0;
cn->num = case_no;
cn = xmalloc (sizeof *cn);
cn->next=0;
cn->num = case_no;
double tc ;
int k1, k2 ;
int i;
double tc ;
int k1, k2 ;
int i;
- moments1_calculate (m->moments, &m->n, &m->mean, &m->var,
+ moments1_calculate (m->moments, &m->n, &m->mean, &m->var,
&m->skewness, &m->kurtosis);
moments1_destroy (m->moments);
&m->skewness, &m->kurtosis);
moments1_destroy (m->moments);
m->n_data = hsh_count(m->ordered_data);
/* Trimmed mean calculation */
m->n_data = hsh_count(m->ordered_data);
/* Trimmed mean calculation */
{
m->trimmed_mean = m->mean;
return;
{
m->trimmed_mean = m->mean;
return;
m->histogram = histogram_create(10, m->min, m->max);
m->histogram = histogram_create(10, m->min, m->max);
- for ( i = 0 ; i < m->n_data ; ++i )
+ for ( i = 0 ; i < m->n_data ; ++i )
{
struct weighted_value **wv = (m->wvp) ;
gsl_histogram_accumulate(m->histogram, wv[i]->v.f, wv[i]->w);
{
struct weighted_value **wv = (m->wvp) ;
gsl_histogram_accumulate(m->histogram, wv[i]->v.f, wv[i]->w);
- for ( i = 0 ; i < m->n_data ; ++i )
+ for ( i = 0 ; i < m->n_data ; ++i )
{
cc += m->wvp[i]->w;
m->wvp[i]->cc = cc;
m->wvp[i]->rank = j + (m->wvp[i]->w - 1) / 2.0 ;
{
cc += m->wvp[i]->w;
m->wvp[i]->cc = cc;
m->wvp[i]->rank = j + (m->wvp[i]->w - 1) / 2.0 ;
- for ( i = m->n_data -1 ; i >= 0; --i )
+ for ( i = m->n_data -1 ; i >= 0; --i )
- if ( tc > m->n - m->wvp[i]->cc)
+ if ( tc > m->n - m->wvp[i]->cc)
m->n_data, m->n, m->hinge);
/* Special case here */
m->n_data, m->n, m->hinge);
/* Special case here */
{
m->trimmed_mean = m->wvp[k2]->v.f;
return;
}
m->trimmed_mean = 0;
{
m->trimmed_mean = m->wvp[k2]->v.f;
return;
}
m->trimmed_mean = 0;
- for ( i = k1 + 2 ; i <= k2 - 1 ; ++i )
+ for ( i = k1 + 2 ; i <= k2 - 1 ; ++i )
{
m->trimmed_mean += m->wvp[i]->v.f * m->wvp[i]->w;
}
{
m->trimmed_mean += m->wvp[i]->v.f * m->wvp[i]->w;
}
weighted_value_free(struct weighted_value *wv)
{
struct case_node *cn ;
weighted_value_free(struct weighted_value *wv)
{
struct case_node *cn ;
return ;
cn = wv->case_nos;
return ;
cn = wv->case_nos;
while(cn)
{
struct case_node *next = cn->next;
while(cn)
{
struct case_node *next = cn->next;
/* Create a factor statistics object with for N dependent vars
/* Create a factor statistics object with for N dependent vars
- and ID as the value of the independent variable */
-struct factor_statistics *
-create_factor_statistics (int n, union value *id0, union value *id1)
+ and ID0 and ID1 as the values of the independent variable */
+struct factor_statistics *
+create_factor_statistics (int n,
+ union value *id0,
+ union value *id1)
{
struct factor_statistics *f;
f = xmalloc (sizeof *f);
{
struct factor_statistics *f;
f = xmalloc (sizeof *f);
- f->id[0] = *id0;
- f->id[1] = *id1;
+ f->id[0] = id0;
+ f->id[1] = id1;
f->m = xnmalloc (n, sizeof *f->m);
memset (f->m, 0, sizeof(struct metrics) * n);
f->n_var = n;
f->m = xnmalloc (n, sizeof *f->m);
memset (f->m, 0, sizeof(struct metrics) * n);
f->n_var = n;
metrics_destroy(struct metrics *m)
{
hsh_destroy(m->ordered_data);
hsh_destroy(m->ptile_hash);
metrics_destroy(struct metrics *m)
{
hsh_destroy(m->ordered_data);
hsh_destroy(m->ptile_hash);
gsl_histogram_free(m->histogram);
}
gsl_histogram_free(m->histogram);
}
factor_statistics_free(struct factor_statistics *f)
{
factor_statistics_free(struct factor_statistics *f)
{
- int i;
- for ( i = 0 ; i < f->n_var; ++i )
+ int i;
+ free (f->id[0]);
+ free (f->id[1]);
+ for ( i = 0 ; i < f->n_var; ++i )
metrics_destroy(&f->m[i]);
metrics_destroy(&f->m[i]);
factor_statistics_compare(const struct factor_statistics *f0,
const struct factor_statistics *f1, int width)
{
factor_statistics_compare(const struct factor_statistics *f0,
const struct factor_statistics *f1, int width)
{
- cmp0 = compare_values(&f0->id[0], &f1->id[0], width);
+ cmp0 = compare_values(f0->id[0], f1->id[0], width);
- if ( ( f0->id[1].f == SYSMIS ) && (f1->id[1].f != SYSMIS) )
+ if ( ( f0->id[1]->f == SYSMIS ) && (f1->id[1]->f != SYSMIS) )
- if ( ( f0->id[1].f != SYSMIS ) && (f1->id[1].f == SYSMIS) )
+ if ( ( f0->id[1]->f != SYSMIS ) && (f1->id[1]->f == SYSMIS) )
- return compare_values(&f0->id[1], &f1->id[1], width);
-
+ return compare_values (f0->id[1], f1->id[1], width);
-unsigned int
-factor_statistics_hash(const struct factor_statistics *f, int width)
+unsigned int
+factor_statistics_hash (const struct factor_statistics *f, int width)
- h = hash_value(&f->id[0], width);
-
- if ( f->id[1].f != SYSMIS )
- h += hash_value(&f->id[1], width);
+ h = hash_value (f->id[0], width);
+
+ if ( f->id[1]->f != SYSMIS )
+ h += hash_value(f->id[1], width);
/* PSPP - A program for statistical analysis . -*-c-*-
Copyright (C) 2004 Free Software Foundation, Inc.
/* PSPP - A program for statistical analysis . -*-c-*-
Copyright (C) 2004 Free Software Foundation, Inc.
-Author: John Darrington 2004
+Author: John Darrington 2004, 2006
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
-/* FIXME: These things should probably be amalgamated with the
+/* FIXME: These things should probably be amalgamated with the
group_statistics struct */
#include <libpspp/hash.h>
group_statistics struct */
#include <libpspp/hash.h>
double n;
double n_missing;
double n;
double n_missing;
double min;
double max;
double mean;
double min;
double max;
double mean;
double se_mean;
double var;
double se_mean;
double var;
void metrics_precalc(struct metrics *m);
void metrics_precalc(struct metrics *m);
-void metrics_calc(struct metrics *m, const union value *f, double weight,
+void metrics_calc(struct metrics *m, const union value *f, double weight,
int case_no);
void metrics_postcalc(struct metrics *m);
int case_no);
void metrics_postcalc(struct metrics *m);
struct case_node *next;
};
struct case_node *next;
};
double w;
/* The cumulative weight */
double w;
/* The cumulative weight */
/* The rank */
double rank;
/* Linked list of cases nos which have this value */
struct case_node *case_nos;
/* The rank */
double rank;
/* Linked list of cases nos which have this value */
struct case_node *case_nos;
struct factor_statistics {
/* The values of the independent variables */
struct factor_statistics {
/* The values of the independent variables */
/* The an array stats for this factor, one for each dependent var */
struct metrics *m;
/* The an array stats for this factor, one for each dependent var */
struct metrics *m;
/* Create a factor statistics object with for N dependent vars
and ID as the value of the independent variable */
/* Create a factor statistics object with for N dependent vars
and ID as the value of the independent variable */
-struct factor_statistics *
-create_factor_statistics (int n, union value *id0, union value *id1);
+struct factor_statistics * create_factor_statistics (int n,
+ union value *id0,
+ union value *id1);
void factor_statistics_free(struct factor_statistics *f);
void factor_statistics_free(struct factor_statistics *f);
/* Compare f0 and f1.
width is the width of the independent variable */
/* Compare f0 and f1.
width is the width of the independent variable */
factor_statistics_compare(const struct factor_statistics *f0,
const struct factor_statistics *f1, int width);
factor_statistics_compare(const struct factor_statistics *f0,
const struct factor_statistics *f1, int width);
factor_statistics_hash(const struct factor_statistics *f, int width);
#endif
factor_statistics_hash(const struct factor_statistics *f, int width);
#endif
#include <data/settings.h>
#include <data/variable.h>
#include <data/storage-stream.h>
#include <data/settings.h>
#include <data/variable.h>
#include <data/storage-stream.h>
-#include <language/expressions/public.h>
#include <libpspp/alloc.h>
#include <libpspp/array.h>
#include <libpspp/assertion.h>
#include <libpspp/alloc.h>
#include <libpspp/array.h>
#include <libpspp/assertion.h>