F# News

Fluid Dynamics demo from the F#.NET Journal

2009-07-11T17:54:00.005Z

The F#.NET Journal just made another downloadable demo freely available. This demo is from the article Simulating smoke in real-time using fluid dynamics (16th January 2008).

The article develops and explains the entire program which, including parallelized numerical code and WPF-based visualization, is only 175 lines of F# code!

Ray Tracer demo from The F#.NET Journal

2009-07-07T00:11:00.004Z

The F#.NET Journal just made another downloadable demo freely available. This demo is from the article Implementing a simple Ray Tracer (16th January 2008).

The article develops and explains the entire program which, including ray intersection routines, visualization, parallelization and GUI controls, is only 160 lines of F# code!

F# development with Visual Studio 2008

2009-07-06T13:54:00.001Z

The F#.NET Journal just published an article about the current integrated development environment for F#:

"The May 2009 Community Technology Preview (CTP) release of F# includes an advanced Visual Studio mode for F# development. This article describes how this may be installed (including the free version of Visual Studio) and used to evaluate F# code interactively and develop F# applications including the generation of standalone .NET executables suitable for redistribution and the static linking of other .NET assemblies (e.g. C# compiled to DLL) as well as new features in the development environment itself..."

To read this article and more, subscribe to The F#.NET Journal today!

F# for Visualization 0.4.0.1 released

2009-07-06T13:53:00.002Z

A minor bug fix release of F# for Visualization is now available.

Least squares: a case study in optimization

2009-06-17T09:32:00.002Z

The F#.NET Journal just published an article about curve fitting:

"The challenge of finding the least squares best fit of a linear sum of functions is a common problem in regression. Linear algebra provides a powerful and general solution by expressing this problem in terms of matrices and then computing the QR decomposition in order to solve the matrix equation. This article describes a remarkably simple implementation of QR decomposition in F# before developing progressively more optimized implementations using the guidance of performance profiles and without sacrificing generality. In particular, heavy use of the F# keyword "inline" is made in order to express efficient reusable numerical methods..."

To read this article and more, subscribe to The F#.NET Journal today!

F# for Numerics 0.2.0.2 released

2009-06-12T02:22:00.003Z

A new version of our F# for Numerics library for F# has been released. This version includes:

Eigenvalues and eigenvectors of real symmetric matrices (the LinearAlgebra.Float.symmetric_eigen and LinearAlgebra.Float32.symmetric_eigen functions).
Singular Value Decomposition of real matrices (the LinearAlgebra.Float.svd and LinearAlgebra.Float32.svd functions).
Complex Cholesky decomposition of positive definite Hermitian matrices (the LinearAlgebra.Complex.cholesky function).
Real and complex Log Gamma function (the Special.gammaln and Special.Complex.gammaln functions).
Real and complex Beta function (the Special.beta and Special.Complex.beta functions).

The HTML documentation for this product is freely available on-line.

F# for Visualization 0.4.0.0 released

2009-06-10T15:52:00.007Z

F# for Visualization version 0.4.0.0 has just been released. This version includes a variety of enhancements.

Perhaps the most important enhancement is the introduction of dynamically typed functions scene and Typeset.math which try to build vector scenes and typeset mathematical layouts, respectively, from values of any type. The View function can be used to visualize any value of any type. For example, the following defines and then visualizes a matrix of rational numbers:

> let A =
    Matrix.Generic.of_seq
      [ for i in 0N..4N ->
          [ for j in 0N..4N ->
              1N / (i + j + 1N) ] ];;
val A : Matrix<BigNum> = matrix [[1N; 1/2N; 1/3N; 1/4N; 1/5N]
                                 [1/2N; 1/3N; 1/4N; 1/5N; 1/6N]
                                 [1/3N; 1/4N; 1/5N; 1/6N; 1/7N]
                                 [1/4N; 1/5N; 1/6N; 1/7N; 1/8N]
                                 [1/5N; 1/6N; 1/7N; 1/8N; 1/9N]]
> View A;;

This makes it a lot easier to see what is going on during matrix computations!

Plots may now be augmented with an "epilog". For example, the following creates a graph of the sinc function:

let g = Plot([Function sinc], (-12., 12.), (-0.3, 1.1))

Accurately typeset axis labels may be added to create a professional-quality plot:

g.Labels <- (Char 'x', Row[Text "sinc"; math "(x)"])

Finally, the first positive root of this function may be highlighted by adding a single data point and a label describing the exact coordinate:

let pi = System.Math.PI
g.Data <- [Function sinc; Data[pi, 0.]]
g.Epilog <- Label(scene(Row[math "("; Greek.pi; math ", 0)"]),
                  0.003, Point(System.Math.PI, 0.), Vector(1.2, 1.2))

Axis and grid styles and the font sizes of ticks are now configurable.

Finally, the DLL is 30% smaller than before!

Sudoku Solver demo from the F#.NET Journal

2009-06-01T18:49:00.004Z

The F#.NET Journal just made another downloadable demo freely available. This demo is from the article Designing and implementing a Sudoku Solver (30th June 2007).

The entire program, developed and explained in the article, including logic solver and programmatic GUI is under 150 lines of F# code!

Visualizing linear algebra: Singular Value Decomposition

2009-06-01T04:20:00.003Z

The F#.NET Journal just published an article about the interactive visualization of linear algebra:

"Singular Value Decomposition (SVD) is an important algorithm from linear algebra that decomposes a matrix into the product of three simpler matrices. The resulting decomposition has several applications. This article describes the design and implementation of an F# program that computes the SVD of an image and uses it to create a lossy compression algorithm with controllable quality. This involves numerical methods for computing the eigenvalues of real symmetric matrices and interactive visualization of the result as a standalone Windows Presentation Foundation application that uses the Task Parallel Library to leverage multicores..."

To read this article and more, subscribe to The F#.NET Journal today!

A self-contained executable demo of the program developed in this article is freely available.

Downloadable demos from the F#.NET Journal

2009-05-26T23:28:00.006Z

Articles published in the F#.NET Journal often culminate in fun graphical programs. Consequently, we have begun the process of uploading demos that everyone can download and enjoy. The first such demo, from the article Real-time Finite Element Materials simulation (15th June 2008), is now freely available for download from the F#.NET Journal web page.

This demo simulates a simple 2D material using finite element methods and the flexible object can be grabbed and pulled with the mouse in order to deform and even smash it:

The entire self-contained F# program is under 200 lines of code and uses Windows Presentation Foundation for easy and efficient real-time visualization.

F# for Numerics 0.1.0.1 and F# for Visualization 0.3.2.2

2009-05-22T11:27:00.005Z

We have completed the updates of our F# for Numerics and F# for Visualization libraries to work with the latest F# May 2009 CTP (1.9.6.16) and the results are now available to our beta release scheme subscribers.

Although the latest version of F# contains many improvements and breaking changes, the updates turned out to be relatively straightforward and the resulting libraries passed all tests first time. Congratulations to the F# team for such a polished release! We recommend that all users upgrade to the latest F# for a better development experience.

Pythagoras Tree

2009-05-21T21:30:00.005Z

A Pythagoras tree is a simple vector graphics image:

The following F# program uses the F# for Visualization library to render this image:

#light

open System.Windows.Media
open FlyingFrog.Graphics

let pi = System.Math.PI

let rotate t = RotateTransform(t / pi * 180.).Value

let branches m =
  [ m * rotate(pi/2. - asin(4. / 5.)) * scale(4. / 5., 4. / 5.) *
      translate(0., 1.);
    m * translate(-1., 0.) * rotate(-pi/2. + asin(3. / 5.)) *
      scale(3. / 5., 3. / 5.) * translate(1., 1.) ]

let line_loop xys = Contour.Closed [ for x, y in xys -> line_to x y ]

let square = line_loop [1., 0.; 1., 1.; 0., 1.; 0., 0.]

let shape brush m =
  Shape([ Interior brush;
          Stroke(Brushes.DarkGreen, { width = 0.01 }) ],
        [ Contour.map (fun p -> p * m) square ])

let trunks brush ms = Group(List.map (shape brush) ms)

let rec tree n ms =
  if n=0 then [trunks Brushes.Green ms] else
    let ms' = List.collect branches ms
    trunks Brushes.BurlyWood ms :: tree (n-1) ms'

do
  let view = View(Group[])
  for n = 1 to 12 do
    view.Scene <- Group(tree n [Matrix.Identity])
  Run()

Download and run the demo!.

F# 1.9.6.16 released

2009-05-21T11:45:00.004Z

Don Syme has announced the release of a new version of F# that replaces the old F# September 2008 CTP. This new release brings F# much more into alignment with the rest of .NET 4, in preparation for the first full product release of F# in Visual Studio 2010. The release is available either as part of the latest Visual Studio 2010 beta or as a separate F# May 2009 CTP that works with Visual Studio 2008.

Many of the improvements in the new version of F# are breaking changes that require existing software to be updated, such as the renaming of basic functions. For example, the List.fold_right function from OCaml has been renamed List.foldBack. We are in the process of bringing our F# for Visualization and F# for Numerics libraries up to date with respect to the latest F# CTP. Our forthcoming book F# for Technical Computing will not only cover the latest version of F# but also all of the latest library versions and new techniques for integration and interoperability.

F# for Numerics 0.1.0.0 released

2009-05-21T00:02:00.004Z

F# for Numerics 0.1.0.0 has just been released. This includes a wealth of new features and improvements such as:

Numerical integration.
Bessel functions.
Skewness and kurtosis.
Series: natural numbers, Fibonacci, primes.
Seeding of Mersenne Twister with a uint32.
Constants: epsilon_float32 and delta32.

Subscribe to our beta release scheme today!

F# for Visualization 0.3.2.1 released

2009-05-20T13:32:00.002Z

F# for Visualization 0.3.2.1 has just been released. This includes bug fixes, performance improvements and new examples.

Purely functional data structures: real-time queues and catenable lists

2009-05-20T12:06:00.001Z

The F#.NET Journal just published an article about data structures:

"This is the second article in a series describing the design and implementation of some purely functional data structures. Real-time queues and catenable lists that provide reliable O(1) time complexity operations are described in detail. In particular, laziness is used to ensure that operations are performed efficiently even when the data structures are used persistently. This culminates in the creation of some useful new data structure implementations...."

To read this article and more, subscribe to The F#.NET Journal today!

Nice F# screencast by Jason Olson

2009-05-11T02:19:00.004Z

Jason Olson has done a great beginners introduction to F# in the form of a video of him walking the viewer through F# using an interactive session.

In particular, Jason explains many of the basic features of the F# language that surprise beginners who have never seen an interactive statically-typed functional programming language before. This is recommended viewing for anyone struggling with basic features like patterns and curried functions.

F# as a next-generation platform for high-performance interactive technical computing

2009-05-07T01:15:00.007Z

We are now in the throws of writing a new book on F# called F# for Technical Computing that is due out in a few months. Amongst other things, we are generating diagrams for the book using our own F# for Visualization library and making extensive use of our F# for Numerics library and Microsoft's excellent Parallel Extensions to .NET Framework 3.5 June 2008 CTP in order to build a next-generation platform for high-performance interactive technical computing.

The following screenshot shows the real-time visualization of performance measurements over the array, list and set data structure implementations provided with the F# September 2008 CTP:

There are several interesting aspects to this F# program:

Individual benchmarks for a given data structure are executed in parallel in order to obtain results faster without artificially degrading the measurements for other data structures via GC load.
The parallelism is so effective that 90% CPU usage is sustained across all 8 cores.
Parallel threads update the visualizations concurrently in real time safe in the knowledge that F# for Visualization handles all thread-related issues automatically and efficiently.
The randomized algorithms in the benchmarks are fuelled by the high-performance Mersenne Twister implementation in our F# for Numerics library.
The entire program is under 80 lines of code.
The resulting high-fidelity diagrams are ideal for inclusion in quality printed literature such as our full-color books.

Here is the entire source code:

open FlyingFrog
open FlyingFrog.Graphics
open FlyingFrog.Graphics.Typeset
let log2 x =
  log x / log 2.0
let plot_mem =
  Plot([], (0., 20.), (-25., 0.0),
       Labels=(Char 'n', Sub(Char 't', Text "mem")))
let plot_mem_rel =
  Plot([], (0., 20.), (0., 20.0),
       Labels=(Char 'n', Fraction(Sub(Char 't', Text "set"), Sub(Char 't', Text "array"))))
let plot_iter =
  Plot([], (0., 20.), (-30., -20.0),
       Labels=(Char 'n', Sub(Char 't', Text "iter")))
let plot_foldl =
  Plot([], (0., 20.), (-30., -20.0),
       Labels=(Char 'n', Sub(Char 't', Text "foldl")))
let plot_foldr =
  Plot([], (0., 20.), (-30., -20.0),
       Labels=(Char 'n', Sub(Char 't', Text "foldr")))
let tss =
  [for plot in 1 .. 4 ->
    [for i in 1 .. 3 ->
      [for i in 0 .. 101 -> float i, infinity]]]
let iters = 4001
let inline time f n m =
  let rand = Random.MersenneTwister()
  let t = System.Diagnostics.Stopwatch.StartNew()
  let mutable j = 0
  while t.ElapsedMilliseconds < 100L do
    for k=0 to j do
      f (abs(rand.int()) % n) m
      j <- j + 1   float t.ElapsedMilliseconds / 1e3 / float j
let inline run d f mem iter foldl foldr =
  System.Threading.Parallel.For(0, iters, fun i' ->
    let i = iters * i' % 101
    let n = 2. ** (float i / 100. * 20.) > int
    let m = f n
    let t' = time mem n m > log2
    if snd tss.[0].[d].[i] > t' then
      tss.[0].[d].[i] <- log2(float n), t'
    for f, tss in [iter, tss.[1]; foldl, tss.[2]; foldr, tss.[3]] do
      let t' = (time f n m / float n) > log2
      if snd tss.[d].[i] > t' then
        tss.[d].[i] <- log2(float n), t'
    if i' % 100 = 0 then
      plot_mem.Data <- [for ts in tss.[0] -> Data ts]
      plot_mem_rel.Data <-
        [Data(Array.map2 (fun (i, ts) (_, ta) -> i, 2. ** ts / 2. ** ta)
                tss.[0].[0] tss.[0].[2])]
      plot_iter.Data <- [for ts in tss.[1] -> Data ts]
      plot_foldl.Data <- [for ts in tss.[2] -> Data ts]
      plot_foldr.Data <- [for ts in tss.[3] -> Data ts]
    )
let inline array_mem x (a: _ array) =
  let rec aux i =
    i < Array.length a && (a.[i] = x  aux(i+1))
  aux 0
do
  run 2 (fun n -> Array.init n (fun i -> float i))
    (fun n m -> ignore(array_mem (float n) m))
    (fun n m -> Array.iter ignore m)
    (fun n m -> Array.fold_left ( + ) 0.0 m > ignore)
    (fun n m -> Array.fold_right ( + ) m 0.0 > ignore)
  run 0 (fun n -> set (seq {for i in 0 .. n-1 -> float i}))
    (fun n m -> ignore(Set.mem (float n) m))
    (fun n m -> Set.iter ignore m)
    (fun n m -> Set.fold_left ( + ) 0.0 m > ignore)
    (fun n m -> Set.fold_right ( + ) m 0.0 > ignore)
  run 1 (fun n -> [for i in 0 .. n-1 -> float i])
    (fun n m -> ignore(list_mem (float n) m))
    (fun n m -> List.iter ignore m)
    (fun n m -> List.fold_left ( + ) 0.0 m > ignore)
    (fun n m -> List.fold_right ( + ) m 0.0 > ignore)
Run()

Re: Microsoft canning F#

2009-05-04T17:27:00.003Z

We went to Cambridge to meet Don Syme last week and attended a great lecture by Tom Wickham-Jones from Wolfram Research. I spoke to Don about the concerns among some of our customers regarding the future of F# and he assured me that they are focused entirely on forthcoming releases with a schedule that spans years. The next release, beta 1, is due out this month and a beta 2 is scheduled for release before the full 2010 release next year.

Purely functional data structures: streams and batched queues

2009-05-04T03:08:00.003Z

The F#.NET Journal just published an article about data structures:

"This article is the first in a series describing the design and implementation of some very useful purely functional data structures. Lazy evaluation, lazy streams and batched queues are described in detail. In particular, new .NET interfaces, classes and objects are used factor the implementations of the data structures and various built-in interfaces are implemented in order to support equality, comparison and hashing of these new data structures...."

To read this article and more, subscribe to The F#.NET Journal today!

Massive savings on F# for Visualization and F# for Numerics

2009-04-19T23:22:00.003Z

We just slashed the price of source code licenses for our F# for Visualization and F# for Numerics libraries.

F# for Visualization augments F# with graphing and visualization capabilities that can be used directly from F# interactive sessions running in Visual Studio itself, as well as WPF Controls that can be used in your own standalone programs. Plot 2D functions and 3D functions, 3D objects and embed the visualization capabilities in your own programs with our reusable Windows Presentation Foundation controls. Read the full documentation here.

F# for Numerics provides a wide variety of invaluable numerical methods with elegant F# interfaces that allow you to solve numerical problems quickly and easily from the comfort of F#, both interactively and in your own standalone programs. Read the full documentation here.

Lempel-Ziv-Welch data compression

2009-04-16T00:58:00.002Z

The F#.NET Journal just published an article about data compression:

"LZW is a simple and effective dictionary-based data compression algorithm originally published in 1984 and subsequently used in several prominent places including the GIF image format. This article describes simple purely-functional implementations of the compression and corresponding decompression algorithms before examining the translation and optimization of these algorithms into longer but more efficient imperative equivalents. In particular, F#'s sequence expressions are used extensively to create on-the-fly compressors and decompressors ideal for stream processing...."

To read this article and more, subscribe to The F#.NET Journal today!

Book review: F# for Scientists

2009-04-08T17:02:00.005Z

Mike Hadlow, a freelance .NET developer from Brighton England, recently wrote a review of our book F# for Scientists:

"I read most of F# for Scientists by Dr Jon Harrop over the Christmas holidays. Now, don’t be put of by the title, it’s a really wonderful little book. I’m no scientist, my undergraduate degree was a general social science pick and mix affair, but I found most of it straightforward. I had to skip some of the complex mathematics but that didn’t seem to hurt my appreciation of programming principles being discussed.
It’s really nice to find a small programming book. Far too many assume too little intelligence from the reader and waffle at length on trivial subjects. It doesn’t help that the IT profession seems to value its books by the killogram. Dr Harrop doesn’t suffer from either of these traits and is happy to introduce difficult subjects in a concise and direct style. Now that means that I sometimes had to spend a while on each page to make sure I understood it, but that’s far better than reading page after page of whatever for dummies.
If I’ve taken anything from this book, it’s a much better understanding of currying. I talked about it a while back when discussing an excellent presentation of functional C# by Oliver Sturm, but at that time I hadn’t understood how central it was to understanding F#..."

Thanks Mike!

Don't forget we are drawing upon the expertise we gained from the feedback about F# for Scientists in our forthcoming book F# for Technical Computing that will cover all of the latest libraries including parallel and concurrent programming the F# way.

Aperiodic tilings

2009-03-31T05:42:00.001Z

The F#.NET Journal just published an article about the generation and visualization of tilings using F#:

"Many sets of polygons can be used to tile an infinite 2D plane. The term "aperiodic tilings" is used informally to refer to tilings that are not periodic. Such tilings are not only of mathematical and scientific interest because they give rise to unexpected diffraction patterns when they appear in quasicrystalline materials but also because they are often beautiful and, consequently, have been used in ornamental decorations for centuries. This article describes a simple program that visualizes tilings using Windows Presentation Foundation where the tilings are described using generic rewrite rules implemented in terms of a .NET interface...."

To read this article and more, subscribe to The F#.NET Journal today!

Retraining? Consider F#...

2009-03-29T01:40:00.004Z

I was just chatting with a friend who is a Microsoft certified trainer and he mentioned that the recession has boosted their turnover significantly as many people are earning new qualifications to in order to prepare themselves for today's highly-competitive hi-tech job market.

Employers have been quick to recognise that bleeding-edge programming languages like F# are an excellent way for them to identify the most motivated and intelligent applicants for a wide range of programming-related jobs.

So why not put F# at the top of your list of languages to learn in 2009?

Here are some resources to help you get started: