Fixed a whole lot more memory leaks.

[pspp-builds.git] / src / t-test.q

diff --git a/src/t-test.q b/src/t-test.q
index a991f29ed6d09bb9bf4f2c0e99b8dc918a6ca619..4d58206d083e3f24151be5795dc09b0c94ccb45a 100644 (file)
--- a/src/t-test.q
+++ b/src/t-test.q
@@ -29,6 +29,7 @@
 #include "str.h"
 #include "case.h"
 #include "command.h"
+#include "dictionary.h"
 #include "lexer.h"
 #include "error.h"
 #include "magic.h"
@@ -42,11 +43,12 @@
 #include "group_proc.h"
 #include "casefile.h"
 #include "levene.h"
+/* (headers) */
 
 /* (specification)
    "T-TEST" (tts_):
      +groups=custom;
-     +testval=double;
+     testval=double;
      variables=varlist("PV_NO_SCRATCH | PV_NUMERIC");
      pairs=custom;
      +missing=miss:!analysis/listwise,
@@ -66,9 +68,11 @@ static is_missing_func value_is_missing;
 /* Variable for the GROUPS subcommand, if given. */
 static struct variable *indep_var;
 
-/* GROUPS: Number of values specified by the user; the values
-   specified if any. */
-
+enum comparison
+  {
+    CMP_LE = -2,
+    CMP_EQ = 0,
+  };
 
 struct group_properties
 {
@@ -234,11 +238,11 @@ static int bad_weight_warn;
 
 static int compare_group_binary(const struct group_statistics *a, 
                                const struct group_statistics *b, 
-                               struct group_properties *p);
+                               const struct group_properties *p);
 
 
 static unsigned  hash_group_binary(const struct group_statistics *g, 
-                                  struct group_properties *p);
+                                  const struct group_properties *p);
 
 
 
@@ -263,6 +267,7 @@ cmd_t_test(void)
        msg(SE, 
            _("TESTVAL, GROUPS and PAIRS subcommands are mutually exclusive.")
            );
+        free_t_test(&cmd);
        return CMD_FAILURE;
       }
   }
@@ -279,6 +284,7 @@ cmd_t_test(void)
       if (cmd.sbc_variables) 
        {
          msg(SE, _("VARIABLES subcommand is not appropriate with PAIRS"));
+          free_t_test(&cmd);
          return CMD_FAILURE;
        }
       else
@@ -316,6 +322,7 @@ cmd_t_test(void)
   else if ( !cmd.sbc_variables) 
     {
       msg(SE, _("One or more VARIABLES must be specified."));
+      free_t_test(&cmd);
       return CMD_FAILURE;
     }
 
@@ -340,11 +347,12 @@ cmd_t_test(void)
       /* Destroy any group statistics we created */
       for (v = 0 ; v < cmd.n_variables ; ++v ) 
        {
-         struct group_proc *grpp = &cmd.v_variables[v]->p.grp_data;
-         free(grpp->group_hash);
+         struct group_proc *grpp = group_proc_get (cmd.v_variables[v]);
+         hsh_destroy (grpp->group_hash);
        }
     }
     
+  free_t_test(&cmd);
   return CMD_SUCCESS;
 }
 
@@ -392,18 +400,25 @@ tts_custom_groups (struct cmd_t_test *cmd UNUSED)
        }
       else
        {
-         msg (SE, _("When applying GROUPS to a string variable, at "
-                    "least one value must be specified."));
+         msg (SE, _("When applying GROUPS to a string variable, two "
+                    "values must be specified."));
          return 0;
        }
     }
 
-  if (!parse_value (&gp.v.g_value[0],indep_var->type))
+  if (!parse_value (&gp.v.g_value[0], indep_var->type))
       return 0;
 
   lex_match (',');
   if (lex_match (')'))
     {
+      if (indep_var->type != NUMERIC)
+       {
+
+         msg (SE, _("When applying GROUPS to a string variable, two "
+                    "values must be specified."));
+         return 0;
+       }
       gp.criterion = CMP_LE;
       gp.v.critical_value = gp.v.g_value[0].f;
 
@@ -411,7 +426,7 @@ tts_custom_groups (struct cmd_t_test *cmd UNUSED)
       return 1;
     }
 
-  if (!parse_value (&gp.v.g_value[1],indep_var->type))
+  if (!parse_value (&gp.v.g_value[1], indep_var->type))
     return 0;
 
   n_group_values = 2;
@@ -747,7 +762,7 @@ ssbox_independent_samples_populate(struct ssbox *ssb,
   for (i=0; i < cmd->n_variables; ++i)
     {
       struct variable *var = cmd->v_variables[i];
-      struct hsh_table *grp_hash = var->p.grp_data.group_hash;
+      struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
       int count=0;
 
       tab_text (ssb->t, 0, i*2+1, TAB_LEFT, cmd->v_variables[i]->name);
@@ -847,7 +862,7 @@ ssbox_paired_populate(struct ssbox *ssb,struct cmd_t_test *cmd UNUSED)
        {
          struct group_statistics *gs;
 
-         gs=&pairs[i].v[j]->p.grp_data.ugs;
+         gs = &group_proc_get (pairs[i].v[j])->ugs;
 
          /* Titles */
 
@@ -873,8 +888,7 @@ ssbox_one_sample_populate(struct ssbox *ssb, struct cmd_t_test *cmd)
 
   for (i=0; i < cmd->n_variables; ++i)
     {
-      struct group_statistics *gs;
-      gs= &cmd->v_variables[i]->p.grp_data.ugs;
+      struct group_statistics *gs = &group_proc_get (cmd->v_variables[i])->ugs;
 
       tab_text (ssb->t, 0, i+1, TAB_LEFT, cmd->v_variables[i]->name);
       tab_float (ssb->t,1, i+1, TAB_RIGHT, gs->n, 2, 0);
@@ -1009,8 +1023,9 @@ trbox_independent_samples_populate(struct trbox *self,
       double mean_diff;
 
       struct variable *var = cmd->v_variables[i];
+      struct group_proc *grp_data = group_proc_get (var);
 
-      struct hsh_table *grp_hash = var->p.grp_data.group_hash;
+      struct hsh_table *grp_hash = grp_data->group_hash;
 
       struct group_statistics *gs0 ;
       struct group_statistics *gs1 ;
@@ -1039,12 +1054,11 @@ trbox_independent_samples_populate(struct trbox *self,
       tab_text (self->t, 1, i*2+3, TAB_LEFT, _("Equal variances assumed"));
 
 
-      tab_float(self->t, 2, i*2+3, TAB_CENTER, 
-               cmd->v_variables[i]->p.grp_data.levene, 8,3);
+      tab_float(self->t, 2, i*2+3, TAB_CENTER, grp_data->levene, 8,3);
 
       /* Now work out the significance of the Levene test */
-      df1 = 1; df2 = cmd->v_variables[i]->p.grp_data.ugs.n - 2;
-      q = gsl_cdf_fdist_Q(cmd->v_variables[i]->p.grp_data.levene, df1, df2);
+      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 );
 
@@ -1246,7 +1260,7 @@ trbox_one_sample_init(struct trbox *self, struct cmd_t_test *cmd )
   tab_vline(self->t, TAL_2, 1, 0, vsize - 1);
 
   tab_joint_text(self->t, 1, 0, hsize-1,0, TAB_CENTER | TAT_PRINTF, 
-                _("Test Value = %f"),cmd->n_testval);
+                _("Test Value = %f"), cmd->n_testval[0]);
 
   tab_box(self->t, -1, -1, -1, TAL_1, 1,1,hsize-1,vsize-1);
 
@@ -1280,13 +1294,12 @@ trbox_one_sample_populate(struct trbox *trb, struct cmd_t_test *cmd)
       double t;
       double p,q;
       double df;
-      struct group_statistics *gs;
-      gs= &cmd->v_variables[i]->p.grp_data.ugs;
+      struct group_statistics *gs = &group_proc_get (cmd->v_variables[i])->ugs;
 
 
       tab_text (trb->t, 0, i+3, TAB_LEFT, cmd->v_variables[i]->name);
 
-      t = (gs->mean - cmd->n_testval ) * sqrt(gs->n) / gs->std_dev ;
+      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);
 
@@ -1443,7 +1456,7 @@ common_calc (const struct ccase *c, void *_cmd)
       struct variable *v = cmd->v_variables[i];
       const union value *val = case_data (c, v->fv);
 
-      gs= &cmd->v_variables[i]->p.grp_data.ugs;
+      gs= &group_proc_get (cmd->v_variables[i])->ugs;
 
       if (! value_is_missing(val,v) )
        {
@@ -1464,7 +1477,7 @@ common_precalc ( struct cmd_t_test *cmd )
   for(i=0; i< cmd->n_variables ; ++i) 
     {
       struct group_statistics *gs;
-      gs= &cmd->v_variables[i]->p.grp_data.ugs;
+      gs= &group_proc_get (cmd->v_variables[i])->ugs;
       
       gs->sum=0;
       gs->n=0;
@@ -1483,7 +1496,7 @@ common_postcalc (  struct cmd_t_test *cmd )
   for(i=0; i< cmd->n_variables ; ++i) 
     {
       struct group_statistics *gs;
-      gs= &cmd->v_variables[i]->p.grp_data.ugs;
+      gs= &group_proc_get (cmd->v_variables[i])->ugs;
       
       gs->mean=gs->sum / gs->n;
       gs->s_std_dev= sqrt(
@@ -1531,10 +1544,10 @@ one_sample_calc (const struct ccase *c, void *cmd_)
       struct variable *v = cmd->v_variables[i];
       const union value *val = case_data (c, v->fv);
 
-      gs= &cmd->v_variables[i]->p.grp_data.ugs;
+      gs= &group_proc_get (cmd->v_variables[i])->ugs;
       
       if ( ! value_is_missing(val,v))
-       gs->sum_diff += weight * (val->f - cmd->n_testval);
+       gs->sum_diff += weight * (val->f - cmd->n_testval[0]);
     }
 
   return 0;
@@ -1549,7 +1562,7 @@ one_sample_precalc ( struct cmd_t_test *cmd )
   for(i=0; i< cmd->n_variables ; ++i) 
     {
       struct group_statistics *gs;
-      gs= &cmd->v_variables[i]->p.grp_data.ugs;
+      gs= &group_proc_get (cmd->v_variables[i])->ugs;
       
       gs->sum_diff=0;
     }
@@ -1564,7 +1577,7 @@ one_sample_postcalc (struct cmd_t_test *cmd)
   for(i=0; i< cmd->n_variables ; ++i) 
     {
       struct group_statistics *gs;
-      gs= &cmd->v_variables[i]->p.grp_data.ugs;
+      gs= &group_proc_get (cmd->v_variables[i])->ugs;
 
       gs->mean_diff = gs->sum_diff / gs->n ;
     }
@@ -1713,7 +1726,7 @@ group_precalc (struct cmd_t_test *cmd )
 
   for(i=0; i< cmd->n_variables ; ++i) 
     {
-      struct group_proc *ttpr = &cmd->v_variables[i]->p.grp_data;
+      struct group_proc *ttpr = group_proc_get (cmd->v_variables[i]);
 
       /* There's always 2 groups for a T - TEST */
       ttpr->n_groups = 2;
@@ -1789,7 +1802,7 @@ group_calc (const struct ccase *c, struct cmd_t_test *cmd)
     {
       struct variable *var = cmd->v_variables[i];
       const union value *val = case_data (c, var->fv);
-      struct hsh_table *grp_hash = var->p.grp_data.group_hash;
+      struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
       struct group_statistics *gs;
 
       gs = hsh_find(grp_hash, (void *) gv);
@@ -1819,7 +1832,7 @@ group_postcalc ( struct cmd_t_test *cmd )
   for(i=0; i< cmd->n_variables ; ++i) 
     {
       struct variable *var = cmd->v_variables[i];
-      struct hsh_table *grp_hash = var->p.grp_data.group_hash;
+      struct hsh_table *grp_hash = group_proc_get (var)->group_hash;
       struct hsh_iterator g;
       struct group_statistics *gs;
       int count=0;
@@ -1932,16 +1945,15 @@ calculate(const struct casefile *cf, void *cmd_)
 static int 
 compare_group_binary(const struct group_statistics *a, 
                     const struct group_statistics *b, 
-                    struct group_properties *p)
+                    const struct group_properties *p)
 {
   
   short flag_a;
   short flag_b;
 
-  assert(p->indep_width == 0 ) ;
-
   if ( p->criterion == CMP_LE ) 
     {
+      assert(p->indep_width == 0 ) ;
       flag_a = ( a->id.f < p->v.critical_value ) ;
       flag_b = ( b->id.f < p->v.critical_value ) ;
     }
@@ -1950,7 +1962,6 @@ compare_group_binary(const struct group_statistics *a,
       flag_a = ( a->id.f == p->v.critical_value ) ;
       flag_b = ( b->id.f == p->v.critical_value ) ;
     }
-     
 
   if ( flag_a == flag_b) 
     return 0 ;
@@ -1958,26 +1969,29 @@ compare_group_binary(const struct group_statistics *a,
   return ( flag_a < flag_b);
 }
 
+/* This is a degenerate case of a hash, since it can only return three possible
+   values.  It's really a comparison, being used as a hash function */
+
 static unsigned 
-hash_group_binary(const struct group_statistics *g, struct group_properties *p)
+hash_group_binary(const struct group_statistics *g, 
+                 const struct group_properties *p)
 {
   short flag = -1;
 
-  assert(p->indep_width == 0 ) ;
-
-      /* FIXME: should compare union values */    
   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) 
     {
-      if ( g->id.f ==  p->v.g_value[0].f ) 
+      if ( 0 == compare_values (&g->id, &p->v.g_value[0], p->indep_width ))
        flag = 0 ;
-      else if ( g->id.f == p->v.g_value[1].f ) 
-       flag = 1;
+      else if ( 0 == compare_values (&g->id, &p->v.g_value[1], p->indep_width ))
+       flag = 1 ;
       else
-       flag = 2;
+       flag = 2 ;
     }
   else
     assert(0);