Calculation of mortgage repayments

Question

I've just started learning R, but I feel that I'm using it only as a normal procedural language without taking advantage of some built-in functions and data structures.

I wrote a function that calculates repayments for mortgage with an option of specifying list of overpayments to reduce monthly payments. Please suggest any improvements on making it more native to R.

source("http://pastebin.com/raw.php?i=q7tyiEmM") ## for pmt()
mortgage <- function(price=1000000, deposit=0.10, rate=0.04, years=25, over=c()) {
    loan <- price - price * deposit
    months <- years * 12
    capital <- c()
    interest <- c()
    payments <- c()
    currentCapital <- loan
    monthlyRate <- rate / 12
    payment <- -pmt(monthlyRate, nper = months + 1, pv = loan)

    cat("Initial capital: ", loan, "\n")
    cat("Months: ", months, "\n")
    cat("Payment: ", payment, "\n")

    totalShouldPay <- payment * months
    totalPaid <- 0

    for(currentMonth in 1:months) {
        interest <- currentCapital * monthlyRate
        repaid <- payment - interest
        currentCapital <- currentCapital - repaid

        overPayments <- subset(over, over$month == currentMonth)
        if (length(overPayments) > 0 && nrow(overPayments) > 0) {
            overPayments <- sum(overPayments$payment)
            currentCapital <- currentCapital - overPayments
            payment <- -pmt(monthlyRate, nper = months + 1 - currentMonth, pv = currentCapital)
        }

        capital <- append(capital, currentCapital)

        totalPaid <- totalPaid + payment
        payments <- append(payments, payment)
    }
    cat("Would have paid: ", round(totalShouldPay, 2), "\n")
    cat("Will pay: ", round(totalPaid, 2), "\n")
    cat("Saved: ", round(totalShouldPay - totalPaid, 2), "\n")
    return(data.frame(capital=capital, payments=payments))
}

overPayments <- data.frame(
    month   = c(20,    25,    30,    35,    40), 
    payment = c(20000, 20000, 20000, 20000, 20000))

cap <- mortgage(
    over = overPayments
)

#print(cap)
par(mfcol=c(1, 2))
plot(cap$payments, type="s", main = "Payments", xlab = "Month", ylab = "Payment")
plot(cap$capital, type="l", main = "Capital", xlab = "Month", ylab = "Remaining loan")

Answer 1

I spent clearly too much time on this... Main ideas:

1. your understanding of how the payment on a fixed mortgage is computed was wrong. The payment is computed once at the beginning and remains the same regardless of prepayments, which is why people who choose to prepay end up repaying their whole mortgage before the scheduled term, as the example below should show.
2. I added pmt as an argument to the function as it is best practice for a function to not use any variable defined outside its scope (the dreaded global variables)
3. A big no-no in your code was the use of constructs like capital <- append(capital, currentCapital). At each iteration, a new and longer vector is created. This is slow and uses a lot of memory. Granted, you would need a very long mortgage to see the negative effects but it's good to learn to implement this the right way. You could a) pre-allocate a vector of length term.in.months and replace its value like this: capital[month.idx] <- currentCapital. Or b) use a list: lists use pointers in memory so they don't suffer the issue I was describing as they grow in size. My implementation uses this b) approach where I grow a list named db. At the end, I am turning this list of monthly data into a data.frame.
4. You'll see I use things like 12L instead of 12. That's the difference between integers and numerics. It is recommended to use integers when possible as it can prevent (rare) issues regarding floating point errors. It uses less memory and can sometimes make your code faster. Again, you won't notice it here, but it is a good practice.
5. Regarding @janos' comment about trying to avoid for loops. I agree, R works best and faster when vectorization can replace loops. However, your particular algorithm is a case of an iterative (state i+1 depends on state i) process so it cannot be vectorized. Whereas vectorization can replace loops only in processes where each iteration can be computed independently. So you will find that my answer still has a loop, in the form of a while().
6. I modified the variables' names to be closer to the official language. (I work in finance.)

---

mortgage <- function(property.value = 1e6,
                     downpayment = 0.10,
                     interest.rate = 0.04,
                     term = 25L,
                     prepayments = NULL,
                     pmt.fun = pmt) {

   original.balance <- property.value * (1 - downpayment)
   monthly.rate     <- interest.rate / 12L
   term.in.months   <- term * 12L
   monthly.payment  <- -pmt.fun(monthly.rate, nper = term.in.months,
                                              pv = original.balance) 
   db <- list()
   month.idx <- 1L
   start.balance <- original.balance

   while(start.balance > 0) {

      balance.due       <- start.balance * (1 + monthly.rate)
      payment.due       <- min(monthly.payment, balance.due)
      prepayment        <- if (is.null(prepayments)) 0 else
                           min(sum(subset(prepayments, month == month.idx)$payment),
                               balance.due - payment.due)
      total.payment     <- payment.due + prepayment
      interest.payment  <- start.balance * monthly.rate
      end.balance       <- balance.due - total.payment
      principal.payment <- start.balance - end.balance

      db[[month.idx]] <- c(month             = month.idx,
                           start.balance     = start.balance,
                           balance.due       = balance.due,
                           payment.due       = payment.due,
                           total.payment     = total.payment,
                           prepayment        = prepayment,
                           interest.payment  = interest.payment,
                           principal.payment = principal.payment,
                           end.balance       = end.balance)
      month.idx     <- month.idx + 1L
      start.balance <- end.balance
   }
   as.data.frame(do.call(rbind, db))
}

source("http://pastebin.com/raw.php?i=q7tyiEmM")  # for pmt()

overPayments <- data.frame(
   month   = c(20,    25,    30,    35,    40), 
   payment = c(20000, 20000, 20000, 20000, 20000))

cap1 <- mortgage()
cap2 <- mortgage(prepayments = overPayments)

par(mfcol=c(1, 2))
plot(c(cap1$start.balance, 0), type="l",
     main = "Without Prepayments", xlab = "Month", ylab = "Balance")
plot(c(cap2$start.balance, 0), type="l",
     main = "With Prepayments",    xlab = "Month", ylab = "Balance")

Answer 2

I'm not sure if great improvements will be possible here. The first thing I wanted to attack was the for loop, many times you can achieve the same by converting a for loop to a function and using one of the apply functions to perform operations on rows in a data frame. But it's tricky here, if at all possible. So I will only nitpick on other stuff.

---

In R, a function returns the last value evaluated by default, so instead of this:

function() {
  # ...
  return(data.frame(capital, payments))
}

You can write like this:

function() {
  # ...
  data.frame(capital, payments)
}

It is a bit controversial topic where you should use an explicit return statement or not. See this related discussion on the topic.

For my part, I like minimalistic code, and omit what is unnecessary, unless there is a good reason not to. In this case, it's easy to omit it, so I would omit.

---

In a data.frame, the columns will automatically take the names of the vectors you used to build it by default. So instead of:

data.frame(capital=capital, payments=payments)

You can write simply:

data.frame(capital, payments)