anchor.diff:          Tensor.OpBinary(a, b, fRaw, fTensor, dfFwdTT, dfFwdTC, dfFwdCT, dfRevTT, dfRevTC, dfRevCT)
   
       /// <summary>Applies a softmax function.</summary>
  -    /// <remarks>Softmax is defined as: \text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}.</remarks>
  +    /// <remarks>Softmax is defined as: \text{softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}.</remarks>
       /// <param name="dim">A dimension along which softmax will be computed.</param>
       member a.softmax(dim:int) =
           let dim = Shape.completeDim a.dim dim  // Handles -1 semantics
  
positive.code:         a.clamp(low=epsilon).log()
  
      /// <summary>Applies the softplus function element-wise.</summary>
      /// <remarks>\[\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))\]</remarks>
      member a.softplus() =
          let inline fRaw(a:RawTensor) = a.SoftplusT()
          let inline fTensor(a:Tensor) = a.softplus()
  
negative.code:         if hot < 0 || hot >= length then failwithf "Expecting 0 <= hot < length"
          a.zerosLike([|length|], ?dtype=dtype, ?device=device, ?backend=backend).addSlice([|hot|], a.onesLike([|1|], ?dtype=dtype, ?device=device, ?backend=backend))
  
      /// <summary>Computes element-wise \(a &lt; b\), returning a boolean tensor containing a <c>true</c> at each location where the comparison is true</summary>
      member a.lt(b:Tensor) = TensorC(a.primalRaw.LtTT(b.primalRaw))
  
      /// <summary>Computes element-wise \(a &gt; b\), returning a boolean tensor containing a <c>true</c> at each location where the comparison is true</summary>
      member a.gt(b:Tensor) = TensorC(a.primalRaw.GtTT(b.primalRaw))
  
      /// <summary>Computes element-wise \(a \leq b\), returning a boolean tensor containing a <c>true</c> at each location where the comparison is true</summary>
      member a.le(b:Tensor) =TensorC(a.primalRaw.LeTT(b.primalRaw))
  
      /// <summary>Computes element-wise \(a \geq b\), returning a boolean tensor containing a <c>true</c> at each location where the comparison is true</summary>
      member a.ge(b:Tensor) = TensorC(a.primalRaw.GeTT(b.primalRaw))
  
      /// <summary>Computes element-wise \(a = b\), returning a boolean tensor containing a <c>true</c> at each location where the comparison is true</summary>
      member a.eq(b:Tensor) = TensorC(a.primalRaw.EqTT(b.primalRaw))
  
      /// <summary>Returns a new tensor with boolean elements representing if each element is +/-INF or not.</summary>
  