04_lists-and-attributes.Rmd

# Lists and Attributes

## Converting between Vector Types {-}
- Use `as.logical()`, `as.numeric()` and `as.character()` 
- `TRUE` and `FALSE` become numeric `1` and `0` when cast into numeric form.
- Any numeric other than `0`, `NA` and `NaN` becomes `TRUE` when cast into logical form. 

## Converting between Vector Types {-}
Some functions expect vectors of a certain type and apply type coercion to the input automatically, e.g.:

```{r}
sum(TRUE + FALSE + TRUE)
```

## Exercise 4-1 {-}

```{r}
p <- runif(1000, 0, 1)
y <- as.logical(rbinom(1000, 1, .5))

cross_entropy_loss_2 <- -mean(y * log(p) + (1-y)*log(1-p))
```

## Exercise 4-6 {-}

- `c(TRUE, FALSE)*1:10` is equal to `c(0,1)*1:10`
- `sum(as.logical(x))` computes the number of non-zero elements in the vector.
- No, for instance `as.numeric(as.character(FALSE))` returns a different value than `as.numeric(FALSE)`. 

## Exercise 4-6 {-}
- For... 
- `as.logical(x+y)`, uses the logic of TRUE + FALSE = TRUE 
- `as.logical(x*y)`, uses the logic of TRUE * FALSE = FALSE 
- `as.logical(1 - x)`, is the inverse of x
- `as.logical(x!=y)`, returns true if x and y have the same different values.

## Exercise 4-6 {-}
```{r}
x <- sample(c(TRUE, FALSE), 10, replace = TRUE)
y <- sample(c(TRUE, FALSE), 10, replace = TRUE)

x
y
print(as.logical(x+y))
```
## Exercise 4-6 {-}

```{r}
x
y
print(as.logical(x*y))
```
## Exercise 4-6 {-}
```{r}
x
y
print(as.logical(1-x))
```
## Exercise 4-6 {-}
```{r}
x
y
print(as.logical(x!=y))
```

## Exercise 4-6 {-}

- `cummin(x)` and `cummin(!x)` can be used to test if any 'x' is `TRUE` or `FALSE`

- `cummax(x)` and `cummax(!x)` can be used to test if any 'x' is `TRUE` or `FALSE`

## Exercise 4-6 {-}
- `cumsum(x)` and `cumsum(!x)` can be used to test if any 'x' is `TRUE` or `FALSE`

- `cumprod(x)` and `cumprod(!x)` can be used to test if any 'x' is `TRUE` or `FALSE`

- In each case, the logical elements are automatically coerced into zeroes and ones. 

- Does this use of cumsum(), etc. have any practical use vs. using `isTrue(x)` or `TRUE %in% x`, etc?

## Lists {-}

```{r}
list(1:3, 4, c(TRUE, FALSE, NA, TRUE), "and so forth")
```
## Lists {-}

```{r}
c(list(1), list(2), list(3))

```

## Lists  {-}

```{r}
as.list(c(1, 2, 3))
```
## Lists {-}

```{r}
unlist(list(list(1, 2), list(3, list(4:8)), 9))

# coerces output to most general data type
unlist(list(list(1, 2), list(3, list(4:8)), "spam"))
```
## Lists {-}
- `NULL` can be used as a placeholder in lists but not in vectors
```{r}
list(NULL, NULL, month.name)

# vs. 

c(1, NA, 3, NULL, 5)
```
## Lists {-}
- What do we use lists for?
- Data frames
- Non tabular data with different types
- "Split Apply Combine" Workflows (Wickham 2011)
- What else?

## Attributes {-}
- Attributes can be created using `structure()`
- Generally, they do not change the function of the object
```{r}
x_simple <- 1:10
x <- structure(
    x_simple,  # the object to be equipped with attributes
    attribute1="value1",
    attribute2=c(6, 100, 324)
)
print(x)
```

## Attributes {-}
- Some R functions use attributes to store indices, names or other useful information.
```{r}
y <- c(10, 20, NA, 40, 50, NA, 70)
(y_na_free <- na.omit(y))
```

## Attributes {-}

```{r}
needle <- "spam|durian"  # pattern to search for: spam OR durian
haystack <- c("spam, bacon, and durian-flavoured spam", "spammer")  # text
(pos <- gregexpr(needle, haystack, perl=TRUE))
```
## Attributes {-}
```{r}
x <- c("a" = 1, "b" = 2, "c" = 3)
attributes(x)
```

## Exercise 4-2 {-}
```{r}
#| warning = FALSE

# Use "https://raw.githubusercontent.com/
repo <- paste0("https://raw.githubusercontent.com/gagolews",
                "/teaching-data/master/marek/")

files <- list(EUR_AUD = "euraud-20200101-20200630.csv",
              EUR_GBP = "eurgbp-20200101-20200630.csv",
              EUR_USD = "eurusd-20200101-20200630.csv")

euro_data <- lapply(files, 
                    \(x) scan(paste0(repo, x),
                     comment.char = "#"))

euro_data_attributes <- lapply(euro_data,
                         \(x) structure(x,
                                currency_from = "EUR",
                                # How can I fix this? purrr:map2()?
                                currency_to = c("AUD", "GBP", "USD"), 
                                date_from = strptime(20200101,
                                                    format = "%Y%m%d"),
                                date_to = strptime(20200630,
                                                  format = "%Y%m%d"))
                          )
```

## Exercise 4-2 {-}
```{r}
print(euro_data_attributes)
```

## Exercise 4-3 {-}

```{r}
#| error = TRUE
whatever <- structure(1:10,
                      comment = 1)
```
## Exercise 4-3 {-}
```{r}
whatever <- structure(1:10,
                      comment = "integers between 1 and 10")
comment(whatever)
```
## Exercise 4-3 {-}
```{r}
print(whatever)
```

## Exercise 4-4 {-}
```{r}
x <- structure(c(13, 2, 6), names = c("spam", "sausage","celery"))
typeof(x)
```
## Exercise 4-4 {-} 
- Names don't effect the operation of functions on the vector
```{r}
sum(x)
```
## Exercise 4-4 {-}
- Names are so special, they can be called with `names()`
```{r}
names(x)
```
## Exercise 4-4 {-}
- And removed with `unname()`
```{r}
x <- unname(x)
# similar to
x <- structure(x, names = NULL)
```

## Exercise 4-5 {-} 
```{r}
z <- quantile(runif(100))
print(z)
```

```{r}
attributes(z)
```

## Exercise 4-5 {-} 
```{r}
h <- hist(runif(100), plot = FALSE)
print(h)
```
## Exercise 4-5 {-}
```{r}
attributes(h)
```


## Exercise 4-6 {-}
- Name attributes are preserved only for vectorized functions. E.g.
```{r}
x <- quantile(runif(100))
2*x
```
## Exercise 4-6 {-}
```{r}
mean(x)
```
## Exercise 4-6 {-}
```{r}
round(x, 2)
```
## Exercise 4-6 {-}
- `x==NULL` is meaningless, use `is.null(x)` instead.
- to name vectors, use `structure(..., names = ...)` and `c(a = ... , b = ...)` 
- to remove names, use `unname()` and `structure(..., names = NULL)` 

## Exercise 4-7 {-}
```{r}
#| error = TRUE
# 1)
as.character(list(list(1, 2), list(3, list(4)), 5))
as.character(unlist(list(list(1, 2), list(3, list(4)), 5)))
```
## Exercise 4-7 {-}
```{r}
#| error = TRUE
# 2)
as.numeric(list(list(1, 2), list(3, list(4)), 5))
as.numeric(unlist(list(list(1, 2), list(3, list(4)), 5)))
```
## Exercise 4-7 {-}
```{r}
#| error = TRUE
# 3)
unlist(list(list(1, 2), sd))
list(1, 2, sd)
```
## Exercise 4-7 {-}
```{r}
#| error = TRUE
# 4)
c(list(c(1, 2), 3), 4, 5)
c(list(c(1, 2), 3), c(4, 5))
```

## Exercise 4-8 {-}
Combine two vectors with a list of *n* vectors, to form a list of 2 + *n* vectors...
```{r}
x <- rnorm(10)
y <- rnorm(10)
zw <- list(z = rnorm(10),
           w = rnorm(10))
```

## Exercise 4-8 {-}
```{r}
c(list(x = x, y = y), zw)
```
## Exercise 4-8 {-}
```{r}
append(list(x = x, y = y), zw)
```
## Exercise 4-8 {-}
not ...
```{r}
list(x = x, y = y, zw)
```
## Exercise 4-8 {-}
or...
```{r}
list(x = x, y = y, unlist(zw))
```
## Exercise 4-9 {-}

```{r}
whatever <- structure(rnorm(10),
                      names = "whatever",
                      value = "none")
saveRDS(whatever, file = "data/whatever.RDS")
```
## Exercise 4-9 {-}
```{r}
whatever <- readRDS(file = "data/whatever.RDS")
attributes(whatever)
```

## Exercise 4-10 {-}
```{r}
jsonlite::fromJSON("data/test_json.json")
```


## Meeting Videos {-}

### Cohort 1 {-}

`r knitr::include_url("https://www.youtube.com/embed/URL")`

<details>
<summary> Meeting chat log </summary>

```
LOG
```
</details>