## Tuesday, 27 July 2010

### F#unctional Londoners meetup lecture (28th July 2010)

Zach Bray of Trayport and Jon Harrop of Flying Frog Consultancy Ltd. will be presenting lectures at Skills Matter eXchange London (UK) at 6:30pm on Wednesday 28th July 2010.

Many thanks to Carolyn Miller and Phil Trelford for organizing F#unctional Londoners Meetup Group, an excellent series of events!

## Saturday, 17 July 2010

### Histogram equalization

The F#.NET Journal just published an article about image processing and the new charting functionality in .NET 4:

"Over- and under-exposed images have their intensity distributions skewed to the high or low end of the range. Histogram equilization is one technique to combat this effect digitally by spreading out the distribution of intensities in an image via the intensity histogram. This article describes a program for image enhancement using histogram equalization with an interactive WPF-based GUI using the new charting functionality in .NET 4 to visualize the intensity histograms in real time..."

## Monday, 5 July 2010

### Happy numbers

Consider the sequence obtained by summing the squares of the digits of a number and then repeating with the result. If this sequence ends with the number one then the numbers in the sequence are Happy Numbers.

One of the challenges on Rosetta code is to compute the first eight Happy Numbers. The current F# solution weighs in at 26 lines of code. Let's see if we can do better...

We begin by writing a next function that computes the next happy number after the given number:

```> let rec next (m: Set<_>) n i =
if i=1 then n else
if m.Contains i then next Set.empty (n+1) (n+1) else
Seq.sumBy (fun d -> pown (int d - int '0') 2) (string i)
val next : Set<int> -> int -> int -> int```

Note the use of the string function to convert an int into its string representation and then the use of the int function to convert each char back into an int.

Finally, we use the List.scan function to build a list of accumulated results as the next function finds each of the happy numbers in turn:

```> List.scan (fun n _ -> next Set.empty (n+1) (n+1)) 1 [1..7];;
val it : int list = [1; 7; 10; 13; 19; 23; 28; 31]```

The scan function is relatively new and, consequently, not as widely appreciated as perhaps it should be.

Our whole program weighs in at only 6 lines of code, much shorter than the original!

## Sunday, 4 July 2010

### Lorenz attractor

The Lorenz attractor is a fractal derived from the trajectory of a 3-dimensional dynamical system that exhibits chaotic flow. This blog post describes a 35-line program that computes trajectories of this attractor and visualizes them as a beautiful whisp using Windows Presentation Foundation: The program is as follows:

```> #r "PresentationCore.dll";;
> #r "PresentationFramework.dll";;
> #r "WindowsBase.dll";;
> #r "System.Xaml.dll";;

> let trajectory f (x, y, z) dt n =
let s, b, p = 10.0, 8.0 / 3.0, 28.0
let mutable x = x
let mutable y = y
let mutable z = z
let a = Array.zeroCreate n
for i=0 to n-1 do
a.[i] <- f (x, y, z)
x <- x + s * (y - x) * dt
y <- y + (x * (p - z) - y) * dt
z <- z + (x * y - b * z) * dt
a;;
val trajectory :
(float * float * float -> 'a) ->
float * float * float -> float -> int -> 'a []

> open System.Windows;;

> let whisp() =
let rand = System.Random()
let f x = x + pown (rand.NextDouble() - 0.5) 2
let x, y, z = f 10.0, f 0.0, f 20.0
let xys =
let f(x, y, z) = Point(20.0 + x, 25.0 + y - z + 50.0)
trajectory f (x, y, z) 0.003 2000
let line_to (xy: Point) =
(Media.LineSegment(xy, true) :> Media.PathSegment)
Media.PathGeometry[ Media.PathFigure(xys., Seq.map line_to xys, false) ];;
val whisp : unit -> Media.PathGeometry

> do
let group = Media.GeometryGroup()
for i=1 to 100 do
let brush = Media.SolidColorBrush Media.Colors.Red
let path = Shapes.Path(Data=group, Stroke=brush, StrokeThickness=0.005)
let box = Controls.Viewbox(Child=path, Stretch=Media.Stretch.Uniform)
let window = Window(Content=box, Title="Lorenz attractor")
(Application()).Run window
|> ignore;;```

The trajectory function generates an array derived from the coordinates along a trajectory with the given starting position. The whisp function computes a trajectory with a slightly randomized starting position and generates a WPF PathGeometry. Finally, the main program generates 100 whisps and visualizes them.

### Rigid body dynamics demo

The F#.NET Journal just made another downloadable demo freely available. This demo is from the article Rigid body dynamics (15th January 2010). The article walks through the design and implementation of a 250-line program that simulates the dynamics of a collection of solid balls as they bound around a scene, using Windows Presentation Foundation for visualization!

## Friday, 2 July 2010

### Diff

The F#.NET Journal just published an article about text processing:

"The unix program diff identifies differences between text files, line by line. This tool is most useful for comparing two versions of a program. This article develops a simple implementation of the diff tool based upon the longest common subsequence (LCS) algorithm with a graphical user interface written using Windows Presentation Foundation to visualize the difference between two text files..."