Flesh out cachematrix

rklancer · rklancer · commit 6b7c120ba8c6 · 2014-04-22T23:11:30.000-04:00
diff --git a/cachematrix.R b/cachematrix.R
@@ -1,15 +1,70 @@
-## Put comments here that give an overall description of what your
-## functions do
-
-## Write a short comment describing this function
+## Custom matrix data type that allows caching of the matrix inverse.
 
+## Creates a 'cache matrix' object representing the matrix x.
+## 
+## A 'cache matrix' is a list with four methods: getValue, setValue,
+## getInverse, and setInverse. The matrix value, x,  is retrievable
+## by invoking the setValue method, and can be updated by invoking
+## setValue with the new value as its only parameter. The inverse of 
+## the matrix can also be cached by passing the value to setInverse
+## (no validation is performed) and retrieved by calling getInvsere.
+## Calls to setValue invalidate the cached inverse, setting it to NULL.
 makeCacheMatrix <- function(x = matrix()) {
-
+    # Closure variable for caching the inverse
+    inverse <- NULL
+    
+    setValue <- function(newX) {
+        x <<- newX
+        message('matrix changed; invalidating cached inverse (if any)')
+        inverse <<- NULL
+    }
+    
+    getValue <- function() {
+        x
+    }
+    
+    setInverse <- function(newInverse) {
+        message('setting cached inverse')
+        inverse <<- newInverse
+    }
+    
+    getInverse <- function() {
+        inverse
+    }
+    
+    # This is exactly analagous to the so-called "revealing module pattern" used in Javascript:
+    # 
+    # function makeObject() {
+    #   function myMethod() { 
+    #     return doStuff(); }
+    #   }
+    # 
+    #   return {
+    #     myMethod: myMethod
+    #   };
+    # }
+    # // later:
+    # obj = makeObject(); obj.myMethod();  // does stuff
+    
+    list(setValue=setValue, getValue=getValue, getInverse=getInverse, setInverse=setInverse)
 }
 
 
-## Write a short comment describing this function
+## Given a 'cache matrix' object, x, returns the inverse of the matrix 
+## represented by x. If a cached value of the inverse exists, it is used; if there
+## is no cache value, the inverse (as computed by solve()) is cached into x.
+## Throws if the matrix is singular.
 
 cacheSolve <- function(x, ...) {
-        ## Return a matrix that is the inverse of 'x'
+    inverse <- x$getInverse()
+    
+    if (!is.null(inverse)) {
+        message('using cached inverse')
+        return(inverse)
+    }
+    
+    xValue <- x$getValue()
+    inverse <- solve(xValue)
+    x$setInverse(inverse)
+    inverse
 }
