anchor.diff:  // n0 The number of mesh points to use in the uniform discretization
   // of the interval @(min,max)@.  If this value is not a power of
   // two, then it is rounded up to the next power of two.
  -let kde n0 (xs:float[]) =
  -    if(xs = null) then failwith "empty sample"     
  +let kde n0 (xs:float seq) =
  +    if(xs = null) then invalidArg "sample" "cannot be empty"
       else
           let mutable max = System.Double.MinValue
           let mutable min = System.Double.MaxValue
           let range =         
  -            if xs.Length = 0 then 
  +            if Seq.isEmpty xs then 
                   min <- 0.0
                   max <- 0.0
                   1.0  // unreasonable guess
               else
  -                for i in 0 .. xs.Length - 1 do
  -                  if max < (xs.[i]) then 
  -                       max <- xs.[i]
  -                  if min > (xs.[i]) then 
  -                       min <- xs.[i]
  -                if min = max then 1.0 else max - min
  +                xs |> Seq.iter (fun xsi -> 
  +                  if max < (xsi) then 
  +                       max <- xsi
  +                  if min > (xsi) then 
  +                       min <- xsi)
  +                if min >= max then 1.0 else max - min
           kde2 n0 (min - range/10.0) (max + range/10.0) xs
positive.code:                     if s=1 then h else go (s-1) (f si time) 
              
                  let eq x = x - (len * (2.0 * m_sqrt_pi) * go 6 (f 7.0 x)) ** (-0.4)
                  (fromRoot (0.28 * len ** (-0.4)) << ridders 1e-14 (0.0,0.1)) eq
                  
              let f2 b z = b * exp (sqr z * sqr pi * t_star * (-0.5)) 
              let a2 = Seq.map2 f2 a [| for i in 0..n0-1 do yield fi i |] |> Array.ofSeq
  
negative.code: 
  
  
  let private fi x = float(x)
  let _i_ = Complex.ImaginaryOne
  let _ip_ = Complex(0.0,1.0)
  
  /// Inverse FFT
  let ifft (xs:Complex[]) = 
      let samples = Array.copy xs
      Radix2(samples,1)
  