Programming assignment 2 - Solution

programming assignment-2/README.md

@@ -0,0 +1,102 @@
+### Introduction
+
+This second programming assignment will require you to write an R
+function is able to cache potentially time-consuming computations. For
+example, taking the mean of a numeric vector is typically a fast
+operation. However, for a very long vector, it may take too long to
+compute the mean, especially if it has to be computed repeatedly (e.g.
+in a loop). If the contents of a vector are not changing, it may make
+sense to cache the value of the mean so that when we need it again, it
+can be looked up in the cache rather than recomputed. In this
+Programming Assignment will take advantage of the scoping rules of the R
+language and how they can be manipulated to preserve state inside of an
+R object.
+
+### Example: Caching the Mean of a Vector
+
+In this example we introduce the `<<-` operator which can be used to
+assign a value to an object in an environment that is different from the
+current environment. Below are two functions that are used to create a
+special object that stores a numeric vector and cache's its mean.
+
+The first function, `makeVector` creates a special "vector", which is
+really a list containing a function to
+
+1.  set the value of the vector
+2.  get the value of the vector
+3.  set the value of the mean
+4.  get the value of the mean
+
+<!-- -->
+
+    makeVector <- function(x = numeric()) {
+            m <- NULL
+            set <- function(y) {
+                    x <<- y
+                    m <<- NULL
+            }
+            get <- function() x
+            setmean <- function(mean) m <<- mean
+            getmean <- function() m
+            list(set = set, get = get,
+                 setmean = setmean,
+                 getmean = getmean)
+    }
+
+The following function calculates the mean of the special "vector"
+created with the above function. However, it first checks to see if the
+mean has already been calculated. If so, it `get`s the mean from the
+cache and skips the computation. Otherwise, it calculates the mean of
+the data and sets the value of the mean in the cache via the `setmean`
+function.
+
+    cachemean <- function(x, ...) {
+            m <- x$getmean()
+            if(!is.null(m)) {
+                    message("getting cached data")
+                    return(m)
+            }
+            data <- x$get()
+            m <- mean(data, ...)
+            x$setmean(m)
+            m
+    }
+
+### Assignment: Caching the Inverse of a Matrix
+
+Matrix inversion is usually a costly computation and their may be some
+benefit to caching the inverse of a matrix rather than compute it
+repeatedly (there are also alternatives to matrix inversion that we will
+not discuss here). Your assignment is to write a pair of functions that
+cache the inverse of a matrix.
+
+Write the following functions:
+
+1.  `makeCacheMatrix`: This function creates a special "matrix" object
+    that can cache its inverse.
+2.  `cacheSolve`: This function computes the inverse of the special
+    "matrix" returned by `makeCacheMatrix` above. If the inverse has
+    already been calculated (and the matrix has not changed), then the
+    `cachesolve` should retrieve the inverse from the cache.
+
+Computing the inverse of a square matrix can be done with the `solve`
+function in R. For example, if `X` is a square invertible matrix, then
+`solve(X)` returns its inverse.
+
+For this assignment, assume that the matrix supplied is always
+invertible.
+
+In order to complete this assignment, you must do the following:
+
+1.  Clone the GitHub repository containing the stub R files at
+    [https://github.com/rdpeng/ProgrammingAssignment2](https://github.com/rdpeng/ProgrammingAssignment2)
+2.  Edit the R file contained in the git repository and place your
+    solution in that file (please do not rename the file).
+3.  Commit your completed R file into YOUR git repository and push your
+    git branch to your GitHub account.
+4.  Submit to Coursera the URL to your GitHub repository that contains
+    the completed R code for the assignment.
+
+### Grading
+
+This assignment will be graded via peer assessment.

programming assignment-2/cachematrix.R

@@ -0,0 +1,65 @@
+## A pair of functions that cache the inverse of a matrix
+
+
+## Creates a special matrix object that can cache its inverse
+makeCacheMatrix <- function( m = matrix() ) {
+
+	## Initialize the inverse property
+    i <- NULL
+
+    ## Method to set the matrix
+    set <- function( matrix ) {
+            m <<- matrix
+            i <<- NULL
+    }
+
+    ## Method the get the matrix
+    get <- function() {
+    	## Return the matrix
+    	m
+    }
+
+    ## Method to set the inverse of the matrix
+    setInverse <- function(inverse) {
+        i <<- inverse
+    }
+
+    ## Method to get the inverse of the matrix
+    getInverse <- function() {
+        ## Return the inverse property
+        i
+    }
+
+    ## Return a list of the methods
+    list(set = set, get = get,
+         setInverse = setInverse,
+         getInverse = getInverse)
+}
+
+
+## Compute the inverse of the special matrix returned by "makeCacheMatrix"
+## above. If the inverse has already been calculated (and the matrix has not
+## changed), then the "cachesolve" should retrieve the inverse from the cache.
+cacheSolve <- function(x, ...) {
+
+    ## Return a matrix that is the inverse of 'x'
+    m <- x$getInverse()
+
+    ## Just return the inverse if its already set
+    if( !is.null(m) ) {
+            message("getting cached data")
+            return(m)
+    }
+
+    ## Get the matrix from our object
+    data <- x$get()
+
+    ## Calculate the inverse using matrix multiplication
+    m <- solve(data) %*% data
+
+    ## Set the inverse to the object
+    x$setInverse(m)
+
+    ## Return the matrix
+    m
+}