docs: public OutlierResult run(Relation<Model> models, Relation<NumberVector> vecs, Relation<?> labels) {
      WritableDoubleDataStore scores = DataStoreUtil.makeDoubleStorage(models.getDBIDs(), DataStoreFactory.HINT_HOT);
  
      HashSet<GeneratorSingleCluster> generators = new HashSet<>();
      for(DBIDIter iditer = models.iterDBIDs(); iditer.valid(); iditer.advance()) {
        Model model = models.get(iditer);
        if(model instanceof GeneratorSingleCluster) {
          generators.add((GeneratorSingleCluster) model);
        }
      }
      if(generators.isEmpty()) {
        LOG.warning("No generator models found for dataset - all points will be considered outliers.");
      }
      for(GeneratorSingleCluster gen : generators) {
        for(int i = 0; i < gen.getDim(); i++) {
          Distribution dist = gen.getDistribution(i);
          if(!(dist instanceof NormalDistribution)) {
            throw new AbortException("TrivialGeneratedOutlier currently only supports normal distributions, got: " + dist);
          }
        }
      }
  
      for(DBIDIter iditer = models.iterDBIDs(); iditer.valid(); iditer.advance()) {
        double score = 1.;
        double[] v = vecs.get(iditer).toArray();
        for(GeneratorSingleCluster gen : generators) {
          double[] tv = v;
          // Transform backwards
          if(gen.getTransformation() != null) {
            tv = gen.getTransformation().applyInverse(v);
          }
          final int dim = tv.length;
          double lensq = 0.0;
          int norm = 0;
          for(int i = 0; i < dim; i++) {
            Distribution dist = gen.getDistribution(i);
            if(dist instanceof NormalDistribution) {
              NormalDistribution d = (NormalDistribution) dist;
              double delta = (tv[i] - d.getMean()) / d.getStddev();
              lensq += delta * delta;
              norm += 1;
            }
            else {
              throw new AbortException("TrivialGeneratedOutlier currently only supports normal distributions, got: " + dist);
            }
          }
          if(norm > 0.) {
            // The squared distances are ChiSquared distributed
            score = Math.min(score, ChiSquaredDistribution.cdf(lensq, norm));
          }
          else {
            score = 0.;
          }
        }
        if(expect < 1) {
          score = expect * score / (1 - score + expect);
        }
        scores.putDouble(iditer, score);
      }
      DoubleRelation scoreres = new MaterializedDoubleRelation("Model outlier scores", "model-outlier", scores, models.getDBIDs());
      OutlierScoreMeta meta = new ProbabilisticOutlierScore(0., 1.);
      return new OutlierResult(meta, scoreres);
    }