← SASnRRetain last non-missing value

Introduction

Last Observation Carried Forward (LOCF) is a common imputation: when a visit value is missing, substitute the most recent non-missing value from the same subject.
LOCF lets downstream summaries treat the visit as if it had the carried value, and keeps the full row count of the original dataset.
SAS does this with a DATA step that RETAINs a helper variable and updates it only on non-missing rows.
Tidyverse uses group_by(usubjid) %>% fill(score, .direction = "down") to propagate non-NA values forward within each group.
Base R uses ave() with a small loop that walks each subject's vector and replaces NAs with the last seen non-NA value.
This lesson keeps an orig_score column as a snapshot so we can see where the fill actually happened.

Retain last non-missing value

SAS (Base SAS)+

*=============================================================================;
* Create the input dataset;
*=============================================================================;

data lnms;
    input usubjid visitnum score;
    datalines;
101 1 20
101 2 .
101 3 30
102 1 90
102 2 10
102 3 .
102 4 .
;
run;

*=============================================================================;
* Sort the dataset by usubjid and visitnum;
*=============================================================================;
proc sort data=lnms;
    by usubjid visitnum;
run;

*=============================================================================;
* Retain last non-missing score;
*=============================================================================;
data lnms01;
    set lnms;
    by usubjid visitnum;

    retain last_score;
    * Store the original score;
    orig_score = score;

    * Update the last non-missing score if present;
    if not missing(score) then last_score = score;

    * If missing, retain the previous value;
    if missing(score) then score = last_score;
run;

To carry the most recent non-missing score forward until a new observed value appears, we use RETAIN together with a missing() check.
We start by sorting the dataset by subject and visit — SAS needs the BY order so that forward-fill means the same thing on every row.
retain last_score; keeps last_score alive across rows instead of resetting to missing at each iteration.
We snapshot the incoming value into orig_score first so we can always see what was there before the fill.
When score is non-missing, we update last_score with it. When it is missing, we replace score with the retained last_score — the classic "LOCF" (Last Observation Carried Forward) step.
After running, we confirm that missing scores have been replaced with the most recent prior non-missing score for the same subject, and orig_score still shows the original NAs.

R (tidyverse)+

#==============================================================================;
#Retain last non-missing score;
#==============================================================================;

lnms <- tribble(
  ~usubjid,~visitnum,~score,
  101,1,20,
  101,2,NA,
  101,3,30,
  102,1,90,
  102,2,10,
  102,3,NA,
  102,4,NA
)

lnms01 <- lnms %>% 
  mutate(orig_score=score) %>% 
  arrange(usubjid,visitnum) %>%
  group_by(usubjid) %>% 
  fill(score,.direction="down")

To do LOCF in tidyverse, we group by subject, sort by visit, and use fill() to push values downward over missing positions.
We snapshot the incoming score into orig_score before the fill so the original NAs remain visible for audit.
arrange(usubjid, visitnum) is the tidyverse analogue of PROC SORT BY usubjid visitnum.
group_by(usubjid) scopes the fill to each subject — we never carry a value from one subject onto another.
fill(score, .direction = "down") walks each group top-to-bottom and replaces every NA in score with the most recent prior non-NA value. Same shape as the SAS retain + conditional assignment.
After running, we confirm that lnms01$score has no NAs within a subject where a prior value existed, and that orig_score still marks where the fills happened.

Happy learning!

Search lessons

Introduction

Retain last non-missing value