Lexical Scoping: Caching Data

makeCacheMatrix()

Calculating the inverse as well as performing other operations can be a very expensive task. It may be useful or more memory efficient to save(cache) the inverse if this operation will be repeated. Lexical scoping in R makes this possible. In lexical scoping R looks up the value of a variable in the environment where the function was defined, not where it was called.

makeCacheMatrix is a function to:
- set the value of the matrix
- get the value of the matrix
- set the inverse of the matrix
- retrieve the inverse of the matrix

The super assignment operator (<<-) is utilized in the function below. “Super assignment, <<-, never creates a variable in the current environment, but instead modifies an existing variable found in a parent environment.”

makeCacheMatrix <- function(x = matrix()) {
  inv <- NULL
  
  set <- function(m){
    x <<- m
    inv <<- NULL
  }
  
  get <- function() x
  
  setInv <- function(a){inv <<- a}
  
  getInv <- function() inv
  
  list(set = set, 
       get = get,
       setInv = setInv, 
       getInv = getInv)

}

cacheSolve()

cacheSolve() takes a makeCacheMatrix object and returns the inverse of the associated matrix. cacheSolve() assumes that the matrix set by makeCacheMatrix is invertible.

If the inverse is cached, cacheSolve retrieves and returns it; otherwise, it calculates the inverse, caches it before returning the inverse to the user.

cacheSolve <- function(x, ...) {
  ## Return a matrix that is the inverse of 'x'
  inv <- x$getInv()
  
  if(!is.null(inv)){
    message('Getting Cached inverse...')
    return(inv)
  }else{
    message('Inverse is not cached! Calculating inverse...')
    
    mat <- x$get()
    inv <- solve(mat, ...)
    x$setInv(inv)
    inv
  }
  
  
}

TESTING

set.seed(1)
m <- matrix(sample(0:10, 9), nrow = 3, ncol = 3)
m

     [,1] [,2] [,3]
[1,]    8    0    2
[2,]    3    1   10
[3,]    6    4    9

Instantiate an instance of makeCacheMatrix

M <- makeCacheMatrix(m)

M$get()

     [,1] [,2] [,3]
[1,]    8    0    2
[2,]    3    1   10
[3,]    6    4    9

M$getInv()

NULL

Get Inverse of M(an object of makeCacheMatrix)

Since this is the first time cacheSolve is called for object M, the inverse is not stored (i.e. M$getInv() yields NULL). cacheSolve(M) calculates and returns the inverse.

cacheSolve(M) # (1)

Inverse is not cached! Calculating inverse...

            [,1]        [,2]         [,3]
[1,]  0.13135593 -0.03389831  0.008474576
[2,] -0.13983051 -0.25423729  0.313559322
[3,] -0.02542373  0.13559322 -0.033898305

Running cachSolve(M) a second time yields:

cacheSolve(M)

Getting Cached inverse...

            [,1]        [,2]         [,3]
[1,]  0.13135593 -0.03389831  0.008474576
[2,] -0.13983051 -0.25423729  0.313559322
[3,] -0.02542373  0.13559322 -0.033898305

The cached inverse was retrieved since inverse was already calculated in (1) above.

Source:
- https://adv-r.hadley.nz/index.html
- https://www.coursera.org/learn/r-programming/home/info