Solution to Coursera 2nd assignment

README.md

@@ -1,105 +1,19 @@
 ### Introduction
 
-This second programming assignment will require you to write an R
-function that 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 you 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 caches 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
-    }
+This repo provides a solution to 2nd programming assignment for R-programming course
+offered by [Coursera](https://class.coursera.org/rprog-034). You can find the original
+assignment on the following [link](https://class.coursera.org/rprog-034/wiki/Week_3)
 
 ### Assignment: Caching the Inverse of a Matrix
 
-Matrix inversion is usually a costly computation and there may be some
-benefit to caching the inverse of a matrix rather than computing 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.
+The repo contains one R script `cachematrix.R` which provides two functions
 
-Write the following functions:
+1.  `makeCacheMatrix`: This function accepts a matrix as an argument 
+     and generates a special list object which provides various functions 
+     to retrieve and modify the underlying matrix and its inverse matrix.
 
-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
-    `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.  Fork the GitHub repository containing the stub R files at
-    [https://github.com/rdpeng/ProgrammingAssignment2](https://github.com/rdpeng/ProgrammingAssignment2)
-    to create a copy under your own account.
-2.  Clone your forked GitHub repository to your computer so that you can
-    edit the files locally on your own machine.
-3.  Edit the R file contained in the git repository and place your
-    solution in that file (please do not rename the file).
-4.  Commit your completed R file into YOUR git repository and push your
-    git branch to the GitHub repository under your account.
-5.  Submit to Coursera the URL to your GitHub repository that contains
-    the completed R code for the assignment.
-
-### Grading
+    `cacheSolve` retrieves its inverted matrix from the cache.
 
-This assignment will be graded via peer assessment.

cachematrix.R

@@ -1,15 +1,47 @@
-## Put comments here that give an overall description of what your
-## functions do
-
-## Write a short comment describing this function
-
+# makeCacheMatrix accepts a matrix as an argument and generates a list object
+# which provides various functions to retrieve and modify the underlying matrix
+# and its inverse matrix
 makeCacheMatrix <- function(x = matrix()) {
-
+        # inverse matrix
+        inv <- NULL
+        # Initialize the underlying matrix object, NULLs its inverse cache
+        # If the matrix hasn't changed we won't modify the underlying matrix
+        set <- function(y = matrix()) {
+                # only change the underlying matrix IF new matrix is not the same
+                if (!(dim(x) == dim(y) && all(x == y))) {
+                        x <<- y
+                        inv <<- NULL
+                }
+        }
+        # returns underlying matrix
+        get <- function() x
+        # sets matrix's inverse cache
+        setinv <- function(invMatrix = matrix()) inv <<- invMatrix
+        # returns inverse cache value
+        getinv <- function() inv
+        # returns matrix object
+        list(set = set, get = get,
+             setinv = setinv,
+             getinv = getinv)
 }
 
-
-## Write a short comment describing this function
-
-cacheSolve <- function(x, ...) {
-        ## Return a matrix that is the inverse of 'x'
-}
+# cacheSolve accepts a special list object that provides get, set, setinv and getinv
+# function objects which allow to calculat an inverse matrix of passed in matrix
+# object or returns a cached data if there is any.
+cacheSolve <- function(x = list(), ...) {
+        # retrieve cached inverse matrix
+        inv <- x$getinv()
+        # check if the cache exists and if the matrix hasn't changed
+        if(!is.null(inv)){
+                message("getting cached data")
+                return(inv)
+        }
+        # read in matrix
+        data <- x$get()
+        # calculate inverse matrix
+        inv <- solve(data)
+        # set inverse cache value
+        x$setinv(inv)
+        # return inverse matrix
+        inv
+}