1

I have the below nested list of dates. I would need to unlist and then to get unique list of dates starting from the earliest date to the latest date. 

> str(datetemp)
List of 3
 $ FCX : Date[1:5747], format: "1995-07-10" "1995-07-11" "1995-07-12" "1995-07-13" ...
 $ MAT : Date[1:9164], format: "1982-01-04" "1982-01-05" "1982-01-06" "1982-01-07" ...
 $ MSFT: Date[1:8104], format: "1986-03-13" "1986-03-14" "1986-03-17" "1986-03-18" ...

The below strip the date class and return a list of numeric.

datetemp <- sort(unique(unlist(datetemp)))

I googled and read that unlist will strip the date class and return as numeric and some examples show do.call on a list of dates.

I am new to R and would appreciate if anyone could show me how I can apply do.call to nested list to get the required output.

Thank you.

Yi Wen Edwin Ang
  • 45
  • 1
  • 7
  • It's an annoying situation, but you can coerce back to Date class if you specify the origin (i.e. [the Unix epoch](https://en.wikipedia.org/wiki/Unix_time)): `as.Date(unlist(datetemp), origin = "1970-01-01")` The harder to explain but technically better approach is to use `do.call` to use `datetemp` as parameters for `c`: `do.call(c, datetemp)` – alistaire May 07 '18 at 21:09

2 Answers2

2

One option is to coerce back to the Date class after unlist drops it. To do so, you'll need to specify the origin from which the integers are counted, which is the Unix epoch, i.e. 1970-01-01.

datetemp <- list(FCX = structure(c(9321, 9322, 9323, 9324), class = "Date"), 
                 MAT = structure(c(4386, 4387, 4388, 4389), class = "Date"), 
                 MSFT = structure(c(5915, 5916, 5919, 5920), class = "Date"))

datetemp2 <- as.Date(unlist(datetemp), origin = "1970-01-01")
datetemp2
#>         FCX1         FCX2         FCX3         FCX4         MAT1 
#> "1995-07-10" "1995-07-11" "1995-07-12" "1995-07-13" "1982-01-04" 
#>         MAT2         MAT3         MAT4        MSFT1        MSFT2 
#> "1982-01-05" "1982-01-06" "1982-01-07" "1986-03-13" "1986-03-14" 
#>        MSFT3        MSFT4 
#> "1986-03-17" "1986-03-18"

A better approach is to use do.call, which splices a list in as the parameters of a call and evaluates it, so if you use do.call(c, list(1, 2)), it effectively calls c(1, 2).

datetemp3 <- do.call(c, datetemp)
datetemp3
#>         FCX1         FCX2         FCX3         FCX4         MAT1 
#> "1995-07-10" "1995-07-11" "1995-07-12" "1995-07-13" "1982-01-04" 
#>         MAT2         MAT3         MAT4        MSFT1        MSFT2 
#> "1982-01-05" "1982-01-06" "1982-01-07" "1986-03-13" "1986-03-14" 
#>        MSFT3        MSFT4 
#> "1986-03-17" "1986-03-18"

Sorting and dropping duplicates drops names, which is probably good:

unique(sort(datetemp3))
#>  [1] "1982-01-04" "1982-01-05" "1982-01-06" "1982-01-07" "1986-03-13"
#>  [6] "1986-03-14" "1986-03-17" "1986-03-18" "1995-07-10" "1995-07-11"
#> [11] "1995-07-12" "1995-07-13"
alistaire
  • 42,459
  • 4
  • 77
  • 117
  • 1
    `unlist(datetemp) %>% \`class<-\`(class(datetemp[[1]])))` allows you to avoid having to remember what the Unix epoch is. Doesn't really matter since `do.call` is the better approach anyway. – IceCreamToucan May 07 '18 at 21:21
  • 1
    Good call. It's easier to read without piping in this case, though: `datetemp2 <- unlist(datetemp); class(datetemp2) <- class(datetemp[[1]])` – alistaire May 07 '18 at 21:27
1

You can flatten the list with do.call(c, ...), while keeping the date type.

ll <- lapply(7:9, function(x) as.Date(sample(7000:7020, x), origin="1970-01-01"))

unique(do.call(c, ll))
AkselA
  • 8,153
  • 2
  • 21
  • 34