anchor.diff:                      let tmp = bootstrapBin binSize posWeightArr bootstrapIterations
                       (binSize,Distributions.Frequency.create (Distributions.Bandwidth.nrd0 tmp) tmp)
                   )
  -            |> Map.ofList
  +            |> Map.ofArray
               
           if verbose then printfn "bootstrapping negative test distributions for %i bins" negativeBinsizes.Length
           let negativeTestDistributions = 
  
positive.code: 
          if verbose then printfn "starting SAILENT characterization"
  
          // get distinct ontology terms in the dataset
          let distinctGroups = getDistinctGroups data
  
          // allocate test targets from the dataset
          let absoluteTestTargets = 
              distinctGroups
              |> List.map (fun (termName)
                              ->  let tmp = getBins termName data
                                  termName,tmp.Length,tmp |> List.sumBy (fun x -> abs x.Item))
              |> List.filter (fun (termName,binSize,weightSum) -> binSize>0)
  
          let positiveTestTargets =
              distinctGroups
              |> List.map (fun (termName)
                              ->  let tmp = getPositiveBins termName data
                                  termName,tmp.Length,tmp |> List.sumBy (fun x -> x.Item))
              |> List.filter (fun (termName,binSize,weightSum) -> binSize>0)
  
          let negativeTestTargets =
              distinctGroups
              |> List.map (fun (termName)
                              ->  let tmp = getNegativeBins termName data
                                  termName,tmp.Length,tmp |> List.sumBy (fun x -> x.Item))
              |> List.filter (fun (termName,binSize,weightSum) -> binSize>0)
  
          let absoluteBinsizes = absoluteTestTargets |> List.map (fun (_,binSize,_) -> binSize) |> List.distinct
          let positiveBinsizes = positiveTestTargets |> List.map (fun (_,binSize,_) -> binSize) |> List.distinct
          let negativeBinsizes = negativeTestTargets |> List.map (fun (_,binSize,_) -> binSize) |> List.distinct
  
          let weightArr =     data        |> Array.map (fun ann -> ann.Item)
          let absWeightArr =  weightArr   |> Array.map abs
  
negative.code: 
          loop 1 []
  
      let private getEmpiricalPvalue (testDistributions: Map<int,Map<float,int>>) (weightSum:float) (binSize:int) =
          match Map.tryFind binSize testDistributions with
          |Some dist ->   let testDist = dist
                          float (testDist |> Map.fold (fun acc key value -> if abs key > abs weightSum then acc + value else acc) 0) / (float (testDist |> Map.fold (fun acc key value -> acc + value) 0))
          |_ -> 10000000.
  
      let private assignPValues (testDistributions:Map<int,Map<float,int>>) (testTargets:(string*int*float)[])=
          testTargets 
          |> Array.map (fun (name,binSize,weightSum) -> createSailentCharacterization name (getEmpiricalPvalue testDistributions weightSum binSize) binSize weightSum)
      
      ///utility function to prepare a dataset column for SAILENT characterization. The ontology map can be created by using the BioFSharp.BioDB module. 
      ///
  