System.ArithmeticException not thrown in F#

Consider the following code

let a = 5. / 0.
let b = sin a
let c = sqrt(-5.)

It produces both Infinity and NaN. In both cases I want to have an exception thrown (for debuging purposes).

I use Visual Studio 2010. I set up Debug/Exceptions.../Common Language Runtime Exceptions/Syst开发者_开发问答em/System.ArithmeticException to "Thrown", but when running the code, no exception is thrown.

Any idea why and how to throw an exception on NaN or Infinity?

As others noted, you'll have to check for the NaN condition explicitly. If you wanted to do this using some advanced F# features, then you could also use computation expressions.

It is possible to define a builder that automatically checks for Nan when you bind value using let!. Then you could write something like:

check { let! a = 5. / 0.    // 'a' is checked here
        let! b = sin a      // 'b' is checked here
        let c = sqrt(-5.)   // 'c' is not checked (no 'let!')
        return a, b, c }

This may be too complicated mechanism for just simple checks, but I find it quite nice. The definition of the computation builder looks like this (you'll need to add While, For and some others to support all language constructs):

open System

type CheckedBuilder() = 
  member x.Bind(v:float, f) = 
    if Double.IsNaN(v) |> not then f v
    else raise (new ArithmeticException())
  member x.Return(v) = v

let check = CheckedBuilder()

If you want an arithmetic exception, try dividing an integer by zero. The System.Double type (float in F#) by design does not throw exceptions (all exceptional circumstances end up at NaN).

From the MSDN docs:

The floating-point operators, including the assignment operators, do not throw exceptions. Instead, in exceptional situations the result of a floating-point operation is zero, infinity, or NaN....

Update: If you want exceptions to be thrown in cases of Infinity or NaN, I would offer the same advice as desco and suggest you wrap the methods you want to call.

Unfortunately, I'm not familiar enough with F# to give code examples in your language of choice; but in C# you might do this for example for a sqrt function:

public static double CheckedSqrt(double x)
{
    double sqrt = Math.Sqrt(x);
    if (double.IsNaN(sqrt))
    {
        throw new ArithmeticException("The square root of " + x + " is NaN.");
    }

    return sqrt;
}

Update 2: Yet another option would be to write your own wrapper for the double type itself which does not allow Infinity or NaN values (again, the below is C#—I apologize if this isn't possible in F# in which case I'm giving you absolutely useless advice):

public struct CheckedDouble // : IEquatable<CheckedDouble>, etc.
{
    double m_value;

    public CheckedDouble(double value)
    {
        if (double.IsInfinity(value) || double.IsNaN(value))
        {
            throw new ArithmeticException("A calculation resulted in infinity or NaN.");
        }

        m_value = value;
    }

    public static implicit operator CheckedDouble(double value)
    {
        return new CheckedDouble(value);
    }

    public static implicit operator double(CheckedDouble checkedDouble)
    {
        return checkedDouble.m_value;
    }
}

Then wherever you're writing code where you don't want to allow Infinity or NaN, use this type rather than double directly.

Just another option.

think, this is possible only by providing your custom wrappers over sin\sqrt. Current behavior is documented for Math.Sqrt and Math.Sin.