Back to Questions
1.7k
views2
comments
BigNat, infinite seq, break/continue ...
f#compiler

Hi,

I am currently developing a biological simulator and have some questions;
they are very related with my project but I hope that they will be usefull to establish skills in F#
(sorry for my bad english)

- At each step of the simulation, I have to compute the number of reagents, of each of a set of reaction, in a solution; these numbers are the multiplication of the binomial coefficients of each sub reagent.
The problem is that this calculation require to compute the factorial of some "big" number e.g. 10 000 ! / ( 9 000 ! * 1 ! )
the numbers can be as far as (System.Int32.MaxValue)!

mi first approach is to use this naive procedure

1
2
3
4
5
6
7
8
9
10
11
12

open Microsoft.FSharp.Math.Primitives.BigNat.BigNat;
open Microsoft.FSharp.Math.Primitives.BigNat;
// return (n!)/((n-k)! * k!)
let binomial(n,k)  : int =
    let a = factorial(BigNat.of_int (n - k) )
    let b = BigNat.factorial(BigNat.of_int k)
    let down = BigNat.mul a b
    let up = factorial(BigNat.of_int n)
    let output = ref 0
    if not (System.Int32.TryParse(BigNat.to_string (BigNat.div up down), output))
        then output := System.Int32.MaxValue ; print_any("approximation!")
    !output

is BigNat the right type ? ( I also had look to unit64 but this structure is not CLS-compliant)

I do not succeed to find the overloaded conversion operators for and from BigNat;
e.g. i would like to do

1
2

let seven = uint16 7
let verybig = bignat 10000000000000000000000000000

What I miss ?

There are no library methods to convert back BigNat to Int32, what could I use ? ( I think that any thing is better than parse it from string representation)

- I had read in the draft chapters of "Expert F#" that is possible to have infinite seq like

1

{0 .. }

but with the 1.9.1.9 compiler I had a syntax error.
What I do wrong ?

- in some procedure i have to visit some trees ad I would like have something like "break" or "continue" in c#. There are something similar in F# to break the execution of for / while ?

- I would like to plot data from the simulation engine in real time
(each concentration have to be computed on request)

in pseudo code I think at something like this

1
2
3
4
5
6
7
8
9
10
11

let concentrations () : seq<concentration> =
    while(clock<stop) do
         let matchSet = getMatch(currentState, rules)
         let(t, reaction) = Gillespie(matchSet)
         clock += t
         updateState(reaction)
         yield getConcentration(state)
done

for c in concentrations
    plot(concentrations)

currently I use a for, limited on the number of iteration (I do not use seq), and do not test if clock<stop, but I am looking for something more elegant

1
2
3
4
5
6
7
8
9
10

initState()

let getNextConcentration =
     let matchSet = getMatch(currentState, rules)
     let(t, reaction) = Gillespie(matchSet)
     clock += t
     updateState(reaction)
     getConcentration(state)

for i in {0 .. Iterations} plot(getNextConcentration)

every suggestion is welcome.
Thanks to all,

Best regards

gs

.

Q1. I would use BigInt. BigNat is really an internal type and it should be hidden.

Q2. You are right there is no overload "bigint". The BigInt module has the to_int32, of_int32 etc. functions you need.

Q3. re:

I read ... that is possible to have infinite seq ... { 0 .. }

This was marked with a "Not Yet Implemented" comment. Just use Seq.init_infinite.

Q4. in some procedure i have to visit some trees ad I would like have something like "break" or "continue" in c#. There are something similar in F# to break the execution of for / while ?

In this situation you should almost certainly recode the function as a recursive function. It's an important technique to learn, and you will find yourself using a lot less mutable local state once you learn it. e.g. 

1
2
3
4
5
6

 

   let rec loop n = 

      if n > LIM then ... else loop (n+1)

etc.

Q5. I would like to plot data from the simulation engine in real time (each concentration have to be computed on request)

I assume you want your simulation to run "full throttle", computing the results at the maximum rate while having them visualized in some way.

A major choice you will have is whether to go multi-threaded or single-threaded. The DirectX 3D visualization demo is single threaded: the paint loop endlessly repaints and the simulation is computed on the GUI thread. This is not a bad choice when prototyping. However if any single step of the computation becomes too long then it causes real problems with a non-responsive or "messed up" GUI.

So ultimately you should be prepared to build a worker that runs in its own thread. This can either "push" results back to a GUI control (e.g. by raising events on the GUI thread) or write its results into some other "sink" for the data (e.g. a queue of pending updates). In the first case the GUI adds event handlers to the events, and in the second case can query the worker (e.g. dequeue updates from the queue) whenever it's able to do a redraw. Note that:

  • Uncontrollable computations are a real pain. The worker should almost certainly respond to signals such as "pause" and "cancel", which get triggered by buttons. This can be done by checking shared state flags or by looking at a message queue.
  • If the worker is producing results very rapidly you may have to slow it down or reduce the reported result rate to ensure a good response from the GUI. It's very important you keep a good user experience in this kind of application - often more important than producing results at the fastest rate possible.

Chapter 14 of the Expert F# book deals with some of these topics, though not in nearly as much depth as I would wish - I have a draft available that I can send you if you would like to read it - I'd actually really like feedback on this chapter from people interested in building simulations as it is a main application area for F#. Send me your email address (mine is dsyme AT microsoft DOT com).

The ConcurrentLife sample in the F# distribution also does something like this. I've jsut updated that sample in our code tree and can send it to you.

The System.ComponentModel.BackgroundWorker class may also be of use to you.

regards

Don

By on 5/14/2007 2:55 PM ()

Many thanks; I did not hope of having an answer so complete, clear, and quick.
Your suggestions are always very useful.
Best regards and best wishes. gs

By on 5/15/2007 9:22 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper