anchor.diff:                      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
  +                match bisect 1e-14 (0.0,0.1) eq with Some root -> root | None -> (0.28 * len ** (-0.4))
                   
               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
  
positive.code: 
  
  
  let fi x = float(x)
  let _i_ = Complex.ImaginaryOne
  let _ip_ = Complex(0.0,1.0)
  let ifft (xs:Complex[]) = 
      let samples = Array.copy xs
      Radix2(samples,1)
  
negative.code: // 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.
  //
  // min Lower bound (@min@) of the mesh range.
  // max Upper bound (@max@) of the mesh range.
  // NaN in the sample are ignored.
  let kde2 n0 min max (sample:float seq) =
      /// find root with bisection method
      let bisect tolerance (lb, ub) (func : float->float) =
          let rec step a fa b fb =
              let m = 0.5 * (a+b)
              if abs(b-a) < 2.* tolerance then Some m
              else
                  let fm = func m
                  if sign fa = sign fm
                  then step m fm b fb
                  else step a fa m fm
          
          let flb = func lb
          let fub = func ub
          if sign flb = sign fub then None
          else step lb flb ub fub
      if sample = null then invalidArg "sample" "cannot be null"
      else if(n0 = 1) then invalidArg "n0" "cannot be 1"
      else
          let xs = Seq.filter (System.Double.IsNaN >> not) sample |> Array.ofSeq
          if Array.isEmpty xs then invalidArg "sample" "doesn't contain numeric values"
          let m_sqrt_2_pi = sqrt (2.0*pi)
          let m_sqrt_pi = sqrt pi
          let r = max - min
  