anchor.diff:  
   [<AutoOpen>]
   module ForwardOps =
  -    
  +    /// Original value and first derivative of a scalar-to-scalar function `f`, at point `x`
       let inline diff' f x =
           x |> dualP1 |> f |> tuple
   
  +    /// First derivative of a scalar-to-scalar function `f`, at point `x`
       let inline diff f x =
           x |> dualP1 |> f |> tangent
   
  +    /// Second derivative of a scalar-to-scalar function `f`, at point `x`
       let inline diff2 f x =
           diff (diff f) x
   
  +    /// Original value, first derivative, and second derivative of a scalar-to-scalar function `f`, at point `x`
       let inline diff2'' f x =
           let v, d = diff' f x
           let d2 = diff2 f x
           (v, d, d2)
   
  +    /// Original value and second derivative of a scalar-to-scalar function `f`, at point `x`
       let inline diff2' f x =
           diff2'' f x |> fsttrd
   
  +    /// `n`-th derivative of a scalar-to-scalar function `f`, at point `x`
       let diffn n f x =
           if n < 0 then invalidArg "" "Order of differentiation cannot be negative."
           elif n = 0 then x |> dual |> f
  
positive.code:                 | 1 -> f
                  | _ -> d (n - 1) (diff f)
              x |> dualP1 |> (d n f) |> tangent
  
      let diffn' n f x =
          (diffn 0 f x, diffn n f x)
  
      let inline gradv' f x v =
          let i = GlobalTagger.Next
          Array.map2 (dualIPT i) x v |> f |> tuple
  
      let inline gradv f x v =
          gradv' f x v |> snd
  
      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)
  
      let inline grad f x =
          grad' f x |> snd
  
      let inline laplacian' f (x:_[]) =
          let i = GlobalTagger.Next
          let a = Array.init x.Length (fun j ->
  
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)
  