How to use de.lmu.ifi.dbs.elki.database.ids

@Override
public DBIDs chooseInitialMedoids(int k, DBIDs ids, DistanceQuery<? super O> distanceFunction) {
 DBIDIter iter = ids.iter();
 ArrayModifiableDBIDs means = DBIDUtil.newArray(k);
 for(int i = 0; i < k && iter.valid(); i++, iter.advance()) {
  means.add(iter);
 }
 return means;
}

 @Override
 public DBIDs getRoots() {
  ArrayModifiableDBIDs roots = DBIDUtil.newArray();
  for(DBIDArrayIter iter = ids.iter(); iter.valid(); iter.advance()) {
   // roots or one element in component
   if(parent[iter.getOffset()] == iter.getOffset()) {
    roots.add(iter);
   }
  }
  return roots;
 }
}

 @Override
 public DBIDs getRoots() {
  ArrayModifiableDBIDs roots = DBIDUtil.newArray();
  for(DBIDArrayIter iter = ids.iter(); iter.valid(); iter.advance()) {
   // roots or one element in component
   if(parent[iter.getOffset()] == iter.getOffset()) {
    roots.add(iter);
   }
  }
  return roots;
 }
}

/**
 * Execute a function for each ID.
 *
 * @param action Action to execute
 */
default void forEachDouble(Consumer action) {
 for(DoubleDBIDListIter it = iter(); it.valid(); it.advance()) {
  action.accept(it, it.doubleValue());
 }
}

@Override
public void clear() {
 // Re-initialize
 DBIDRef inv = DBIDUtil.invalid();
 final int size = data.size();
 data.clear();
 for(int i = 0; i < size; i++) {
  data.add(inv);
 }
}

@Override
public DBID get(DBIDRef id) {
 assert(ids.contains(id));
 return DBIDUtil.deref(id);
}

/**
 * Returns the difference of the two specified collection of IDs.
 *
 * @param ids1 the first collection
 * @param ids2 the second collection
 * @return the difference of ids1 minus ids2
 */
public static ModifiableDBIDs difference(DBIDs ids1, DBIDs ids2) {
 ModifiableDBIDs result = DBIDUtil.newHashSet(ids1);
 result.removeDBIDs(ids2);
 return result;
}

/**
 * Compute the median of an array efficiently using the QuickSelect method.
 *
 * Note: the array is <b>modified</b> by this.
 *
 * @param data Data to process
 * @param comparator Comparator to use
 * @return Median position
 */
public static int median(ArrayModifiableDBIDs data, Comparator<? super DBIDRef> comparator) {
 return median(data, comparator, 0, data.size());
}

/**
 * Produce a random shuffling of the given DBID array.
 *
 * @param ids Original DBIDs, no duplicates allowed
 * @param random Random generator
 */
public static void randomShuffle(ArrayModifiableDBIDs ids, Random random) {
 randomShuffle(ids, random, ids.size());
}

/**
 * Dereference a DBID reference.
 *
 * @param ref DBID reference
 * @return DBID
 */
public static DBID deref(DBIDRef ref) {
 return ref instanceof DBID ? (DBID) ref : importInteger(ref.internalGetIndex());
}

/**
 * QuickSelect is essentially quicksort, except that we only "sort" that half
 * of the array that we are interested in.
 *
 * Note: the array is <b>modified</b> by this.
 *
 * @param data Data to process
 * @param rank Rank position that we are interested in (integer!)
 */
public static void quickSelect(ModifiableDoubleDBIDList data, int rank) {
 quickSelect(data, 0, data.size(), rank);
}

/**
 * Compute the median of an array efficiently using the QuickSelect method.
 *
 * Note: the array is <b>modified</b> by this.
 *
 * @param data Data to process
 * @return Median position
 */
public static int median(ModifiableDoubleDBIDList data) {
 return median(data, 0, data.size());
}

/**
 * Compute the median of an array efficiently using the QuickSelect method.
 *
 * Note: the array is <b>modified</b> by this.
 *
 * @param data Data to process
 * @param quant Quantile to compute
 * @return Quantile position
 */
public static int quantile(ModifiableDoubleDBIDList data, double quant) {
 return quantile(data, 0, data.size(), quant);
}

@Override
public DBIDs chooseInitialMedoids(int k, DBIDs ids, DistanceQuery<? super O> distanceFunction) {
 DBIDIter iter = ids.iter();
 ArrayModifiableDBIDs means = DBIDUtil.newArray(k);
 for(int i = 0; i < k && iter.valid(); i++, iter.advance()) {
  means.add(iter);
 }
 return means;
}

 @Override
 public DBIDs getRoots() {
  ArrayModifiableDBIDs roots = DBIDUtil.newArray();
  for(DBIDArrayIter iter = ids.iter(); iter.valid(); iter.advance()) {
   // roots or one element in component
   if(parent[iter.getOffset()] == iter.getOffset()) {
    roots.add(iter);
   }
  }
  return roots;
 }
}

 @Override
 public DBIDs getRoots() {
  ArrayModifiableDBIDs roots = DBIDUtil.newArray();
  for(DBIDArrayIter iter = ids.iter(); iter.valid(); iter.advance()) {
   // roots or one element in component
   if(parent[iter.getOffset()] == iter.getOffset()) {
    roots.add(iter);
   }
  }
  return roots;
 }
}

@Override
public void clear() {
 // Re-initialize
 DBIDRef inv = DBIDUtil.invalid();
 final int size = data.size();
 data.clear();
 for(int i = 0; i < size; i++) {
  data.add(inv);
 }
}

@Override
public DBIDs chooseInitialMedoids(int k, DBIDs ids, DistanceQuery<? super O> distanceFunction) {
 DBIDIter iter = ids.iter();
 ArrayModifiableDBIDs means = DBIDUtil.newArray(k);
 for(int i = 0; i < k && iter.valid(); i++, iter.advance()) {
  means.add(iter);
 }
 return means;
}

 @Override
 public DBIDs getRoots() {
  ArrayModifiableDBIDs roots = DBIDUtil.newArray();
  for(DBIDArrayIter iter = ids.iter(); iter.valid(); iter.advance()) {
   // roots or one element in component
   if(parent[iter.getOffset()] == iter.getOffset()) {
    roots.add(iter);
   }
  }
  return roots;
 }
}

 @Override
 public DBIDs getRoots() {
  ArrayModifiableDBIDs roots = DBIDUtil.newArray();
  for(DBIDArrayIter iter = ids.iter(); iter.valid(); iter.advance()) {
   // roots or one element in component
   if(parent[iter.getOffset()] == iter.getOffset()) {
    roots.add(iter);
   }
  }
  return roots;
 }
}