From b90b6214b20946747afbb69704369e8b44928773 Mon Sep 17 00:00:00 2001 From: Peter Gowen Date: Wed, 23 Apr 2014 20:55:07 -0500 Subject: [PATCH 1/2] Added functionality to cache inverted matrices --- .Rhistory | 36 +++++++++ README.md | 204 +++++++++++++++++++++++++------------------------- cachematrix.R | 36 +++++++-- 3 files changed, 166 insertions(+), 110 deletions(-) create mode 100644 .Rhistory diff --git a/.Rhistory b/.Rhistory new file mode 100644 index 00000000000..6ccadd52e73 --- /dev/null +++ b/.Rhistory @@ -0,0 +1,36 @@ +swirl() +library(swirl) +swirl() +c(z, 555, 5) +c(z, 555, z) +z * 2 + 100 +mySqrt <- sqrt(z-1) +mySqrt +myDiv <- z / mySqrt +myDiv +c(1,2,3,4) + c(0,10) +c(1,2,3,4) + c(0,10,100) +bye() +getwd() +setwd("C:/Users/A126482/") +setwd("C:/Users/A126482/Downloads/Dropbox/Apps/R/R Prog/Assign 2") +setwd("C:/Users/A126482/Downloads/Dropbox/Apps/R/R Prog/ProgrammingAssignment2") +?solve +source("cachematrix.R") +c <- rnorm(1000) +cc <- makeCacheMatrix(c) +?matrix +?rnorm +c <- matrix(c, 100, 100) +cc <- makeCacheMatrix(c) +cacheSolve(cc) +source("cacheMatrix.R") +m <- matrix(c(1,2,3,4), 2, 2) +m +cacheSolve(m) +m1 <- makeCacheMatrix(m) +m2 <- cacheSolve(m1) +m2 +solve(m) +m %*% m2 +cacheSolve(m1) diff --git a/README.md b/README.md index 6d028906790..d6261a18a15 100644 --- a/README.md +++ b/README.md @@ -1,102 +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. +### 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. diff --git a/cachematrix.R b/cachematrix.R index a50be65aa44..03e24e650ae 100644 --- a/cachematrix.R +++ b/cachematrix.R @@ -1,15 +1,35 @@ -## Put comments here that give an overall description of what your -## functions do - -## Write a short comment describing this function +## "Matrix inversion is usually a costly computation", to these functions set up caching functionality +## for inverting matrices. +## makeCacheMatrix() +## +## Sets up caching functionality for matrices. makeCacheMatrix <- function(x = matrix()) { - + i <- NULL + set <- function(y) { + x <<- y + i <<- NULL + } + get <- function() x + setInv <- function(inv) i <<- inv + getInv <- function() i + list(set = set, get = get, + setInv = setInv, + getInv = getInv) } -## Write a short comment describing this function - +## cacheSolve() +## +## Returns a matrix that is the inverse of 'x' cacheSolve <- function(x, ...) { - ## Return a matrix that is the inverse of 'x' + i <- x$getInv() + if(!is.null(i)) { + message("getting cached data") + return(i) + } + data <- x$get() + i <- solve(data) + x$setInv(i) + i } From 83a998b103af542e21cd461f9edebe5c6f6f80ed Mon Sep 17 00:00:00 2001 From: Peter Gowen Date: Wed, 23 Apr 2014 20:58:45 -0500 Subject: [PATCH 2/2] Delete .Rhistory --- .Rhistory | 36 ------------------------------------ 1 file changed, 36 deletions(-) delete mode 100644 .Rhistory diff --git a/.Rhistory b/.Rhistory deleted file mode 100644 index 6ccadd52e73..00000000000 --- a/.Rhistory +++ /dev/null @@ -1,36 +0,0 @@ -swirl() -library(swirl) -swirl() -c(z, 555, 5) -c(z, 555, z) -z * 2 + 100 -mySqrt <- sqrt(z-1) -mySqrt -myDiv <- z / mySqrt -myDiv -c(1,2,3,4) + c(0,10) -c(1,2,3,4) + c(0,10,100) -bye() -getwd() -setwd("C:/Users/A126482/") -setwd("C:/Users/A126482/Downloads/Dropbox/Apps/R/R Prog/Assign 2") -setwd("C:/Users/A126482/Downloads/Dropbox/Apps/R/R Prog/ProgrammingAssignment2") -?solve -source("cachematrix.R") -c <- rnorm(1000) -cc <- makeCacheMatrix(c) -?matrix -?rnorm -c <- matrix(c, 100, 100) -cc <- makeCacheMatrix(c) -cacheSolve(cc) -source("cacheMatrix.R") -m <- matrix(c(1,2,3,4), 2, 2) -m -cacheSolve(m) -m1 <- makeCacheMatrix(m) -m2 <- cacheSolve(m1) -m2 -solve(m) -m %*% m2 -cacheSolve(m1)