Question

I have these 2 values:

decimal totalAmountDue = 1332.29m;
short installmentCount = 3;

I want to create 3 installments that have an even amount based on the totalAmountDue (extra pennies apply starting with the lowest installment number going to the highest installment number) using this class:

public class Installment
{
   public Installment( short installmentNumber, decimal amount )
   {
     InstallmentNumber = installmentNumber;
     Amount = amount;
   }

   public short InstallmentNumber { get; private set; }
   public decimal Amount { get; private set; }
}

The installments should be as follows:

{ InstallmentNumber = 1, Amount = 444.10m }
{ InstallmentNumber = 2, Amount = 444.10m }
{ InstallmentNumber = 3, Amount = 444.09m }

I am looking for an interesting way to create my 3 installments. Using a simple LINQ to objects method would be nice. I have been trying to understand more about functional programming lately and this seems like it could be a fairly good exercise in recursion. The only decent way I can think of doing this is with a traditional while or for loop at the moment…

Answer 1

There’s not a whole lot here that is “functional”. I would approach the problem like this:

var pennies = (totalAmountDue * 100) % installmentCount;
var monthlyPayment = totalAmountDue / installmentCount;
var installments = from installment in Enumerable.Range(1, installmentCount)
                   let amount = monthlyPayment + (Math.Max(pennies--, 0m) / 100)
                   select new Installment(installment, amount);

---

You might be able to work something out where you constantly subtract the previous payment from the total amount and do the division rounding up to the nearest penny. In F# (C# is too wordy for this) it might be something like:

let calculatePayments totalAmountDue installmentCount =
  let rec getPayments l (amountLeft:decimal) = function
            | 0 -> l
            | count -> let paymentAmount = 
                         (truncate (amountLeft / (decimal)count * 100m)) / 100m
                       getPayments (new Installment(count, paymentAmount)::l)
                                   (amountLeft - paymentAmount)
                                   (count - 1)
  getPayments [] totalAmountDue installmentCount

For those unfamiliar with F#, what that code is doing is setting up a recursive function (getPayments) and bootstrapping it with some initial values (empty list, starting values). Using match expressions it sets up a terminator (if installmentCount is 0) returning the list so far. Otherwise it calculates the payment amount and calls the recursive method adding the new installment to the front of the list, subtracting the payment amount from the amount left, and subtracting the count.

This is actually building the list in reverse (adding on to the front each time), so we throw away the extra pennies (the truncate) and eventually it catches up with us so the penny rounding works as expected. This is obviously more math intensive than the add/subtract code above since we divide and multiply in every iteration. But it is fully recursive and takes advantage of tail recursion so we’ll never run out of stack.

The trouble with C# here is that you want a sequence of installments and recursion and there’s no idiomatic built-in structure for doing that in C#. Here I’m using F#’s list which is immutable and O(1) operation to prepend.

You could possibly build something using the Scan() method in the Reactive Extensions to pass state from once instance to another.