anchor.diff:      // a: input, NxCxI (batchSize x inputChannels x inputLength)
       // b: filters, KxCxF (outputChannels x inputChannels x kernelLength)
       // t: output, NxKxL (batchSize x outputChannels x outputLength)
  -    member internal t.conv1ReverseDiff(a: Tensor, b:Tensor, stride:int, padding:int) =
  +    member internal t.conv1dReverseDiff(a: Tensor, b:Tensor, aConst:bool, bConst:bool, stride:int, padding:int) =
  +        let a = if aConst then a else a.primal
  +        let b = if bConst then b else b.primal
           let batchSize = t.shape.[0]
           let outputChannels = t.shape.[1]
           let outputLength = t.shape.[2]
  
positive.code:         a.conv2d(b, [|stride; stride|], [|padding; padding|], [|dilation; dilation|])
  
      member a.conv2d(b:Tensor) = a.conv2d(b, [1; 1], [0; 0], [1; 1])
  
      member t.reverse(?value:Tensor, ?zeroDerivatives:bool) =
          let value = defaultArg value (t.onesLike())
  
negative.code:                         | MatMulT2T2Const(a,b) -> push ((t.derivative.matmul(b.transpose()), a) :: tt)
                          | MatMulT2ConstT2(a,b) -> push ((a.transpose().matmul(t.derivative), b) :: tt)
                          | Conv1DTT(a,b,stride,padding) -> 
                              let aderivative, bderivative = t.conv1dReverseDiff(a, b, false, false, stride, padding)
                              push ((aderivative, a) :: (bderivative, b) :: tt)
                          | Conv1DTTConst(a,b,stride,padding) ->
                              let aderivative, _ = t.conv1dReverseDiff(a, b, false, true, stride, padding)
                              push ((aderivative, a) :: tt)                        
                          | Conv1DTConstT(a,b,stride,padding) ->
                              let _, bderivative = t.conv1dReverseDiff(a, b, true, false, stride, padding)
                              push ((bderivative, b) :: tt)                        
                          | Conv2DTT(a,b,stride,padding) -> 
                              let aderivative, bderivative = t.conv2dReverseDiff(a, b, false, false, stride, padding)
                              push ((aderivative, a) :: (bderivative, b) :: tt)
                          | Conv2DTTConst(a,b,stride,padding) ->
                              let aderivative, _ = t.conv2dReverseDiff(a, b, false, true, stride, padding)
                              push ((aderivative, a) :: tt)
                          | Conv2DTConstT(a,b,stride,padding) ->
                              let _, bderivative = t.conv2dReverseDiff(a, b, true, false, stride, padding)
                              push ((bderivative, b) :: tt)
                          | NegT(a) -> push ((-t.derivative, a) :: tt)
                          | SumT(a) -> push ((t.derivative.expand(a.shape), a) :: tt)
  