Autorecode: Add the /GROUP subcommand

diff --git a/doc/transformation.texi b/doc/transformation.texi
index 27181b3cde64b1fe62b54c2b62be1296a1feaa14..6964facd31c9695adcb93c7959e9f5439b9cc516 100644 (file)
--- a/doc/transformation.texi
+++ b/doc/transformation.texi
@@ -219,8 +219,9 @@ settings (@pxref{SPLIT FILE}).
 
 @display
 AUTORECODE VARIABLES=src_vars INTO dest_vars
-        /DESCENDING
-        /PRINT
+        [ /DESCENDING ]
+        [ /PRINT ]
+        [ /GROUP ]
 @end display
 
 The @cmd{AUTORECODE} procedure considers the @var{n} values that a variable
@@ -241,6 +242,10 @@ to 1), specify DESCENDING.
 
 PRINT is currently ignored.
 
+The GROUP subcommand is relevant only if more than one variable is to be
+recoded.   It causes a single mapping between source and target values to
+be used, instead of one map per variable.
+
 @cmd{AUTORECODE} is a procedure.  It causes the data to be read.
 
 @node COMPUTE

diff --git a/src/language/stats/autorecode.c b/src/language/stats/autorecode.c
index 03de84e28592b3d5422df5192518d27b3e01d498..05016548e37b4d98cb6cedb6e3416f891cf763e3 100644 (file)
--- a/src/language/stats/autorecode.c
+++ b/src/language/stats/autorecode.c
@@ -57,7 +57,7 @@ struct arc_spec
   {
     const struct variable *src;        /* Source variable. */
     struct variable *dst;      /* Target variable. */
-    struct hmap items;          /* Hash table of "struct arc_item"s. */
+    struct hmap *items;         /* Hash table of "struct arc_item"s. */
   };
 
 /* Descending or ascending sort order. */
@@ -69,10 +69,13 @@ enum arc_direction
 
 /* AUTORECODE data. */
 struct autorecode_pgm
-  {
-    struct arc_spec *specs;
-    size_t n_specs;
-  };
+{
+  struct arc_spec *specs;
+  size_t n_specs;
+
+  /* Hash table of "struct arc_item"s. */
+  struct hmap *global_items;
+};
 
 static trns_proc_func autorecode_trns_proc;
 static trns_free_func autorecode_trns_free;
@@ -94,8 +97,8 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds)
   size_t n_srcs = 0;
   size_t n_dsts = 0;
 
-  enum arc_direction direction;
-  bool print;
+  enum arc_direction direction = ASCENDING;
+  bool print = true;
 
   struct casereader *input;
   struct ccase *c;
@@ -103,6 +106,9 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds)
   size_t i;
   bool ok;
 
+  /* Create procedure. */
+  arc = xzalloc (sizeof *arc);
+
   /* Parse variable lists. */
   lex_match_id (lexer, "VARIABLES");
   lex_match (lexer, '=');
@@ -135,31 +141,45 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds)
     }
 
   /* Parse options. */
-  direction = ASCENDING;
-  print = false;
   while (lex_match (lexer, '/'))
-    if (lex_match_id (lexer, "DESCENDING"))
-      direction = DESCENDING;
-    else if (lex_match_id (lexer, "PRINT"))
-      print = true;
+    {
+      if (lex_match_id (lexer, "DESCENDING"))
+       direction = DESCENDING;
+      else if (lex_match_id (lexer, "PRINT"))
+       print = true;
+      else if (lex_match_id (lexer, "GROUP"))
+       {
+         arc->global_items = xmalloc (sizeof (*arc->global_items));
+         hmap_init (arc->global_items);
+       }
+    }
+
   if (lex_token (lexer) != '.')
     {
       lex_error (lexer, _("expecting end of command"));
       goto error;
     }
 
-  /* Create procedure. */
-  arc = xmalloc (sizeof *arc);
   arc->specs = xmalloc (n_dsts * sizeof *arc->specs);
   arc->n_specs = n_dsts;
+
   for (i = 0; i < n_dsts; i++)
     {
       struct arc_spec *spec = &arc->specs[i];
 
       spec->src = src_vars[i];
-      hmap_init (&spec->items);
+      if (arc->global_items)
+       {
+         spec->items = arc->global_items;
+       }
+      else
+       {
+         spec->items = xmalloc (sizeof (*spec->items));
+         hmap_init (spec->items);
+       }
     }
 
+
   /* Execute procedure. */
   input = proc_open (ds);
   for (; (c = casereader_read (input)) != NULL; case_unref (c))
@@ -176,7 +196,7 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds)
           {
             item = xmalloc (sizeof *item);
             value_clone (&item->from, value, width);
-            hmap_insert (&spec->items, &item->hmap_node, hash);
+            hmap_insert (spec->items, &item->hmap_node, hash);
           }
       }
   ok = casereader_destroy (input);
@@ -196,12 +216,13 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds)
       spec->dst = dict_create_var_assert (dict, dst_names[i], 0);
 
       /* Create array of pointers to items. */
-      n_items = hmap_count (&spec->items);
+      n_items = hmap_count (spec->items);
       items = xmalloc (n_items * sizeof *items);
       j = 0;
-      HMAP_FOR_EACH (item, struct arc_item, hmap_node, &spec->items)
+      HMAP_FOR_EACH (item, struct arc_item, hmap_node, spec->items)
         items[j++] = item;
-      assert (j == n_items);
+      if (!arc->global_items)
+       assert (j == n_items);
 
       /* Sort array by value. */
       src_width = var_get_width (spec->src);
@@ -226,8 +247,11 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds)
             the source value from whence the new value comes. */
 
          if (src_width > 0)
-           recoded_value = 
-             recode_string (UTF8, dict_get_encoding (dict), (char *) value_str (from, src_width), src_width);
+           {
+             const char *str = (const char *) value_str (from, src_width);
+
+             recoded_value = recode_string (UTF8, dict_get_encoding (dict), str, src_width);
+           }
          else
            recoded_value = asnprintf (NULL, &len, "%g", from->f);
          
@@ -273,15 +297,32 @@ arc_free (struct autorecode_pgm *arc)
           int width = var_get_width (spec->src);
           struct arc_item *item, *next;
 
-          HMAP_FOR_EACH_SAFE (item, next, struct arc_item, hmap_node,
-                              &spec->items)
-            {
-              value_destroy (&item->from, width);
-              hmap_delete (&spec->items, &item->hmap_node);
-              free (item);
-            }
-          hmap_destroy (&spec->items);
+         HMAP_FOR_EACH_SAFE (item, next, struct arc_item, hmap_node,
+                             spec->items)
+           {
+             value_destroy (&item->from, width);
+             hmap_delete (spec->items, &item->hmap_node);
+             free (item);
+           }
         }
+
+      if (arc->global_items)
+       {
+         free (arc->global_items);
+       }
+      else
+       {
+         for (i = 0; i < arc->n_specs; i++)
+           {
+             struct arc_spec *spec = &arc->specs[i];
+             if (spec->items)
+               {
+                 hmap_destroy (spec->items);
+                 free (spec->items);
+               }
+           }
+       }
+
       free (arc->specs);
       free (arc);
     }
@@ -293,8 +334,7 @@ find_arc_item (struct arc_spec *spec, const union value *value,
 {
   struct arc_item *item;
 
-  HMAP_FOR_EACH_WITH_HASH (item, struct arc_item, hmap_node, hash,
-                           &spec->items)
+  HMAP_FOR_EACH_WITH_HASH (item, struct arc_item, hmap_node, hash, spec->items)
     if (value_equal (value, &item->from, var_get_width (spec->src)))
       return item;
   return NULL;

diff --git a/tests/language/stats/autorecode.at b/tests/language/stats/autorecode.at
index 6f112def33c1427f175366e63cf443371c78eb3c..8f971aefb7f0fa715d5f5e861e91a12f3628e9a7 100644 (file)
--- a/tests/language/stats/autorecode.at
+++ b/tests/language/stats/autorecode.at
@@ -107,3 +107,36 @@ new,Format: F8.2,,3
 ])
 
 AT_CLEANUP
+
+
+AT_SETUP([AUTORECODE group subcommand])
+AT_DATA([ar-group.sps],
+[data list notable list /x * y *.
+begin data.
+11 10
+12 12 
+13 15
+14 11
+15 12
+16 18
+end data.
+
+autorecode 
+       x y into a b
+       /group.
+
+list.
+])
+
+AT_CHECK([pspp -O format=csv ar-group.sps], [0],
+[Table: Data List
+x,y,a,b
+11.00,10.00,2.00,1.00
+12.00,12.00,3.00,3.00
+13.00,15.00,4.00,6.00
+14.00,11.00,5.00,2.00
+15.00,12.00,6.00,3.00
+16.00,18.00,7.00,8.00
+])
+
+AT_CLEANUP