hubFS: THE place for F#

Microsoft.FSharp.Math provides the type BigInt which is not provided by C#.
How can I benefit from this library from C#? What is the right way to access
the assembly?

using Microsoft.FSharp;
using Microsoft.FSharp.Math;
namespace FsharpBigInts {
    class Program    {
        static void Main(string[] args)      {
            BigInt x  = new ...;
            BigInt y = new ...;
            x = x + y;
} } }

Apologies for the delayed reply. In F# 1.1.12 the concrete type for BigInt lives at Microsoft.FSharp.Math.Types.BigInt.  If you open Microsoft.FSharp.Math.Types you should get a lot further, or at least make a type alias

  using bigint = Microsoft.FSharp.Math.Types.BigInt

In F# 1.1.13 the concrete type definition will actually be moving to Microsoft.FSharp.Math as part of a general library cleanup and rationalization.  So you went looking in the right place, it's just not there yet :-)   But you can always find out the concrete canonical type name using the documentation at http://research.microsoft.com/fsharp/manual/fslib/Microsoft.FSharp.type_bigint.html etc.

Don

 

Thank you Don!

The following works now. Is there a more efficient way to
interface to FSharps' BigInts?
--------------------------------------------------------------

using System;
using Bigint = Microsoft.FSharp.Math.Types.BigInt;
using Bignat = Microsoft.FSharp.Primitives.BigNat.BigNat;

namespace SharpFool
{
    class Program
    {
        static Bigint makeBigint(int n)
        {
            Bignat bn = new Bignat(1, new object[] { Math.Abs(n) });
            Bigint bi = new Bigint(Math.Sign(n), bn);
            return bi;
        }

        static Bigint Factorial(int n)
        {
            if (n < 0)
            {
                throw new System.ArgumentException(
                   ": n >= 0 required, but was " + n);
            }

            Bigint nFact = makeBigint(1);

            for (int i = 2; i <= n; i++)
            {
                nFact *= makeBigint(i);
            }
            return nFact;
        }

        static void Main(string[] args)
        {
            Bigint f = Factorial(32);
            Bigint g = Factorial(16);
            Console.WriteLine(f);
            Console.WriteLine(f / g);
            Console.ReadLine();
        }
    }
}
--------------------------------------------------------------

I still have a problem. What is the right way to
convert longs to BigInts? I tried

static Bigint makeBigint(long n)
{
   Bignat bn = new Bignat(1, new object[] { Math.Abs(n) });
   Bigint bi = new Bigint(Math.Sign(n), bn);
   return bi;
}

However, executing

    Bigint x = makeBigint(14L);
    Bigint y = makeBigint(long.MaxValue - 22L);
    x = x + y;

gives me an InvalidCastException.    
Thanks again.

This is an update which reflects the changes and enhancements of F# 1.1.13 in relation to my question.
Here the test case as it works now:

using System;
using BigInt  = Microsoft.FSharp.Math.BigInt;
using BigMath = Microsoft.FSharp.Math.BigIntModule;

namespace SharpFool
{
    public class UsingBigIntWithCsharp
    {
        static BigInt Factorial(int n)
        {
            if (n < 0)
            {
                throw new System.ArgumentException(
                   "n >= 0 required, but was " + n );
            }

            BigInt nFact = BigMath.one;

            for (int i = 2; i <= n; i++)
            {
                nFact *= BigMath.of_int(i);
            }
            return nFact;
        }

        static void Main(string[] args)
        {
            BigInt f = Factorial(132), g = Factorial(71);
            Console.WriteLine(f / g);
            Console.WriteLine(
                  BigMath.factorial(BigMath.of_int(132))
                / BigMath.factorial(BigMath.of_int(71))
            );
            Console.ReadLine();
        }
    }
}

Nice! Thanks for taking the time to post an update.

 

Well, there is a keen competition, and I read today the following announcement for the Microsoft pre-release software "Orcas" - January 2007 CTP.

"A new numeric type that provides support for very large numbers.
This is the first type that supports arbitrary range and will extend
to accommodate any large number as needed. This type lives in the
new System.Numeric namespace where all new numeric and arithmetic
features are going to reside. It supports all the basic arithmetic
operations including things like Pow, DivRem and GreatestCommonDivisor.
It implements the following interfaces: IFormattable, IComparable,
IComparable<BigInteger> and IEquatable<BigInteger>.
It is serliazable and immutable. It has implicit casts from all
basic integral types and explicit casts to/from all numeric type."

So BigInteger is here now soon and this thread is obsolete now.

Cheers SharpFool

Just as an update to save time for others, I went looking for the BigInteger class and found out that it was cut from .Net 3.5 but looks to be slated for .Net 4.0.

http://blogs.msdn.com/bclteam/archive/2008/01/04/where-did-biginteger-go-melitta-andersen.aspx