test

README.md

+<<<<<<< HEAD
 ## Introduction
 
 This assignment uses data from
@@ -112,3 +113,107 @@ The four plots that you will need to construct are shown below.
 
 ![plot of chunk unnamed-chunk-5](figure/unnamed-chunk-5.png) 
 
+=======
+### 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.
+>>>>>>> 5fd2f2223f883be36d2bdbb748ff8e46483bdb79

cachematrix.R

+## Put comments here that give an overall description of what your
+## functions do
+
+## make matrix assign to variable x, and initialize m to NULL
+
+makeCacheMatrix <- function(x = matrix()) {
+    m <- NULL
+    set <- function(y) {            ## if user want to reset matrix 
+        x <<- y                     ## reassign "new" matrix to x 
+        m <<- NULL                  ## reinitialize m to NULL
+    }
+    get <- function() x
+    setInvmatrix <- function(InvMatrix) m <<- InvMatrix
+    getInvmatrix <- function() m
+    list(set = set, get = get,
+         setInvmatrix = setInvmatrix,
+         getInvmatrix = getInvmatrix)
+
+}
+
+
+## Return a matrix that is the inverse of 'x'
+
+cacheSolve <- function(x, ...) {
+        
+    m <- x$getInvmatrix()              
+    if(!is.null(m)) {           ## if user had calculated the same matrix before
+        message("getting cached data")  
+        return(m)               ## return old result(m) directly 
+    }
+    data <- x$get()             ## otherwise, get the uncalculated matrix
+    m <- solve(data, ...)       ## calculate the inverse matrix
+    x$setInvmatrix(m)           ## reassign inverse matrix 
+    m                           ## print the inverse matrix 
+}
+
+