anchor.diff:                                  termName,tmp.Length,tmp |> List.sumBy (fun x -> x.Item))
               |> List.filter (fun (termName,binSize,weightSum) -> binSize>0)
   
  -        let absoluteBinsizes =  [for (_,binSize,_) in absoluteTestTargets do yield binSize]
  -        let positiveBinsizes =  [for (_,binSize,_) in positiveTestTargets do yield binSize]
  -        let negativeBinsizes =  [for (_,binSize,_) in negativeTestTargets do yield binSize]
  -
  -        let weightArr =     [|for ann in data do yield ann.Item|]
  -        let posWeightArr =  [|for ann in data do yield ann.Item|] |> Array.filter(fun x -> x>0.)
  -        let negWeightArr =  [|for ann in data do yield ann.Item|] |> Array.filter(fun x -> x<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
  +        let posWeightArr =  weightArr   |> Array.filter(fun x -> x>0.)
  +        let negWeightArr =  weightArr   |> Array.filter(fun x -> x<0.)
   
   
           // create bootstrapped test distributions for all test targets
  -        printfn "bootstrapping absolute test distributions..."
  +        if verbose then printfn "bootstrapping absolute test distributions for %i bins" absoluteBinsizes.Length
           let absoluteTestDistributions =
  -            [|  
  -                for binSize in absoluteBinsizes do
  -                let tmp = bootstrapBin verbose binSize weightArr bootstrapIterations
  -                yield (binSize,Distributions.Frequency.create (Distributions.Bandwidth.nrd0 tmp) tmp)
  -            |]
  -            |> Map.ofArray
  -
  -        printfn "bootstrapping positive test distributions..."
  +
  +            let startTime = System.DateTime.Now
  +
  +            absoluteBinsizes
  +            |> List.mapi 
  +                (fun i binSize ->
  +
  +                    if verbose && (i % (absoluteBinsizes.Length / 10) = 0 ) then
  +                        let elapsed = System.DateTime.Now.Subtract(startTime)
  +                        printfn "[%i/%i] bins @ %imin %is" i absoluteBinsizes.Length elapsed.Minutes elapsed.Seconds
  +
  +                    let tmp = bootstrapBin binSize absWeightArr bootstrapIterations
  +                    (binSize,Distributions.Frequency.create (Distributions.Bandwidth.nrd0 tmp) tmp)
  +                )
  +            |> Map.ofList
  +
  +        if verbose then printfn "bootstrapping positive test distributions for %i bins" positiveBinsizes.Length
           let positiveTestDistributions =
  -            [|  
  -                for binSize in positiveBinsizes do
  -                let tmp = bootstrapBin verbose binSize posWeightArr bootstrapIterations
  -                yield (binSize,Distributions.Frequency.create (Distributions.Bandwidth.nrd0 tmp) tmp)
  -            |]
  -            |> Map.ofArray
  -        
  -        printfn "bootstrapping negative test distributions..."
  +
  +            let startTime = System.DateTime.Now
  +
  +            positiveBinsizes
  +            |> List.mapi 
  +                (fun i binSize ->
  +
  +                    if verbose && (i % (positiveBinsizes.Length / 10) = 0 ) then
  +                        let elapsed = System.DateTime.Now.Subtract(startTime)
  +                        printfn "[%i/%i] bins @ %imin %is" i positiveBinsizes.Length elapsed.Minutes elapsed.Seconds
  +
  +                    let tmp = bootstrapBin binSize posWeightArr bootstrapIterations
  +                    (binSize,Distributions.Frequency.create (Distributions.Bandwidth.nrd0 tmp) tmp)
  +                )
  +            |> Map.ofList
  +            
  +        if verbose then printfn "bootstrapping negative test distributions for %i bins" negativeBinsizes.Length
           let negativeTestDistributions = 
  -            [|  
  -                for binSize in negativeBinsizes do
  -                let tmp = bootstrapBin verbose binSize negWeightArr bootstrapIterations
  -                yield (binSize,Distributions.Frequency.create (Distributions.Bandwidth.nrd0 tmp) tmp)
  -            |]
  -            |> Map.ofArray
  +
  +            let startTime = System.DateTime.Now
  +
  +            negativeBinsizes
  +            |> List.mapi 
  +                (fun i binSize ->
  +
  +                    if verbose && (i % (negativeBinsizes.Length / 10) = 0 ) then
  +                        let elapsed = System.DateTime.Now.Subtract(startTime)
  +                        printfn "[%i/%i] bins @ %imin %is" i negativeBinsizes.Length elapsed.Minutes elapsed.Seconds
  +
  +                    let tmp = bootstrapBin binSize negWeightArr bootstrapIterations
  +                    (binSize,Distributions.Frequency.create (Distributions.Bandwidth.nrd0 tmp) tmp)
  +                )
  +            |> Map.ofList
  +
  +        if verbose then printfn "assigning empirical pValues for all bins..."
   
           //assign Pvalues for all test targets
           let absResults = assignPValues absoluteTestDistributions absoluteTestTargets
  
positive.code: 
  
      ///Compute SAILENT (Surprisal AnalysIs EmpiricaL pErmutatioN Test) for the given Surprisal Analysis result. This empirical test was
      ///is designed for the biological application of Surprisal Analysis to test the weight distribution of a given bin of annotations is significantly different than a random distribution 
      ///of the same size given the whole dataset.
      ///
      ///Input: 
  
negative.code:     ///Absolute descriptor: test distributions and tests are performed on the positive values of the dataset only
      let compute (verbose:bool) (bootstrapIterations:int) (data: OntologyItem<float> array) =
  
          if verbose then printfn "starting SAILENT characterization"
  
          // get distinct ontology terms in the dataset
          let distinctGroups = getDistinctGroups data
  