Back to Questions
1.4k
views4
comments
VB to F# interface for large binary arrays
f#classes

What is the best practice to interface large Visual Basic binary arrays with F#

routines?

I have an established library of Visual Basic classes to handle the manipulation of scientific data which lives in a file format of mixed binary and text. We use a 4GL to do some number crunching on the data and I thought I might do some benchmark comparisons in pure .NET. Steffen Forkmann had a .NET blog with a cluster analysis routine written in F#, so I thought I'd try calling that from my Visual Basic code.

[link:www.navision-blog.de]

My Visual Basic code loads the data into generic arrays, either short or double depending upon the particular data file.

VBData() as short

VBData() as double

I attempted to test the transfer of data from VB to F# with a simply mean function in order to get a feel for F#.

Dim test = FCSDataLibrary.FCSData.mean(objFCS.VBData())

where 'mean' is

let mean xs =

Seq.fold ( + ) 0.0 xs / float(Seq.length xs)

I received a casting error going from VB to F#

VB is 'System.Int16[]'

F# is expecting 'System.Collections.Generic.IEnumerable`1[System.Double]'

That seems to make sense due to the '0.0' locking the type into double. However, I thought the .NET framework would be able to handle the casting of array to System.Collections.Generic.IEnumerable.

My question, which end should I adjust for the most efficient F# array. The cluster interface is generic:

let kMeansClustering K dimensions epsilon

(items:'a array when 'a :> IClusterable) =

let k = if K <= 0 then 1 else K

let rec clustering lastError (clusters:Cluster<'a> array) =

let newClusters =

AssignItemsToClusters k dimensions clusters items

let newError = calcClusterError newClusters

if abs(lastError - newError) > epsilon then

clustering newError newClusters

else

newClusters,newError

InitClusters k dimensions items

|> clustering Double.PositiveInfinity

dgp

.

I am unclear what your actual question is, so here are a couple comments.

The 'mean' function you have is inefficient. If you intend to work with arrays, use Array.fold & Array.length; as it stands, e.g. Seq.length is O(N) as it re-walks the IEnumerable.

I don't think an array of shorts can be implicitly 'cast' to an IEnumerable<double> in any language (though I could be wrong). You want the F# and VB code to both use the same numeric data types. An array of int can be passed to a function expecting an IEnumerable<int> in every language, I think.

By on 5/3/2010 8:57 AM ()

1) I got the 'mean' function from an example in F# for Scientists. I was more concerning with passing the data, than the efficiency. Yet, I will be very interested in efficiency once I get the basics working, so I'll move to the array structure.

2) The actual question was, should I cast on the VB side or the F# side and what is the best internal format. From your answer, I should be good with maintaining an array on both sides.

3) I changed the '0.0' to '0', but now I get a cast error from int16 to int32. I'll keep playing around.

dgp

By on 5/3/2010 11:27 AM ()

See the docs

[link:msdn.microsoft.com]

to find out that e.g. "0s" is a signed 16-bit zero.

By on 5/3/2010 11:46 AM ()

You can perform the conversion on either side; on the F# side, your function might look like:

1
2
3
4

let mean (xs:seq<int16>) =
  xs
  |> Seq.map float
  |> Seq.average

This takes a sequence, but since arrays are sequences this should work on your VB data without any problems. The key is the first step, which converts the int16 values to floats by mapping over the sequence. In other words, you can pass an int16[] where a seq<int16> is expected, but you can't pass an int16[] where a seq<float> is expected.

By on 5/3/2010 11:42 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