From 2c4b104df57f2e8b5ed2afa50819294aaac4aa6c Mon Sep 17 00:00:00 2001
From: Ben Pfaff <blp@cs.stanford.edu>
Date: Thu, 2 Sep 2021 19:59:23 -0700
Subject: [PATCH] case: Introduce new functions for numbers and substrings in
 cases.

Use the case_num_*() functions everywhere in the tree for clarity and
brevity.
---
 src/data/case.c                          | 43 +++++++++++
 src/data/case.h                          |  7 +-
 src/data/casereader-translator.c         | 18 ++---
 src/data/dataset.c                       |  2 +-
 src/data/por-file-reader.c               |  2 +-
 src/language/control/loop.c              |  4 +-
 src/language/data-io/combine-files.c     | 10 +--
 src/language/data-io/data-list.c         |  2 +-
 src/language/data-io/matrix-reader.c     |  2 +-
 src/language/stats/aggregate.c           |  5 +-
 src/language/stats/autorecode.c          |  2 +-
 src/language/stats/cochran.c             |  2 +-
 src/language/stats/descriptives.c        | 10 +--
 src/language/stats/examine.c             | 10 +--
 src/language/stats/flip.c                |  2 +-
 src/language/stats/friedman.c            |  2 +-
 src/language/stats/glm.c                 |  6 +-
 src/language/stats/graph.c               | 12 +--
 src/language/stats/jonckheere-terpstra.c | 15 ++--
 src/language/stats/kruskal-wallis.c      |  2 +-
 src/language/stats/logistic.c            |  2 +-
 src/language/stats/mann-whitney.c        |  2 +-
 src/language/stats/means.c               |  2 +-
 src/language/stats/quick-cluster.c       | 14 ++--
 src/language/stats/rank.c                |  6 +-
 src/language/stats/regression.c          | 14 ++--
 src/language/stats/reliability.c         | 11 +--
 src/language/stats/roc.c                 | 96 ++++++++++++------------
 src/language/stats/runs.c                |  8 +-
 src/language/stats/wilcoxon.c            | 25 +++---
 src/language/xforms/compute.c            |  4 +-
 src/language/xforms/count.c              |  2 +-
 src/language/xforms/recode.c             |  2 +-
 src/math/box-whisker.c                   |  2 +-
 src/math/categoricals.c                  |  2 +-
 src/math/covariance.c                    |  6 +-
 src/math/np.c                            |  6 +-
 src/math/order-stats.c                   |  4 +-
 src/output/charts/np-plot-cairo.c        |  8 +-
 src/output/charts/roc-chart-cairo.c      |  8 +-
 src/output/charts/scatterplot-cairo.c    |  4 +-
 41 files changed, 208 insertions(+), 178 deletions(-)

diff --git a/src/data/case.c b/src/data/case.c
index 70c1b44075..742d1f0f22 100644
--- a/src/data/case.c
+++ b/src/data/case.c
@@ -323,6 +323,29 @@ case_num_idx (const struct ccase *c, size_t idx)
   return c->values[idx].f;
 }
 
+/* Returns a pointer to the `double' in the `union value' in C for variable V.
+   The caller is allowed to modify the returned data.
+
+   Case C must be drawn from V's dictionary and must not be shared. */
+double *
+case_num_rw (struct ccase *c, const struct variable *v)
+{
+  assert_variable_matches_case (c, v);
+  assert (!case_is_shared (c));
+  return &c->values[var_get_case_index (v)].f;
+}
+
+/* Returns a pointer to the `double' in the `union value' in C numbered IDX.
+   The caller is allowed to modify the returned data.
+
+   Case C must not be shared. */
+double *
+case_num_rw_idx (struct ccase *c, size_t idx)
+{
+  assert (!case_is_shared (c));
+  return &c->values[idx].f;
+}
+
 /* Returns the string value of the `union value' in C for
    variable V.  Case C must be drawn from V's dictionary.  The
    caller must not modify the return value.
@@ -348,6 +371,26 @@ case_str_idx (const struct ccase *c, size_t idx)
   return c->values[idx].s;
 }
 
+/* Returns a substring for the `union value' in C for variable V.  Case C must
+   be drawn from V's dictionary. */
+struct substring
+case_ss (const struct ccase *c, const struct variable *v)
+{
+  assert_variable_matches_case (c, v);
+  return ss_buffer (CHAR_CAST (char *, c->values[var_get_case_index (v)].s),
+                    var_get_width (v));
+}
+
+/* Returns a substring for the `union value' in C numbered IDX.  WIDTH must be
+   the value's width. */
+struct substring
+case_ss_idx (const struct ccase *c, size_t width, size_t idx)
+{
+  assert (width > 0);
+  assert (idx < c->proto->n_widths);
+  return ss_buffer (CHAR_CAST (char *, c->values[idx].s), width);
+}
+
 /* Returns the string value of the `union value' in C for
    variable V.  Case C must be drawn from V's dictionary.  The
    caller may modify the return value.
diff --git a/src/data/case.h b/src/data/case.h
index 4b20d477d6..45fdf52c9b 100644
--- a/src/data/case.h
+++ b/src/data/case.h
@@ -23,6 +23,7 @@
 #include <stdlib.h>
 
 #include "libpspp/compiler.h"
+#include "libpspp/str.h"
 #include "data/caseproto.h"
 
 struct variable;
@@ -94,9 +95,13 @@ union value *case_data_rw_idx (struct ccase *, size_t idx);
 
 double case_num (const struct ccase *, const struct variable *);
 double case_num_idx (const struct ccase *, size_t idx);
+double *case_num_rw (struct ccase *, const struct variable *);
+double *case_num_rw_idx (struct ccase *, size_t idx);
 
 const uint8_t *case_str (const struct ccase *, const struct variable *);
 const uint8_t *case_str_idx (const struct ccase *, size_t idx);
+struct substring case_ss (const struct ccase *, const struct variable *);
+struct substring case_ss_idx (const struct ccase *, size_t width, size_t idx);
 uint8_t *case_str_rw (struct ccase *, const struct variable *);
 uint8_t *case_str_rw_idx (struct ccase *, size_t idx);
 
@@ -121,7 +126,7 @@ void case_unref__ (struct ccase *);
    This function should be used before attempting to modify any
    of the data in a case that might be shared, e.g.:
         c = case_unshare (c);              // Make sure that C is not shared.
-        case_data_rw (c, myvar)->f = 1;    // Modify data in C.
+        *case_num_rw (c, myvar) = 1;       // Modify data in C.
 */
 static inline struct ccase *
 case_unshare (struct ccase *c)
diff --git a/src/data/casereader-translator.c b/src/data/casereader-translator.c
index cab13fe31d..a6508502b7 100644
--- a/src/data/casereader-translator.c
+++ b/src/data/casereader-translator.c
@@ -264,7 +264,7 @@ can_translate (struct ccase *c, void *can_)
   struct casereader_append_numeric *can = can_;
   double new_value = can->func (c, can->n++, can->aux);
   c = case_unshare_and_resize (c, can->proto);
-  case_data_rw_idx (c, caseproto_get_n_widths (can->proto) - 1)->f = new_value;
+  *case_num_rw_idx (c, caseproto_get_n_widths (can->proto) - 1) = new_value;
   return c;
 }
 
@@ -405,7 +405,7 @@ car_translate (struct ccase *input, void *car_)
 {
   struct casereader_append_rank *car = car_;
 
-  const double value = case_data (input, car->var)->f;
+  const double value = case_num (input, car->var);
 
   if (car->prev_value != SYSMIS)
     {
@@ -420,7 +420,7 @@ car_translate (struct ccase *input, void *car_)
       double weight = 1.0;
       if (car->weight)
 	{
-	  weight = case_data (input, car->weight)->f;
+	  weight = case_num (input, car->weight);
 	  if (car->err && weight < 0)
 	    *car->err |= RANK_ERR_NEGATIVE_WEIGHT;
 	}
@@ -430,13 +430,13 @@ car_translate (struct ccase *input, void *car_)
 	  struct ccase *c = casereader_peek (car->clone, car->n + ++k);
 	  if (c == NULL)
 	    break;
-	  vxx = case_data (c, car->var)->f;
+	  vxx = case_num (c, car->var);
 
 	  if (vxx == value)
 	    {
 	      if (car->weight)
 		{
-		  double w = case_data (c, car->weight)->f;
+		  double w = case_num (c, car->weight);
 
 		  if (car->err && w < 0)
 		    *car->err |= RANK_ERR_NEGATIVE_WEIGHT;
@@ -462,7 +462,7 @@ car_translate (struct ccase *input, void *car_)
   car->n++;
 
   input = case_unshare_and_resize (input, car->proto);
-  case_data_rw_idx (input, caseproto_get_n_widths (car->proto) - 1)->f
+  *case_num_rw_idx (input, caseproto_get_n_widths (car->proto) - 1)
     = car->mean_rank;
   car->prev_value = value;
   return input;
@@ -490,7 +490,7 @@ uniquify (const struct ccase *c, void *aux)
   struct consolidator *cdr = aux;
   const union value *current_value = case_data (c, cdr->key);
   const int key_width = var_get_width (cdr->key);
-  const double weight = cdr->weight ? case_data (c, cdr->weight)->f : 1.0;
+  const double weight = cdr->weight ? case_num (c, cdr->weight) : 1.0;
   struct ccase *next_case = casereader_peek (cdr->clone, cdr->n + 1);
   int dir = 0;
 
@@ -530,12 +530,12 @@ consolodate_weight (struct ccase *input, void *aux)
   if (cdr->weight)
     {
       c = case_unshare (input);
-      case_data_rw (c, cdr->weight)->f = cdr->prev_cc;
+      *case_num_rw (c, cdr->weight) = cdr->prev_cc;
     }
   else
     {
       c = case_unshare_and_resize (input, cdr->proto);
-      case_data_rw_idx (c, caseproto_get_n_widths (cdr->proto) - 1)->f = cdr->prev_cc;
+      *case_num_rw_idx (c, caseproto_get_n_widths (cdr->proto) - 1) = cdr->prev_cc;
     }
 
   return c;
diff --git a/src/data/dataset.c b/src/data/dataset.c
index b94a3675c6..f966b63af9 100644
--- a/src/data/dataset.c
+++ b/src/data/dataset.c
@@ -818,7 +818,7 @@ store_case_num (void *var_, struct ccase **cc, casenumber case_num)
   struct variable *var = var_;
 
   *cc = case_unshare (*cc);
-  case_data_rw (*cc, var)->f = case_num;
+  *case_num_rw (*cc, var) = case_num;
 
   return TRNS_CONTINUE;
 }
diff --git a/src/data/por-file-reader.c b/src/data/por-file-reader.c
index 8d008b1dd6..b5cc35b825 100644
--- a/src/data/por-file-reader.c
+++ b/src/data/por-file-reader.c
@@ -901,7 +901,7 @@ por_file_casereader_read (struct casereader *reader, void *r_)
       int width = caseproto_get_width (r->proto, i);
 
       if (width == 0)
-        case_data_rw_idx (c, i)->f = read_float (r);
+        *case_num_rw_idx (c, i) = read_float (r);
       else
         {
           uint8_t buf[256];
diff --git a/src/language/control/loop.c b/src/language/control/loop.c
index 765d213147..156e647ea0 100644
--- a/src/language/control/loop.c
+++ b/src/language/control/loop.c
@@ -315,7 +315,7 @@ loop_trns_proc (void *loop_, struct ccase **c, casenumber case_num)
       /* Even if the loop is never entered, set the index
          variable to the initial value. */
       *c = case_unshare (*c);
-      case_data_rw (*c, loop->index_var)->f = loop->cur;
+      *case_num_rw (*c, loop->index_var) = loop->cur;
 
       /* Throw out pathological cases. */
       if (!isfinite (loop->cur) || !isfinite (loop->by)
@@ -374,7 +374,7 @@ end_loop_trns_proc (void *loop_, struct ccase **c, casenumber case_num UNUSED)
           || (loop->by < 0.0 && loop->cur < loop->last))
         goto break_out;
       *c = case_unshare (*c);
-      case_data_rw (*c, loop->index_var)->f = loop->cur;
+      *case_num_rw (*c, loop->index_var) = loop->cur;
     }
 
   if (loop->loop_condition != NULL
diff --git a/src/language/data-io/combine-files.c b/src/language/data-io/combine-files.c
index c63901d3dc..c51f04aaa9 100644
--- a/src/language/data-io/combine-files.c
+++ b/src/language/data-io/combine-files.c
@@ -835,7 +835,7 @@ create_output_case (const struct comb_proc *proc)
     {
       struct comb_file *file = &proc->files[i];
       if (file->in_var != NULL)
-        case_data_rw (output, file->in_var)->f = false;
+        *case_num_rw (output, file->in_var) = false;
     }
   return output;
 }
@@ -844,7 +844,7 @@ static void
 mark_file_used (const struct comb_file *file, struct ccase *output)
 {
   if (file->in_var != NULL)
-    case_data_rw (output, file->in_var)->f = true;
+    *case_num_rw (output, file->in_var) = true;
 }
 
 /* Copies the data from FILE's case into output case OUTPUT.
@@ -913,7 +913,7 @@ output_case (struct comb_proc *proc, struct ccase *output, union value by[])
         {
           new_BY = !subcase_equal_xx (&proc->by_vars, proc->prev_BY, by);
           if (proc->last != NULL)
-            case_data_rw (proc->buffered_case, proc->last)->f = new_BY;
+            *case_num_rw (proc->buffered_case, proc->last) = new_BY;
           casewriter_write (proc->output, proc->buffered_case);
         }
       else
@@ -921,7 +921,7 @@ output_case (struct comb_proc *proc, struct ccase *output, union value by[])
 
       proc->buffered_case = output;
       if (proc->first != NULL)
-        case_data_rw (proc->buffered_case, proc->first)->f = new_BY;
+        *case_num_rw (proc->buffered_case, proc->first) = new_BY;
 
       if (new_BY)
         {
@@ -946,7 +946,7 @@ output_buffered_case (struct comb_proc *proc)
   if (proc->prev_BY != NULL)
     {
       if (proc->last != NULL)
-        case_data_rw (proc->buffered_case, proc->last)->f = 1.0;
+        *case_num_rw (proc->buffered_case, proc->last) = 1.0;
       casewriter_write (proc->output, proc->buffered_case);
       proc->buffered_case = NULL;
     }
diff --git a/src/language/data-io/data-list.c b/src/language/data-io/data-list.c
index f689c99711..b6dc078985 100644
--- a/src/language/data-io/data-list.c
+++ b/src/language/data-io/data-list.c
@@ -527,7 +527,7 @@ data_list_trns_proc (void *trns_, struct ccase **c, casenumber case_num UNUSED)
   /* If there was an END subcommand handle it. */
   if (trns->end != NULL)
     {
-      double *end = &case_data_rw (*c, trns->end)->f;
+      double *end = case_num_rw (*c, trns->end);
       if (retval == TRNS_END_FILE)
         {
           *end = 1.0;
diff --git a/src/language/data-io/matrix-reader.c b/src/language/data-io/matrix-reader.c
index eac86744af..a7db15e029 100644
--- a/src/language/data-io/matrix-reader.c
+++ b/src/language/data-io/matrix-reader.c
@@ -182,7 +182,7 @@ matrix_fill_row (gsl_matrix **matrix,
   for (col = 0; col < n_vars; ++col)
     {
       const struct variable *cv = vars [col];
-      double x = case_data (c, cv)->f;
+      double x = case_num (c, cv);
       assert (col  < (*matrix)->size2);
       assert (mrow < (*matrix)->size1);
       gsl_matrix_set (*matrix, mrow, col, x);
diff --git a/src/language/stats/aggregate.c b/src/language/stats/aggregate.c
index 9f0b271533..565e26d938 100644
--- a/src/language/stats/aggregate.c
+++ b/src/language/stats/aggregate.c
@@ -789,12 +789,11 @@ accumulate_aggregate_info (struct agr_proc *agr, const struct ccase *input)
 
               cout = case_create (casewriter_get_proto (iter->writer));
 
-	      case_data_rw (cout, iter->subject)->f
-                = case_data (input, iter->src)->f;
+	      *case_num_rw (cout, iter->subject) = case_num (input, iter->src);
 
 	      wv = dict_get_case_weight (agr->src_dict, input, NULL);
 
-	      case_data_rw (cout, iter->weight)->f = wv;
+	      *case_num_rw (cout, iter->weight) = wv;
 
 	      iter->cc += wv;
 
diff --git a/src/language/stats/autorecode.c b/src/language/stats/autorecode.c
index 005ba7622a..6481a26326 100644
--- a/src/language/stats/autorecode.c
+++ b/src/language/stats/autorecode.c
@@ -568,7 +568,7 @@ autorecode_trns_proc (void *arc_, struct ccase **c,
       size_t hash = value_hash (value, width, 0);
       const struct arc_item *item = find_arc_item (spec->items, value, width,
                                                    hash);
-      case_data_rw (*c, spec->dst)->f = item ? item->to : SYSMIS;
+      *case_num_rw (*c, spec->dst) = item ? item->to : SYSMIS;
     }
 
   return TRNS_CONTINUE;
diff --git a/src/language/stats/cochran.c b/src/language/stats/cochran.c
index 4b881f393c..935d612b5e 100644
--- a/src/language/stats/cochran.c
+++ b/src/language/stats/cochran.c
@@ -80,7 +80,7 @@ cochran_execute (const struct dataset *ds,
   for (; (c = casereader_read (input)); case_unref (c))
     {
       double case_hits = 0.0;
-      const double w = weight ? case_data (c, weight)->f: 1.0;
+      const double w = weight ? case_num (c, weight) : 1.0;
       for (v = 0; v < ct->n_vars; ++v)
 	{
 	  const struct variable *var = ct->vars[v];
diff --git a/src/language/stats/descriptives.c b/src/language/stats/descriptives.c
index 0cee83e06b..eefd0598e3 100644
--- a/src/language/stats/descriptives.c
+++ b/src/language/stats/descriptives.c
@@ -606,7 +606,7 @@ descriptives_set_all_sysmis_zscores (const struct dsc_trns *t, struct ccase *c)
   const struct dsc_z_score *z;
 
   for (z = t->z_scores; z < t->z_scores + t->z_score_cnt; z++)
-    case_data_rw (c, z->z_var)->f = SYSMIS;
+    *case_num_rw (c, z->z_var) = SYSMIS;
 }
 
 /* Transformation function to calculate Z-scores. Will return SYSMIS if any of
@@ -684,7 +684,7 @@ descriptives_trns_proc (void *trns_, struct ccase **c,
   for (z = t->z_scores; z < t->z_scores + t->z_score_cnt; z++)
     {
       double input = case_num (*c, z->src_var);
-      double *output = &case_data_rw (*c, z->z_var)->f;
+      double *output = case_num_rw (*c, z->z_var);
 
       if (z->mean == SYSMIS || z->std_dev == SYSMIS
           || var_is_num_missing (z->src_var, input, t->exclude))
@@ -904,7 +904,7 @@ calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
     {
       c = case_create (casewriter_get_proto (dsc->z_writer));
       z_idx = 0;
-      case_data_rw_idx (c, z_idx++)->f = count;
+      *case_num_rw_idx (c, z_idx++) = count;
     }
   else
     c = NULL;
@@ -945,8 +945,8 @@ calc_descriptives (struct dsc_proc *dsc, struct casereader *group,
 
       if (dv->z_name && c != NULL)
         {
-          case_data_rw_idx (c, z_idx++)->f = dv->stats[DSC_MEAN];
-          case_data_rw_idx (c, z_idx++)->f = dv->stats[DSC_STDDEV];
+          *case_num_rw_idx (c, z_idx++) = dv->stats[DSC_MEAN];
+          *case_num_rw_idx (c, z_idx++) = dv->stats[DSC_STDDEV];
         }
     }
 
diff --git a/src/language/stats/examine.c b/src/language/stats/examine.c
index ad8a9baa76..00fb801fce 100644
--- a/src/language/stats/examine.c
+++ b/src/language/stats/examine.c
@@ -1068,7 +1068,7 @@ update_n (const void *aux1, void *aux2 UNUSED, void *user_data,
     {
       struct ccase *outcase ;
       const struct variable *var = examine->dep_vars[v];
-      const double x = case_data (c, var)->f;
+      const double x = case_num (c, var);
 
       if (var_is_value_missing (var, case_data (c, var), examine->dep_excl))
         {
@@ -1090,11 +1090,11 @@ update_n (const void *aux1, void *aux2 UNUSED, void *user_data,
 
       /* Save the value and the ID to the writer */
       assert (examine->id_idx != -1);
-      case_data_rw_idx (outcase, EX_VAL)->f = x;
+      *case_num_rw_idx (outcase, EX_VAL) = x;
       value_copy (case_data_rw_idx (outcase, EX_ID),
                   case_data_idx (c, examine->id_idx), examine->id_width);
 
-      case_data_rw_idx (outcase, EX_WT)->f = weight;
+      *case_num_rw_idx (outcase, EX_WT) = weight;
 
       es[v].cc += weight;
 
@@ -1148,8 +1148,8 @@ calculate_n (const void *aux1, void *aux2 UNUSED, void *user_data)
       for (reader = casereader_clone (es[v].sorted_reader);
            (c = casereader_read (reader)) != NULL; case_unref (c))
         {
-          const double val = case_data_idx (c, EX_VAL)->f;
-          double wt = case_data_idx (c, EX_WT)->f;
+          const double val = case_num_idx (c, EX_VAL);
+          double wt = case_num_idx (c, EX_WT);
 	  wt = var_force_valid_weight (examine->wv, wt, &warn);
 
           moments_pass_two (es[v].mom, val, wt);
diff --git a/src/language/stats/flip.c b/src/language/stats/flip.c
index 216c9d7921..993f8975a6 100644
--- a/src/language/stats/flip.c
+++ b/src/language/stats/flip.c
@@ -440,7 +440,7 @@ flip_casereader_read (struct casereader *reader, void *flip_)
           flip->error = true;
           return NULL;
         }
-      case_data_rw_idx (c, i + 1)->f = in;
+      *case_num_rw_idx (c, i + 1) = in;
     }
 
   flip->cases_read++;
diff --git a/src/language/stats/friedman.c b/src/language/stats/friedman.c
index 5d476fab2c..55e42489f4 100644
--- a/src/language/stats/friedman.c
+++ b/src/language/stats/friedman.c
@@ -123,7 +123,7 @@ friedman_execute (const struct dataset *ds,
       double prev_x = SYSMIS;
       int run_length = 0;
 
-      const double w = weight ? case_data (c, weight)->f: 1.0;
+      const double w = weight ? case_num (c, weight) : 1.0;
 
       fr.cc += w;
 
diff --git a/src/language/stats/glm.c b/src/language/stats/glm.c
index a689850270..2766279f2e 100644
--- a/src/language/stats/glm.c
+++ b/src/language/stats/glm.c
@@ -618,8 +618,7 @@ run_glm (struct glm_spec *cmd, struct casereader *input,
       double weight = dict_get_case_weight (dict, c, &warn_bad_weight);
 
       for (v = 0; v < cmd->n_dep_vars; ++v)
-	moments_pass_one (ws.totals, case_data (c, cmd->dep_vars[v])->f,
-			  weight);
+	moments_pass_one (ws.totals, case_num (c, cmd->dep_vars[v]), weight);
 
       covariance_accumulate_pass1 (cov, c);
     }
@@ -636,8 +635,7 @@ run_glm (struct glm_spec *cmd, struct casereader *input,
       double weight = dict_get_case_weight (dict, c, &warn_bad_weight);
 
       for (v = 0; v < cmd->n_dep_vars; ++v)
-	moments_pass_two (ws.totals, case_data (c, cmd->dep_vars[v])->f,
-			  weight);
+	moments_pass_two (ws.totals, case_num (c, cmd->dep_vars[v]), weight);
 
       covariance_accumulate_pass2 (cov, c);
     }
diff --git a/src/language/stats/graph.c b/src/language/stats/graph.c
index 147d654ac4..425fd24157 100644
--- a/src/language/stats/graph.c
+++ b/src/language/stats/graph.c
@@ -355,8 +355,8 @@ show_histogr (const struct graph *cmd, struct casereader *input)
 
   for (;(c = casereader_read (input)) != NULL; case_unref (c))
     {
-      const double x      = case_data_idx (c, HG_IDX_X)->f;
-      const double weight = case_data_idx (c, HG_IDX_WT)->f;
+      const double x      = case_num_idx (c, HG_IDX_X);
+      const double weight = case_num_idx (c, HG_IDX_WT);
       moments_pass_two (cmd->es[0].mom, x, weight);
       histogram_add (histogram, x, weight);
     }
@@ -489,7 +489,7 @@ run_barchart (struct graph *cmd, struct casereader *input)
 	{
 	  const double weight = dict_get_case_weight (cmd->dict,c,NULL);
 	  const double x = (cmd->n_dep_vars > 0)
-	    ? case_data (c, cmd->dep_vars[0])->f : SYSMIS;
+	    ? case_num (c, cmd->dep_vars[0]) : SYSMIS;
 
 	  cc += weight;
 
@@ -609,7 +609,7 @@ run_graph (struct graph *cmd, struct casereader *input)
       struct ccase *outcase = case_create (cmd->gr_proto);
       const double weight = dict_get_case_weight (cmd->dict,c,NULL);
       if (cmd->chart_type == CT_HISTOGRAM)
-	case_data_rw_idx (outcase, HG_IDX_WT)->f = weight;
+	*case_num_rw_idx (outcase, HG_IDX_WT) = weight;
       if (cmd->chart_type == CT_SCATTERPLOT && cmd->n_by_vars > 0)
 	value_copy (case_data_rw_idx (outcase, SP_IDX_BY),
 		    case_data (c, cmd->by_var[0]),
@@ -617,7 +617,7 @@ run_graph (struct graph *cmd, struct casereader *input)
       for(int v=0;v<cmd->n_dep_vars;v++)
 	{
 	  const struct variable *var = cmd->dep_vars[v];
-	  const double x = case_data (c, var)->f;
+	  const double x = case_num (c, var);
 
 	  if (var_is_value_missing (var, case_data (c, var), cmd->dep_excl))
 	    {
@@ -625,7 +625,7 @@ run_graph (struct graph *cmd, struct casereader *input)
 	      continue;
 	    }
 	  /* Magically v value fits to SP_IDX_X, SP_IDX_Y, HG_IDX_X */
-	  case_data_rw_idx (outcase, v)->f = x;
+	  *case_num_rw_idx (outcase, v) = x;
 
 	  if (x > cmd->es[v].maximum)
 	    cmd->es[v].maximum = x;
diff --git a/src/language/stats/jonckheere-terpstra.c b/src/language/stats/jonckheere-terpstra.c
index bc5c76f58e..7d654bbecb 100644
--- a/src/language/stats/jonckheere-terpstra.c
+++ b/src/language/stats/jonckheere-terpstra.c
@@ -101,16 +101,16 @@ u (const struct group_data *grp0, const struct group_data *grp1)
     {
       struct ccase *c1;
       struct casereader *r1 = casereader_clone (grp1->reader);
-      double x0 = case_data_idx (c0, 0)->f;
-      double cc0 = case_data_idx (c0, 1)->f;
+      double x0 = case_num_idx (c0, 0);
+      double cc0 = case_num_idx (c0, 1);
       double w0 = cc0 - prev_cc0;
 
       double prev_cc1 = 0;
 
       for (; (c1 = casereader_read (r1)); case_unref (c1))
         {
-          double x1 = case_data_idx (c1, 0)->f;
-          double cc1 = case_data_idx (c1, 1)->f;
+          double x1 = case_num_idx (c1, 0);
+          double cc1 = case_num_idx (c1, 1);
 
           if (x0 > x1)
             {
@@ -203,7 +203,7 @@ void variance_calculation (struct casereader *ir, const struct variable *var,
 
   for (; (c = casereader_read (r)); case_unref (c))
     {
-      double w = case_data_idx (c, w_idx)->f;
+      double w = case_num_idx (c, w_idx);
 
       for (i = 0; i < n; ++i)
         result[i] += f[i] (w);
@@ -295,12 +295,11 @@ jonckheere_terpstra_execute (const struct dataset *ds,
         for (; (c = casereader_read (group)); case_unref (c))
           {
             struct ccase *c_out = case_create (proto);
-            const union value *x = case_data (c, nst->vars[v]);
 
-            case_data_rw_idx (c_out, 0)->f = x->f;
+            *case_num_rw_idx (c_out, 0) = case_num (c, nst->vars[v]);
 
             cc += dict_get_case_weight (dict, c, &warn);
-            case_data_rw_idx (c_out, 1)->f = cc;
+            *case_num_rw_idx (c_out, 1) = cc;
             casewriter_write (writer, c_out);
           }
 
diff --git a/src/language/stats/kruskal-wallis.c b/src/language/stats/kruskal-wallis.c
index 061857d30e..62c49e4848 100644
--- a/src/language/stats/kruskal-wallis.c
+++ b/src/language/stats/kruskal-wallis.c
@@ -192,7 +192,7 @@ kruskal_wallis_execute (const struct dataset *ds,
 			   value_hash (&rank->group, group_var_width, 0));
 	    }
 
-	  rank->sum_of_ranks += case_data_idx (c, rank_idx)->f;
+	  rank->sum_of_ranks += case_num_idx (c, rank_idx);
 	  rank->n += dict_get_case_weight (dict, c, &warn);
 
 	  /* If this assertion fires, then either the data wasn't sorted or some other
diff --git a/src/language/stats/logistic.c b/src/language/stats/logistic.c
index dbf54c6b0b..d62390644d 100644
--- a/src/language/stats/logistic.c
+++ b/src/language/stats/logistic.c
@@ -227,7 +227,7 @@ predictor_value (const struct ccase *c,
 {
   /* Values of the scalar predictor variables */
   if (index < n_x)
-    return case_data (c, x[index])->f;
+    return case_num (c, x[index]);
 
   /* Coded values of categorical predictor variables (or interactions) */
   if (cats && index - n_x  < categoricals_df_total (cats))
diff --git a/src/language/stats/mann-whitney.c b/src/language/stats/mann-whitney.c
index b45f8f910e..2301cd13c5 100644
--- a/src/language/stats/mann-whitney.c
+++ b/src/language/stats/mann-whitney.c
@@ -127,7 +127,7 @@ mann_whitney_execute (const struct dataset *ds,
 	{
 	  const union value *group = case_data (c, nst->indep_var);
 	  const size_t group_var_width = var_get_width (nst->indep_var);
-	  const double rank = case_data_idx (c, rank_idx)->f;
+	  const double rank = case_num_idx (c, rank_idx);
 
 	  if (value_equal (group, &nst->val1, group_var_width))
 	    {
diff --git a/src/language/stats/means.c b/src/language/stats/means.c
index bb1cf59926..2235433fb9 100644
--- a/src/language/stats/means.c
+++ b/src/language/stats/means.c
@@ -939,7 +939,7 @@ service_cell_map (const struct means *means, const struct mtable *mt,
                                                               NULL);
                   stat_update *su = cell_spec[means->statistics[stat]].su;
                   su (cell->stat[stat + v * means->n_statistics], weight,
-		      case_data (c, dep_var)->f);
+		      case_num (c, dep_var));
                 }
             }
         }
diff --git a/src/language/stats/quick-cluster.c b/src/language/stats/quick-cluster.c
index 8b2432ac45..e3bb76e422 100644
--- a/src/language/stats/quick-cluster.c
+++ b/src/language/stats/quick-cluster.c
@@ -482,7 +482,7 @@ kmeans_cluster (struct Kmeans *kmeans, struct casereader *reader,
 		}
 
 	      long *n = gsl_vector_long_ptr (kmeans->num_elements_groups, group);
-	      *n += qc->wv ? case_data (c, qc->wv)->f : 1.0;
+	      *n += qc->wv ? case_num (c, qc->wv) : 1.0;
 	      kmeans->n++;
 
 	      for (j = 0; j < qc->n_vars; ++j)
@@ -491,7 +491,7 @@ kmeans_cluster (struct Kmeans *kmeans, struct casereader *reader,
 		  if (var_is_value_missing (qc->vars[j], val, qc->exclude))
 		    continue;
 		  double *x = gsl_matrix_ptr (kmeans->updated_centers, group, j);
-		  *x += val->f * (qc->wv ? case_data (c, qc->wv)->f : 1.0);
+		  *x += val->f * (qc->wv ? case_num (c, qc->wv) : 1.0);
 		}
 	    }
 
@@ -537,7 +537,7 @@ kmeans_cluster (struct Kmeans *kmeans, struct casereader *reader,
 	      }
 
 	    long *n = gsl_vector_long_ptr (kmeans->num_elements_groups, group);
-	    *n += qc->wv ? case_data (c, qc->wv)->f : 1.0;
+	    *n += qc->wv ? case_num (c, qc->wv) : 1.0;
 	    kmeans->n++;
 	  }
 	casereader_destroy (cs);
@@ -621,10 +621,10 @@ save_trans_func (void *aux, struct ccase **c, casenumber x UNUSED)
   *c = case_unshare (*c);
 
   if (std->CASE_IDX_MEMBERSHIP >= 0)
-    case_data_rw (*c, std->membership)->f = case_data_idx (ca, std->CASE_IDX_MEMBERSHIP)->f;
+    *case_num_rw (*c, std->membership) = case_num_idx (ca, std->CASE_IDX_MEMBERSHIP);
 
   if (std->CASE_IDX_DISTANCE >= 0)
-    case_data_rw (*c, std->distance)->f = case_data_idx (ca, std->CASE_IDX_DISTANCE)->f;
+    *case_num_rw (*c, std->distance) = case_num_idx (ca, std->CASE_IDX_DISTANCE);
 
   case_unref (ca);
 
@@ -708,10 +708,10 @@ quick_cluster_show_membership (struct Kmeans *kmeans,
 	/* Calculate the membership and distance values.  */
 	struct ccase *outc = case_create (proto);
 	if (qc->save_values & SAVE_MEMBERSHIP)
-	  case_data_rw_idx (outc, qc->save_trans_data->CASE_IDX_MEMBERSHIP)->f = cluster + 1;
+	  *case_num_rw_idx (outc, qc->save_trans_data->CASE_IDX_MEMBERSHIP) = cluster + 1;
 
 	if (qc->save_values & SAVE_DISTANCE)
-	  case_data_rw_idx (outc, qc->save_trans_data->CASE_IDX_DISTANCE)->f
+	  *case_num_rw_idx (outc, qc->save_trans_data->CASE_IDX_DISTANCE)
 	    = sqrt (dist_from_case (kmeans, c, qc, clust));
 
 	casewriter_write (qc->save_trans_data->writer, outc);
diff --git a/src/language/stats/rank.c b/src/language/stats/rank.c
index fe277c7de3..dc40a0954a 100644
--- a/src/language/stats/rank.c
+++ b/src/language/stats/rank.c
@@ -573,12 +573,12 @@ rank_sorted_file (struct casereader *input,
           size_t i;
 
           out_case = case_create (casewriter_get_proto (output));
-          case_data_rw_idx (out_case, 0)->f = case_num_idx (c, 1);
+          *case_num_rw_idx (out_case, 0) = case_num_idx (c, 1);
           for (i = 0; i < cmd->n_rs; ++i)
             {
               rank_function_t func = rank_func[cmd->rs[i].rfunc];
               double rank = func (cmd, tw, cc, cc_1, tie_group, w);
-              case_data_rw_idx (out_case, i + 1)->f = rank;
+              *case_num_rw_idx (out_case, i + 1) = rank;
             }
 
           casewriter_write (output, out_case);
@@ -928,7 +928,7 @@ rank_trns_proc (void *trns_, struct ccase **c, casenumber case_idx UNUSED)
             size_t i;
 
             for (i = 0; i < trns->n_funcs; i++)
-              case_data_rw (*c, iv->output_vars[i])->f
+              *case_num_rw (*c, iv->output_vars[i])
                 = case_num_idx (iv->current, i + 1);
             advance_ranking (iv);
             break;
diff --git a/src/language/stats/regression.c b/src/language/stats/regression.c
index 6fa114338e..7c98dba047 100644
--- a/src/language/stats/regression.c
+++ b/src/language/stats/regression.c
@@ -175,14 +175,14 @@ save_trans_func (void *aux, struct ccase **c, casenumber x UNUSED)
         {
           if (ws->pred_idx != -1)
             {
-              double pred = case_data_idx (in, ws->extras * k + ws->pred_idx)->f;
-              case_data_rw (*c, ws->predvars[k])->f = pred;
+              double pred = case_num_idx (in, ws->extras * k + ws->pred_idx);
+              *case_num_rw (*c, ws->predvars[k]) = pred;
             }
 
           if (ws->res_idx != -1)
             {
-              double resid = case_data_idx (in, ws->extras * k + ws->res_idx)->f;
-              case_data_rw (*c, ws->residvars[k])->f = resid;
+              double resid = case_num_idx (in, ws->extras * k + ws->res_idx);
+              *case_num_rw (*c, ws->residvars[k]) = resid;
             }
         }
       case_unref (in);
@@ -827,14 +827,14 @@ run_regression (const struct regression *cmd,
               if (cmd->pred)
                 {
                   double pred = linreg_predict (models[k], vals, n_indep);
-                  case_data_rw_idx (outc, k * ws->extras + ws->pred_idx)->f = pred;
+                  *case_num_rw_idx (outc, k * ws->extras + ws->pred_idx) = pred;
                 }
 
               if (cmd->resid)
                 {
-                  double obs = case_data (c, linreg_dep_var (models[k]))->f;
+                  double obs = case_num (c, linreg_dep_var (models[k]));
                   double res = linreg_residual (models[k], obs,  vals, n_indep);
-                  case_data_rw_idx (outc, k * ws->extras + ws->res_idx)->f = res;
+                  *case_num_rw_idx (outc, k * ws->extras + ws->res_idx) = res;
                 }
 	      free (vals);
 	      free (vars);
diff --git a/src/language/stats/reliability.c b/src/language/stats/reliability.c
index 615e108a78..86c1add760 100644
--- a/src/language/stats/reliability.c
+++ b/src/language/stats/reliability.c
@@ -426,11 +426,8 @@ append_sum (const struct ccase *c, casenumber n UNUSED, void *aux)
   double sum = 0;
   const struct cronbach *s = aux;
 
-  int v;
-  for (v = 0 ; v < s->n_items; ++v)
-    {
-      sum += case_data (c, s->items[v])->f;
-    }
+  for (int v = 0 ; v < s->n_items; ++v)
+    sum += case_num (c, s->items[v]);
 
   return sum;
 };
@@ -495,9 +492,9 @@ do_reliability (struct casereader *input, struct dataset *ds,
 	  struct cronbach *s = &rel->sc[si];
 
 	  for (i = 0 ; i < s->n_items ; ++i)
-	    moments1_add (s->m[i], case_data (c, s->items[i])->f, weight);
+	    moments1_add (s->m[i], case_num (c, s->items[i]), weight);
 
-	  moments1_add (s->total, case_data_idx (c, s->totals_idx)->f, weight);
+	  moments1_add (s->total, case_num_idx (c, s->totals_idx), weight);
 	}
     }
   casereader_destroy (input);
diff --git a/src/language/stats/roc.c b/src/language/stats/roc.c
index b3f8e91e47..1a4fcba657 100644
--- a/src/language/stats/roc.c
+++ b/src/language/stats/roc.c
@@ -336,9 +336,7 @@ dump_casereader (struct casereader *reader)
     {
       int i;
       for (i = 0 ; i < case_get_value_cnt (c); ++i)
-	{
-	  printf ("%g ", case_data_idx (c, i)->f);
-	}
+        printf ("%g ", case_num_idx (c, i));
       printf ("\n");
     }
 
@@ -358,7 +356,7 @@ match_positives (const struct ccase *c, void *aux)
 {
   struct cmd_roc *roc = aux;
   const struct variable *wv = dict_get_weight (roc->dict);
-  const double weight = wv ? case_data (c, wv)->f : 1.0;
+  const double weight = wv ? case_num (c, wv) : 1.0;
 
   const bool positive =
   (0 == value_compare_3way (case_data (c, roc->state_var), &roc->state_value,
@@ -428,7 +426,7 @@ accumulate_counts (struct casereader *input,
   for (; (cpc = casereader_read (input)); case_unref (cpc))
     {
       struct ccase *new_case;
-      const double cp = case_data_idx (cpc, ROC_CUTPOINT)->f;
+      const double cp = case_num_idx (cpc, ROC_CUTPOINT);
 
       assert (cp != SYSMIS);
 
@@ -438,10 +436,8 @@ accumulate_counts (struct casereader *input,
 
       new_case = case_clone (cpc);
 
-      if (pos_cond (result, cp))
-	case_data_rw_idx (new_case, true_index)->f += weight;
-      else
-	case_data_rw_idx (new_case, false_index)->f += weight;
+      int index = pos_cond (result, cp) ? true_index : false_index;
+      *case_num_rw_idx (new_case, index) += weight;
 
       prev_cp = cp;
 
@@ -509,8 +505,8 @@ process_group (const struct variable *var, struct casereader *reader,
       struct ccase *c2;
       struct casereader *r2 = casereader_clone (rclone);
 
-      const double weight1 = case_data_idx (c1, weight_idx)->f;
-      const double d1 = case_data (c1, var)->f;
+      const double weight1 = case_num_idx (c1, weight_idx);
+      const double d1 = case_num (c1, var);
       double n_eq = 0.0;
       double n_pred = 0.0;
 
@@ -522,8 +518,8 @@ process_group (const struct variable *var, struct casereader *reader,
 
       for (; (c2 = casereader_read (r2)); case_unref (c2))
 	{
-	  const double d2 = case_data (c2, var)->f;
-	  const double weight2 = case_data_idx (c2, weight_idx)->f;
+	  const double d2 = case_num (c2, var);
+	  const double weight2 = case_num_idx (c2, weight_idx);
 
 	  if (d1 == d2)
 	    {
@@ -536,9 +532,9 @@ process_group (const struct variable *var, struct casereader *reader,
 	    }
 	}
 
-      case_data_rw_idx (new_case, VALUE)->f = d1;
-      case_data_rw_idx (new_case, N_EQ)->f = n_eq;
-      case_data_rw_idx (new_case, N_PRED)->f = n_pred;
+      *case_num_rw_idx (new_case, VALUE) = d1;
+      *case_num_rw_idx (new_case, N_EQ) = n_eq;
+      *case_num_rw_idx (new_case, N_PRED) = n_pred;
 
       casewriter_write (wtr, new_case);
 
@@ -624,11 +620,11 @@ append_cutpoint (struct casewriter *writer, double cutpoint)
 {
   struct ccase *cc = case_create (casewriter_get_proto (writer));
 
-  case_data_rw_idx (cc, ROC_CUTPOINT)->f = cutpoint;
-  case_data_rw_idx (cc, ROC_TP)->f = 0;
-  case_data_rw_idx (cc, ROC_FN)->f = 0;
-  case_data_rw_idx (cc, ROC_TN)->f = 0;
-  case_data_rw_idx (cc, ROC_FP)->f = 0;
+  *case_num_rw_idx (cc, ROC_CUTPOINT) = cutpoint;
+  *case_num_rw_idx (cc, ROC_TP) = 0;
+  *case_num_rw_idx (cc, ROC_FN) = 0;
+  *case_num_rw_idx (cc, ROC_TN) = 0;
+  *case_num_rw_idx (cc, ROC_FP) = 0;
 
   casewriter_write (writer, cc);
 }
@@ -791,18 +787,18 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 	{
 	  struct ccase *pos_case = case_create (n_proto);
 	  struct ccase *cneg;
-	  const double jpos = case_data_idx (cpos, VALUE)->f;
+	  const double jpos = case_num_idx (cpos, VALUE);
 
 	  while ((cneg = casereader_read (n_neg_reader)))
 	    {
 	      struct ccase *nc = case_create (n_proto);
 
-	      const double jneg = case_data_idx (cneg, VALUE)->f;
+	      const double jneg = case_num_idx (cneg, VALUE);
 
-	      case_data_rw_idx (nc, VALUE)->f = jneg;
-	      case_data_rw_idx (nc, N_POS_EQ)->f = 0;
+	      *case_num_rw_idx (nc, VALUE) = jneg;
+	      *case_num_rw_idx (nc, N_POS_EQ) = 0;
 
-	      case_data_rw_idx (nc, N_POS_GT)->f = SYSMIS;
+	      *case_num_rw_idx (nc, N_POS_GT) = SYSMIS;
 
 	      *case_data_rw_idx (nc, N_NEG_EQ) = *case_data_idx (cneg, N_EQ);
 	      *case_data_rw_idx (nc, N_NEG_LT) = *case_data_idx (cneg, N_PRED);
@@ -814,11 +810,11 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 		break;
 	    }
 
-	  case_data_rw_idx (pos_case, VALUE)->f = jpos;
+	  *case_num_rw_idx (pos_case, VALUE) = jpos;
 	  *case_data_rw_idx (pos_case, N_POS_EQ) = *case_data_idx (cpos, N_EQ);
 	  *case_data_rw_idx (pos_case, N_POS_GT) = *case_data_idx (cpos, N_PRED);
-	  case_data_rw_idx (pos_case, N_NEG_EQ)->f = 0;
-	  case_data_rw_idx (pos_case, N_NEG_LT)->f = SYSMIS;
+	  *case_num_rw_idx (pos_case, N_NEG_EQ) = 0;
+	  *case_num_rw_idx (pos_case, N_NEG_LT) = SYSMIS;
 
 	  casewriter_write (w, pos_case);
 	}
@@ -840,13 +836,13 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 
 	for (; (c = casereader_read (r)); case_unref (c))
 	  {
-	    double n_pos_gt = case_data_idx (c, N_POS_GT)->f;
+	    double n_pos_gt = case_num_idx (c, N_POS_GT);
 	    struct ccase *nc = case_clone (c);
 
 	    if (n_pos_gt == SYSMIS)
 	      {
 		n_pos_gt = prev_pos_gt;
-		case_data_rw_idx (nc, N_POS_GT)->f = n_pos_gt;
+		*case_num_rw_idx (nc, N_POS_GT) = n_pos_gt;
 	      }
 
 	    casewriter_write (w, nc);
@@ -865,13 +861,13 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 
 	for (; (c = casereader_read (r)); case_unref (c))
 	  {
-	    double n_neg_lt = case_data_idx (c, N_NEG_LT)->f;
+	    double n_neg_lt = case_num_idx (c, N_NEG_LT);
 	    struct ccase *nc = case_clone (c);
 
 	    if (n_neg_lt == SYSMIS)
 	      {
 		n_neg_lt = prev_neg_lt;
-		case_data_rw_idx (nc, N_NEG_LT)->f = n_neg_lt;
+		*case_num_rw_idx (nc, N_NEG_LT) = n_neg_lt;
 	      }
 
 	    casewriter_write (w, nc);
@@ -888,28 +884,28 @@ do_roc (struct cmd_roc *roc, struct casereader *reader, struct dictionary *dict)
 	  {
 	    struct ccase *next_case = casereader_peek (r, 0);
 
-	    const double j = case_data_idx (c, VALUE)->f;
-	    double n_pos_eq = case_data_idx (c, N_POS_EQ)->f;
-	    double n_pos_gt = case_data_idx (c, N_POS_GT)->f;
-	    double n_neg_eq = case_data_idx (c, N_NEG_EQ)->f;
-	    double n_neg_lt = case_data_idx (c, N_NEG_LT)->f;
+	    const double j = case_num_idx (c, VALUE);
+	    double n_pos_eq = case_num_idx (c, N_POS_EQ);
+	    double n_pos_gt = case_num_idx (c, N_POS_GT);
+	    double n_neg_eq = case_num_idx (c, N_NEG_EQ);
+	    double n_neg_lt = case_num_idx (c, N_NEG_LT);
 
-	    if (prev_case && j == case_data_idx (prev_case, VALUE)->f)
+	    if (prev_case && j == case_num_idx (prev_case, VALUE))
 	      {
-		if (0 ==  case_data_idx (c, N_POS_EQ)->f)
+		if (0 ==  case_num_idx (c, N_POS_EQ))
 		  {
-		    n_pos_eq = case_data_idx (prev_case, N_POS_EQ)->f;
-		    n_pos_gt = case_data_idx (prev_case, N_POS_GT)->f;
+		    n_pos_eq = case_num_idx (prev_case, N_POS_EQ);
+		    n_pos_gt = case_num_idx (prev_case, N_POS_GT);
 		  }
 
-		if (0 ==  case_data_idx (c, N_NEG_EQ)->f)
+		if (0 ==  case_num_idx (c, N_NEG_EQ))
 		  {
-		    n_neg_eq = case_data_idx (prev_case, N_NEG_EQ)->f;
-		    n_neg_lt = case_data_idx (prev_case, N_NEG_LT)->f;
+		    n_neg_eq = case_num_idx (prev_case, N_NEG_EQ);
+		    n_neg_lt = case_num_idx (prev_case, N_NEG_LT);
 		  }
 	      }
 
-	    if (NULL == next_case || j != case_data_idx (next_case, VALUE)->f)
+	    if (NULL == next_case || j != case_num_idx (next_case, VALUE))
 	      {
 		rs[i].auc += n_pos_gt * n_neg_eq + (n_pos_eq * n_neg_eq) / 2.0;
 
@@ -1087,11 +1083,11 @@ show_coords (struct roc_state *rs, const struct cmd_roc *roc)
       int coord_idx = 0;
       for (; (cc = casereader_read (r)) != NULL; case_unref (cc))
 	{
-	  const double se = case_data_idx (cc, ROC_TP)->f /
-	    (case_data_idx (cc, ROC_TP)->f + case_data_idx (cc, ROC_FN)->f);
+	  const double se = case_num_idx (cc, ROC_TP) /
+	    (case_num_idx (cc, ROC_TP) + case_num_idx (cc, ROC_FN));
 
-	  const double sp = case_data_idx (cc, ROC_TN)->f /
-	    (case_data_idx (cc, ROC_TN)->f + case_data_idx (cc, ROC_FP)->f);
+	  const double sp = case_num_idx (cc, ROC_TN) /
+	    (case_num_idx (cc, ROC_TN) + case_num_idx (cc, ROC_FP));
 
           if (coord_idx >= n_coords)
             {
diff --git a/src/language/stats/runs.c b/src/language/stats/runs.c
index d12bd0d2b5..9ef4c64add 100644
--- a/src/language/stats/runs.c
+++ b/src/language/stats/runs.c
@@ -143,7 +143,7 @@ runs_execute (const struct dataset *ds,
 		struct ccase *c;
 		for (; (c = casereader_read (group)); case_unref (c))
 		  {
-		    const double w = weight ? case_data (c, weight)->f: 1.0;
+		    const double w = weight ? case_num (c, weight) : 1.0;
 		    const union value *val = case_data (c, var);
 		    if (var_is_value_missing (var, val, exclude))
 		      continue;
@@ -191,7 +191,7 @@ runs_execute (const struct dataset *ds,
  	    for (; (c = casereader_read (reader));)
 	      {
 		const union value *val = case_data (c, var);
-		const double w = weight ? case_data (c, weight)->f: 1.0;
+		const double w = weight ? case_num (c, weight) : 1.0;
 		if (var_is_value_missing (var, val, exclude))
 		  {
 		    case_unref (c);
@@ -224,7 +224,7 @@ runs_execute (const struct dataset *ds,
 	struct casereader *reader = casereader_clone (input);
 	for (; (c = casereader_read (reader)); case_unref (c))
 	  {
-	    const double w = weight ? case_data (c, weight)->f: 1.0;
+	    const double w = weight ? case_num (c, weight) : 1.0;
 	    for (v = 0; v < otp->n_vars; ++v)
 	      {
 		const struct variable *var = otp->vars[v];
@@ -260,7 +260,7 @@ runs_execute (const struct dataset *ds,
 
   for (; (c = casereader_read (input)); case_unref (c))
     {
-      const double w = weight ? case_data (c, weight)->f: 1.0;
+      const double w = weight ? case_num (c, weight) : 1.0;
 
       for (v = 0; v < otp->n_vars; ++v)
 	{
diff --git a/src/language/stats/wilcoxon.c b/src/language/stats/wilcoxon.c
index 622db2292e..775e63ef4a 100644
--- a/src/language/stats/wilcoxon.c
+++ b/src/language/stats/wilcoxon.c
@@ -49,7 +49,7 @@ append_difference (const struct ccase *c, casenumber n UNUSED, void *aux)
 {
   const variable_pair *vp = aux;
 
-  return case_data (c, (*vp)[0])->f - case_data (c, (*vp)[1])->f;
+  return case_num (c, (*vp)[0]) - case_num (c, (*vp)[1]);
 }
 
 static void show_ranks_box (const struct wilcoxon_state *,
@@ -124,19 +124,14 @@ wilcoxon_execute (const struct dataset *ds,
 	  double d = append_difference (c, 0, vp);
 
 	  if (d > 0)
-	    {
-	      case_data_rw (output, ws[i].sign)->f = 1.0;
-
-	    }
+            *case_num_rw (output, ws[i].sign) = 1.0;
 	  else if (d < 0)
-	    {
-	      case_data_rw (output, ws[i].sign)->f = -1.0;
-	    }
+            *case_num_rw (output, ws[i].sign) = -1.0;
 	  else
 	    {
 	      double w = 1.0;
 	      if (weight)
-		w = case_data (c, weight)->f;
+		w = case_num (c, weight);
 
 	      /* Central point values should be dropped */
 	      ws[i].n_zeros += w;
@@ -144,10 +139,10 @@ wilcoxon_execute (const struct dataset *ds,
               continue;
 	    }
 
-	  case_data_rw (output, ws[i].absdiff)->f = fabs (d);
+	  *case_num_rw (output, ws[i].absdiff) = fabs (d);
 
 	  if (weight)
-	   case_data_rw (output, weightx)->f = case_data (c, weight)->f;
+	   *case_num_rw (output, weightx) = case_num (c, weight);
 
 	  casewriter_write (writer, output);
 	}
@@ -169,11 +164,9 @@ wilcoxon_execute (const struct dataset *ds,
 
       for (; (c = casereader_read (rr)) != NULL; case_unref (c))
 	{
-	  double sign = case_data (c, ws[i].sign)->f;
-	  double rank = case_data_idx (c, weight ? 3 : 2)->f;
-	  double w = 1.0;
-	  if (weight)
-	    w = case_data (c, weightx)->f;
+	  double sign = case_num (c, ws[i].sign);
+	  double rank = case_num_idx (c, weight ? 3 : 2);
+	  double w = weight ? case_num (c, weightx) : 1.0;
 
 	  if (sign > 0)
 	    {
diff --git a/src/language/xforms/compute.c b/src/language/xforms/compute.c
index aa81729827..8e0ce85d61 100644
--- a/src/language/xforms/compute.c
+++ b/src/language/xforms/compute.c
@@ -133,7 +133,7 @@ compute_num (void *compute_, struct ccase **c, casenumber case_num)
       || expr_evaluate_num (compute->test, *c, case_num) == 1.0)
     {
       *c = case_unshare (*c);
-      case_data_rw (*c, compute->variable)->f
+      *case_num_rw (*c, compute->variable)
         = expr_evaluate_num (compute->rvalue, *c, case_num);
     }
 
@@ -170,7 +170,7 @@ compute_num_vec (void *compute_, struct ccase **c, casenumber case_num)
         }
 
       *c = case_unshare (*c);
-      case_data_rw (*c, vector_get_var (compute->vector, rindx - 1))->f
+      *case_num_rw (*c, vector_get_var (compute->vector, rindx - 1))
         = expr_evaluate_num (compute->rvalue, *c, case_num);
     }
 
diff --git a/src/language/xforms/count.c b/src/language/xforms/count.c
index bf3c9e9ac5..1f35045290 100644
--- a/src/language/xforms/count.c
+++ b/src/language/xforms/count.c
@@ -356,7 +356,7 @@ count_trns_proc (void *trns_, struct ccase **c,
 	  counter += count_numeric (crit, *c);
 	else
 	  counter += count_string (crit, *c);
-      case_data_rw (*c, dv->var)->f = counter;
+      *case_num_rw (*c, dv->var) = counter;
     }
   return TRNS_CONTINUE;
 }
diff --git a/src/language/xforms/recode.c b/src/language/xforms/recode.c
index b5e0e3fcde..f1834cc8a5 100644
--- a/src/language/xforms/recode.c
+++ b/src/language/xforms/recode.c
@@ -710,7 +710,7 @@ recode_trns_proc (void *trns_, struct ccase **c, casenumber case_idx UNUSED)
 
       if (trns->dst_type == VAL_NUMERIC)
         {
-          double *dst = &case_data_rw (*c, dst_var)->f;
+          double *dst = case_num_rw (*c, dst_var);
           if (out != NULL)
             *dst = !out->copy_input ? out->value.f : case_num (*c, src_var);
           else if (trns->src_vars != trns->dst_vars)
diff --git a/src/math/box-whisker.c b/src/math/box-whisker.c
index 3e501ccaeb..344561a6fd 100644
--- a/src/math/box-whisker.c
+++ b/src/math/box-whisker.c
@@ -105,7 +105,7 @@ acc (struct statistic *s, const struct ccase *cx,
     {
       ds_put_format (&o->label,
                      "%ld",
-                     (casenumber) case_data_idx (cx, bw->id_idx)->f);
+                     (casenumber) case_num_idx (cx, bw->id_idx));
     }
 
   ll_push_head (&bw->outliers, &o->ll);
diff --git a/src/math/categoricals.c b/src/math/categoricals.c
index 4e6d8dad7a..28d51a9dd7 100644
--- a/src/math/categoricals.c
+++ b/src/math/categoricals.c
@@ -367,7 +367,7 @@ categoricals_update (struct categoricals *cat, const struct ccase *c)
   assert (!cat->cat_to_iact);
 
   double weight;
-  weight = cat->wv ? case_data (c, cat->wv)->f : 1.0;
+  weight = cat->wv ? case_num (c, cat->wv) : 1.0;
   weight = var_force_valid_weight (cat->wv, weight, NULL);
 
   /* Update the frequency table for each variable. */
diff --git a/src/math/covariance.c b/src/math/covariance.c
index cd8ec2ffd1..44787c679a 100644
--- a/src/math/covariance.c
+++ b/src/math/covariance.c
@@ -301,7 +301,7 @@ void
 covariance_accumulate_pass1 (struct covariance *cov, const struct ccase *c)
 {
   size_t i, j, m;
-  const double weight = cov->wv ? case_data (c, cov->wv)->f : 1.0;
+  const double weight = cov->wv ? case_num (c, cov->wv) : 1.0;
 
   assert (cov->passes == 2);
   if (!cov->pass_one_first_case_seen)
@@ -346,7 +346,7 @@ void
 covariance_accumulate_pass2 (struct covariance *cov, const struct ccase *c)
 {
   size_t i, j;
-  const double weight = cov->wv ? case_data (c, cov->wv)->f : 1.0;
+  const double weight = cov->wv ? case_num (c, cov->wv) : 1.0;
 
   assert (cov->passes == 2);
   assert (cov->state >= 1);
@@ -464,7 +464,7 @@ void
 covariance_accumulate (struct covariance *cov, const struct ccase *c)
 {
   size_t i, j, m;
-  const double weight = cov->wv ? case_data (c, cov->wv)->f : 1.0;
+  const double weight = cov->wv ? case_num (c, cov->wv) : 1.0;
 
   assert (cov->passes == 1);
 
diff --git a/src/math/np.c b/src/math/np.c
index dd197f9c6d..8b7d09e7d3 100644
--- a/src/math/np.c
+++ b/src/math/np.c
@@ -63,9 +63,9 @@ acc (struct statistic *s, const struct ccase *cx UNUSED,
   minimize (&np->y_min, y);
 
   cp = case_create (casewriter_get_proto (np->writer));
-  case_data_rw_idx (cp, NP_IDX_Y)->f = y;
-  case_data_rw_idx (cp, NP_IDX_NS)->f = ns;
-  case_data_rw_idx (cp, NP_IDX_DNS)->f = dns;
+  *case_num_rw_idx (cp, NP_IDX_Y) = y;
+  *case_num_rw_idx (cp, NP_IDX_NS) = ns;
+  *case_num_rw_idx (cp, NP_IDX_DNS) = dns;
   casewriter_write (np->writer, cp);
 
   np->prev_cc = cc;
diff --git a/src/math/order-stats.c b/src/math/order-stats.c
index 59edc92fc8..1a4aef891a 100644
--- a/src/math/order-stats.c
+++ b/src/math/order-stats.c
@@ -125,8 +125,8 @@ order_stats_accumulate_idx (struct order_stats **os, size_t nos,
 
   for (; (cx = casereader_read (reader)) != NULL; case_unref (cx))
     {
-      const double weight = (wt_idx == -1) ? 1.0 : case_data_idx (cx, wt_idx)->f;
-      const double this_value = case_data_idx (cx, val_idx)->f;
+      const double weight = wt_idx == -1 ? 1.0 : case_num_idx (cx, wt_idx);
+      const double this_value = case_num_idx (cx, val_idx);
 
       /* The casereader MUST be sorted */
       assert (this_value >= prev_value);
diff --git a/src/output/charts/np-plot-cairo.c b/src/output/charts/np-plot-cairo.c
index ae866831f6..f74572d0c8 100644
--- a/src/output/charts/np-plot-cairo.c
+++ b/src/output/charts/np-plot-cairo.c
@@ -48,8 +48,8 @@ np_plot_chart_draw (const struct chart *chart, cairo_t *cr,
   data = casereader_clone (npp->data);
   for (; (c = casereader_read (data)) != NULL; case_unref (c))
     xrchart_datum (cr, geom, 0,
-                 case_data_idx (c, NP_IDX_Y)->f,
-                 case_data_idx (c, NP_IDX_NS)->f);
+                   case_num_idx (c, NP_IDX_Y),
+                   case_num_idx (c, NP_IDX_NS));
   casereader_destroy (data);
 
   xrchart_line (cr, geom, npp->slope, npp->intercept,
@@ -74,8 +74,8 @@ dnp_plot_chart_draw (const struct chart *chart, cairo_t *cr,
 
   data = casereader_clone (dnpp->data);
   for (; (c = casereader_read (data)) != NULL; case_unref (c))
-    xrchart_datum (cr, geom, 0, case_data_idx (c, NP_IDX_Y)->f,
-                   case_data_idx (c, NP_IDX_DNS)->f);
+    xrchart_datum (cr, geom, 0, case_num_idx (c, NP_IDX_Y),
+                   case_num_idx (c, NP_IDX_DNS));
   casereader_destroy (data);
 
   xrchart_line (cr, geom, 0, 0, dnpp->y_min, dnpp->y_max, XRCHART_DIM_X);
diff --git a/src/output/charts/roc-chart-cairo.c b/src/output/charts/roc-chart-cairo.c
index 910d6152f0..04e37405f1 100644
--- a/src/output/charts/roc-chart-cairo.c
+++ b/src/output/charts/roc-chart-cairo.c
@@ -58,11 +58,11 @@ xrchart_draw_roc (const struct chart *chart, cairo_t *cr,
       xrchart_vector_start (cr, geom, rv->name);
       for (; (cc = casereader_read (r)) != NULL; case_unref (cc))
 	{
-	  double se = case_data_idx (cc, ROC_TP)->f;
-	  double sp = case_data_idx (cc, ROC_TN)->f;
+	  double se = case_num_idx (cc, ROC_TP);
+	  double sp = case_num_idx (cc, ROC_TN);
 
-	  se /= case_data_idx (cc, ROC_FN)->f + case_data_idx (cc, ROC_TP)->f ;
-	  sp /= case_data_idx (cc, ROC_TN)->f + case_data_idx (cc, ROC_FP)->f ;
+	  se /= case_num_idx (cc, ROC_FN) + case_num_idx (cc, ROC_TP);
+	  sp /= case_num_idx (cc, ROC_TN) + case_num_idx (cc, ROC_FP);
 
 	  xrchart_vector (cr, geom, 1 - sp, se);
 	}
diff --git a/src/output/charts/scatterplot-cairo.c b/src/output/charts/scatterplot-cairo.c
index 17307497c7..f03d33bc16 100644
--- a/src/output/charts/scatterplot-cairo.c
+++ b/src/output/charts/scatterplot-cairo.c
@@ -101,8 +101,8 @@ xrchart_draw_scatterplot (const struct chart *chart, cairo_t *cr,
                             colour->blue / 255.0);
 
       xrchart_datum (cr, geom, 0,
-		     case_data_idx (c, SP_IDX_X)->f,
-		     case_data_idx (c, SP_IDX_Y)->f);
+		     case_num_idx (c, SP_IDX_X),
+		     case_num_idx (c, SP_IDX_Y));
     }
   casereader_destroy (data);
   cairo_restore (cr);
-- 
2.30.2