/* 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
/* 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
}
static int
-tts_custom_groups (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cmd UNUSED, void *aux UNUSED)
+tts_custom_groups (struct lexer *lexer, struct dataset *ds, struct cmd_t_test *cmd UNUSED,
+ void *aux UNUSED)
{
int n_group_values=0;
gp.criterion = CMP_LE ;
+ if ( var_is_alpha (indep_var))
+ {
+ buf_copy_rpad (gp.v.g_value [0].s, var_get_width (indep_var),
+ gp.v.g_value [0].s, strlen (gp.v.g_value[0].s));
+
+ buf_copy_rpad (gp.v.g_value [1].s, var_get_width (indep_var),
+ gp.v.g_value [1].s, strlen (gp.v.g_value[1].s));
+ }
+
return 1;
}
{
if (!lex_force_string (lexer))
return 0;
+ memset (v->s, ' ', MAX_SHORT_STRING);
strncpy (v->s, ds_cstr (lex_tokstr (lexer)), ds_length (lex_tokstr (lexer)));
}
{
int i;
- const char *val_lab0;
- const char *val_lab1;
+ char *val_lab[2] = {NULL, NULL};
double indep_value[2];
char prefix[2][3]={"",""};
if ( var_is_numeric (indep_var) )
{
- val_lab0 = var_lookup_value_label (indep_var, &gp.v.g_value[0]);
- val_lab1 = var_lookup_value_label (indep_var, &gp.v.g_value[1]);
+ const char *s;
+
+ s = var_lookup_value_label (indep_var, &gp.v.g_value[0]);
+ val_lab[0] = s ? strdup (s) : NULL;
+
+ s = var_lookup_value_label (indep_var, &gp.v.g_value[1]);
+ val_lab[1] = s ? strdup (s) : NULL;
}
else
{
- val_lab0 = gp.v.g_value[0].s;
- val_lab1 = gp.v.g_value[1].s;
+ val_lab[0] = calloc (sizeof (char), MAX_SHORT_STRING + 1);
+ val_lab[1] = calloc (sizeof (char), MAX_SHORT_STRING + 1);
+ memcpy (val_lab[0], gp.v.g_value[0].s, MAX_SHORT_STRING);
+ memcpy (val_lab[1], gp.v.g_value[1].s, MAX_SHORT_STRING);
}
if (gp.criterion == CMP_LE )
tab_text (ssb->t, 0, i*2+1, TAB_LEFT,
var_get_name (cmd->v_variables[i]));
- if (val_lab0)
+ if (val_lab[0])
tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF,
- "%s%s", prefix[0], val_lab0);
+ "%s%s", prefix[0], val_lab[0]);
else
tab_text (ssb->t, 1, i*2+1, TAB_LEFT | TAT_PRINTF,
"%s%g", prefix[0], indep_value[0]);
- if (val_lab1)
+ if (val_lab[1])
tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF,
- "%s%s", prefix[1], val_lab1);
+ "%s%s", prefix[1], val_lab[1]);
else
tab_text (ssb->t, 1, i*2+1+1, TAB_LEFT | TAT_PRINTF,
"%s%g", prefix[1], indep_value[1]);
tab_float (ssb->t, 5 ,i*2+count+1, TAB_RIGHT, gs->se_mean, 8, 3);
}
}
+ free (val_lab[0]);
+ free (val_lab[1]);
}
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,
cmd->v_variables,
cmd->n_variables,
- exclude, NULL);
+ exclude, NULL, NULL);
input = casereader_create_filter_weight (input, dict, NULL, NULL);
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 ( 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;
projects / pspp-builds.git / blobdiff