X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fbinomial.c;h=94d0d9721e0b7f4c543d44a975ec8b8b9b7cbed0;hb=2be9bee9da6a2ce27715e58128569594319abfa2;hp=f543505166f6129f53eb8b3db032ce53145950ab;hpb=502855f1d746c4acf920006326daa8c86a561a5b;p=pspp-builds.git

diff --git a/src/language/stats/binomial.c b/src/language/stats/binomial.c
index f5435051..94d0d972 100644
--- a/src/language/stats/binomial.c
+++ b/src/language/stats/binomial.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 2006 Free Software Foundation, Inc.
+   Copyright (C) 2006, 2009, 2010, 2011 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
@@ -15,36 +15,32 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 #include <config.h>
-#include <libpspp/compiler.h>
-#include <output/table.h>
 
-#include <data/case.h>
-#include <data/casereader.h>
-#include <data/dictionary.h>
-#include <data/procedure.h>
-#include <data/variable.h>
-#include <data/value.h>
-#include <data/value-labels.h>
-
-#include <libpspp/message.h>
-#include <libpspp/assertion.h>
-
-#include "binomial.h"
-#include "freq.h"
-
-#include "xalloc.h"
-
-#include "gettext.h"
-#define _(msgid) gettext (msgid)
-
-#include <libpspp/misc.h>
+#include "language/stats/binomial.h"
 
 #include <gsl/gsl_cdf.h>
 #include <gsl/gsl_randist.h>
 
-#include <minmax.h>
+#include "data/case.h"
+#include "data/casereader.h"
+#include "data/dataset.h"
+#include "data/dictionary.h"
+#include "data/format.h"
+#include "data/value-labels.h"
+#include "data/value.h"
+#include "data/variable.h"
+#include "language/stats/freq.h"
+#include "libpspp/assertion.h"
+#include "libpspp/compiler.h"
+#include "libpspp/message.h"
+#include "libpspp/misc.h"
+#include "output/tab.h"
+
+#include "gl/xalloc.h"
+#include "gl/minmax.h"
 
-#include <libpspp/hash.h>
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
 
 static double calculate_binomial_internal (double n1, double n2,
 					   double p);
@@ -89,50 +85,57 @@ calculate_binomial_internal (double n1, double n2, double p)
 static bool
 do_binomial (const struct dictionary *dict,
 	     struct casereader *input,
-	     const struct binomial_test *bst,
-	     struct freq_mutable *cat1,
-	     struct freq_mutable *cat2,
+	     const struct one_sample_test *ost,
+	     struct freq *cat1,
+	     struct freq *cat2,
              enum mv_class exclude
 	     )
 {
+  const struct binomial_test *bst = UP_CAST (ost, const struct binomial_test, parent);
   bool warn = true;
 
-  const struct one_sample_test *ost = (const struct one_sample_test *) bst;
-  struct ccase c;
+  struct ccase *c;
 
-  while (casereader_read(input, &c))
+  for (; (c = casereader_read (input)) != NULL; case_unref (c))
     {
       int v;
-      double w = dict_get_case_weight (dict, &c, &warn);
+      double w = dict_get_case_weight (dict, c, &warn);
 
       for (v = 0 ; v < ost->n_vars ; ++v )
 	{
 	  const struct variable *var = ost->vars[v];
-	  const union value *value = case_data (&c, var);
-          int width = var_get_width (var);
+	  double value = case_num (c, var);
 
-	  if (var_is_value_missing (var, value, exclude))
-	    break;
+	  if (var_is_num_missing (var, value, exclude))
+	    continue;
 
-	  if ( NULL == cat1[v].value )
+	  if (bst->cutpoint != SYSMIS)
 	    {
-	      cat1[v].value = value_dup (value, width);
-	      cat1[v].count = w;
+	      if ( cat1[v].value.f >= value )
+		  cat1[v].count  += w;
+	      else
+		  cat2[v].count += w;
 	    }
-	  else if ( 0 == compare_values (cat1[v].value, value, width))
-	    cat1[v].count += w;
-	  else if ( NULL == cat2[v].value )
+	  else
 	    {
-	      cat2[v].value = value_dup (value, width);
-	      cat2[v].count = w;
+	      if ( SYSMIS == cat1[v].value.f )
+		{
+		  cat1[v].value.f = value;
+		  cat1[v].count = w;
+		}
+	      else if ( cat1[v].value.f == value )
+		cat1[v].count += w;
+	      else if ( SYSMIS == cat2[v].value.f )
+		{
+		  cat2[v].value.f = value;
+		  cat2[v].count = w;
+		}
+	      else if ( cat2[v].value.f == value )
+		cat2[v].count += w;
+	      else if ( bst->category1 == SYSMIS)
+		msg (ME, _("Variable %s is not dichotomous"), var_get_name (var));
 	    }
-	  else if ( 0 == compare_values (cat2[v].value, value, width))
-	    cat2[v].count += w;
-	  else if ( bst->category1 == SYSMIS)
-	    msg (ME, _("Variable %s is not dichotomous"), var_get_name (var));
 	}
-
-      case_destroy (&c);
     }
   return casereader_destroy (input);
 }
@@ -148,53 +151,64 @@ binomial_execute (const struct dataset *ds,
 		  double timer UNUSED)
 {
   int v;
-  const struct binomial_test *bst = (const struct binomial_test *) test;
-  const struct one_sample_test *ost = (const struct one_sample_test*) test;
+  const struct dictionary *dict = dataset_dict (ds);
+  const struct one_sample_test *ost = UP_CAST (test, const struct one_sample_test, parent);
+  const struct binomial_test *bst = UP_CAST (ost, const struct binomial_test, parent);
 
-  struct freq_mutable *cat1 = xzalloc (sizeof (*cat1) * ost->n_vars);
-  struct freq_mutable *cat2 = xzalloc (sizeof (*cat1) * ost->n_vars);
+  struct freq *cat[2];
+  int i;
 
-  assert ((bst->category1 == SYSMIS) == (bst->category2 == SYSMIS) );
+  assert ((bst->category1 == SYSMIS) == (bst->category2 == SYSMIS) || bst->cutpoint != SYSMIS);
 
-  if ( bst->category1 != SYSMIS )
+  for (i = 0; i < 2; i++)
     {
-      union value v;
-      v.f = bst->category1;
-      cat1->value = value_dup (&v, 0);
-    }
-
-  if ( bst->category2 != SYSMIS )
-    {
-      union value v;
-      v.f = bst->category2;
-      cat2->value = value_dup (&v, 0);
+      double value;
+      if (i == 0)
+        value = bst->cutpoint != SYSMIS ? bst->cutpoint : bst->category1;
+      else
+        value = bst->category2;
+
+      cat[i] = xnmalloc (ost->n_vars, sizeof *cat[i]);
+      for (v = 0; v < ost->n_vars; v++)
+        {
+          cat[i][v].value.f = value;
+          cat[i][v].count = 0;
+        }
     }
 
-  if (do_binomial (dataset_dict(ds), input, bst, cat1, cat2, exclude))
+  if (do_binomial (dataset_dict (ds), input, ost, cat[0], cat[1], exclude))
     {
-      struct tab_table *table = tab_create (7, ost->n_vars * 3 + 1, 0);
+      const struct variable *wvar = dict_get_weight (dict);
+      const struct fmt_spec *wfmt = wvar ?
+	var_get_print_format (wvar) : & F_8_0;
 
-      tab_dim (table, tab_natural_dimensions);
+      struct tab_table *table = tab_create (7, ost->n_vars * 3 + 1);
 
       tab_title (table, _("Binomial Test"));
 
       tab_headers (table, 2, 0, 1, 0);
 
       tab_box (table, TAL_1, TAL_1, -1, TAL_1,
-               0, 0, table->nc - 1, tab_nr(table) - 1 );
+               0, 0, tab_nc (table) - 1, tab_nr(table) - 1 );
 
       for (v = 0 ; v < ost->n_vars; ++v)
         {
           double n_total, sig;
-	  struct string catstr1;
-	  struct string catstr2;
+	  struct string catstr[2];
           const struct variable *var = ost->vars[v];
 
-	  ds_init_empty (&catstr1);
-	  ds_init_empty (&catstr2);
+	  ds_init_empty (&catstr[0]);
+	  ds_init_empty (&catstr[1]);
 
-	  var_append_value_name (var, cat1[v].value, &catstr1);
-	  var_append_value_name (var, cat2[v].value, &catstr2);
+	  if ( bst->cutpoint != SYSMIS)
+	    {
+	      ds_put_format (&catstr[0], "<= %g", bst->cutpoint);
+	    }
+          else
+            {
+              var_append_value_name (var, &cat[0][v].value, &catstr[0]);
+              var_append_value_name (var, &cat[1][v].value, &catstr[1]);
+            }
 
           tab_hline (table, TAL_1, 0, tab_nc (table) -1, 1 + v * 3);
 
@@ -205,33 +219,34 @@ binomial_execute (const struct dataset *ds,
           tab_text (table, 1, 3 + v * 3, TAB_LEFT, _("Total"));
 
           /* Test Prop */
-          tab_float (table, 5, 1 + v * 3, TAB_NONE, bst->p, 8, 3);
+          tab_double (table, 5, 1 + v * 3, TAB_NONE, bst->p, NULL);
 
           /* Category labels */
-          tab_text (table, 2, 1 + v * 3, TAB_NONE, ds_cstr (&catstr1));
-	  tab_text (table, 2, 2 + v * 3, TAB_NONE, ds_cstr (&catstr2));
+          tab_text (table, 2, 1 + v * 3, TAB_NONE, ds_cstr (&catstr[0]));
+	  tab_text (table, 2, 2 + v * 3, TAB_NONE, ds_cstr (&catstr[1]));
 
           /* Observed N */
-          tab_float (table, 3, 1 + v * 3, TAB_NONE, cat1[v].count, 8, 0);
-          tab_float (table, 3, 2 + v * 3, TAB_NONE, cat2[v].count, 8, 0);
+          tab_double (table, 3, 1 + v * 3, TAB_NONE, cat[0][v].count, wfmt);
+          tab_double (table, 3, 2 + v * 3, TAB_NONE, cat[1][v].count, wfmt);
 
-          n_total = cat1[v].count + cat2[v].count;
-          tab_float (table, 3, 3 + v * 3, TAB_NONE, n_total, 8, 0);
+          n_total = cat[0][v].count + cat[1][v].count;
+          tab_double (table, 3, 3 + v * 3, TAB_NONE, n_total, wfmt);
 
           /* Observed Proportions */
-          tab_float (table, 4, 1 + v * 3, TAB_NONE,
-                     cat1[v].count / n_total, 8, 3);
-          tab_float (table, 4, 2 + v * 3, TAB_NONE,
-                     cat2[v].count / n_total, 8, 3);
-          tab_float (table, 4, 3 + v * 3, TAB_NONE,
-                     (cat1[v].count + cat2[v].count) / n_total, 8, 2);
+          tab_double (table, 4, 1 + v * 3, TAB_NONE,
+                     cat[0][v].count / n_total, NULL);
+          tab_double (table, 4, 2 + v * 3, TAB_NONE,
+                     cat[1][v].count / n_total, NULL);
+
+          tab_double (table, 4, 3 + v * 3, TAB_NONE,
+                     (cat[0][v].count + cat[1][v].count) / n_total, NULL);
 
           /* Significance */
-          sig = calculate_binomial (cat1[v].count, cat2[v].count, bst->p);
-          tab_float (table, 6, 1 + v * 3, TAB_NONE, sig, 8, 3);
+          sig = calculate_binomial (cat[0][v].count, cat[1][v].count, bst->p);
+          tab_double (table, 6, 1 + v * 3, TAB_NONE, sig, NULL);
 
-	  ds_destroy (&catstr1);
-	  ds_destroy (&catstr2);
+	  ds_destroy (&catstr[0]);
+	  ds_destroy (&catstr[1]);
         }
 
       tab_text (table,  2, 0,  TAB_CENTER, _("Category"));
@@ -239,19 +254,14 @@ binomial_execute (const struct dataset *ds,
       tab_text (table,  4, 0,  TAB_CENTER, _("Observed Prop."));
       tab_text (table,  5, 0,  TAB_CENTER, _("Test Prop."));
 
-      tab_text (table,  6, 0,  TAB_CENTER | TAT_PRINTF,
-                _("Exact Sig. (%d-tailed)"),
-                bst->p == 0.5 ? 2: 1);
+      tab_text_format (table,  6, 0,  TAB_CENTER,
+                       _("Exact Sig. (%d-tailed)"),
+                       bst->p == 0.5 ? 2 : 1);
 
       tab_vline (table, TAL_2, 2, 0, tab_nr (table) -1);
       tab_submit (table);
     }
 
-  for (v = 0; v < ost->n_vars; v++)
-    {
-      free (cat1[v].value);
-      free (cat2[v].value);
-    }
-  free (cat1);
-  free (cat2);
+  for (i = 0; i < 2; i++)
+    free (cat[i]);
 }