New Horizons

The algorithm I came up with is essentially a depth first search like approach.  Taking the first element and printing it and then moving it to the ancestor list and printing it with the next one and so on.  This will print the permutations in lexicographic order providing the input elements are sorted.  Here is the source code below.

#light
/// List printing function need a generic version
let ListPrinter format a n =
 printf  "%A. " n
 a|> List.iter (fun x -> (printf format x))
 printf "\n"

/// Print all the permutation of a list of elements
/// Algorithm Pseudo Code
/// PermutationGenerator(list items)
///    PermuationHelper([], items)
/// end
///
/// PermutationHelper(list ancestors, list descendants)
///  if descandants is null return
///  foreach descendant
///    newAncestors  = ancestors + descendant
///    print(newAncestors)
///    newDescandants = descendants - descendant
///    PernumationHelper(newAncestors, newDescandants)
///  end
/// end
let PermutationGenerator printer items =
 ///internal counter function
 let counter =
  let count = ref 0I
  fun () -> count.contents <- count.contents + 1I; !count
 /// Helper recursive function that does the work
 let rec PermutationHelper ancestors descendants =
  if ancestors <> [] then printer ancestors (counter())

  match descendants with
  | [] -> ()
  | y::ys -> let fn = (fun (front, back : 'a list) curr ->
                 let newFront = front @ [curr]
                 let newBack = back.Tail
                 let newAncestors = ancestors @ [curr]
                 let newDescendants = front @ newBack
                 PermutationHelper newAncestors newDescendants
                 (newFront, newBack))
   in List.fold_left fn ([],descendants) descendants |> ignore
 // call the nested function
 PermutationHelper [] items

let items = ["apple";"banana"; "canteloupe";]
 //"cherry"; "grape";"orange";
 //"peach";"pear"; "strawberry"]
let numbers = [ 1..5 ]

let chars = ['a'..'e']

let StringPrinter = ListPrinter "%s "
let NumericPrinter = ListPrinter "%d"
let CharPrinter = ListPrinter "%c"

let StringPermutations = PermutationGenerator StringPrinter
let NumericPermutations = PermutationGenerator NumericPrinter
let CharPermutations = PermutationGenerator CharPrinter

You can load the above into the F# interactive window and run the following command and see the following results.

> StringPermutations items;;
1I. apple
2I. apple banana
3I. apple banana canteloupe
4I. apple canteloupe
5I. apple canteloupe banana
6I. banana
7I. banana apple
8I. banana apple canteloupe
9I. banana canteloupe
10I. banana canteloupe apple
11I. canteloupe
12I. canteloupe apple
13I. canteloupe apple banana
14I. canteloupe banana
15I. canteloupe banana apple

Some of the more interesting parts as someone learning functional programming include the use of curried functions, the fold operator, and pattern matching.

PermutationGenerator is a generic function that can work with any list of items of  type a’ list as long as a corresponding printer for the items is supplied of type  a’ list -> bigint -> unit.  The basic algorithm is listed above PermutationGeneration in the comments.  Although, F# supports loops the functional way to iterate over elements is to use a function like map or fold, so the foreach loop is replaced by List.fold_left with fn essentially being the body of the loop.

I then build a ListPrinter function that takes a format string.  From this I create printers for three different types using partial application or currying, StringPrinter, NumericPrinter, and CharPrinter.  This allows the creation of three new more specialized functions from the ListPrinter.  Currying is also used to create three specific Permutation Generators, StringPermutations, NumericPermutations, CharPermutations from PermutationGenerator by applying the particular printer.

There are other techniques for generating permutations.  Some involve shuffling of positions of elements after selecting the number of items.  Another technique is to use factoradics which give a way to select elements or permutations based on the factorial number system.

1. Time consuming – between work and grad school I didn’t have time to pull it off
2. Tons of features – having not blogged much I thought I only needed to build something that displayed posts and comments but the sheer number of features blog engines support today is daunting
3. Need great themes – even if you do build a great blog engine it is only as good as the themes available for it
4. Learning while building it – asp.net mvc was a beta product at the time and many of the patterns and best practices were not fully formed

It wasn’t all for naught as I learned a ton about asp.net mvc which was helpful as I went on to do several projects at work with this technology.  And I think if I was starting something like this again I would have a better idea on how I would approach such a project.

That being said, I came away with a great respect for people who do this kind of open source work and actually produce great tools.

And for blogging wordpress is hard to beat.  I haven’t seen anything else that comes close.  So, I will be importing posts from my previous blog and I hope to post more frequently than once a year.

This same logic doesn’t only apply, though, to birthdays.  One can calculate the probability of collision for any set of elements given the number of samples.  For instance, assume you want to assign a unique number to each of your customers.  And let’s say you were going to choose the number at random from a huge pool of numbers say 999,999,999. If you anticipate having 100,000 customers then one would expect with probability 99.3% to sample a number that was previously sampled for another customer, even though you have only selected .01% of the available numbers. I thought it would be fun to write an F# program to calculate this.

The probability is calculated as follows P = 1 – Probability of no collisions

It is easier to calculate the probability that there aren’t collisions and subtract that from one. We can use simple counting principles to calculate the probability of choosing n samples without any collisions. For example if we have 365 days as the elements and we have 3 people (samples), then the first person has 365 possibble days he could choose without collision. The second person has 364 possible days out of 365 and the third 363 possible days. So

Probabiliby of No Collisions = (365/365)*(364/365)*(363/365)
and
Probabiliby of Collision = 1 – (365/365)*(364/365)*(363/365)

Here is the following code which implements the above algorithm in F#

let collisionProbability  elements samples =
 let probNthSample n =
  let a = (float  elements)
  let b = (float  (elements - n + 1))
  b / a
 let rec probNoCollision  counter answer =
  match counter with
  | 0 -> answer
  | _ -> probNoCollision (counter - 1) (answer *  (probNthSample counter))
 in
  1.0 - (probNoCollision samples 1.0)

Some things I like about F# are its terseness. You don’t have to provide type annotations for everything unlike in C# or Java. The compiler infers them based on how they are used. Here, I am also using nested functions, which are great for breaking up an algorithm into smaller bits while still maintaining the scope of the functions to where they will be used. Also, nested functions can use values in scope. For instance elements is not passed into probNthSample. This algorithm was coded using tail-recursion to iterate over the different samples. Typically one would use a loop for this in imperative programming, but in a functional style recursion is used more often. (One could also make a list of the samples and fold_left.) Tail-recursion prevents the stack size from growing by not keeping previously called procedures on the stack if there is no additional work to be done. In the inner probNoCollision method, this is the case. The last thing that is used here is pattern matching. Stylistically, I like pattern matching better than if statements.

The probNoCollision function calculates what it name says. It multiplies together the probability of all the samples not colliding.

probNthSample is a helper function which just gets a float of the probability of the nth sample not colliding. For instance, in the birthday problem for the 2nd sample this method would return 364/365.

The last step just returns 1-probNoCollision.

To run this you could load this in the F# interactive window. And then run the command
collisionProbability 365 23;;
collisionProbability 999999999 100000;;

I am really enjoying F# and OCAML programming so far. I will be posting an article soon on permutations that I also coded in F#. This will also be in a functional style and will show more techniques of code reuse that are powerful, that one doesn’t typically enjoy in languages like C#.

Update -

I have rewritten the above function in a more functional style.

let collisionProb2 elements samples =
 let probNoCollision answer n =
  let a = (float elements)
  let b = (float (elements - n + 1))
  answer * b / a
 let answer = seq { 1 .. samples } |> Seq.fold probNoCollision 1.0
 1.0 - answer

This version of the code is more succinct and uses the fold function, as opposed to explicitly recursing over the elements.

public delegate T DatabaseCodeBlock<T>(SqlConnection conn);

public class HoleInTheMiddle
{
  ConnectionHelper connHelper =new
  ConnectionHelper();

  public T ExecuteProcedure<T>(DatabaseCodeBlock<T> block)
  {
    SqlConnection conn = connHelper.GetSQLConnection();

    try
    {
      return block(conn);
    }
    catch(Exception ex)
    {
      LogError(ex.ToString());
      throw;
    }
    finally
    {
      conn.Close();
    }
  }
}

public class DbLayer
{
  HoleInTheMiddle holeInTheMiddle = new HoleInTheMiddle();

  public DataTable GetCustomerByCustomerKey(int customerKey)
  {
    return holeInTheMiddle.ExecuteProcedure<DataTable>( conn =>
      {
        RunSpParmsClass parm = new RunSpParmsClass();

        parm.AppendEx("@CustomerID", SqlDbType. Int, ParameterDirection.Input, 4, customerKey);
        DataSet ds= dbHelper.RunSpGetDataset("GetCustomer", parm, conn);

        if (ds !=null && ds.Tables[0].Rows.Count > 0)
        {
          return ds.Tables[0];
        }
        else
        {
          return null;
        }
       }
     );
   }
}

Now some of you are wondering why go through this trouble when you can use the Microsoft Data Access Application Block. Good question, but the point of this sample is to illustrate one way of using this design pattern. Now let’s take a look at the code.  I have created a method ExecuteProcedure that has code to open and close a connection and to handle exceptions.  It then fires a delegate of type DatabaseCodeBlock.  This is the code block that we supply to fill the hole in this helper function.  I am using generics to strongly type the return type of the DatabaseCodeBlock and the ExecuteProcedure method.  This is not really neccessary as you could just set the value of a local variable in your anonymous delegate that you could return from the method that is calling ExecuteProcedure, but I think using generics makes for cleaner code.

Now the intersting part of this is the power of the anonymous delegate we are using for the DatabaseCodeBlock. Anonymous Delegates are what are known as closures and they can capture local variables and reference them in the code block.  Even if this code block is executed in a another context.  This allows one to not have to define different delegate interfaces if you want to use different patterns or to build some parameter array of inputs.  Instead, you can just pass in your anonymous delegate and use any local variable in it magically.  So in our example we are getting a Customer record by using the local customerKey variable.  Now imagine we have a different stored procedure that we want to invoke that requires three or four parameters.  If these are in the local scope of where the delegate is created then we can access them.  Easy as pie!  The last point is a subtle one.  I suggest reading up on closures to get a better feel for some of the power of this way of doing things.