protected Collection<EnforcedRelation> match(
      TIntHashSet subset, TIntObjectHashMap<Collection<EnforcedRelation>> index) {
    TIntIterator keyI = subset.iterator();

    int firstKey = keyI.next();

    if (index.get(firstKey) == null) {
      return Collections.emptyList();
    }
    Collection<EnforcedRelation> result = new ArrayList<EnforcedRelation>(index.get(firstKey));

    if (result.isEmpty()) {
      return Collections.emptyList();
    }

    while (keyI.hasNext()) {
      int key = keyI.next();

      if (result.isEmpty()) return result;

      Collection<EnforcedRelation> rest = index.get(key);
      if (rest == null) {
        return Collections.emptyList();
      }
      result.retainAll(rest);
    }

    return result;
  }
  public void testIterator() {

    TIntSet set = new TIntHashSet();
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(4);

    TIntIterator iter = set.iterator();
    assertTrue("iterator should have a next item", iter.hasNext());

    int last = -1;
    while (iter.hasNext()) {
      int next = iter.next();
      assertTrue(Integer.valueOf(next).toString(), next >= 1 && next <= 4);
      assertTrue(Integer.valueOf(next).toString(), next != last);
      last = next;
    }

    assertFalse("iterator should not have a next item", iter.hasNext());

    assertTrue("set should contain 1", set.contains(1));
    assertTrue("set should contain 2", set.contains(2));
    assertTrue("set should contain 3", set.contains(3));
    assertTrue("set should contain 4", set.contains(4));
    assertEquals(4, set.size());
  }
 /** {@inheritDoc} */
 public boolean containsAll(TIntCollection collection) {
   TIntIterator iter = collection.iterator();
   while (iter.hasNext()) {
     if (!TIntIntHashMap.this.containsValue(iter.next())) {
       return false;
     }
   }
   return true;
 }
  // Kien added this mathRolesAnhType1AndType2
  public Collection<EnforcedRelation> matchRolesAndType1AndType2(
      TIntHashSet candidateRoles, TIntHashSet candidateType1, TIntHashSet candidateType2) {
    TIntIterator roleKeyI = candidateRoles.iterator();

    int firstRoleKey = roleKeyI.next();

    if (rolesIndex.get(firstRoleKey) == null) {
      return Collections.emptyList();
    }
    Collection<EnforcedRelation> result =
        new ArrayList<EnforcedRelation>(rolesIndex.get(firstRoleKey));

    if (result.isEmpty()) {
      return Collections.emptyList();
    }

    while (roleKeyI.hasNext()) {
      int key = roleKeyI.next();

      if (result.isEmpty()) return result;

      Collection<EnforcedRelation> rest = rolesIndex.get(key);
      if (rest == null) {
        return Collections.emptyList();
      }
      result.retainAll(rest);
    }

    TIntIterator type1KeyI = candidateType1.iterator();
    while (type1KeyI.hasNext()) {
      int key = type1KeyI.next();

      if (result.isEmpty()) return result;

      Collection<EnforcedRelation> rest = type1Index.get(key);
      if (rest == null) {
        return Collections.emptyList();
      }
      result.retainAll(rest);
    }
    TIntIterator type2KeyI = candidateType2.iterator();
    // Old code: while (roleKeyI.hasNext()) {
    // Kien changed roleKeyI to type2KeyI
    while (type2KeyI.hasNext()) {
      int key = type2KeyI.next();

      if (result.isEmpty()) return result;

      Collection<EnforcedRelation> rest2 = type2Index.get(key);
      if (rest2 == null) {
        return Collections.emptyList();
      }
      result.retainAll(rest2);
    }
    return result;
  }
 @Override
 public Set<Integer> getFeatureIndicies() {
   Set<Integer> out = Sets.newHashSet();
   TIntIterator it = w.keySet().iterator();
   while (it.hasNext()) {
     int next = it.next();
     out.add(next);
   }
   return out;
 }
  @Override
  public boolean add(EnforcedRelation enf) {
    if (!this.subsubmedEnf(enf)) {

      enfs.add(enf);

      TIntHashSet type1 = enf.getType1();
      TIntIterator type1Iterator = type1.iterator();
      while (type1Iterator.hasNext()) {
        int key = type1Iterator.next();
        ensureContainsKey(type1Index, key);
        type1Index.get(key).add(enf);
      }

      TIntHashSet type2 = enf.getType2();
      TIntIterator type2Iterator = type2.iterator();
      while (type2Iterator.hasNext()) {
        int key = type2Iterator.next();
        ensureContainsKey(type2Index, key);
        type2Index.get(key).add(enf);
      }

      TIntHashSet roles = enf.getRoles();
      TIntIterator rolesIterator = roles.iterator();
      while (rolesIterator.hasNext()) {
        int key = rolesIterator.next();
        ensureContainsKey(rolesIndex, key);
        rolesIndex.get(key).add(enf);
      }

      return true;
    } else {
      return false;
    }
  }
  @Override
  public boolean remove(Object o) {
    EnforcedRelation enf = (EnforcedRelation) o;
    enfs.remove(enf);

    TIntHashSet type1 = enf.getType1();
    TIntIterator type1Iterator = type1.iterator();
    while (type1Iterator.hasNext()) {
      int key = type1Iterator.next();
      ensureContainsKey(type1Index, key);
      type1Index.get(key).remove(enf);
    }

    TIntHashSet type2 = enf.getType2();
    TIntIterator type2Iterator = type2.iterator();
    while (type2Iterator.hasNext()) {
      int key = type2Iterator.next();
      ensureContainsKey(type2Index, key);
      type2Index.get(key).remove(enf);
    }

    TIntHashSet roles = enf.getRoles();
    TIntIterator rolesIterator = roles.iterator();
    while (rolesIterator.hasNext()) {
      int key = rolesIterator.next();
      ensureContainsKey(rolesIndex, key);
      rolesIndex.get(key).remove(enf);
    }

    return true;
  }
 public boolean containsWord(int word, Mention mention) {
   if (!indexWithoutStopWords.containsKey(word)) return false;
   TIntLinkedList positions = indexIncludingStopWords.get(word);
   int mentionStart = mention.getStartToken();
   int mentionEnd = mention.getEndToken();
   for (TIntIterator itr = positions.iterator(); itr.hasNext(); ) {
     int position = itr.next();
     if (position < mentionStart || position > mentionEnd) return true;
   }
   return false;
 }
 /** {@inheritDoc} */
 @SuppressWarnings({"SuspiciousMethodCalls"})
 public boolean retainAll(Collection<?> collection) {
   boolean modified = false;
   TIntIterator iter = iterator();
   while (iter.hasNext()) {
     if (!collection.contains(Integer.valueOf(iter.next()))) {
       iter.remove();
       modified = true;
     }
   }
   return modified;
 }
  /**
   * Write top lin and balanced inclusion (cover) scores to a file
   *
   * @param writer
   * @param entailedElementId
   * @param entailingElements
   * @param entailedElement2NormMap
   * @param entailingElement2NormMap
   */
  private void writeEntailedElementScores(
      PrintWriter writer,
      Integer entailedElementId,
      TIntObjectMap<Pair<DoubleContainer, DoubleContainer>> entailingElements,
      TIntDoubleHashMap entailedElement2NormMap,
      TIntDoubleHashMap entailingElement2NormMap) {

    BoundedPriorityQueue<DistSimRule> linScores =
        new BoundedPriorityQueue<DistSimRule>(new DistSimRuleComparator(), m_maxRulesPerElement);
    BoundedPriorityQueue<DistSimRule> coverScores =
        new BoundedPriorityQueue<DistSimRule>(new DistSimRuleComparator(), m_maxRulesPerElement);

    double entailedElementNorm = entailedElement2NormMap.get(entailedElementId);

    TIntIterator iter = entailingElements.keySet().iterator();
    while (iter.hasNext()) {
      Integer entailingElementId = iter.next();

      // if there are no features for this element - then it is not similar to any other and we can
      // move on
      if (entailingElement2NormMap.get(entailingElementId) == 0.0) continue;

      double entailingElementNorm = entailingElement2NormMap.get(entailingElementId);

      Pair<DoubleContainer, DoubleContainer> scores = entailingElements.get(entailingElementId);

      Double linNominator = scores.key().value();
      Double coverNominator = scores.value().value();

      double linScore = linNominator / (entailedElementNorm + entailingElementNorm);
      double coverScore = coverNominator / entailingElementNorm;
      coverScore = Math.sqrt(linScore * coverScore);

      if (linScore > 0.0) {
        linScores.offer(new DistSimRule(entailedElementId, entailingElementId, linScore));
      }

      if (coverScore > 0.0) {
        coverScores.offer(new DistSimRule(entailedElementId, entailingElementId, coverScore));
      }
    }
    while (!linScores.isEmpty()) {
      DistSimRule linRule = linScores.poll();
      writer.println("LIN\t" + linRule);
    }
    while (!coverScores.isEmpty()) {
      DistSimRule coverRule = coverScores.poll();
      writer.println("COVER\t" + coverRule);
    }

    // we are done with the left element so we clear rightElements
    entailingElements.clear();
  }
  /** Creates a deep copy of a TIntObjectHashMap<TIntHashSet>. */
  public static TIntObjectHashMap<TIntHashSet> deepClone(TIntObjectHashMap<TIntHashSet> map) {

    TIntObjectHashMap<TIntHashSet> clone = new TIntObjectHashMap<TIntHashSet>();

    for (TIntIterator keyit = map.keySet().iterator(); keyit.hasNext(); ) {
      int key = keyit.next();

      clone.put(key, new TIntHashSet(map.get(key).capacity()));
      clone.get(key).addAll(map.get(key));
    }

    return clone;
  }
 /** {@inheritDoc} */
 public boolean retainAll(TIntCollection collection) {
   if (this == collection) {
     return false;
   }
   boolean modified = false;
   TIntIterator iter = iterator();
   while (iter.hasNext()) {
     if (!collection.contains(iter.next())) {
       iter.remove();
       modified = true;
     }
   }
   return modified;
 }
 /** {@inheritDoc} */
 public boolean removeAll(TIntCollection collection) {
   if (this == collection) {
     clear();
     return true;
   }
   boolean changed = false;
   TIntIterator iter = collection.iterator();
   while (iter.hasNext()) {
     int element = iter.next();
     if (remove(element)) {
       changed = true;
     }
   }
   return changed;
 }
  // bulk load
  public double loadTable(Table t, String dataFile, String delimiter) {
    switch (t.type.getId()) {
      case TABLE:
        if (t.partitions == null)
          return execute(
              "COPY " + t.name + " FROM '" + dataFile + "' DELIMITER '" + delimiter + "'");
        else {
          this.t.reset();
          this.t.start();

          List<Table> partitionTables = TableUtils.perPartitionTables(t);

          TableRowIterator itr = new TableRowIterator(t, dataFile, delimiter);
          int count = 0;
          while (itr.hasNext()) {
            TableRow row = itr.next();
            for (TIntIterator keyit = t.partitions.keySet().iterator(); keyit.hasNext(); ) {
              int key = keyit.next();

              TableRow partialRow =
                  TableRowUtils.partialTableRow(
                      row, partitionTables.get(key), t.partitions.get(key).toArray());
              partialRow.add(count);
              insertRow(partitionTables.get(key), partialRow);
            }
            count++;
            if (count % 10000 == 0) log("Inserted " + count + " rows");
          }
          close();
          this.t.stop();
          return this.t.getElapsedTime();
        }
      case CTABLE:
        this.t.reset();
        this.t.start();
        TableRowIterator itr = new TableRowIterator(t, dataFile, delimiter);
        int count = 0;
        while (itr.hasNext()) {
          insertRow(t, itr.next());
          count++;
          if (count % 10000 == 0) log("Inserted " + count + " rows");
        }
        this.t.stop();
        return this.t.getElapsedTime();
      default:
        throw new UnsupportedOperationException("Unknown table type !");
    }
  }
  public void testToArrayMatchesIteratorOrder() {
    TIntSet set = new TIntHashSet();
    int[] ints = {42, 1138, 13, 86, 99};
    set.addAll(ints);
    int[] toarray_ints = set.toArray();

    int[] iter_ints = new int[5];
    TIntIterator iter = set.iterator();

    int index = 0;
    while (iter.hasNext()) {
      iter_ints[index++] = iter.next();
    }

    assertTrue(Arrays.equals(iter_ints, toarray_ints));
  }
示例#16
0
 // If there is enf(T1,R,T2) such that R contains Rho, T2 contain type of X
 // Then substitute all role wich contain X by T1(X)
 private Set<Atom> addTypeOfXToBody(Term x, TIntHashSet type, Set<Atom> body) {
   Set<Atom> addedAtoms = new HashSet<Atom>();
   TIntIterator iterator = type.iterator();
   while (iterator.hasNext()) {
     int i = iterator.next();
     // for (int i = type.nextSetBit(0); i >= 0; i = type.nextSetBit(i +
     // 1)) {
     if (i != ClipperManager.getInstance().getThing()) {
       Predicate predicate = new DLPredicate(i, 1);
       List<Term> terms = new ArrayList<Term>();
       terms.add(x);
       Atom newAtom = new Atom(predicate, terms);
       if (!body.contains(newAtom) && !addedAtoms.contains(newAtom)) {
         addedAtoms.add(newAtom);
       }
     }
   }
   return addedAtoms;
 }
  private int calculateTotal(int base, TFloatList multipliers, TIntList modifiers) {
    // For now, add all modifiers and multiply by all multipliers. Negative modifiers cap to zero,
    // but negative
    // multipliers remain (so damage can be flipped to healing)

    float total = base;
    TIntIterator modifierIter = modifiers.iterator();
    while (modifierIter.hasNext()) {
      total += modifierIter.next();
    }
    total = Math.max(0, total);
    if (total == 0) {
      return 0;
    }
    TFloatIterator multiplierIter = multipliers.iterator();
    while (multiplierIter.hasNext()) {
      total *= multiplierIter.next();
    }
    return TeraMath.floorToInt(total);
  }
示例#18
0
 // returns number of docs
 public int readCorpusDat(String inFile, boolean updatePWord) throws Exception {
   BufferedReader brIn =
       new BufferedReader(new InputStreamReader(new FileInputStream(inFile), "UTF8"));
   String sLine;
   int i = 0;
   long toks = 0L;
   ArrayList<TIntArrayList> aldocs = new ArrayList<TIntArrayList>();
   if (updatePWord) _pWord = new double[_VOCABSIZE];
   int ct = 0;
   while ((sLine = brIn.readLine()) != null) {
     TIntArrayList ll = lineToList(sLine);
     aldocs.add(ll);
     if (updatePWord) {
       TIntIterator it = ll.iterator();
       while (it.hasNext()) {
         _pWord[it.next()]++;
       }
     }
     toks += (long) ll.size();
     ct++;
   }
   brIn.close();
   System.out.println("Tokens: " + toks);
   System.out.println("Lines processed: " + ct + " Lines saved: " + aldocs.size());
   _NUMTOKENS = toks;
   double dubToks = (double) toks;
   if (updatePWord)
     for (int j = 0; j < _pWord.length; j++) if (_pWord[j] > 0.0) _pWord[j] /= dubToks;
   _NUMDOCS = aldocs.size();
   _docs = aldocs.toArray(new TIntArrayList[aldocs.size()]);
   _changeFactor = new TDoubleArrayList[_docs.length][_NUMLAYERS];
   for (int lay = 0; lay < _NUMLAYERS; lay++) {
     for (int j = 0; j < _docs.length; j++) {
       _changeFactor[j][lay] = new TDoubleArrayList(_docs[j].size());
       for (int k = 0; k < _docs[j].size(); k++) {
         _changeFactor[j][lay].add(1.0); // start with maximal change
       }
     }
   }
   return i;
 }
示例#19
0
 private void sendEntities(NetData.NetMessage.Builder message) {
   TIntIterator dirtyIterator = netDirty.iterator();
   while (dirtyIterator.hasNext()) {
     int netId = dirtyIterator.next();
     EntityRef entity = networkSystem.getEntity(netId);
     if (isOwned(entity)) {
       Set<Class<? extends Component>> emptyComponentClassSet = Collections.emptySet();
       EntityData.PackedEntity entityData =
           entitySerializer.serialize(
               entity,
               emptyComponentClassSet,
               changedComponents.get(netId),
               emptyComponentClassSet,
               new ClientComponentFieldCheck());
       if (entityData != null) {
         message.addUpdateEntity(
             NetData.UpdateEntityMessage.newBuilder().setEntity(entityData).setNetId(netId));
       }
     }
   }
   netDirty.clear();
 }
    @Override
    public Vec gradient(final Vec mu) {
      final Vec grad = new ArrayVec(mu.dim());
      for (int k = 0; k < grad.dim(); k++) {
        final TIntList idxs = classesIdxs.get(k);
        double val = 0.0;
        for (final TIntIterator listIter = idxs.iterator(); listIter.hasNext(); ) {
          final Vec x = ds.data().row(listIter.next());
          final double trans = binClassifier.value(x);
          final double sigmoid = MathTools.sigmoid(trans);
          val -= (2 * sigmoid - 1) / (mu.get(k) * sigmoid + (1 - mu.get(k)) * (1 - sigmoid));
          grad.set(k, val);
        }
      }

      final double norm = VecTools.norm(grad);
      VecTools.scale(grad, 1 / norm);

      for (int k = 0; k < grad.dim(); k++) {
        final double val = VecTools.multiply(laplacian.row(k), mu);
        grad.adjust(k, val);
      }
      return grad;
    }
  public void mergeRules(File vectorsDir, int maxVectorLen)
      throws NumberFormatException, IOException {
    TIntObjectHashMap<BoundedPriorityQueue<Pair<Integer, Double>>> linScores =
        new TIntObjectHashMap<BoundedPriorityQueue<Pair<Integer, Double>>>();
    TIntObjectHashMap<BoundedPriorityQueue<Pair<Integer, Double>>> balScores =
        new TIntObjectHashMap<BoundedPriorityQueue<Pair<Integer, Double>>>();
    String line;
    BufferedReader reader = null;

    for (String fileName : vectorsDir.list()) {
      if (fileName.endsWith(".rules") && fileName.contains("Trunc" + maxVectorLen)) {
        System.out.println("Reading: " + fileName);
        reader = new BufferedReader(new FileReader(vectorsDir.getAbsolutePath() + "/" + fileName));
        while ((line = reader.readLine()) != null) {

          String[] tokens = line.split("\t");
          String scoreType = tokens[0];
          Integer entailedElement = Integer.parseInt(tokens[1]);
          Integer entailingElement = Integer.parseInt(tokens[2]);
          Double score = Double.parseDouble(tokens[3]);
          if (scoreType.equals("LIN")) {
            if (linScores.contains(entailedElement))
              linScores
                  .get(entailedElement)
                  .offer(new Pair<Integer, Double>(entailingElement, score));
            else {
              linScores.put(
                  entailedElement,
                  new BoundedPriorityQueue<Pair<Integer, Double>>(
                      new obj.PairComparator(), m_maxRulesPerElement));
              linScores
                  .get(entailedElement)
                  .offer(new Pair<Integer, Double>(entailingElement, score));
            }
          } else if (scoreType.equals("COVER"))
            if (balScores.contains(entailedElement))
              balScores
                  .get(entailedElement)
                  .offer(new Pair<Integer, Double>(entailingElement, score));
            else {
              balScores.put(
                  entailedElement,
                  new BoundedPriorityQueue<Pair<Integer, Double>>(
                      new obj.PairComparator(), m_maxRulesPerElement));
              balScores
                  .get(entailedElement)
                  .offer(new Pair<Integer, Double>(entailingElement, score));
            }
        }
        reader.close();
      }
    }

    System.out.println("Uploading elements");
    TIntObjectMap<String> id2elementDesc = new TIntObjectHashMap<String>();
    TIntObjectMap<String> id2targetElementDesc = new TIntObjectHashMap<String>();

    reader = new BufferedReader(new FileReader(vectorsDir.getAbsolutePath() + "/elements.txt"));
    while ((line = reader.readLine()) != null) {
      id2elementDesc.put(Integer.parseInt(line.split("\t")[1]), line.split("\t")[0]);
    }
    reader.close();

    reader =
        new BufferedReader(new FileReader(vectorsDir.getAbsolutePath() + "/targetElements.txt"));
    while ((line = reader.readLine()) != null) {
      id2targetElementDesc.put(Integer.parseInt(line.split("\t")[1]), line.split("\t")[0]);
    }
    reader.close();

    PrintWriter writer =
        new PrintWriter(new FileOutputStream(vectorsDir.getAbsolutePath() + "/linRules.txt"));

    TIntIterator iter = linScores.keySet().iterator();
    while (iter.hasNext()) {
      Integer entailedElementId = iter.next();
      String entailedStr = id2targetElementDesc.get(entailedElementId);
      //			if (entailedStr.contains("_")) {
      //				String confDir = entailedStr.substring(entailedStr.indexOf("_")+1);
      //				File resultsDir = new File(f.getAbsolutePath()+"/" + confDir);
      //				if(!resultsDir.exists())
      //					resultsDir.mkdir();
      //				writer = new PrintWriter(new
      // FileOutputStream(resultsDir.getAbsolutePath()+"/"+entailedStr.substring(0,entailedStr.indexOf("_"))));
      //				writer = new PrintWriter(new
      // FileOutputStream(resultsDir.getAbsolutePath()+"/"+entailedElementId));
      //			}
      //			else
      //				writer = new PrintWriter(new FileOutputStream(f.getAbsoluteFile()+"/"+entailedStr));
      //				writer = new PrintWriter(new
      // FileOutputStream(f.getAbsoluteFile()+"/"+entailedElementId));

      while (!linScores.get(entailedElementId).isEmpty()) {
        Pair<Integer, Double> linRule = linScores.get(entailedElementId).poll();
        writer.println(
            entailedStr + "\t" + id2elementDesc.get(linRule.key()) + "\t" + linRule.value());
      }
    }
    if (writer != null) writer.close();
    writer = new PrintWriter(new FileOutputStream(vectorsDir.getAbsolutePath() + "/balRules.txt"));
    iter = balScores.keySet().iterator();
    while (iter.hasNext()) {
      Integer entailedElementId = iter.next();
      String entailedStr = id2targetElementDesc.get(entailedElementId);
      //			if (entailedStr.contains("_")) {
      //				String confDir = entailedStr.substring(entailedStr.indexOf("_")+1);
      //				File resultsDir = new File(f.getAbsolutePath()+"/" + confDir);
      //				if(!resultsDir.exists())
      //					resultsDir.mkdir();
      //				writer = new PrintWriter(new
      // FileOutputStream(resultsDir.getAbsolutePath()+"/"+entailedStr.substring(0,entailedStr.indexOf("_"))));
      //				writer = new PrintWriter(new
      // FileOutputStream(resultsDir.getAbsolutePath()+"/"+entailedElementId));
      //			}
      //			else
      //				writer = new PrintWriter(new FileOutputStream(f.getAbsoluteFile()+"/"+entailedStr));
      //				writer = new PrintWriter(new
      // FileOutputStream(f.getAbsoluteFile()+"/"+entailedElementId));
      while (!balScores.get(entailedElementId).isEmpty()) {
        Pair<Integer, Double> balRule = balScores.get(entailedElementId).poll();
        writer.println(
            entailedStr + "\t" + id2elementDesc.get(balRule.key()) + "\t" + balRule.value());
      }
    }
    writer.close();
  }
示例#22
0
 /**
  * Write the resulting clusters to an output stream.
  *
  * @param outStream output stream
  * @param data Generated data
  * @throws IOException thrown on write errors
  */
 public void writeClusters(OutputStreamWriter outStream, MultipleObjectsBundle data)
     throws IOException {
   int modelcol = -1;
   { // Find model column
     for (int i = 0; i < data.metaLength(); i++) {
       if (TypeUtil.MODEL.isAssignableFromType(data.meta(i))) {
         modelcol = i;
         break;
       }
     }
   }
   if (modelcol < 0) {
     throw new AbortException("No model column found in bundle.");
   }
   ArrayList<Model> models = new ArrayList<>();
   Map<Model, TIntList> modelMap = new HashMap<>();
   { // Build a map from model to the actual objects
     for (int i = 0; i < data.dataLength(); i++) {
       Model model = (Model) data.data(i, modelcol);
       TIntList modelids = modelMap.get(model);
       if (modelids == null) {
         models.add(model);
         modelids = new TIntArrayList();
         modelMap.put(model, modelids);
       }
       modelids.add(i);
     }
   }
   // compute global discard values
   int totalsize = 0, totaldisc = 0;
   for (Entry<Model, TIntList> ent : modelMap.entrySet()) {
     totalsize += ent.getValue().size();
     if (ent.getKey() instanceof GeneratorSingleCluster) {
       totaldisc += ((GeneratorSingleCluster) ent.getKey()).getDiscarded();
     }
   }
   double globdens = (double) (totalsize + totaldisc) / totalsize;
   outStream
       .append("########################################################")
       .append(LINE_SEPARATOR);
   outStream.append("## Number of clusters: " + models.size()).append(LINE_SEPARATOR);
   for (Model model : models) {
     TIntList ids = modelMap.get(model);
     outStream
         .append("########################################################")
         .append(LINE_SEPARATOR);
     outStream.append("## Size: " + ids.size()).append(LINE_SEPARATOR);
     if (model instanceof GeneratorSingleCluster) {
       GeneratorSingleCluster cursclus = (GeneratorSingleCluster) model;
       outStream
           .append("########################################################")
           .append(LINE_SEPARATOR);
       outStream.append("## Cluster: ").append(cursclus.getName()).append(LINE_SEPARATOR);
       Vector cmin = cursclus.getClipmin();
       Vector cmax = cursclus.getClipmax();
       if (cmin != null && cmax != null) {
         outStream
             .append("## Clipping: ")
             .append(cmin.toString()) //
             .append(" - ")
             .append(cmax.toString())
             .append(LINE_SEPARATOR);
       }
       outStream
           .append("## Density correction factor: " + cursclus.getDensityCorrection())
           .append(LINE_SEPARATOR);
       outStream.append("## Generators:").append(LINE_SEPARATOR);
       for (int i = 0; i < cursclus.getDim(); i++) {
         Distribution gen = cursclus.getDistribution(i);
         outStream.append("##   ").append(gen.toString()).append(LINE_SEPARATOR);
       }
       if (cursclus.getTransformation() != null
           && cursclus.getTransformation().getTransformation() != null) {
         outStream.append("## Affine transformation matrix:").append(LINE_SEPARATOR);
         outStream
             .append(FormatUtil.format(cursclus.getTransformation().getTransformation(), "## "))
             .append(LINE_SEPARATOR);
       }
       outStream
           .append(
               "## Discards: "
                   + cursclus.getDiscarded()
                   + " Retries left: "
                   + cursclus.getRetries())
           .append(LINE_SEPARATOR);
       double corf = /* cursclus.overweight */
           (double) (cursclus.getSize() + cursclus.getDiscarded()) / cursclus.getSize() / globdens;
       outStream.append("## Density correction factor estimation: " + corf).append(LINE_SEPARATOR);
     }
     outStream
         .append("########################################################")
         .append(LINE_SEPARATOR);
     for (TIntIterator iter = ids.iterator(); iter.hasNext(); ) {
       int num = iter.next();
       for (int c = 0; c < data.metaLength(); c++) {
         if (c != modelcol) {
           if (c > 0) {
             outStream.append(' ');
           }
           outStream.append(data.data(num, c).toString());
         }
       }
       outStream.append(LINE_SEPARATOR);
     }
   }
 }