docs: public HistogramResult evaluateOutlierResult(Database database, OutlierResult or) {
      if(scaling instanceof OutlierScaling) {
        ((OutlierScaling) scaling).prepare(or);
      }
  
      ModifiableDBIDs ids = DBIDUtil.newHashSet(or.getScores().getDBIDs());
      DBIDs outlierIds = DatabaseUtil.getObjectsByLabelMatch(database, positiveClassName);
      // first value for outliers, second for each object
      // If we have useful (finite) min/max, use these for binning.
      double min = scaling.getMin(), max = scaling.getMax();
      final ObjHistogram<double[]> hist;
      if(Double.isInfinite(min) || Double.isNaN(min) || Double.isInfinite(max) || Double.isNaN(max)) {
        hist = new AbstractObjDynamicHistogram<double[]>(bins) {
          @Override
          public double[] aggregate(double[] first, double[] second) {
            return VMath.plusEquals(first, second);
          }
  
          @Override
          protected double[] makeObject() {
            return new double[2];
          }
  
          @Override
          protected double[] cloneForCache(double[] data) {
            return data.clone();
          }
  
          @Override
          protected double[] downsample(Object[] data, int start, int end, int size) {
            double[] sum = new double[2];
            for(int i = start; i < end; i++) {
              Object p = data[i];
              if(p != null) {
                VMath.plusEquals(sum, (double[]) p);
              }
            }
            return sum;
          }
        };
      }
      else {
        hist = new ObjHistogram<double[]>(bins, min, max, () -> {
          return new double[2];
        });
      }
  
      // first fill histogram only with values of outliers
      double negative = 1. / ids.size(), positive = negative;
      if(splitfreq) {
        negative = 1. / (ids.size() - outlierIds.size());
        positive = 1. / outlierIds.size();
      }
      ids.removeDBIDs(outlierIds);
      // fill histogram with values of each object
      for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) {
        double result = or.getScores().doubleValue(iter);
        result = scaling.getScaled(result);
        if(result > Double.NEGATIVE_INFINITY && result < Double.POSITIVE_INFINITY) {
          hist.get(result)[0] += negative;
        }
      }
      for(DBIDIter iter = outlierIds.iter(); iter.valid(); iter.advance()) {
        double result = or.getScores().doubleValue(iter);
        result = scaling.getScaled(result);
        if(result > Double.NEGATIVE_INFINITY && result < Double.POSITIVE_INFINITY) {
          hist.get(result)[1] += positive;
        }
      }
      Collection<double[]> collHist = new ArrayList<>(hist.getNumBins());
      for(ObjHistogram<double[]>.Iter iter = hist.iter(); iter.valid(); iter.advance()) {
        double[] data = iter.getValue();
        collHist.add(new double[] { iter.getCenter(), data[0], data[1] });
      }
      return new HistogramResult("Outlier Score Histogram", "outlier-histogram", collHist);
    }