anchor.diff:              return qrBidiagonalizeNative floatEps pU pB pVt |> ignore
           }
   
  -
  +    static member BidiagonalizeInPlace(U : float[,], B : float[,], Vt : float[,]) =
  +        let mutable U = U
  +        let mutable B = B
  +        let mutable Vt = Vt
  +
  +        tensor {
  +            let! pU = &U
  +            let! pB = &B
  +            let! pVt = &Vt
  +            return qrBidiagonalizeNative doubleEps pU pB pVt |> ignore
  +        }
  +
  +    static member BidiagonalizeInPlace(U : float32[,], B : float32[,], Vt : float32[,]) =
  +        let mutable U = U
  +        let mutable B = B
  +        let mutable Vt = Vt
  +
  +        tensor {
  +            let! pU = &U
  +            let! pB = &B
  +            let! pVt = &Vt
  +            return qrBidiagonalizeNative floatEps pU pB pVt |> ignore
  +        }
  +
  +   
       static member Bidiagonalize(m : Matrix<float>) =
           let U = Matrix<float>(m.SY, m.SY)
           let B = m.Copy()
           let Vt = Matrix<float>(m.SX, m.SX)
           QR.BidiagonalizeInPlace(U, B, Vt) |> ignore
           U, B, Vt
  -        
  +
  +    static member Bidiagonalize(m : float[,]) =
  +        let r = m.GetLength(0)
  +        let c = m.GetLength(1)
  +        let U = Array2D.zeroCreate r r
  +        let B = Array2D.copy m
  +        let Vt = Array2D.zeroCreate c c
  +        QR.BidiagonalizeInPlace(U, B, Vt) |> ignore
  +        U, B, Vt       
  +
       static member Bidiagonalize (m : M22d) =
           let mutable U = M22d()
           let mutable B = m
  
positive.code:             let! pR = &R
              qrDecomposeNative floatEps pQ pR
          }
  
      static member Decompose (m : Matrix<float>) =
          let R = m.Copy()
          let Q = Matrix<float>(m.SY, m.SY)
  
negative.code:     static let doubleEps = 1E-20
      static let floatEps = 1E-15f
  
  
      static member DecomposeInPlace(Q : float[,], R : float[,]) =
          let mutable Q = Q
          let mutable R = R
          tensor {
              let! pQ = &Q
              let! pR = &R
              qrDecomposeNative doubleEps pQ pR
          }
  
      static member DecomposeInPlace(Q : float32[,], R : float32[,]) =
          let mutable Q = Q
          let mutable R = R
          tensor {
              let! pQ = &Q
              let! pR = &R
              qrDecomposeNative floatEps pQ pR
          }
  
      static member DecomposeInPlace(Q : NativeMatrix<float>, R : NativeMatrix<float>) =
          qrDecomposeNative doubleEps Q R
          
  