anchor.diff:          trgt.Backend.FillConst (trgt=trgt, value=Tensor<'T>.Zero)
           trgt.Backend.Scatter (trgt=trgt, trgtIdxs=indices, src=src)
   
  -    /// Creates a new tensor of shape trgtShp by dispersing elements from src according to 
  -    /// the specified target indices.
  -    /// If an index occurs multiple times the corresponding values are summed.
  -    /// Target elements that do not occur, are set to zero.
  -    /// Indices must be a list of Tensor<int64> options, one per dimension of trgt and of the same shape
  -    /// (or broadcastable to) as src.
  -    /// If None is specified instead of a tensor in an dimension, the source index will match the 
  -    /// target index in that dimension.
  +    /// <summary>Disperses elements from a source tensor to a new tensor according to the specified indices.</summary>
  +    /// <param name="indices">A list of tensors, one per dimension of this tensor, containing the target indicies
  +    /// for each element of <paramref name="src"/>.</param>
  +    /// <param name="trgtShp">The shape of the resulting tensor.</param>    
  +    /// <param name="src">The tensor containing the source values.</param>    
  +    /// <returns>Result with the shape specified in <paramref name="trgtShp"/>.</returns>
  +    /// <example><code language="fsharp">
  +    /// </code></example>
  +    /// <remarks>
  +    /// <para>The source element with indices <c>[i_0; i_1; i_2; ...]</c> is written to the target element with indices 
  +    /// <c>[j_0; j_1; j_2; ...]</c>, where each index <c>j_k</c> is given by <c>j_k = indices.[k].[i_0; i_1; i_2; ...]</c>.
  +    /// If <c>indices.[k]</c> is <c>None</c>, then <c>j_k = i_k</c> is assumed instead.</para>
  +    /// <para>If a target index occurs multiple times, the corresponding source values are summed.
  +    /// If a target element is not referenced by any index, it is set to zero.</para>
  +    /// <para>The tensors <paramref name="indices"/> and <paramref name="src"/> must have the same storage.</para>
  +    /// </remarks>
  +    /// <seealso cref="FillScatter"/><seealso cref="gather"/>
       static member scatter (indices: Tensor<int64> option list) (trgtShp: int64 list) (src: Tensor<'T>) =
           let trgt = Tensor<'T> (trgtShp, src.Dev)
           trgt.FillScatter indices src
  
positive.code:     /// <remarks>Logically negates each element of the specified tensor and writes the result into this tensor.
      /// This tensor and <paramref name="a"/> must be of type <c>bool</c>.
      /// This tensor and <paramref name="a"/> must have the same shape and storage.</remarks>
      /// <seealso cref="~~~~"/>
      member trgt.FillNegate (a: Tensor<bool>) = 
          let trgt = trgt.AsBool
          let a = Tensor.PrepareElemwiseSources (trgt, a)
  
negative.code:     /// <remarks>Multiplies each element of tensor <paramref name="a"/> to the corresponding element of tensor <paramref name="b"/>
      /// and writes the result into this tensor.
      /// This tensor, <paramref name="a"/> and <paramref name="b"/> must have the same type and storage.</remarks>
      /// <seealso cref="op_Multiply"/>
      member trgt.FillMultiply (a: Tensor<'T>) (b: Tensor<'T>) = 
          let a, b = Tensor.PrepareElemwiseSources (trgt, a, b)
          trgt.Backend.Multiply (trgt=trgt, src1=a, src2=b)
  