anchor.diff:              for k=i to m-1 do
                   A.[l,k] <- A.[l,k] - 2.0 * v.[l-i] * v'A.[k-i]
           v                                                              // Return reflection vector.
  -    
  -    type SparseEntry (index:int, value:float) =
  -        member m.index = index
  -        member val value = value with get, set
   
       type SparseVector() = 
  -        member val entries = new ResizeArray<SparseEntry>() with get,set
  -        member m.Front =
  -            m.entries.[0]
  -        member m.Add (entry:SparseEntry) =
  +        member val entries = new ResizeArray<(int*float)>() with get,set
  +        member m.Front
  +            with get() = m.entries.[0]
  +            and set(value) = m.entries.[0] <- value
  +        member m.Add (entry:(int*float)) =
               m.entries.Add(entry)
           member m.IsEmpty =
               m.entries.Count <= 0
           member m.Swap (other:SparseVector) =
  -            let temp = new ResizeArray<SparseEntry> (other.entries)
  -            other.entries <- new ResizeArray<SparseEntry>(m.entries)
  -            m.entries <- new ResizeArray<SparseEntry>(temp)
  +            let temp = new ResizeArray<(int*float)> (other.entries)
  +            other.entries <- new ResizeArray<(int*float)>(m.entries)
  +            m.entries <- new ResizeArray<(int*float)>(temp)
           member m.PopFront =
               let value = m.entries.[0]
               m.entries.RemoveAt(0)
  
positive.code:         for a = 0 to m-1 do
              let row = CopyRow(A.SparseRowOffsets.[a+1] - A.SparseRowOffsets.[a], A.SparseRowOffsets.[a], A)
              let mutable q = 0
              while((not row.IsEmpty) && row.Front.index < a && row.Front.index < n) do
                  let j = row.Front.index
  
                  if(R.[j].IsEmpty || R.[j].Front.index > j) then
                      R.[j].Swap(row)
                      Q.[a].entries.Insert(q, SparseEntry(j, 1.0))
                      q <- q + 1
                      ()
                  else
                      let ret = applyGivens(R.[j], row)
                      Q.[a].entries.Insert(q, SparseEntry(j, ret))
                      q <- q + 1
                      ()
              if (a < n) then
  
negative.code: 
          // Apply the givens rotation on 2 Sparsevectors
          let applyGivens( x : SparseVector, y : SparseVector) = 
              let a = snd x.Front
              let b = snd y.Front
      
              let mutable c = -1.0
              let mutable s = -1.0
  