Added casefilter structure to assist with missing values. Changed T-TEST

[pspp-builds.git] / src / math / sort.c

diff --git a/src/math/sort.c b/src/math/sort.c
index 732c4b86555d30d7362bb0ac85d9199282235453..9f5e5fb956a4c94f31f78bd03139c78fd3742126 100644 (file)
--- a/src/math/sort.c
+++ b/src/math/sort.c
@@ -59,31 +59,26 @@ static struct casefile *do_internal_sort (struct casereader *,
 static struct casefile *do_external_sort (struct casereader *,
                                           const struct sort_criteria *);
 
-/* Get ready to sort the active file. */
-static void
-prepare_to_sort_active_file (void) 
-{
-  proc_cancel_temporary_transformations (); 
-}
 
 /* Sorts the active file in-place according to CRITERIA.
-   Returns nonzero if successful. */
-int
-sort_active_file_in_place (const struct sort_criteria *criteria) 
+   Returns true if successful. */
+bool
+sort_active_file_in_place (struct dataset *ds, 
+                          const struct sort_criteria *criteria) 
 {
   struct casefile *in, *out;
 
-  prepare_to_sort_active_file ();
-  if (!procedure (NULL, NULL))
-    return 0;
+  proc_cancel_temporary_transformations (ds);
+  if (!procedure (ds, NULL, NULL))
+    return false;
   
-  in = proc_capture_output ();
+  in = proc_capture_output (ds);
   out = sort_execute (casefile_get_destructive_reader (in), criteria);
   if (out == NULL) 
-    return 0;
+    return false;
 
-  proc_set_source (storage_source_create (out));
-  return 1;
+  proc_set_source (ds, storage_source_create (out));
+  return true;
 }
 
 /* Data passed to sort_to_casefile_callback(). */
@@ -98,7 +93,7 @@ static bool
 sort_to_casefile_callback (const struct casefile *cf, void *cb_data_) 
 {
   struct sort_to_casefile_cb_data *cb_data = cb_data_;
-  cb_data->output = sort_execute (casefile_get_reader (cf), cb_data->criteria);
+  cb_data->output = sort_execute (casefile_get_reader (cf, NULL), cb_data->criteria);
   return cb_data->output != NULL;
 }
 
@@ -106,15 +101,16 @@ sort_to_casefile_callback (const struct casefile *cf, void *cb_data_)
    returns the sorted casefile.  Returns a null pointer on
    failure. */
 struct casefile *
-sort_active_file_to_casefile (const struct sort_criteria *criteria) 
+sort_active_file_to_casefile (struct dataset *ds, 
+                             const struct sort_criteria *criteria) 
 {
   struct sort_to_casefile_cb_data cb_data;
   
-  prepare_to_sort_active_file ();
+  proc_cancel_temporary_transformations (ds);
 
   cb_data.criteria = criteria;
   cb_data.output = NULL;
-  if (!multipass_procedure (sort_to_casefile_callback, &cb_data)) 
+  if (!multipass_procedure (ds, sort_to_casefile_callback, &cb_data)) 
     {
       casefile_destroy (cb_data.output);
       return NULL;
@@ -143,7 +139,7 @@ struct indexed_case
     unsigned long idx;  /* Index to allow for stable sorting. */
   };
 
-static int compare_indexed_cases (const void *, const void *, void *);
+static int compare_indexed_cases (const void *, const void *, const void *);
 
 /* If the data is in memory, do an internal sort and return a new
    casefile for the data.  Otherwise, return a null pointer. */
@@ -204,9 +200,9 @@ do_internal_sort (struct casereader *reader,
    at A and B, with a "last resort" comparison for stability, and
    returns a strcmp()-type result. */
 static int
-compare_indexed_cases (const void *a_, const void *b_, void *criteria_)
+compare_indexed_cases (const void *a_, const void *b_, const void *criteria_)
 {
-  struct sort_criteria *criteria = criteria_;
+  const struct sort_criteria *criteria = criteria_;
   const struct indexed_case *a = a_;
   const struct indexed_case *b = b_;
   int result = compare_record (&a->c, &b->c, criteria);
@@ -313,16 +309,17 @@ struct initial_run_state
   };
 
 static bool destroy_initial_run_state (struct initial_run_state *);
-static void process_case (struct initial_run_state *, const struct ccase *,
-                          size_t);
+static void process_case (struct initial_run_state *, 
+                         const struct ccase *, size_t);
 static int allocate_cases (struct initial_run_state *);
 static void output_record (struct initial_run_state *);
 static void start_run (struct initial_run_state *);
 static void end_run (struct initial_run_state *);
 static int compare_record_run (const struct record_run *,
                                const struct record_run *,
-                               struct initial_run_state *);
-static int compare_record_run_minheap (const void *, const void *, void *);
+                               const struct initial_run_state *);
+static int compare_record_run_minheap (const void *, const void *, 
+                                      const void *);
 
 /* Reads cases from READER and composes initial runs in XSRT. */
 static int
@@ -365,7 +362,8 @@ write_runs (struct external_sort *xsrt, struct casereader *reader)
 
 /* Add a single case to an initial run. */
 static void
-process_case (struct initial_run_state *irs, const struct ccase *c, size_t idx)
+process_case (struct initial_run_state *irs, const struct ccase *c, 
+             size_t idx)
 {
   struct record_run *rr;
 
@@ -484,7 +482,7 @@ compare_record (const struct ccase *a, const struct ccase *b,
 static int
 compare_record_run (const struct record_run *a,
                     const struct record_run *b,
-                    struct initial_run_state *irs)
+                    const struct initial_run_state *irs)
 {
   int result = a->run < b->run ? -1 : a->run > b->run;
   if (result == 0)
@@ -498,7 +496,7 @@ compare_record_run (const struct record_run *a,
    on the current record according to SCP, but in descending
    order. */
 static int
-compare_record_run_minheap (const void *a, const void *b, void *irs) 
+compare_record_run_minheap (const void *a, const void *b, const void *irs) 
 {
   return -compare_record_run (a, b, irs);
 }