anchor.diff:          elif a.shape = b.shape then
               let inline fRaw(a:RawTensor,b) = a.PowTT(b)
               let inline fTensor(a:Tensor,b:Tensor) = a ** b
  -            let inline dfTensorFwdTT(ap:Tensor,ad:Tensor,bp:Tensor,bd:Tensor,cp:Tensor) = (ap ** (bp - 1.)) * (ad * bp + ap * bd * log ap)
  -            let inline dfTensorFwdTC(ap,ad,cp) = ad * (ap ** (b - 1.)) * b
  -            let inline dfTensorFwdCT(bp,bd,cp) = bd * cp * log a
  -            let inline dfTensorRevTT(a,b) = PowTT(a,b)
  -            let inline dfTensorRevTC(a,b) = PowTTConst(a,b)
  -            let inline dfTensorRevCT(a,b) = PowTConstT(a,b)
  -            Tensor.OpBinary(a, b, fRaw, fTensor, dfTensorFwdTT, dfTensorFwdTC, dfTensorFwdCT, dfTensorRevTT, dfTensorRevTC, dfTensorRevCT)
  +            let inline dfFwdTT(ap:Tensor,ad:Tensor,bp:Tensor,bd:Tensor,fp:Tensor) = (ap ** (bp - 1.)) * (ad * bp + ap * bd * log ap)
  +            let inline dfFwdTC(ap,ad,fp) = ad * (ap ** (b - 1.)) * b
  +            let inline dfFwdCT(bp,bd,fp) = bd * fp * log a
  +            let inline dfRevTT(a,b) = PowTT(a,b)
  +            let inline dfRevTC(a,b) = PowTTConst(a,b)
  +            let inline dfRevCT(a,b) = PowTConstT(a,b)
  +            Tensor.OpBinary(a, b, fRaw, fTensor, dfFwdTT, dfFwdTC, dfFwdCT, dfRevTT, dfRevTC, dfRevCT)
           else
               let newShape = Shape.broadcast2 a.shape b.shape
               let aExpanded = a.expand(newShape)
  
positive.code:     member a.asin() =
          let inline fRaw(a:RawTensor) = a.AsinT()
          let inline fTensor(a:Tensor) = a.asin()
          let inline dfTensorFwd(ap:Tensor,ad,cp:Tensor) = ad / (1. - ap*ap).sqrt()
          let inline dfTensorRev(a) = AsinT(a)
          Tensor.OpUnary(a, fRaw, fTensor, dfTensorFwd, dfTensorRev)
  
      /// <summary>A method to enable the use of the F# function <c>asin</c>.</summary>
      static member Asin(t:Tensor) = t.asin() // needed for FSharp.Core asin operator overload
  
negative.code:         | ValueNone ->
              let inline fRaw(b:RawTensor) = b.DivFromT0T(a)
              let inline fTensor(b) = a / b
              let inline dfFwd(bp,bd,fp) = -bd * fp / bp
              let inline dfRev(b) = DivT0ConstT(a,b)
              Tensor.OpUnary(b, fRaw, fTensor, dfFwd, dfRev)
  
      /// <summary>Divides each element of the object tensor by the corresponding element of the tensor <paramref name="b" />. The resulting tensor is returned.</summary>
      /// <remarks>The shapes of the two tensors must be broadcastable.</remarks>
  