anchor.diff:          // 28s 1000 * 100
           // 10s 100*1000
           // 9s 100*1000 with MemoryMappedFile caching
  +        // Sparse
           
       let testGebco() =
           ignore // TODO
  
positive.code:     
  module Reader =
      let simpleQuery indices fileName =
          SimpleReadWrite.readValues fileName indices
          //MemoryMappedSimpleRead.readValues fileName indices
  
      let sparseQuery indices fileName =
          SparseReadWrite.readValues fileName indices
  
negative.code:             defaultValue
  
  module BitMap =
      type bitmap = bool [] * int64 // map * skipped count
      
      let ofArray (bools:bool []) = 
          let skippedCount = bools |> Seq.filter (not) |> Seq.length
          (bools, (int64 skippedCount)):bitmap
      
      let transform (b:bitmap []) = 
          let mutable total = 0L
          for i=0 to b.Length-1 do
              let (m,s):bitmap = b.[i] 
              total <- total+s
              b.[i] <- (m,total)
  
      let init n (f:int->bool) = 
          let bools = Array.init n f
          ofArray bools
  
      let sparseIndex sparseIndexConsumer (map:bitmap[]) (cellIndex:int64) =
          let ncols = int64 (fst map.[0]).Length
          let rowIndex = int (cellIndex / ncols)
          let colIndex = int (cellIndex - ((int64 rowIndex)*ncols))
          if (fst map.[rowIndex]).[colIndex] then
              let mutable skippedCount = 0L
              if rowIndex > 0 then
                  skippedCount <- (snd map.[rowIndex-1])
              let m = fst  map.[rowIndex]
              for i=0 to colIndex-1 do
                  if not (m.[i]) then
                      skippedCount <- skippedCount+1L
  
              Some(sparseIndexConsumer (cellIndex - skippedCount))
          else
              None
  