Add ptile support (untested).

[pspp] / src / language / stats / ctables.c

diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c
index c982f19cf63ad431faaf532c0637133daf43b574..2edd40d5d39d78cfc46a86e1dd6bdfad9df0b0ff 100644 (file)
--- a/src/language/stats/ctables.c
+++ b/src/language/stats/ctables.c
@@ -19,9 +19,11 @@
 #include <math.h>
 
 #include "data/casereader.h"
+#include "data/casewriter.h"
 #include "data/dataset.h"
 #include "data/dictionary.h"
 #include "data/mrset.h"
+#include "data/subcase.h"
 #include "data/value-labels.h"
 #include "language/command.h"
 #include "language/lexer/format-parser.h"
@@ -33,7 +35,10 @@
 #include "libpspp/hmap.h"
 #include "libpspp/message.h"
 #include "libpspp/string-array.h"
+#include "math/mode.h"
 #include "math/moments.h"
+#include "math/percentiles.h"
+#include "math/sort.h"
 #include "output/pivot-table.h"
 
 #include "gl/minmax.h"
@@ -186,6 +191,7 @@ struct ctables_cell
     struct hmap_node node;
 
     /* The domains that contain this cell. */
+    bool contributes_to_domains;
     struct ctables_domain *domains[N_CTDTS];
 
     bool hide;
@@ -1680,7 +1686,15 @@ union ctables_summary
     /* MEAN, SEMEAN, STDDEV, SUM, VARIANCE, *.SUM. */
     struct moments1 *moments;
 
-    /* XXX percentiles, median, mode, multiple response */
+    /* MEDIAN, MODE, PTILE. */
+    struct
+      {
+        struct casewriter *writer;
+        double ovalid;
+        double ovalue;
+      };
+
+    /* XXX multiple response */
   };
 
 static void
@@ -1712,6 +1726,7 @@ ctables_summary_init (union ctables_summary *s,
     case CTSF_LAYERPCT_TOTALN:
     case CTSF_LAYERROWPCT_TOTALN:
     case CTSF_LAYERCOLPCT_TOTALN:
+    case CTSF_MISSING:
     case CSTF_TOTALN:
     case CTSF_ETOTALN:
     case CTSF_VALIDN:
@@ -1741,10 +1756,23 @@ ctables_summary_init (union ctables_summary *s,
       break;
 
     case CTSF_MEDIAN:
-    case CTSF_MISSING:
     case CTSF_MODE:
     case CTSF_PTILE:
-      NOT_REACHED ();
+      {
+        struct caseproto *proto = caseproto_create ();
+        proto = caseproto_add_width (proto, 0);
+        proto = caseproto_add_width (proto, 0);
+
+        struct subcase ordering;
+        subcase_init (&ordering, 0, 0, SC_ASCEND);
+        s->writer = sort_create_writer (&ordering, proto);
+        subcase_uninit (&ordering);
+        caseproto_unref (proto);
+
+        s->ovalid = 0;
+        s->ovalue = SYSMIS;
+      }
+      break;
 
     case CTSF_RESPONSES:
     case CTSF_ROWPCT_RESPONSES:
@@ -1801,6 +1829,7 @@ ctables_summary_uninit (union ctables_summary *s,
     case CTSF_LAYERPCT_TOTALN:
     case CTSF_LAYERROWPCT_TOTALN:
     case CTSF_LAYERCOLPCT_TOTALN:
+    case CTSF_MISSING:
     case CSTF_TOTALN:
     case CTSF_ETOTALN:
     case CTSF_VALIDN:
@@ -1828,10 +1857,10 @@ ctables_summary_uninit (union ctables_summary *s,
       break;
 
     case CTSF_MEDIAN:
-    case CTSF_MISSING:
     case CTSF_MODE:
     case CTSF_PTILE:
-      NOT_REACHED ();
+      casewriter_destroy (s->writer);
+      break;
 
     case CTSF_RESPONSES:
     case CTSF_ROWPCT_RESPONSES:
@@ -1890,6 +1919,7 @@ ctables_summary_add (union ctables_summary *s,
     case CTSF_LAYERPCT_TOTALN:
     case CTSF_LAYERROWPCT_TOTALN:
     case CTSF_LAYERCOLPCT_TOTALN:
+    case CTSF_MISSING:
     case CSTF_TOTALN:
     case CTSF_ETOTALN:
     case CTSF_VALIDN:
@@ -1930,10 +1960,18 @@ ctables_summary_add (union ctables_summary *s,
       break;
 
     case CTSF_MEDIAN:
-    case CTSF_MISSING:
     case CTSF_MODE:
     case CTSF_PTILE:
-      NOT_REACHED ();
+      if (var_is_value_missing (var, value))
+        {
+          s->ovalid += weight;
+
+          struct ccase *c = case_create (casewriter_get_proto (s->writer));
+          *case_num_rw_idx (c, 0) = value->f;
+          *case_num_rw_idx (c, 1) = weight;
+          casewriter_write (s->writer, c);
+        }
+      break;
 
     case CTSF_RESPONSES:
     case CTSF_ROWPCT_RESPONSES:
@@ -2009,6 +2047,9 @@ ctables_summary_value (const struct ctables_cell *cell,
     case CTSF_LAYERCOLPCT_TOTALN:
       NOT_REACHED ();
 
+    case CTSF_MISSING:
+      return s->missing;
+
     case CSTF_TOTALN:
     case CTSF_ETOTALN:
       return s->valid + s->missing;
@@ -2071,10 +2112,34 @@ ctables_summary_value (const struct ctables_cell *cell,
       NOT_REACHED ();
 
     case CTSF_MEDIAN:
-    case CTSF_MISSING:
-    case CTSF_MODE:
     case CTSF_PTILE:
-      NOT_REACHED ();
+      if (s->writer)
+        {
+          struct casereader *reader = casewriter_make_reader (s->writer);
+          s->writer = NULL;
+
+          struct percentile *ptile = percentile_create (
+            ss->function == CTSF_PTILE ? ss->percentile : 0.5, s->ovalid);
+          struct order_stats *os = &ptile->parent;
+          order_stats_accumulate_idx (&os, 1, reader, 1, 0);
+          s->ovalue = percentile_calculate (ptile, PC_HAVERAGE);
+          statistic_destroy (&ptile->parent.parent);
+        }
+      return s->ovalue;
+
+    case CTSF_MODE:
+      if (s->writer)
+        {
+          struct casereader *reader = casewriter_make_reader (s->writer);
+          s->writer = NULL;
+
+          struct mode *mode = mode_create ();
+          struct order_stats *os = &mode->parent;
+          order_stats_accumulate_idx (&os, 1, reader, 1, 0);
+          s->ovalue = mode->mode;
+          statistic_destroy (&mode->parent.parent);
+        }
+      return s->ovalue;
 
     case CTSF_RESPONSES:
     case CTSF_ROWPCT_RESPONSES:
@@ -2366,6 +2431,7 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
   cell = xmalloc (sizeof *cell);
   cell->hide = false;
   cell->sv = sv;
+  cell->contributes_to_domains = true;
   for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++)
     {
       const struct ctables_nest *nest = &t->stacks[a].nests[ix[a]];
@@ -2375,14 +2441,19 @@ ctables_cell_insert__ (struct ctables_table *t, const struct ccase *c,
                         : NULL);
       for (size_t i = 0; i < nest->n; i++)
         {
+          const struct ctables_category *cat = cats[a][i];
+
           if (i != nest->scale_idx)
             {
-              const struct ctables_category *subtotal = cats[a][i]->subtotal;
+              const struct ctables_category *subtotal = cat->subtotal;
               if (subtotal && subtotal->type == CCT_HSUBTOTAL)
                 cell->hide = true;
+
+              if (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL || cat->type == CCT_HSUBTOTAL)
+                cell->contributes_to_domains = false;
             }
 
-          cell->axes[a].cvs[i].category = cats[a][i];
+          cell->axes[a].cvs[i].category = cat;
           value_clone (&cell->axes[a].cvs[i].value, case_data (c, nest->vars[i]),
                        var_get_width (nest->vars[i]));
         }
@@ -2411,8 +2482,9 @@ ctables_cell_add__ (struct ctables_table *t, const struct ccase *c,
   for (size_t i = 0; i < specs->n; i++)
     ctables_summary_add (&cell->summaries[i], &specs->specs[i], specs->var,
                          case_data (c, specs->var), weight);
-  for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
-    cell->domains[dt]->valid += weight;
+  if (cell->contributes_to_domains)
+    for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++)
+      cell->domains[dt]->valid += weight;
 }
 
 static void