anchor.diff:          SVD.decomposeInPlace a b c
   
           let arr = Array2D.init 10 10 (fun i j -> 0.1)
  -        let (U, B, Vt) = SVD.decompose arr
  +        let a = SVD.decompose arr
   
           ()
  
positive.code:         let U = Array2D.zeroCreate r r
          let S = Array2D.copy m
          let Vt = Array2D.zeroCreate c c
          SVD.DecomposeInPlace(U, S, Vt)
          U, S, Vt
          
  
      static member Decompose(m : M22d) =
          let mutable S = m
          let mutable U = M22d()
          let mutable Vt = M22d()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
      static member Decompose(m : M23d) =
          let mutable S = m
          let mutable U = M22d()
          let mutable Vt = M33d()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
      static member Decompose(m : M33d) =
          let mutable S = m
          let mutable U = M33d()
          let mutable Vt = M33d()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
      static member Decompose(m : M34d) =
          let mutable S = m
          let mutable U = M33d()
          let mutable Vt = M44d()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
      static member Decompose(m : M44d) =
          let mutable S = m
          let mutable U = M44d()
          let mutable Vt = M44d()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
  
      static member Decompose(m : M22f) =
          let mutable S = m
          let mutable U = M22f()
          let mutable Vt = M22f()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
      static member Decompose(m : M23f) =
          let mutable S = m
          let mutable U = M22f()
          let mutable Vt = M33f()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
      static member Decompose(m : M33f) =
          let mutable S = m
          let mutable U = M33f()
          let mutable Vt = M33f()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
      static member Decompose(m : M34f) =
          let mutable S = m
          let mutable U = M33f()
          let mutable Vt = M44f()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
  
      static member Decompose(m : M44f) =
          let mutable S = m
          let mutable U = M44f()
          let mutable Vt = M44f()
          tensor {
              let! pS = &S
              let! pU = &U
              let! pVt = &Vt
              SVD.DecomposeInPlace(pU, pS, pVt)
          }
          U, S, Vt
          
  
  
  
negative.code:         let U = Matrix<float32>(r,r)
          let S = m.Copy()
          let Vt = Matrix<float32>(c,c)
          if SVD.DecomposeInPlace(U, S, Vt) then
              Some (U, S, Vt)
          else
              None
  
      static member Decompose(m : float[,]) =
          let r = m.GetLength(0)
  