anchor.diff:      static member acos(a:Tensor) = a.acos()
       static member atan(a:Tensor) = a.atan()
       static member softmax(a:Tensor, dim:int) = a.softmax(dim)
  -    static member softmax (dim:int) = fun (a:Tensor) -> a.softmax(dim)
  +    static member softmax(dim:int) = fun (a:Tensor) -> a.softmax(dim)
       static member logsoftmax(a:Tensor, dim:int) = a.logsoftmax(dim)
  -    static member logsoftmax (dim:int) = fun (a:Tensor) -> a.logsoftmax(dim)
  +    static member logsoftmax(dim:int) = fun (a:Tensor) -> a.logsoftmax(dim)
       static member logsumexp(a:Tensor, dim:int, ?keepDim:bool) = a.logsumexp(dim, ?keepDim=keepDim)
  +    static member logsumexp(dim:int, ?keepDim:bool) = fun (a:Tensor) -> a.logsumexp(dim, ?keepDim=keepDim)
       static member mseLoss(a:Tensor, b:Tensor, ?reduction:string) = a.mseLoss(b, ?reduction=reduction)
       static member nllLoss(a:Tensor, b:Tensor, ?weights:Tensor, ?reduction:string) = a.nllLoss(b, ?weights=weights, ?reduction=reduction)
       static member crossEntropyLoss(a:Tensor, b:Tensor, ?weights:Tensor, ?reduction:string) = a.crossEntropyLoss(b, ?weights=weights, ?reduction=reduction)
       static member conv1d(a:Tensor, b:Tensor, ?stride:int, ?padding:int, ?dilation:int) = a.conv1d(b, ?stride=stride, ?padding=padding, ?dilation=dilation)
       static member conv2d(a:Tensor, b:Tensor, ?stride:seq<int>, ?padding:seq<int>, ?dilation:seq<int>) = a.conv2d(b, ?stride=stride, ?padding=padding, ?dilation=dilation)
       static member conv2d(a:Tensor, b:Tensor, ?stride:int, ?padding:int, ?dilation:int) = a.conv2d(b, ?stride=stride, ?padding=padding, ?dilation=dilation)
  -
   
   // Methods mirroring F# array modules
   // TODO: update to support non-float types once we have backing DTypes implemented
  
positive.code:     static member max(a:Tensor, b:Tensor) = a.max(b)
      static member min(a:Tensor, b:Tensor) = a.min(b)
      static member diagonal(a:Tensor, ?offset:int, ?dim1:int, ?dim2:int) = a.diagonal(?offset=offset, ?dim1=dim1, ?dim2=dim2)
      static member trace(a:Tensor) = a.trace()
      static member expand(a:Tensor, shape:seq<int>) = a.expand(shape)
      static member stack(tensors:seq<Tensor>, ?dim:int) = Tensor.stack(tensors, ?dim=dim)
      static member unstack(a:Tensor, ?dim:int) = a.unstack(?dim=dim)
      static member cat(tensors:seq<Tensor>, ?dim:int) = Tensor.cat(tensors, ?dim=dim)
      static member split(a:Tensor, sizes:seq<int>, ?dim:int) = a.split(sizes, ?dim=dim)
      static member add(a:Tensor, b:Tensor) = a.add(b)
      static member sub(a:Tensor, b:Tensor) = a.sub(b)
      static member mul(a:Tensor, b:Tensor) = a.mul(b)
      static member div(a:Tensor, b:Tensor) = a.div(b)
      static member pow(a:Tensor, b:Tensor) = a.pow(b)
      static member matmul(a:Tensor, b:Tensor) = a.matmul(b)
      static member dot(a:Tensor, b:Tensor) = a.dot(b)
      static member neg(a:Tensor) = a.neg()
      static member sum(a:Tensor) = a.sum()
      static member sum(a:Tensor, dim:int, ?keepDim:bool) = a.sum(dim, ?keepDim=keepDim)
      static member mean(a:Tensor) = a.mean()
      static member mean(a:Tensor, dim:int, ?keepDim:bool) = a.mean(dim, ?keepDim=keepDim)
      static member variance(a:Tensor) = a.variance()
      static member variance(a:Tensor, dim:int, ?keepDim:bool) = a.variance(dim, ?keepDim=keepDim)
      static member stddev(a:Tensor) = a.stddev()
      static member stddev(a:Tensor, dim:int, ?keepDim:bool) = a.stddev(dim, ?keepDim=keepDim)
      static member transpose(a:Tensor) = a.transpose()
      static member squeeze(a:Tensor, ?dim:int) = a.squeeze(?dim=dim)
      static member unsqueeze(a:Tensor, dim:int) = a.unsqueeze(dim)
      static member flip(a:Tensor, dims:seq<int>) = a.flip(dims)
      static member dilate(a:Tensor, dilations:seq<int>) = a.dilate(dilations)
      static member undilate(a:Tensor, dilations:seq<int>) = a.undilate(dilations)
      static member repeat(a:Tensor, dim:int, times:int) = a.repeat(dim, times)
      static member view(a:Tensor, shape:seq<int>) = a.view(shape)
      static member view (shape:seq<int>) = fun (a:Tensor) -> a.view(shape)
      static member view(a:Tensor, shape:int) = a.view(shape)
      static member viewAs(a:Tensor, b:Tensor) = a.viewAs(b)
      static member flatten(a:Tensor, ?startDim:int, ?endDim:int) = a.flatten(?startDim=startDim, ?endDim=endDim)
      static member sign(a:Tensor) = a.sign()
      static member floor(a:Tensor) = a.floor()
      static member ceil(a:Tensor) = a.ceil()
  
negative.code:     static member abs(a:Tensor) = a.abs()
      static member relu(a:Tensor) = a.relu()
      static member leakyRelu(a:Tensor, ?negativeSlope:float) = a.leakyRelu(?negativeSlope=negativeSlope)
      static member leakyRelu(negativeSlope:float) = fun (a:Tensor) -> a.leakyRelu(negativeSlope=negativeSlope)
      static member sigmoid(a:Tensor) = a.sigmoid()
      static member softplus(a:Tensor) = a.softplus()
      static member exp(a:Tensor) = a.exp()
  