/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2009 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <math/levene.h>
#include <output/manager.h>
#include <output/table.h>
+#include <data/format.h>
#include "xalloc.h"
/* The comparison criterion */
enum comparison criterion;
- /* The width of the independent variable */
- int indep_width ;
+ /* The independent variable */
+ struct variable *indep_var;
union {
/* The value of the independent variable at which groups are determined to
/* Structures and Functions for the Statistics Summary Box */
struct ssbox;
typedef void populate_ssbox_func (struct ssbox *ssb,
- struct cmd_t_test *cmd);
+ const struct dictionary *,
+ struct cmd_t_test *cmd);
typedef void finalize_ssbox_func (struct ssbox *ssb);
struct ssbox
void ssbox_create (struct ssbox *ssb, struct cmd_t_test *cmd, int mode);
/* Populate a ssbox according to cmd */
-void ssbox_populate (struct ssbox *ssb, struct cmd_t_test *cmd);
+void ssbox_populate (struct ssbox *ssb, const struct dictionary *dict,
+ struct cmd_t_test *cmd);
/* Submit and destroy a ssbox */
void ssbox_finalize (struct ssbox *ssb);
/* A function to create, populate and submit the Paired Samples Correlation
box */
-void pscbox (void);
+static void pscbox (const struct dictionary *);
/* Structures and Functions for the Test Results Box */
struct trbox;
typedef void populate_trbox_func (struct trbox *trb,
- struct cmd_t_test *cmd);
+ const struct dictionary *dict,
+ struct cmd_t_test *cmd);
typedef void finalize_trbox_func (struct trbox *trb);
struct trbox {
void trbox_create (struct trbox *trb, struct cmd_t_test *cmd, int mode);
/* Populate a ssbox according to cmd */
-void trbox_populate (struct trbox *trb, struct cmd_t_test *cmd);
+static void trbox_populate (struct trbox *trb, const struct dictionary *dict,
+ struct cmd_t_test *cmd);
/* Submit and destroy a ssbox */
void trbox_finalize (struct trbox *trb);
/* Despatcher for the populate method */
void
-ssbox_populate (struct ssbox *ssb,struct cmd_t_test *cmd)
+ssbox_populate (struct ssbox *ssb, const struct dictionary *dict,
+ struct cmd_t_test *cmd)
{
- ssb->populate (ssb,cmd);
+ ssb->populate (ssb, dict, cmd);
}
}
void ssbox_one_sample_populate (struct ssbox *ssb,
- struct cmd_t_test *cmd);
+ const struct dictionary *,
+ struct cmd_t_test *cmd);
/* Initialize the one_sample ssbox */
void
tab_text (this->t, 4, 0, TAB_CENTER | TAT_TITLE, _ ("SE. Mean"));
}
-void ssbox_independent_samples_populate (struct ssbox *ssb,
- struct cmd_t_test *cmd);
+static void ssbox_independent_samples_populate (struct ssbox *ssb,
+ const struct dictionary *,
+ struct cmd_t_test *cmd);
/* Initialize the independent samples ssbox */
void
/* Populate the ssbox for independent samples */
-void
+static void
ssbox_independent_samples_populate (struct ssbox *ssb,
- struct cmd_t_test *cmd)
+ const struct dictionary *dict,
+ struct cmd_t_test *cmd)
{
int i;
+ const struct variable *wv = dict_get_weight (dict);
+ const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0;
+
char *val_lab[2] = {NULL, NULL};
double indep_value[2];
gs = hsh_find (grp_hash, (void *) &search_val);
assert (gs);
- tab_float (ssb->t, 2 ,i*2+count+1, TAB_RIGHT, gs->n, 10, 0);
- tab_float (ssb->t, 3 ,i*2+count+1, TAB_RIGHT, gs->mean, 8, 2);
- tab_float (ssb->t, 4 ,i*2+count+1, TAB_RIGHT, gs->std_dev, 8, 3);
- tab_float (ssb->t, 5 ,i*2+count+1, TAB_RIGHT, gs->se_mean, 8, 3);
+ tab_double (ssb->t, 2, i*2+count+1, TAB_RIGHT, gs->n, wfmt);
+ tab_double (ssb->t, 3, i*2+count+1, TAB_RIGHT, gs->mean, NULL);
+ tab_double (ssb->t, 4, i*2+count+1, TAB_RIGHT, gs->std_dev, NULL);
+ tab_double (ssb->t, 5, i*2+count+1, TAB_RIGHT, gs->se_mean, NULL);
}
}
free (val_lab[0]);
}
-void ssbox_paired_populate (struct ssbox *ssb,
- struct cmd_t_test *cmd);
+static void ssbox_paired_populate (struct ssbox *ssb,
+ const struct dictionary *dict,
+ struct cmd_t_test *cmd);
/* Initialize the paired values ssbox */
void
/* Populate the ssbox for paired values */
void
-ssbox_paired_populate (struct ssbox *ssb,struct cmd_t_test *cmd UNUSED)
+ssbox_paired_populate (struct ssbox *ssb, const struct dictionary *dict,
+ struct cmd_t_test *cmd UNUSED)
{
int i;
+ const struct variable *wv = dict_get_weight (dict);
+ const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0;
+
assert (ssb->t);
for (i=0; i < n_pairs; ++i)
var_get_name (pairs[i].v[j]));
/* Values */
- tab_float (ssb->t,2, i*2+j+1, TAB_RIGHT, pairs[i].mean[j], 8, 2);
- tab_float (ssb->t,3, i*2+j+1, TAB_RIGHT, pairs[i].n, 10, 0);
- tab_float (ssb->t,4, i*2+j+1, TAB_RIGHT, pairs[i].std_dev[j], 8, 3);
- tab_float (ssb->t,5, i*2+j+1, TAB_RIGHT, pairs[i].std_dev[j]/sqrt (pairs[i].n), 8, 3);
+ tab_double (ssb->t,2, i*2+j+1, TAB_RIGHT, pairs[i].mean[j], NULL);
+ tab_double (ssb->t,3, i*2+j+1, TAB_RIGHT, pairs[i].n, wfmt);
+ tab_double (ssb->t,4, i*2+j+1, TAB_RIGHT, pairs[i].std_dev[j], NULL);
+ tab_double (ssb->t,5, i*2+j+1, TAB_RIGHT,
+ pairs[i].std_dev[j]/sqrt (pairs[i].n), NULL);
}
}
/* Populate the one sample ssbox */
void
-ssbox_one_sample_populate (struct ssbox *ssb, struct cmd_t_test *cmd)
+ssbox_one_sample_populate (struct ssbox *ssb, const struct dictionary *dict,
+ struct cmd_t_test *cmd)
{
int i;
+ const struct variable *wv = dict_get_weight (dict);
+ const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0;
+
assert (ssb->t);
for (i=0; i < cmd->n_variables; ++i)
struct group_statistics *gs = &group_proc_get (cmd->v_variables[i])->ugs;
tab_text (ssb->t, 0, i+1, TAB_LEFT, var_get_name (cmd->v_variables[i]));
- tab_float (ssb->t,1, i+1, TAB_RIGHT, gs->n, 10, 0);
- tab_float (ssb->t,2, i+1, TAB_RIGHT, gs->mean, 8, 2);
- tab_float (ssb->t,3, i+1, TAB_RIGHT, gs->std_dev, 8, 2);
- tab_float (ssb->t,4, i+1, TAB_RIGHT, gs->se_mean, 8, 3);
+ tab_double (ssb->t,1, i+1, TAB_RIGHT, gs->n, wfmt);
+ tab_double (ssb->t,2, i+1, TAB_RIGHT, gs->mean, NULL);
+ tab_double (ssb->t,3, i+1, TAB_RIGHT, gs->std_dev, NULL);
+ tab_double (ssb->t,4, i+1, TAB_RIGHT, gs->se_mean, NULL);
}
-
}
void trbox_independent_samples_init (struct trbox *trb,
struct cmd_t_test *cmd );
-void trbox_independent_samples_populate (struct trbox *trb,
- struct cmd_t_test *cmd);
+static void trbox_independent_samples_populate (struct trbox *trb,
+ const struct dictionary *dict,
+ struct cmd_t_test *cmd);
void trbox_one_sample_init (struct trbox *self,
struct cmd_t_test *cmd );
-void trbox_one_sample_populate (struct trbox *trb,
- struct cmd_t_test *cmd);
+static void trbox_one_sample_populate (struct trbox *trb,
+ const struct dictionary *,
+ struct cmd_t_test *cmd);
void trbox_paired_init (struct trbox *self,
struct cmd_t_test *cmd );
-void trbox_paired_populate (struct trbox *trb,
- struct cmd_t_test *cmd);
+static void trbox_paired_populate (struct trbox *trb,
+ const struct dictionary *,
+ struct cmd_t_test *cmd);
}
/* Populate a trbox according to cmd */
-void
-trbox_populate (struct trbox *trb, struct cmd_t_test *cmd)
+static void
+trbox_populate (struct trbox *trb, const struct dictionary *dict,
+ struct cmd_t_test *cmd)
{
- trb->populate (trb,cmd);
+ trb->populate (trb, dict, cmd);
}
/* Submit and destroy a trbox */
}
/* Populate the independent samples trbox */
-void
+static void
trbox_independent_samples_populate (struct trbox *self,
- struct cmd_t_test *cmd )
+ const struct dictionary *dict UNUSED,
+ struct cmd_t_test *cmd)
{
int i;
tab_text (self->t, 1, i*2+3, TAB_LEFT, _ ("Equal variances assumed"));
- tab_float (self->t, 2, i*2+3, TAB_CENTER, grp_data->levene, 8,3);
+ tab_double (self->t, 2, i*2+3, TAB_CENTER, grp_data->levene, NULL);
/* Now work out the significance of the Levene test */
df1 = 1; df2 = grp_data->ugs.n - 2;
q = gsl_cdf_fdist_Q (grp_data->levene, df1, df2);
- tab_float (self->t, 3, i*2+3, TAB_CENTER, q, 8,3 );
+ tab_double (self->t, 3, i*2+3, TAB_CENTER, q, NULL);
df = gs0->n + gs1->n - 2.0 ;
- tab_float (self->t, 5, i*2+3, TAB_RIGHT, df, 10, 0);
+ tab_double (self->t, 5, i*2+3, TAB_RIGHT, df, NULL);
pooled_variance = ( (gs0->n )*pow2 (gs0->s_std_dev)
+
t = (gs0->mean - gs1->mean) / sqrt (pooled_variance) ;
t /= sqrt ((gs0->n + gs1->n)/ (gs0->n*gs1->n));
- tab_float (self->t, 4, i*2+3, TAB_RIGHT, t, 8, 3);
+ tab_double (self->t, 4, i*2+3, TAB_RIGHT, t, NULL);
p = gsl_cdf_tdist_P (t, df);
q = gsl_cdf_tdist_Q (t, df);
- tab_float (self->t, 6, i*2+3, TAB_RIGHT, 2.0* (t>0?q:p) , 8, 3);
+ tab_double (self->t, 6, i*2+3, TAB_RIGHT, 2.0* (t>0?q:p), NULL);
mean_diff = gs0->mean - gs1->mean;
- tab_float (self->t, 7, i*2+3, TAB_RIGHT, mean_diff, 8, 3);
+ tab_double (self->t, 7, i*2+3, TAB_RIGHT, mean_diff, NULL);
std_err_diff = sqrt ( pow2 (gs0->se_mean) + pow2 (gs1->se_mean));
- tab_float (self->t, 8, i*2+3, TAB_RIGHT, std_err_diff, 8, 3);
+ tab_double (self->t, 8, i*2+3, TAB_RIGHT, std_err_diff, NULL);
/* Now work out the confidence interval */
q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
t = gsl_cdf_tdist_Qinv (q,df);
- tab_float (self->t, 9, i*2+3, TAB_RIGHT,
- mean_diff - t * std_err_diff, 8, 3);
+ tab_double (self->t, 9, i*2+3, TAB_RIGHT,
+ mean_diff - t * std_err_diff, NULL);
- tab_float (self->t, 10, i*2+3, TAB_RIGHT,
- mean_diff + t * std_err_diff, 8, 3);
+ tab_double (self->t, 10, i*2+3, TAB_RIGHT,
+ mean_diff + t * std_err_diff, NULL);
{
(pow2 (gs1->s_std_dev)/ (gs1->n -1) );
t = mean_diff / sqrt (se2) ;
- tab_float (self->t, 4, i*2+3+1, TAB_RIGHT, t, 8, 3);
+ tab_double (self->t, 4, i*2+3+1, TAB_RIGHT, t, NULL);
df = pow2 (se2) / (
(pow2 (pow2 (gs0->s_std_dev)/ (gs0->n - 1 ))
/ (gs1->n -1 )
)
) ;
- tab_float (self->t, 5, i*2+3+1, TAB_RIGHT, df, 8, 3);
+
+ tab_double (self->t, 5, i*2+3+1, TAB_RIGHT, df, NULL);
p = gsl_cdf_tdist_P (t, df);
q = gsl_cdf_tdist_Q (t, df);
- tab_float (self->t, 6, i*2+3+1, TAB_RIGHT, 2.0* (t>0?q:p) , 8, 3);
+ tab_double (self->t, 6, i*2+3+1, TAB_RIGHT, 2.0* (t>0?q:p), NULL);
/* Now work out the confidence interval */
q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
t = gsl_cdf_tdist_Qinv (q, df);
- tab_float (self->t, 7, i*2+3+1, TAB_RIGHT, mean_diff, 8, 3);
-
+ tab_double (self->t, 7, i*2+3+1, TAB_RIGHT, mean_diff, NULL);
- tab_float (self->t, 8, i*2+3+1, TAB_RIGHT, std_err_diff, 8, 3);
+ tab_double (self->t, 8, i*2+3+1, TAB_RIGHT, std_err_diff, NULL);
- tab_float (self->t, 9, i*2+3+1, TAB_RIGHT,
- mean_diff - t * std_err_diff, 8, 3);
- tab_float (self->t, 10, i*2+3+1, TAB_RIGHT,
- mean_diff + t * std_err_diff, 8, 3);
+ tab_double (self->t, 9, i*2+3+1, TAB_RIGHT,
+ mean_diff - t * std_err_diff, NULL);
+ tab_double (self->t, 10, i*2+3+1, TAB_RIGHT,
+ mean_diff + t * std_err_diff, NULL);
}
}
}
}
/* Populate the paired samples trbox */
-void
+static void
trbox_paired_populate (struct trbox *trb,
- struct cmd_t_test *cmd UNUSED)
+ const struct dictionary *dict,
+ struct cmd_t_test *cmd UNUSED)
{
int i;
+ const struct variable *wv = dict_get_weight (dict);
+ const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0;
+
for (i=0; i < n_pairs; ++i)
{
double p,q;
var_get_name (pairs[i].v[0]),
var_get_name (pairs[i].v[1]));
- tab_float (trb->t, 2, i+3, TAB_RIGHT, pairs[i].mean_diff, 8, 4);
+ tab_double (trb->t, 2, i+3, TAB_RIGHT, pairs[i].mean_diff, NULL);
- tab_float (trb->t, 3, i+3, TAB_RIGHT, pairs[i].std_dev_diff, 8, 5);
+ tab_double (trb->t, 3, i+3, TAB_RIGHT, pairs[i].std_dev_diff, NULL);
/* SE Mean */
se_mean = pairs[i].std_dev_diff / sqrt (n) ;
- tab_float (trb->t, 4, i+3, TAB_RIGHT, se_mean, 8,5 );
+ tab_double (trb->t, 4, i+3, TAB_RIGHT, se_mean, NULL);
/* Now work out the confidence interval */
q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
t = gsl_cdf_tdist_Qinv (q, df);
- tab_float (trb->t, 5, i+3, TAB_RIGHT,
- pairs[i].mean_diff - t * se_mean , 8, 4);
+ tab_double (trb->t, 5, i+3, TAB_RIGHT,
+ pairs[i].mean_diff - t * se_mean , NULL);
- tab_float (trb->t, 6, i+3, TAB_RIGHT,
- pairs[i].mean_diff + t * se_mean , 8, 4);
+ tab_double (trb->t, 6, i+3, TAB_RIGHT,
+ pairs[i].mean_diff + t * se_mean , NULL);
t = (pairs[i].mean[0] - pairs[i].mean[1])
/ sqrt (
- ( pow2 (pairs[i].s_std_dev[0]) + pow2 (pairs[i].s_std_dev[1]) -
+ ( pow2 (pairs[i].s_std_dev[0]) + pow2 (pairs[i].s_std_dev[1]) -
2 * pairs[i].correlation *
pairs[i].s_std_dev[0] * pairs[i].s_std_dev[1] )
/ (n - 1)
);
- tab_float (trb->t, 7, i+3, TAB_RIGHT, t , 8,3 );
+ tab_double (trb->t, 7, i+3, TAB_RIGHT, t, NULL);
/* Degrees of freedom */
- tab_float (trb->t, 8, i+3, TAB_RIGHT, df , 10, 0 );
+ tab_double (trb->t, 8, i+3, TAB_RIGHT, df, wfmt);
p = gsl_cdf_tdist_P (t,df);
q = gsl_cdf_tdist_P (t,df);
- tab_float (trb->t, 9, i+3, TAB_RIGHT, 2.0* (t>0?q:p) , 8, 3);
+ tab_double (trb->t, 9, i+3, TAB_RIGHT, 2.0* (t>0?q:p), NULL);
}
}
/* Populate the one sample trbox */
-void
-trbox_one_sample_populate (struct trbox *trb, struct cmd_t_test *cmd)
+static void
+trbox_one_sample_populate (struct trbox *trb,
+ const struct dictionary *dict,
+ struct cmd_t_test *cmd)
{
int i;
+ const struct variable *wv = dict_get_weight (dict);
+ const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0;
+
assert (trb->t);
for (i=0; i < cmd->n_variables; ++i)
t = (gs->mean - cmd->n_testval[0] ) * sqrt (gs->n) / gs->std_dev ;
- tab_float (trb->t, 1, i+3, TAB_RIGHT, t, 8,3);
+ tab_double (trb->t, 1, i+3, TAB_RIGHT, t, NULL);
/* degrees of freedom */
df = gs->n - 1;
- tab_float (trb->t, 2, i+3, TAB_RIGHT, df, 8,0);
+ tab_double (trb->t, 2, i+3, TAB_RIGHT, df, wfmt);
p = gsl_cdf_tdist_P (t, df);
q = gsl_cdf_tdist_Q (t, df);
/* Multiply by 2 to get 2-tailed significance, makeing sure we've got
the correct tail*/
- tab_float (trb->t, 3, i+3, TAB_RIGHT, 2.0* (t>0?q:p), 8,3);
+ tab_double (trb->t, 3, i+3, TAB_RIGHT, 2.0* (t>0?q:p), NULL);
- tab_float (trb->t, 4, i+3, TAB_RIGHT, gs->mean_diff, 8,3);
+ tab_double (trb->t, 4, i+3, TAB_RIGHT, gs->mean_diff, NULL);
q = (1 - cmd->criteria)/2.0; /* 2-tailed test */
t = gsl_cdf_tdist_Qinv (q, df);
- tab_float (trb->t, 5, i+3, TAB_RIGHT,
- gs->mean_diff - t * gs->se_mean, 8,4);
+ tab_double (trb->t, 5, i+3, TAB_RIGHT,
+ gs->mean_diff - t * gs->se_mean, NULL);
- tab_float (trb->t, 6, i+3, TAB_RIGHT,
- gs->mean_diff + t * gs->se_mean, 8,4);
+ tab_double (trb->t, 6, i+3, TAB_RIGHT,
+ gs->mean_diff + t * gs->se_mean, NULL);
}
}
/* Create , populate and submit the Paired Samples Correlation box */
-void
-pscbox (void)
+static void
+pscbox (const struct dictionary *dict)
{
- const int rows=1+n_pairs;
- const int cols=5;
+ const struct variable *wv = dict_get_weight (dict);
+ const struct fmt_spec *wfmt = wv ? var_get_print_format (wv) : &F_8_0;
+
+ const int rows = 1 + n_pairs;
+ const int cols = 5;
int i;
struct tab_table *table;
/* row data */
- tab_float (table, 2, i+1, TAB_RIGHT, pairs[i].n, 4, 0);
- tab_float (table, 3, i+1, TAB_RIGHT, pairs[i].correlation, 8, 3);
+ tab_double (table, 2, i+1, TAB_RIGHT, pairs[i].n, wfmt);
+ tab_double (table, 3, i+1, TAB_RIGHT, pairs[i].correlation, NULL);
p = gsl_cdf_tdist_P (correlation_t, df);
q = gsl_cdf_tdist_Q (correlation_t, df);
- tab_float (table, 4, i+1, TAB_RIGHT, 2.0* (correlation_t>0?q:p), 8, 3);
+ tab_double (table, 4, i+1, TAB_RIGHT, 2.0* (correlation_t>0?q:p), NULL);
}
tab_submit (table);
gs->n += weight;
gs->sum += weight * val->f;
- gs->ssq += weight * val->f * val->f;
+ gs->ssq += weight * pow2 (val->f);
}
}
return 0;
gs->mean=gs->sum / gs->n;
gs->s_std_dev= sqrt (
- ( (gs->ssq / gs->n ) - gs->mean * gs->mean )
+ ( (gs->ssq / gs->n ) - pow2 (gs->mean))
) ;
gs->std_dev= sqrt (
gs->n/ (gs->n-1) *
- ( (gs->ssq / gs->n ) - gs->mean * gs->mean )
+ ( (gs->ssq / gs->n ) - pow2 (gs->mean))
) ;
gs->se_mean = gs->std_dev / sqrt (gs->n);
/* There's always 2 groups for a T - TEST */
ttpr->n_groups = 2;
- gp.indep_width = var_get_width (indep_var);
+ gp.indep_var = indep_var;
ttpr->group_hash = hsh_create (2,
(hsh_compare_func *) compare_group_binary,
gs->mean = gs->sum / gs->n;
gs->s_std_dev= sqrt (
- ( (gs->ssq / gs->n ) - gs->mean * gs->mean )
+ ( (gs->ssq / gs->n ) - pow2 (gs->mean))
) ;
gs->std_dev= sqrt (
gs->n/ (gs->n-1) *
- ( (gs->ssq / gs->n ) - gs->mean * gs->mean )
+ ( (gs->ssq / gs->n ) - pow2 (gs->mean))
) ;
gs->se_mean = gs->std_dev / sqrt (gs->n);
struct casereader *pass1, *pass2, *pass3;
struct taint *taint;
- struct ccase c;
+ struct ccase *c;
enum mv_class exclude = cmd->miss != TTS_INCLUDE ? MV_ANY : MV_SYSTEM;
- if (!casereader_peek (input, 0, &c))
+ c = casereader_peek (input, 0);
+ if (c == NULL)
{
casereader_destroy (input);
return;
}
- output_split_file_values (ds, &c);
- case_destroy (&c);
+ output_split_file_values (ds, c);
+ case_unref (c);
if ( cmd->miss == TTS_LISTWISE )
input = casereader_create_filter_missing (input,
casereader_split (input, &pass1, &pass2);
common_precalc (cmd);
- for (; casereader_read (pass1, &c); case_destroy (&c))
- common_calc (dict, &c, cmd, exclude);
+ for (; (c = casereader_read (pass1)) != NULL; case_unref (c))
+ common_calc (dict, c, cmd, exclude);
casereader_destroy (pass1);
common_postcalc (cmd);
{
case T_1_SAMPLE:
one_sample_precalc (cmd);
- for (; casereader_read (pass2, &c); case_destroy (&c))
- one_sample_calc (dict, &c, cmd, exclude);
+ for (; (c = casereader_read (pass2)) != NULL; case_unref (c))
+ one_sample_calc (dict, c, cmd, exclude);
one_sample_postcalc (cmd);
break;
case T_PAIRED:
paired_precalc (cmd);
- for (; casereader_read (pass2, &c); case_destroy (&c))
- paired_calc (dict, &c, cmd, exclude);
+ for (; (c = casereader_read (pass2)) != NULL; case_unref (c))
+ paired_calc (dict, c, cmd, exclude);
paired_postcalc (cmd);
break;
case T_IND_SAMPLES:
pass3 = casereader_clone (pass2);
group_precalc (cmd);
- for (; casereader_read (pass2, &c); case_destroy (&c))
- group_calc (dict, &c, cmd, exclude);
+ for (; (c = casereader_read (pass2)) != NULL; case_unref (c))
+ group_calc (dict, c, cmd, exclude);
group_postcalc (cmd);
levene (dict, pass3, indep_var, cmd->n_variables, cmd->v_variables,
if (!taint_has_tainted_successor (taint))
{
ssbox_create (&stat_summary_box,cmd,mode);
- ssbox_populate (&stat_summary_box,cmd);
+ ssbox_populate (&stat_summary_box, dict, cmd);
ssbox_finalize (&stat_summary_box);
if ( mode == T_PAIRED )
- pscbox ();
+ pscbox (dict);
- trbox_create (&test_results_box,cmd,mode);
- trbox_populate (&test_results_box,cmd);
+ trbox_create (&test_results_box, cmd, mode);
+ trbox_populate (&test_results_box, dict, cmd);
trbox_finalize (&test_results_box);
}
if ( p->criterion == CMP_LE )
{
- /* less-than comparision is not meaningfull for
- alpha variables, so we shouldn't ever arrive here */
- assert (p->indep_width == 0 ) ;
-
flag_a = ( a->id.f < p->v.critical_value ) ;
flag_b = ( b->id.f < p->v.critical_value ) ;
}
if ( p->criterion == CMP_LE )
{
- /* Not meaningfull to do a less than compare for alpha values ? */
- assert (p->indep_width == 0 ) ;
flag = ( g->id.f < p->v.critical_value ) ;
}
else if ( p->criterion == CMP_EQ)
which_group (const struct group_statistics *g,
const struct group_properties *p)
{
- if ( 0 == compare_values (&g->id, &p->v.g_value[0], p->indep_width))
+ if ( 0 == compare_values_short (&g->id, &p->v.g_value[0], p->indep_var))
return 0;
- if ( 0 == compare_values (&g->id, &p->v.g_value[1], p->indep_width))
+ if ( 0 == compare_values_short (&g->id, &p->v.g_value[1], p->indep_var))
return 1;
return 2;