anchor.diff:  
       member a.matmul (b:Tensor) =
           checkCanMatmul a.shape b.shape
  -        let inline fRaw(a:RawTensor,b) = a.MatMulT2T2(b)
  -        let inline fTensor(a:Tensor,b) = a.matmul(b)
  -        let inline dfTensorFwdTT(cp,ap:Tensor,ad:Tensor,bp:Tensor,bd:Tensor) = ad.matmul(bp) + ap.matmul(bd)
  -        let inline dfTensorFwdTC(cp,ap,ad:Tensor) = ad.matmul(b)
  -        let inline dfTensorFwdCT(cp,bp,bd) = a.matmul(bd)
  -        let inline dfTensorRevTT(a,b) = MatMulT2T2(a,b)
  -        let inline dfTensorRevTC(a,b) = MatMulT2T2Const(a,b)
  -        let inline dfTensorRevCT(a,b) = MatMulT2ConstT2(a,b)
  +        let fRaw(a:RawTensor,b) = a.MatMulT2T2(b)
  +        let fTensor(a:Tensor,b) = a.matmul(b)
  +        let dfTensorFwdTT(cp,ap:Tensor,ad:Tensor,bp:Tensor,bd:Tensor) = ad.matmul(bp) + ap.matmul(bd)
  +        let dfTensorFwdTC(cp,ap,ad:Tensor) = ad.matmul(b)
  +        let dfTensorFwdCT(cp,bp,bd) = a.matmul(bd)
  +        let dfTensorRevTT(a,b) = MatMulT2T2(a,b)
  +        let dfTensorRevTC(a,b) = MatMulT2T2Const(a,b)
  +        let dfTensorRevCT(a,b) = MatMulT2ConstT2(a,b)
           Tensor.OpBinary(a, b, fRaw, fTensor, dfTensorFwdTT, dfTensorFwdTC, dfTensorFwdCT, dfTensorRevTT, dfTensorRevTC, dfTensorRevCT)
   
       member a.dot(b:Tensor) =
  
positive.code:         let mutable b = b
          if dilation > 1 then
              b <- b.dilate([|1;1;dilation|])
          let inline fRaw(a:RawTensor,b) = a.Conv1D(b, stride, padding)
          let inline fTensor(a:Tensor,b) = a.conv1d(b, stride, padding)
          let inline dfTensorFwdTT(cp,ap:Tensor,ad:Tensor,bp:Tensor,bd:Tensor) = ad.conv1d(bp, stride, padding) + ap.conv1d(bd, stride, padding)
          let inline dfTensorFwdTC(cp,ap,ad:Tensor) = ad.conv1d(b, stride, padding)
          let inline dfTensorFwdCT(cp,bp,bd) = a.conv1d(bd, stride, padding)
          let inline dfTensorRevTT(a,b) = Conv1DTT(a,b, stride, padding)
          let inline dfTensorRevTC(a,b) = Conv1DTTConst(a,b, stride, padding)
          let inline dfTensorRevCT(a,b) = Conv1DTConstT(a,b, stride, padding)
          Tensor.OpBinary(a, b, fRaw, fTensor, dfTensorFwdTT, dfTensorFwdTC, dfTensorFwdCT, dfTensorRevTT, dfTensorRevTC, dfTensorRevCT)
  
      // a: input, NxCxI (batchSize x inputChannels x inputLength)
  
negative.code:         a.matmul(b).view([])
  
      static member (~-) (a:Tensor) =
          let fRaw(a:RawTensor) = a.NegT()
          let fTensor(a) = -a
          let dfTensorFwd(cp,ap,ad) = -ad
          let dfTensorRev(a) = NegT(a)
          Tensor.OpUnary(a, fRaw, fTensor, dfTensorFwd, dfTensorRev)
      member a.neg() = -a
  
      member a.sum() =
          let fRaw(a:RawTensor) = a.SumT()
          let fTensor(a:Tensor) = a.sum()
          let dfTensorFwd(cp,ap,ad:Tensor) = ad.sum()
          let dfTensorRev(a) = SumT(a)
          Tensor.OpUnary(a, fRaw, fTensor, dfTensorFwd, dfTensorRev)
  
      // TODO: this can be implemented in a more memory efficient way by pushing the sum operation to the RawTensor level and implementing the derivatives using general broadcasting when it's available
  