anchor.diff:          if (float a) <= 0. then invalidArgLog()
           match a with
           | D(a) -> D(log a)
  -        | DD(ap, at, ai) -> DD(log ap, at / ap, ai)
  +        | DF(ap, at, ai) -> DF(log ap, at / ap, ai)
       static member Log10 (a:D) =
           if (float a) <= 0. then invalidArgLog10()
           match a with
           | D(a) -> D(log10 a)
  -        | DD(ap, at, ai) -> DD(log10 ap, at / (ap * log10val), ai)
  +        | DF(ap, at, ai) -> DF(log10 ap, at / (ap * log10val), ai)
       static member Exp (a:D) =
           match a with
           | D(a) -> D(exp a)
  -        | DD(ap, at, ai) -> let expa = exp ap in DD(expa, at * expa, ai)
  +        | DF(ap, at, ai) -> let expa = exp ap in DF(expa, at * expa, ai)
       static member Sin (a:D) =
           match a with
           | D(a) -> D(sin a)
  -        | DD(ap, at, ai) -> DD(sin ap, at * cos ap, ai)
  +        | DF(ap, at, ai) -> DF(sin ap, at * cos ap, ai)
       static member Cos (a:D) =
           match a with
           | D(a) -> D(cos a)
  -        | DD(ap, at, ai) -> DD(cos ap, -at * sin ap, ai)
  +        | DF(ap, at, ai) -> DF(cos ap, -at * sin ap, ai)
       static member Tan (a:D) =
           match a with
           | D(a) -> 
               if cos a = 0. then invalidArgTan()
               D(tan a)
  -        | DD(ap, at, ai) ->
  +        | DF(ap, at, ai) ->
               let cosa = cos ap
               if (float cosa) = 0. then invalidArgTan()
  -            DD(tan ap, at / (cosa * cosa), ai)
  +            DF(tan ap, at / (cosa * cosa), ai)
       static member (~-) (a:D) =
           match a with
           | D(a) -> D(-a)
  -        | DD(ap, at, ai) -> DD(-ap, -at, ai)
  +        | DF(ap, at, ai) -> DF(-ap, -at, ai)
       static member Sqrt (a:D) =
           if (float a) <= 0. then invalidArgSqrt()
           match a with
           | D(a) -> D(sqrt a)
  -        | DD(ap, at, ai) -> let sqrta = sqrt ap in DD(sqrta, at / (2. * sqrta), ai)
  +        | DF(ap, at, ai) -> let sqrta = sqrt ap in DF(sqrta, at / (2. * sqrta), ai)
       static member Sinh (a:D) =
           match a with
           | D(a) -> D(sinh a)
  -        | DD(ap, at, ai) -> DD(sinh ap, at * cosh ap, ai)
  +        | DF(ap, at, ai) -> DF(sinh ap, at * cosh ap, ai)
       static member Cosh (a:D) =
           match a with
           | D(a) -> D(cosh a)
  -        | DD(ap, at, ai) -> DD(cosh ap, at * sinh ap, ai)
  +        | DF(ap, at, ai) -> DF(cosh ap, at * sinh ap, ai)
       static member Tanh (a:D) =
           match a with
           | D(a) -> D(tanh a)
  -        | DD(ap, at, ai) -> let cosha = cosh ap in DD(tanh ap, at / (cosha * cosha), ai)
  +        | DF(ap, at, ai) -> let cosha = cosh ap in DF(tanh ap, at / (cosha * cosha), ai)
       static member Asin (a:D) =
           if abs (float a) >= 1. then invalidArgAsin()
           match a with
           | D(a) -> D(asin a)
  -        | DD(ap, at, ai) -> DD(asin ap, at / sqrt (1. - ap * ap), ai)
  +        | DF(ap, at, ai) -> DF(asin ap, at / sqrt (1. - ap * ap), ai)
       static member Acos (a:D) =
           if abs (float a) >= 1. then invalidArgAcos()
           match a with
           | D(a) -> D(acos a)
  -        | DD(ap, at, ai) -> DD(acos ap, -at / sqrt (1. - ap * ap), ai)
  +        | DF(ap, at, ai) -> DF(acos ap, -at / sqrt (1. - ap * ap), ai)
       static member Atan (a:D) =
           match a with
           | D(a) -> D(atan a)
  -        | DD(ap, at, ai) -> DD(atan ap, at / (1. + ap * ap), ai)
  +        | DF(ap, at, ai) -> DF(atan ap, at / (1. + ap * ap), ai)
       static member Abs (a:D) =
           if (float a) = 0. then invalidArgAbs()
           match a with
           | D(a) -> D(abs a)
  -        | DD(ap, at, ai) -> DD(abs ap, at * float (sign (float ap)), ai)
  +        | DF(ap, at, ai) -> DF(abs ap, at * float (sign (float ap)), ai)
       static member Floor (a:D) =
           if isInteger (float a) then invalidArgFloor()
           match a with
           | D(a) -> D(floor a)
  -        | DD(ap, _, ai) -> DD(floor ap, D 0., ai)
  +        | DF(ap, _, ai) -> DF(floor ap, D 0., ai)
       static member Ceiling (a:D) =
           if isInteger (float a) then invalidArgCeil()
           match a with
           | D(a) -> D(ceil a)
  -        | DD(ap, _, ai) -> DD(ceil ap, D 0., ai)
  +        | DF(ap, _, ai) -> DF(ceil ap, D 0., ai)
       static member Round (a:D) =
           if isHalfway (float a) then invalidArgRound()
           match a with
           | D(a) -> D(round a)
  -        | DD(ap, _, ai) -> DD(round ap, D 0., ai)
  +        | DF(ap, _, ai) -> DF(round ap, D 0., ai)
   
   
   /// Tagger for generating incremental integers
  
positive.code:     /// Original value and Jacobian-vector product of a vector-to-vector function `f`, at point `x`, along vector `v`
      let inline jacobianv' f x v =
          let i = GlobalTagger.Next
          Array.map2 (dualIPT i) x v |> f |> Array.map tuple |> Array.unzip
  
      /// Jacobian-vector product of a vector-to-vector function `f`, at point `x`, along vector `v`
      let inline jacobianv f x v =
  
negative.code:     /// Original value and gradient-vector product (directional derivative) of a vector-to-scalar function `f`, at point `x`, along vector `v`
      let inline gradv' f x v =
          let i = GlobalTagger.Next
          Array.map2 (makeDFIPT i) x v |> f |> tuple
  
      /// Gradient-vector product (directional derivative) of a vector-to-scalar function `f`, at point `x`, along vector `v`
      let inline gradv f x v =
  