Implementation and test cases

parente · parente · commit 1b21e2a5fe3a · 2015-01-10T19:35:33.000-05:00
diff --git a/cachematrix.R b/cachematrix.R
@@ -1,15 +1,62 @@
-## Put comments here that give an overall description of what your
-## functions do
+## Defines functions that compute and cache the inverse of a matrix to improve
+## performance when the inverse is needed multiple times.
 
-## Write a short comment describing this function
+## Wraps the given matrix to enable the caching of its inverse. Returns a 
+## list with the ability to get/set the matrix and get/set its inverse.
 
 makeCacheMatrix <- function(x = matrix()) {
+    inv <- NULL
 
-}
+    ## Set a new matrix, and be sure to reset the
+    ## cached inverse
+    set <- function(y) {
+        x <<- y
+        inv <- NULL
+    }
+
+    ## Return the current matrix
+    get <- function() x
+
+    ## Cache the computed inverse
+    setInverse <- function(i) {
+        inv <<- i
+    }
 
+    ## Return the cached inverse
+    getInverse <- function() inv
+
+    ## Return a list with the functions as properties
+    list(
+        set=set, 
+        get=get,
+        setInverse=setInverse,
+        getInverse=getInverse
+    )
+}
 
-## Write a short comment describing this function
+## Finds the inverse of a matrix constructed by makeCacheMatrix. Caches the
+## inverse and returns it. On repeat invocations, returns the cached value
+## without solving for the inverse again.
 
 cacheSolve <- function(x, ...) {
-        ## Return a matrix that is the inverse of 'x'
+    ## Check if the inverse has been computed and cached
+    inv <- x$getInverse()
+
+    if(!is.null(inv)) {
+        ## If so, return it without recomputing it
+        return(inv)
+    }
+
+    ## Fetch the matrix from its wrapping
+    m <- x$get()
+
+    ## Compute the inverse of the given matrix, passing through any additional
+    ## parameters given to the cacheSolve function
+    inv <- solve(m, ...)
+
+    ## Cache the inverse to avoid recomputing it next time
+    x$setInverse(inv)
+
+    ## Return the inverted matrix
+    inv
 }
diff --git a/run_tests.R b/run_tests.R
@@ -0,0 +1,5 @@
+library('testthat')
+ 
+source('cachematrix.R')
+ 
+test_dir('test', reporter = 'Summary')
diff --git a/test/test_cachematrix.R b/test/test_cachematrix.R
@@ -0,0 +1,50 @@
+## Defines unit tests for functions in cachematrix
+
+context("cachematrix")
+
+test_that("makeCacheMatrix() returns a list", {
+    x <- makeCacheMatrix()
+    expect_is(x, "list")
+})
+
+test_that("makeCacheMatrix(m)$get returns the matrix", {
+    m <- matrix(2,3)
+    x <- makeCacheMatrix(m)
+    expect_identical(x$get(), m)
+})
+
+test_that("makeCacheMatrix(m)$set stores a new matrix", {
+    x <- makeCacheMatrix()
+    m <- matrix(2,3)
+    x$set(m)
+    expect_identical(x$get(), m)
+})
+
+test_that("makeCacheMatrix(m) sets/gets the cached inverse", {
+    x <- makeCacheMatrix()
+
+    expect_identical(x$getInverse(), NULL)
+
+    ## bogus inverse, just for unit testing
+    im <- matrix(1,1)
+    x$setInverse(im)
+    expect_identical(x$getInverse(), im)
+})
+
+test_that("cacheSolve(x) uses the cached inverse", {
+    x <- makeCacheMatrix()
+
+    ## mock a cached inverse and expect to get it back
+    im <- matrix(2,2)
+    x$setInverse(im)
+    expect_identical(cacheSolve(x), im)
+})
+
+test_that("cacheSolve(x) caches a newly computed inverse", {
+    ## expected inverse
+    im <- matrix(c(-2, 1, 1.5, -0.5), nrow=2)
+    m <- matrix(1:4, nrow=2, ncol=2)
+    x <- makeCacheMatrix(m)
+    expect_equal(cacheSolve(x), im)
+})
+
