How to use

IntIterable

in

it.unimi.dsi.fastutil.ints

 @Override
 public Iterator<ImmutableBitmap> iterator()
 {
  final IntIterator iterator = indexes.iterator();
  return new Iterator<ImmutableBitmap>()
  {
   @Override
   public boolean hasNext()
   {
    return iterator.hasNext();
   }
   @Override
   public ImmutableBitmap next()
   {
    return bitmapIndex.getBitmap(iterator.nextInt());
   }
   @Override
   public void remove()
   {
    throw new UnsupportedOperationException();
   }
  };
 }
};

  /**
   * {@inheritDoc}
   * 
   * @deprecated Please use the corresponding type-specific method instead.
   */
  @Deprecated
  @Override
  default void forEach(final Consumer<? super Integer> action) {
    forEach((java.util.function.IntConsumer) action::accept);
  }
}

bitmapIndex,
IntIteratorUtils.toIntList(
  makePredicateQualifyingIndexIterable(bitmapIndex, predicate, dimValues).iterator()
),
indexSelector.getNumRows()

List<IntIterator> convertedInvertedIndexesIterators = new ArrayList<>(convertedInvertedIndexesToMerge.size());
for (IntIterable convertedInvertedIndexes : convertedInvertedIndexesToMerge) {
 convertedInvertedIndexesIterators.add(convertedInvertedIndexes.iterator());

@Override
public double estimateSelectivity(BitmapIndexSelector indexSelector)
{
 if (extractionFn == null) {
  final BitmapIndex bitmapIndex = indexSelector.getBitmapIndex(dimension);
  return Filters.estimateSelectivity(
    bitmapIndex,
    IntIteratorUtils.toIntList(getBitmapIndexIterable(bitmapIndex).iterator()),
    indexSelector.getNumRows()
  );
 } else {
  return Filters.estimateSelectivity(
    dimension,
    indexSelector,
    getPredicateFactory().makeStringPredicate()
  );
 }
}

  @Override
  public IntIterator iterator() {
    return iterable.iterator();
  }
}

 @Override
 public Iterator<ImmutableBitmap> iterator()
 {
  final IntIterator iterator = indexes.iterator();
  return new Iterator<ImmutableBitmap>()
  {
   @Override
   public boolean hasNext()
   {
    return iterator.hasNext();
   }
   @Override
   public ImmutableBitmap next()
   {
    return bitmapIndex.getBitmap(iterator.nextInt());
   }
   @Override
   public void remove()
   {
    throw new UnsupportedOperationException();
   }
  };
 }
};

 @Override
 public Iterator<ImmutableBitmap> iterator()
 {
  final IntIterator iterator = indexes.iterator();
  return new Iterator<ImmutableBitmap>()
  {
   @Override
   public boolean hasNext()
   {
    return iterator.hasNext();
   }
   @Override
   public ImmutableBitmap next()
   {
    return bitmapIndex.getBitmap(iterator.nextInt());
   }
   @Override
   public void remove()
   {
    throw new UnsupportedOperationException();
   }
  };
 }
};

/** Builds a new two-sizes long big list using a given iterable object.
 *
 * @param elements an iterable object.
 */
public TwoSizesLongBigList(final IntIterable elements) {
  this((LongIterable) () -> LongIterators.wrap(elements.iterator()));
}

@Override
public boolean isEmpty() {
  return !iterable.iterator().hasNext();
}
@Override

/** Creates a new Elias–Fano long big list.
 *
 * @param elements an iterable object.
 */
public EliasFanoLongBigList(final IntIterable elements) {
  this((LongIterable) () -> LongIterators.wrap(elements.iterator()));
}

/** Creates a new Elias–Fano prefix-sum long big list.
 *
 * @param elements an iterable object.
 */
public EliasFanoPrefixSumLongBigList(final IntIterable elements) {
  this((LongIterable) () -> LongIterators.wrap(elements.iterator()));
}

/** Creates an Elias–Fano representation of the values returned by the given {@linkplain Iterable iterable object}.
 *
 * @param list an iterable object.
 */
public EliasFanoMonotoneLongBigList(final IntIterable list) {
  this((LongIterable) () -> LongIterators.wrap(list.iterator()));
}

  public LongIterator iterator() {
    return LongIterators.wrap( BinIO.asIntIterable( xx ).iterator() );
  }
};

/**
 * Performs the given action for each element of this type-specific
 * {@link java.lang.Iterable} until all elements have been processed or the
 * action throws an exception.
 * 
 * @param action
 *            the action to be performed for each element.
 * @see java.lang.Iterable#forEach(java.util.function.Consumer)
 * @since 8.0.0
 */
@SuppressWarnings("overloads")
default void forEach(final java.util.function.IntConsumer action) {
  Objects.requireNonNull(action);
  for (final IntIterator iterator = iterator(); iterator.hasNext();)
    action.accept(iterator.nextInt());
}
/**

bitmapIndex,
IntIteratorUtils.toIntList(
  makePredicateQualifyingIndexIterable(bitmapIndex, predicate, dimValues).iterator()
),
indexSelector.getNumRows()

return estimateSelectivity(
  bitmapIndex,
  IntIteratorUtils.toIntList(makePredicateQualifyingIndexIterable(bitmapIndex, predicate, dimValues).iterator()),
  indexSelector.getNumRows()
);

List<IntIterator> convertedInvertedIndexesIterators = new ArrayList<>(convertedInvertedIndexesToMerge.size());
for (IntIterable convertedInvertedIndexes : convertedInvertedIndexesToMerge) {
 convertedInvertedIndexesIterators.add(convertedInvertedIndexes.iterator());

  @Override
  public Vector<Double> apply(Vector<Double> v) {
    double[] mid = new double[J];
    int n = 0;
    IntIterator data = corpus.iterator();
    while (data.hasNext()) {
      int i = data.nextInt();
      if (i != 0) {
        mid[n] += v.doubleValue(i - 1);
      } else {
        n++;
      }
    }
    n = 0;
    double[] a = new double[v.length()];
    data = corpus.iterator();
    while (data.hasNext()) {
      int i = data.nextInt();
      if (i != 0) {
        a[i - 1] += mid[n];
      } else {
        n++;
      }
    }
    return new RealVector(a);
  }
}

  @Override
  public Vector<Double> apply(Vector<Double> v) {
    double[] mid = new double[W];
    int n = 0;
    IntIterator data = corpus.iterator();
    while (data.hasNext()) {
      int i = data.nextInt();
      if (i != 0) {
        mid[i - 1] += v.doubleValue(n);
      } else {
        n++;
      }
    }
    n = 0;
    double[] a = new double[v.length()];
    data = corpus.iterator();
    while (data.hasNext()) {
      int i = data.nextInt();
      if (i != 0) {
        a[n] += mid[i - 1];
      } else {
        n++;
      }
    }
    return new RealVector(a);
  }
}