X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Frank.c;h=48eda85474c5e995f3768b0d1d088220aae44abc;hb=3d594a844cecb4f7759ebf9b8b2ea920e64ff379;hp=dd3bea12832cf11887e28983932369454c0a838b;hpb=6f763403034b44b809fae1580dda3af0ab24a11b;p=pspp

diff --git a/src/language/stats/rank.c b/src/language/stats/rank.c
index dd3bea1283..48eda85474 100644
--- a/src/language/stats/rank.c
+++ b/src/language/stats/rank.c
@@ -41,8 +41,7 @@
 #include "libpspp/pool.h"
 #include "libpspp/string-set.h"
 #include "libpspp/taint.h"
-
-#include "output/tab.h"
+#include "output/pivot-table.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
@@ -162,7 +161,7 @@ try_new_name (const char *new_name,
 }
 
 /* Returns a variable name for storing ranks of a variable named SRC_NAME
-   accoring to the rank function F.  The name chosen will not be one already in
+   according to the rank function F.  The name chosen will not be one already in
    DICT or NEW_NAMES.
 
    If successful, adds the new name to NEW_NAMES and returns the name added.
@@ -257,7 +256,7 @@ parse_into (struct lexer *lexer, struct rank *cmd,
 
   cmd->rs = pool_realloc (cmd->pool, cmd->rs, sizeof (*cmd->rs) * (cmd->n_rs + 1));
   rs = &cmd->rs[cmd->n_rs];
-      
+
   if (lex_match_id (lexer, "RANK"))
     {
       rs->rfunc = RANK;
@@ -288,16 +287,16 @@ parse_into (struct lexer *lexer, struct rank *cmd,
     }
   else if (lex_match_id (lexer, "NTILES"))
     {
-      if ( !lex_force_match (lexer, T_LPAREN))
+      if (!lex_force_match (lexer, T_LPAREN))
 	return false;
-      
-      if (! lex_force_int (lexer) )
+
+      if (! lex_force_int (lexer))
 	return false;
-      
+
       cmd->k_ntiles = lex_integer (lexer);
       lex_get (lexer);
-      
-      if ( !lex_force_match (lexer, T_RPAREN))
+
+      if (!lex_force_match (lexer, T_RPAREN))
 	return false;
 
       rs->rfunc = NTILES;
@@ -314,13 +313,13 @@ parse_into (struct lexer *lexer, struct rank *cmd,
 
   if (lex_match_id (lexer, "INTO"))
     {
-      while( lex_token (lexer) == T_ID )
+      while(lex_token (lexer) == T_ID)
 	{
 	  const char *name = lex_tokcstr (lexer);
 
-	  if ( var_count >= subcase_get_n_fields (&cmd->sc) )
+	  if (var_count >= subcase_get_n_fields (&cmd->sc))
             msg (SE, _("Too many variables in %s clause."), "INTO");
-	  else if ( dict_lookup_var (cmd->dict, name) != NULL )
+	  else if (dict_lookup_var (cmd->dict, name) != NULL)
             msg (SE, _("Variable %s already exists."), name);
           else if (string_set_contains (new_names, name))
             msg (SE, _("Duplicate variable name %s."), name);
@@ -355,7 +354,7 @@ rank_rank (const struct rank *cmd, double c, double cc, double cc_1,
 {
   double rank;
 
-  if ( c >= 1.0 )
+  if (c >= 1.0)
     {
       switch (cmd->ties)
 	{
@@ -424,7 +423,7 @@ rank_proportion (const struct rank *cmd, double c, double cc, double cc_1,
 
   double f;
 
-  switch ( cmd->fraction )
+  switch (cmd->fraction)
     {
     case FRAC_BLOM:
       f =  (r - 3.0/8.0) / (w + 0.25);
@@ -436,7 +435,7 @@ rank_proportion (const struct rank *cmd, double c, double cc, double cc_1,
       f = (r - 1.0/3.0) / (w + 1.0/3.0);
       break;
     case FRAC_VW:
-      f = r / ( w + 1.0);
+      f = r / (w + 1.0);
       break;
     default:
       NOT_REACHED ();
@@ -462,7 +461,7 @@ rank_ntiles (const struct rank *cmd, double c, double cc, double cc_1,
   double r = rank_rank (cmd, c, cc, cc_1, i, w);
 
 
-  return ( floor (( r * cmd->k_ntiles) / ( w + 1) ) + 1);
+  return (floor ((r * cmd->k_ntiles) / (w + 1)) + 1);
 }
 
 /* Expected value of the order statistics from an exponential distribution */
@@ -473,7 +472,7 @@ ee (int j, double w_star)
   double sum = 0.0;
 
   for (k = 1 ; k <= j; k++)
-    sum += 1.0 / ( w_star + 1 - k );
+    sum += 1.0 / (w_star + 1 - k);
 
   return sum;
 }
@@ -487,29 +486,29 @@ rank_savage (const struct rank *cmd UNUSED, double c, double cc, double cc_1,
   const int i_1 = floor (cc_1);
   const int i_2 = floor (cc);
 
-  const double w_star = (modf (w, &int_part) == 0 ) ? w : floor (w) + 1;
+  const double w_star = (modf (w, &int_part) == 0) ? w : floor (w) + 1;
 
   const double g_1 = cc_1 - i_1;
   const double g_2 = cc - i_2;
 
   /* The second factor is infinite, when the first is zero.
      Therefore, evaluate the second, only when the first is non-zero */
-  const double expr1 =  (1 - g_1) ? (1 - g_1) * ee(i_1+1, w_star) : ( 1 - g_1);
+  const double expr1 =  (1 - g_1) ? (1 - g_1) * ee(i_1+1, w_star) : (1 - g_1);
   const double expr2 =  g_2 ? g_2 * ee (i_2+1, w_star) : g_2 ;
 
-  if ( i_1 == i_2 )
+  if (i_1 == i_2)
     return ee (i_1 + 1, w_star) - 1;
 
-  if ( i_1 + 1 == i_2 )
-    return ( ( expr1 + expr2 )/c ) - 1;
+  if (i_1 + 1 == i_2)
+    return ((expr1 + expr2)/c) - 1;
 
-  if ( i_1 + 2 <= i_2 )
+  if (i_1 + 2 <= i_2)
     {
       int j;
       double sigma = 0.0;
-      for (j = i_1 + 2 ; j <= i_2; ++j )
+      for (j = i_1 + 2 ; j <= i_2; ++j)
 	sigma += ee (j, w_star);
-      return ( (expr1 + expr2 + sigma) / c) -1;
+      return ((expr1 + expr2 + sigma) / c) -1;
     }
 
   NOT_REACHED();
@@ -596,7 +595,7 @@ rank_cmd (struct dataset *ds,  const struct rank *cmd);
 static const char *
 fraction_name (const struct rank *cmd)
 {
-  switch (cmd->fraction )
+  switch (cmd->fraction)
     {
     case FRAC_BLOM:   return "BLOM";
     case FRAC_RANKIT: return "RANKIT";
@@ -616,16 +615,16 @@ create_var_label (struct rank *cmd, const struct variable *src_var,
 
   ds_init_empty (&label);
 
-  if ( cmd->n_group_vars > 0 )
+  if (cmd->n_group_vars > 0)
     {
       struct string group_var_str;
       int g;
 
       ds_init_empty (&group_var_str);
 
-      for (g = 0 ; g < cmd->n_group_vars ; ++g )
+      for (g = 0 ; g < cmd->n_group_vars ; ++g)
 	{
-	  if ( g > 0 ) ds_put_cstr (&group_var_str, " ");
+	  if (g > 0) ds_put_cstr (&group_var_str, " ");
 	  ds_put_cstr (&group_var_str, var_get_name (cmd->group_vars[g]));
 	}
 
@@ -638,7 +637,7 @@ create_var_label (struct rank *cmd, const struct variable *src_var,
                    function_name[f], var_get_name (src_var));
 
   pool_label = pool_strdup (cmd->pool, ds_cstr (&label));
-  
+
   ds_destroy (&label);
 
   return pool_label;
@@ -650,7 +649,6 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
   struct string_set new_names;
   struct rank rank;
   struct rank_spec *rs;
-  int i;
 
   subcase_init_empty (&rank.sc);
 
@@ -668,7 +666,8 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
   string_set_init (&new_names);
 
   if (lex_match_id (lexer, "VARIABLES"))
-    lex_force_match (lexer, T_EQUALS);
+    if (! lex_force_match (lexer, T_EQUALS))
+      goto error;
 
   if (!parse_sort_criteria (lexer, rank.dict,
 			    &rank.sc,
@@ -677,21 +676,23 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
 
   rank.n_vars = rank.sc.n_fields;
 
-  if (lex_match (lexer, T_BY) )
+  if (lex_match (lexer, T_BY))
     {
-      if ( ! parse_variables_const (lexer, rank.dict,
+      if (! parse_variables_const (lexer, rank.dict,
 				    &rank.group_vars, &rank.n_group_vars,
 				    PV_NO_DUPLICATE | PV_NO_SCRATCH))
 	goto error;
     }
 
 
-  while (lex_token (lexer) != T_ENDCMD )
+  while (lex_token (lexer) != T_ENDCMD)
     {
-      lex_force_match (lexer, T_SLASH);
+      if (! lex_force_match (lexer, T_SLASH))
+	goto error;
       if (lex_match_id (lexer, "TIES"))
 	{
-	  lex_force_match (lexer, T_EQUALS);
+	  if (! lex_force_match (lexer, T_EQUALS))
+	    goto error;
 	  if (lex_match_id (lexer, "MEAN"))
 	    {
 	      rank.ties = TIES_MEAN;
@@ -716,7 +717,8 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
 	}
       else if (lex_match_id (lexer, "FRACTION"))
 	{
-	  lex_force_match (lexer, T_EQUALS);
+	  if (! lex_force_match (lexer, T_EQUALS))
+	    goto error;
 	  if (lex_match_id (lexer, "BLOM"))
 	    {
 	      rank.fraction = FRAC_BLOM;
@@ -741,7 +743,8 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
 	}
       else if (lex_match_id (lexer, "PRINT"))
 	{
-	  lex_force_match (lexer, T_EQUALS);
+	  if (! lex_force_match (lexer, T_EQUALS))
+	    goto error;
 	  if (lex_match_id (lexer, "YES"))
 	    {
 	      rank.print = true;
@@ -758,7 +761,8 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
 	}
       else if (lex_match_id (lexer, "MISSING"))
 	{
-	  lex_force_match (lexer, T_EQUALS);
+	  if (! lex_force_match (lexer, T_EQUALS))
+	    goto error;
 	  if (lex_match_id (lexer, "INCLUDE"))
 	    {
 	      rank.exclude = MV_SYSTEM;
@@ -779,7 +783,7 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
 
 
   /* If no rank specs are given, then apply a default */
-  if ( rank.n_rs == 0)
+  if (rank.n_rs == 0)
     {
       struct rank_spec *rs;
 
@@ -796,14 +800,12 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
      created with INTO. */
   for (rs = rank.rs; rs < &rank.rs[rank.n_rs]; rs++)
     {
-      int v;
-
       rs->dest_labels = pool_calloc (rank.pool, rank.n_vars,
                                      sizeof *rs->dest_labels);
-      for ( v = 0 ; v < rank.n_vars ;  v ++ )
+      for (int v = 0 ; v < rank.n_vars ;  v ++)
         {
           const char **dst_name = &rs->dest_names[v];
-          if ( *dst_name == NULL )
+          if (*dst_name == NULL)
             {
               *dst_name = rank_choose_dest_name (rank.dict, &new_names,
                                                  rs->rfunc,
@@ -817,74 +819,57 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
         }
     }
 
-  if ( rank.print )
+  if (rank.print)
     {
-      int v;
+      struct pivot_table *table = pivot_table_create (
+        N_("Variables Created by RANK"));
+      table->omit_empty = true;
 
-      tab_output_text_format (0, _("Variables Created By %s"), "RANK");
-      tab_output_text (0, "");
+      pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("New Variable"),
+                              N_("New Variable"), N_("Function"),
+                              N_("Fraction"), N_("Grouping Variables"));
 
-      for (i = 0 ; i <  rank.n_rs ; ++i )
+      struct pivot_dimension *variables = pivot_dimension_create (
+        table, PIVOT_AXIS_ROW, N_("Existing Variable"),
+        N_("Existing Variable"));
+      variables->root->show_label = true;
+
+      for (size_t i = 0 ; i <  rank.n_rs ; ++i)
 	{
-	  for ( v = 0 ; v < rank.n_vars ;  v ++ )
+	  for (size_t v = 0 ; v < rank.n_vars ;  v ++)
 	    {
-	      if ( rank.n_group_vars > 0 )
-		{
-		  struct string varlist;
-		  int g;
-
-		  ds_init_empty (&varlist);
-		  for ( g = 0 ; g < rank.n_group_vars ; ++g )
-		    {
-		      ds_put_cstr (&varlist, var_get_name (rank.group_vars[g]));
-
-		      if ( g < rank.n_group_vars - 1)
-			ds_put_cstr (&varlist, " ");
-		    }
-
-		  if ( rank.rs[i].rfunc == NORMAL ||
-		       rank.rs[i].rfunc == PROPORTION )
-		    tab_output_text_format (0,
-                                            _("%s into %s(%s of %s using %s BY %s)"),
-                                            var_get_name (rank.vars[v]),
-                                            rank.rs[i].dest_names[v],
-                                            function_name[rank.rs[i].rfunc],
-                                            var_get_name (rank.vars[v]),
-                                            fraction_name (&rank),
-                                            ds_cstr (&varlist));
-
-		  else
-		    tab_output_text_format (0,
-                                            _("%s into %s(%s of %s BY %s)"),
-                                            var_get_name (rank.vars[v]),
-                                            rank.rs[i].dest_names[v],
-                                            function_name[rank.rs[i].rfunc],
-                                            var_get_name (rank.vars[v]),
-                                            ds_cstr (&varlist));
-		  ds_destroy (&varlist);
-		}
-	      else
-		{
-		  if ( rank.rs[i].rfunc == NORMAL ||
-		       rank.rs[i].rfunc == PROPORTION )
-		    tab_output_text_format (0,
-                                            _("%s into %s(%s of %s using %s)"),
-                                            var_get_name (rank.vars[v]),
-                                            rank.rs[i].dest_names[v],
-                                            function_name[rank.rs[i].rfunc],
-                                            var_get_name (rank.vars[v]),
-                                            fraction_name (&rank));
-
-		  else
-		    tab_output_text_format (0,
-                                            _("%s into %s(%s of %s)"),
-                                            var_get_name (rank.vars[v]),
-                                            rank.rs[i].dest_names[v],
-                                            function_name[rank.rs[i].rfunc],
-                                            var_get_name (rank.vars[v]));
-		}
+              int row_idx = pivot_category_create_leaf (
+                variables->root, pivot_value_new_variable (rank.vars[v]));
+
+              struct string group_vars = DS_EMPTY_INITIALIZER;
+              for (int g = 0 ; g < rank.n_group_vars ; ++g)
+                {
+                  if (g)
+                    ds_put_byte (&group_vars, ' ');
+                  ds_put_cstr (&group_vars, var_get_name (rank.group_vars[g]));
+                }
+
+              enum rank_func rfunc = rank.rs[i].rfunc;
+              bool has_fraction = rfunc == NORMAL || rfunc == PROPORTION;
+              const char *entries[] =
+                {
+                  rank.rs[i].dest_names[v],
+                  function_name[rank.rs[i].rfunc],
+                  has_fraction ? fraction_name (&rank) : NULL,
+                  rank.n_group_vars ? ds_cstr (&group_vars) : NULL,
+                };
+              for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
+                {
+                  const char *entry = entries[j];
+                  if (entry)
+                    pivot_table_put2 (table, j, row_idx,
+                                      pivot_value_new_user_text (entry, -1));
+                }
+              ds_destroy (&group_vars);
 	    }
 	}
+
+      pivot_table_submit (table);
     }
 
   /* Do the ranking */
@@ -1012,7 +997,7 @@ rank_cmd (struct dataset *ds, const struct rank *cmd)
   /* Open the active file and make one pass per input variable. */
   input = proc_open (ds);
   input = casereader_create_filter_weight (input, d, NULL, NULL);
-  for (i = 0 ; i < cmd->n_vars ; ++i )
+  for (i = 0 ; i < cmd->n_vars ; ++i)
     {
       const struct variable *input_var = cmd->vars[i];
       struct casereader *input_pass;