anchor.diff:                  | 1 -> f
                   | _ -> d (n - 1) (diff f)
               x |> dualP1 |> (d n f) |> tangent
  -
  +    
  +    /// Original value and `n`-th derivative of a scalar-to-scalar function `f`, at point `x`
       let diffn' n f x =
           (diffn 0 f x, diffn n f x)
   
  +    /// 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 (dualIPT 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 =
           gradv' f x v |> snd
   
  +    /// Original value and gradient of a vector-to-scalar function `f`, at point `x`
       let inline grad' f (x:_[]) =
           let a = Array.init x.Length (fun i -> gradv' f x (standardBasis x.Length i))
           (fst a.[0], Array.map snd a)
   
  +    /// Gradient of a vector-to-scalar function `f`, at point `x`
       let inline grad f x =
           grad' f x |> snd
   
  +    /// Original value and Laplacian of a vector-to-scalar function `f`, at point `x`
       let inline laplacian' f (x:_[]) =
           let i = GlobalTagger.Next
           let a = Array.init x.Length (fun j ->
  
positive.code:         match a with
          | Df(a) -> Df(atan2 a b)
          | D(ap, at, ai) -> D(D.Atan2(ap, b), (b * at) / (b * b + ap * ap), ai)
      static member (+) (a:float, b:D) =
          match b with
          | Df(b) -> Df(a + b)
  
negative.code:         match d with
          | Df(a) -> hash [| a |]
          | D(ap, at, ai) -> hash [|ap; at; ai|]
          // D - D binary operations
      static member (+) (a:D, b:D) =
          match a, b with
          | Df(a),         Df(b)         -> Df(a + b)
  