anchor.diff:              type GenericComparer(comparerType:ComparerType) = 
                   interface System.Collections.IComparer 
                   member  c.ComparerType = comparerType
  +
  +            let getPERNaNCompareToResult (comp:GenericComparer) =
  +                match comp.ComparerType with
  +                | ComparerType.PER_gt -> -2
  +                | ComparerType.PER_lt -> 2
  +                | _ -> raise (Exception "Invalid logic")
                       
               /// Implements generic comparison between two objects. This corresponds to the pseudo-code in the F#
               /// specification.  The treatment of NaNs is governed by "comp".
  
positive.code:                             | _ -> raise (Exception "invalid logic")
                          | f -> f
  
                      match pass2 with
                      | null -> makeCompareDelegate ty ty typedefof<GenericComparerObj<_>>
                      | f -> f
  
                  type Function<'relation, 'a>() =
                      static let func : Func<IComparer,'a, 'a, int> =
  
negative.code:                         if comp.ComparerType.Equals ComparerType.ER then
                              x.CompareTo yobj
                          else 
                              match xobj, yobj with
                              | (:? float as x), (:? float as y) -> 
                                  if System.Double.IsNaN x || System.Double.IsNaN y
                                      then getPERNaNCompareToResult comp
                                      else x.CompareTo y
                              | (:? float32 as x), (:? float32 as y) -> 
                                  if System.Single.IsNaN x || System.Single.IsNaN y
                                      then getPERNaNCompareToResult comp
                                      else x.CompareTo y
                              | _ -> x.CompareTo yobj
  
  