X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Faggregate.c;h=5979204d08c0c407a078f2ca1ad367665ff0ed67;hb=c9e2bf6cb988f8c00d89ccf191a28388cccbd868;hp=9d925707c2d819235f03a42cd5b9fed4ea4d1a28;hpb=1d985886f778e35f8d89c4e3c897b79fde8de6ed;p=pspp-builds.git

diff --git a/src/aggregate.c b/src/aggregate.c
index 9d925707..5979204d 100644
--- a/src/aggregate.c
+++ b/src/aggregate.c
@@ -14,8 +14,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA. */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA. */
 
 #include <config.h>
 #include "error.h"
@@ -33,12 +33,16 @@
 #include "pool.h"
 #include "settings.h"
 #include "sfm-write.h"
+#include "sort-prs.h"
 #include "sort.h"
 #include "str.h"
 #include "var.h"
 #include "vfm.h"
 #include "vfmP.h"
 
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
+
 /* Specifies how to make an aggregate variable. */
 struct agr_var
   {
@@ -124,7 +128,7 @@ struct agr_proc
     struct sort_criteria *sort;         /* Sort criteria. */
     struct variable **break_vars;       /* Break variables. */
     size_t break_var_cnt;               /* Number of break variables. */
-    union value *prev_break;            /* Last values of break variables. */
+    struct ccase break_case;            /* Last values of break variables. */
 
     enum missing_treatment missing;     /* How to treat missing values. */
     struct agr_var *agr_vars;           /* First aggregate variable. */
@@ -133,7 +137,8 @@ struct agr_proc
     struct ccase agr_case;              /* Aggregate case for output. */
   };
 
-static void initialize_aggregate_info (struct agr_proc *);
+static void initialize_aggregate_info (struct agr_proc *,
+                                       const struct ccase *);
 
 /* Prototypes. */
 static int parse_aggregate_functions (struct agr_proc *);
@@ -164,6 +169,7 @@ cmd_aggregate (void)
 
   memset(&agr, 0 , sizeof (agr));
   agr.missing = ITEMWISE;
+  case_nullify (&agr.break_case);
   
   agr.dict = dict_create ();
   dict_set_label (agr.dict, dict_get_label (default_dict));
@@ -206,16 +212,13 @@ cmd_aggregate (void)
 	  lex_match ('=');
           agr.sort = sort_parse_criteria (default_dict,
                                           &agr.break_vars, &agr.break_var_cnt,
-                                          &saw_direction);
+                                          &saw_direction, NULL);
           if (agr.sort == NULL)
             goto error;
 	  
           for (i = 0; i < agr.break_var_cnt; i++)
-            {
-              struct variable *v = dict_clone_var (agr.dict, agr.break_vars[i],
-                                                   agr.break_vars[i]->name);
-              assert (v != NULL);
-            }
+            dict_clone_var_assert (agr.dict, agr.break_vars[i],
+                                   agr.break_vars[i]->name);
 
           /* BREAK must follow the options. */
           break;
@@ -246,7 +249,6 @@ cmd_aggregate (void)
   /* Initialize. */
   agr.case_cnt = 0;
   case_create (&agr.agr_case, dict_get_next_value_idx (agr.dict));
-  initialize_aggregate_info (&agr);
 
   /* Output to active file or external file? */
   if (out_file == NULL) 
@@ -276,7 +278,8 @@ cmd_aggregate (void)
     }
   else
     {
-      agr.writer = sfm_open_writer (out_file, agr.dict, get_scompression ());
+      agr.writer = sfm_open_writer (out_file, agr.dict,
+                                    sfm_writer_default_options ());
       if (agr.writer == NULL)
         goto error;
       
@@ -396,7 +399,7 @@ parse_aggregate_functions (struct agr_proc *agr)
 	}
       
       for (function = agr_func_tab; function->name; function++)
-	if (!strcmp (function->name, tokid))
+	if (!strcasecmp (function->name, tokid))
 	  break;
       if (NULL == function->name)
 	{
@@ -452,7 +455,8 @@ parse_aggregate_functions (struct agr_proc *agr)
 		    arg[i].f = tokval;
 		    type = NUMERIC;
 		  } else {
-		    msg (SE, _("Missing argument %d to %s."), i + 1, function->name);
+		    msg (SE, _("Missing argument %d to %s."), i + 1,
+                         function->name);
 		    goto error;
 		  }
 	    
@@ -492,8 +496,7 @@ parse_aggregate_functions (struct agr_proc *agr)
               || func_index == FIN || func_index == FOUT) 
               && ((src[0]->type == NUMERIC && arg[0].f > arg[1].f)
                   || (src[0]->type == ALPHA
-                      && st_compare_pad (arg[0].c, strlen (arg[0].c),
-                                         arg[1].c, strlen (arg[1].c)) > 0)))
+                      && str_compare_rpad (arg[0].c, arg[1].c) > 0)))
             {
               union value t = arg[0];
               arg[0] = arg[1];
@@ -540,29 +543,28 @@ parse_aggregate_functions (struct agr_proc *agr)
 
 		if (function->alpha_type == ALPHA)
 		  destvar = dict_clone_var (agr->dict, v->src, dest[i]);
-		else if (v->src->type == NUMERIC
-                         || function->alpha_type == NUMERIC)
+		else
                   {
+                    assert (v->src->type == NUMERIC
+                            || function->alpha_type == NUMERIC);
                     destvar = dict_create_var (agr->dict, dest[i], 0);
-                        
-                    if ((func_index == N
-                            || func_index == N_NO_VARS
-                            || func_index == NMISS)
-                        && dict_get_weight (default_dict) != NULL)
+                    if (destvar != NULL) 
                       {
-                        static const struct fmt_spec f8_2 = {FMT_F, 8, 2};
-                            
-                        destvar->print = destvar->write = f8_2; 
+                        if ((func_index == N || func_index == NMISS)
+                            && dict_get_weight (default_dict) != NULL)
+                          destvar->print = destvar->write = f8_2; 
+                        else
+                          destvar->print = destvar->write = function->format;
                       }
-                    else
-                      destvar->print = destvar->write = function->format;
                   }
-                else 
-                  destvar = dict_create_var (agr->dict, dest[i],
-                                             v->src->width);
 	      } else {
 		v->src = NULL;
 		destvar = dict_create_var (agr->dict, dest[i], 0);
+                if (func_index == N_NO_VARS
+                    && dict_get_weight (default_dict) != NULL)
+                  destvar->print = destvar->write = f8_2; 
+                else
+                  destvar->print = destvar->write = function->format;
 	      }
 	  
 	    if (!destvar)
@@ -572,7 +574,6 @@ parse_aggregate_functions (struct agr_proc *agr)
 			   "the aggregate variables and the break "
 			   "variables."),
 		     dest[i]);
-		free (dest[i]);
 		goto error;
 	      }
 
@@ -655,7 +656,7 @@ agr_destroy (struct agr_proc *agr)
   if (agr->sort != NULL)
     sort_destroy_criteria (agr->sort);
   free (agr->break_vars);
-  free (agr->prev_break);
+  case_destroy (&agr->break_case);
   for (iter = agr->agr_vars; iter; iter = next)
     {
       next = iter->next;
@@ -693,105 +694,21 @@ static int
 aggregate_single_case (struct agr_proc *agr,
                        const struct ccase *input, struct ccase *output)
 {
-  /* The first case always begins a new break group.  We also need to
-     preserve the values of the case for later comparison. */
+  bool finished_group = false;
+  
   if (agr->case_cnt++ == 0)
+    initialize_aggregate_info (agr, input);
+  else if (case_compare (&agr->break_case, input,
+                         agr->break_vars, agr->break_var_cnt))
     {
-      int n_elem = 0;
-      
-      {
-	int i;
+      dump_aggregate_info (agr, output);
+      finished_group = true;
 
-	for (i = 0; i < agr->break_var_cnt; i++)
-	  n_elem += agr->break_vars[i]->nv;
-      }
-      
-      agr->prev_break = xmalloc (sizeof *agr->prev_break * n_elem);
-
-      /* Copy INPUT into prev_break. */
-      {
-	union value *iter = agr->prev_break;
-	int i;
-
-	for (i = 0; i < agr->break_var_cnt; i++)
-	  {
-	    struct variable *v = agr->break_vars[i];
-	    
-	    if (v->type == NUMERIC)
-	      (iter++)->f = case_num (input, v->fv);
-	    else
-	      {
-		memcpy (iter->s, case_str (input, v->fv), v->width);
-		iter += v->nv;
-	      }
-	  }
-      }
-	    
-      accumulate_aggregate_info (agr, input);
-	
-      return 0;
+      initialize_aggregate_info (agr, input);
     }
-      
-  /* Compare the value of each break variable to the values on the
-     previous case. */
-  {
-    union value *iter = agr->prev_break;
-    int i;
-    
-    for (i = 0; i < agr->break_var_cnt; i++)
-      {
-	struct variable *v = agr->break_vars[i];
-      
-	switch (v->type)
-	  {
-	  case NUMERIC:
-	    if (case_num (input, v->fv) != iter->f)
-	      goto not_equal;
-	    iter++;
-	    break;
-	  case ALPHA:
-	    if (memcmp (case_str (input, v->fv), iter->s, v->width))
-	      goto not_equal;
-	    iter += v->nv;
-	    break;
-	  default:
-	    assert (0);
-	  }
-      }
-  }
-
-  accumulate_aggregate_info (agr, input);
 
-  return 0;
-  
-not_equal:
-  /* The values of the break variable are different from the values on
-     the previous case.  That means that it's time to dump aggregate
-     info. */
-  dump_aggregate_info (agr, output);
-  initialize_aggregate_info (agr);
   accumulate_aggregate_info (agr, input);
-
-  /* Copy INPUT into prev_break. */
-  {
-    union value *iter = agr->prev_break;
-    int i;
-
-    for (i = 0; i < agr->break_var_cnt; i++)
-      {
-	struct variable *v = agr->break_vars[i];
-	    
-	if (v->type == NUMERIC)
-	  (iter++)->f = case_num (input, v->fv);
-	else
-	  {
-	    memcpy (iter->s, case_str (input, v->fv), v->width);
-	    iter += v->nv;
-	  }
-      }
-  }
-  
-  return 1;
+  return finished_group;
 }
 
 /* Accumulates aggregation data from the case INPUT. */
@@ -810,16 +727,19 @@ accumulate_aggregate_info (struct agr_proc *agr,
       {
 	const union value *v = case_data (input, iter->src->fv);
 
-	if ((!iter->include_missing && is_missing (v, iter->src))
+	if ((!iter->include_missing
+             && mv_is_value_missing (&iter->src->miss, v))
 	    || (iter->include_missing && iter->src->type == NUMERIC
 		&& v->f == SYSMIS))
 	  {
 	    switch (iter->function)
 	      {
 	      case NMISS:
+	      case NMISS | FSTRING:
 		iter->dbl[0] += weight;
                 break;
 	      case NUMISS:
+	      case NUMISS | FSTRING:
 		iter->int1++;
 		break;
 	      }
@@ -832,6 +752,7 @@ accumulate_aggregate_info (struct agr_proc *agr,
 	  {
 	  case SUM:
 	    iter->dbl[0] += v->f * weight;
+            iter->int1 = 1;
 	    break;
 	  case MEAN:
             iter->dbl[0] += v->f * weight;
@@ -904,7 +825,7 @@ accumulate_aggregate_info (struct agr_proc *agr,
 	  case FOUT | FSTRING:
 	  case POUT | FSTRING:
             if (memcmp (iter->arg[0].c, v->s, iter->src->width) > 0
-                && memcmp (iter->arg[1].c, v->s, iter->src->width) < 0)
+                || memcmp (iter->arg[1].c, v->s, iter->src->width) < 0)
               iter->dbl[0] += weight;
             iter->dbl[1] += weight;
             break;
@@ -975,11 +896,11 @@ dump_aggregate_info (struct agr_proc *agr, struct ccase *output)
 
     for (i = 0; i < agr->break_var_cnt; i++) 
       {
-        int nv = agr->break_vars[i]->nv;
+        struct variable *v = agr->break_vars[i];
         memcpy (case_data_rw (output, value_idx),
-                &agr->prev_break[value_idx],
-                sizeof (union value) * nv);
-        value_idx += nv; 
+                case_data (&agr->break_case, v->fv),
+                sizeof (union value) * v->nv);
+        value_idx += v->nv; 
       }
   }
   
@@ -994,7 +915,7 @@ dump_aggregate_info (struct agr_proc *agr, struct ccase *output)
 	    && (i->function & FUNC) != N && (i->function & FUNC) != NU
 	    && (i->function & FUNC) != NMISS && (i->function & FUNC) != NUMISS)
 	  {
-	    if (i->function & FSTRING)
+	    if (i->dest->type == ALPHA)
 	      memset (v->s, ' ', i->dest->width);
 	    else
 	      v->f = SYSMIS;
@@ -1004,7 +925,7 @@ dump_aggregate_info (struct agr_proc *agr, struct ccase *output)
 	switch (i->function)
 	  {
 	  case SUM:
-	    v->f = i->dbl[0];
+	    v->f = i->int1 ? i->dbl[0] : SYSMIS;
 	    break;
 	  case MEAN:
 	    v->f = i->dbl[1] != 0.0 ? i->dbl[0] / i->dbl[1] : SYSMIS;
@@ -1033,16 +954,14 @@ dump_aggregate_info (struct agr_proc *agr, struct ccase *output)
 	    else
 	      memset (v->s, ' ', i->dest->width);
 	    break;
-	  case FGT | FSTRING:
-	  case FLT | FSTRING:
-	  case FIN | FSTRING:
-	  case FOUT | FSTRING:
-	    v->f = i->int2 ? (double) i->int1 / (double) i->int2 : SYSMIS;
-	    break;
 	  case FGT:
+	  case FGT | FSTRING:
 	  case FLT:
+	  case FLT | FSTRING:
 	  case FIN:
+	  case FIN | FSTRING:
 	  case FOUT:
+	  case FOUT | FSTRING:
 	    v->f = i->dbl[1] ? i->dbl[0] / i->dbl[1] : SYSMIS;
 	    break;
 	  case PGT:
@@ -1097,25 +1016,28 @@ dump_aggregate_info (struct agr_proc *agr, struct ccase *output)
 
 /* Resets the state for all the aggregate functions. */
 static void
-initialize_aggregate_info (struct agr_proc *agr)
+initialize_aggregate_info (struct agr_proc *agr, const struct ccase *input)
 {
   struct agr_var *iter;
 
+  case_destroy (&agr->break_case);
+  case_clone (&agr->break_case, input);
+
   for (iter = agr->agr_vars; iter; iter = iter->next)
     {
       iter->missing = 0;
+      iter->dbl[0] = iter->dbl[1] = iter->dbl[2] = 0.0;
+      iter->int1 = iter->int2 = 0;
       switch (iter->function)
 	{
 	case MIN:
 	  iter->dbl[0] = DBL_MAX;
-          iter->int1 = 0;
 	  break;
 	case MIN | FSTRING:
 	  memset (iter->string, 255, iter->src->width);
 	  break;
 	case MAX:
 	  iter->dbl[0] = -DBL_MAX;
-          iter->int1 = 0;
 	  break;
 	case MAX | FSTRING:
 	  memset (iter->string, 0, iter->src->width);
@@ -1126,10 +1048,8 @@ initialize_aggregate_info (struct agr_proc *agr)
           else
             moments1_clear (iter->moments);
           break;
-	default:
-	  iter->dbl[0] = iter->dbl[1] = iter->dbl[2] = 0.0;
-	  iter->int1 = iter->int2 = 0;
-	  break;
+        default:
+          break;
 	}
     }
 }