com.landawn.abacus.util.stream.FloatStream Maven / Gradle / Ivy
Show all versions of abacus-android Show documentation
/*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.landawn.abacus.util.stream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Queue;
import com.landawn.abacus.exception.AbacusException;
import com.landawn.abacus.util.ContinuableFuture;
import com.landawn.abacus.util.FloatIterator;
import com.landawn.abacus.util.FloatList;
import com.landawn.abacus.util.FloatMatrix;
import com.landawn.abacus.util.FloatSummaryStatistics;
import com.landawn.abacus.util.Fn;
import com.landawn.abacus.util.Holder;
import com.landawn.abacus.util.IndexedFloat;
import com.landawn.abacus.util.MutableInt;
import com.landawn.abacus.util.N;
import com.landawn.abacus.util.Nth;
import com.landawn.abacus.util.Optional;
import com.landawn.abacus.util.OptionalDouble;
import com.landawn.abacus.util.OptionalFloat;
import com.landawn.abacus.util.Pair;
import com.landawn.abacus.util.Percentage;
import com.landawn.abacus.util.Try;
import com.landawn.abacus.util.function.BiConsumer;
import com.landawn.abacus.util.function.BinaryOperator;
import com.landawn.abacus.util.function.BooleanSupplier;
import com.landawn.abacus.util.function.FloatBiFunction;
import com.landawn.abacus.util.function.FloatBiPredicate;
import com.landawn.abacus.util.function.FloatBinaryOperator;
import com.landawn.abacus.util.function.FloatConsumer;
import com.landawn.abacus.util.function.FloatFunction;
import com.landawn.abacus.util.function.FloatNFunction;
import com.landawn.abacus.util.function.FloatPredicate;
import com.landawn.abacus.util.function.FloatSupplier;
import com.landawn.abacus.util.function.FloatToDoubleFunction;
import com.landawn.abacus.util.function.FloatToIntFunction;
import com.landawn.abacus.util.function.FloatToLongFunction;
import com.landawn.abacus.util.function.FloatTriFunction;
import com.landawn.abacus.util.function.FloatUnaryOperator;
import com.landawn.abacus.util.function.Function;
import com.landawn.abacus.util.function.ObjFloatConsumer;
import com.landawn.abacus.util.function.Supplier;
import com.landawn.abacus.util.function.ToFloatFunction;
/**
* Note: It's copied from OpenJDK at: http://hg.openjdk.java.net/jdk8u/hs-dev/jdk
*
*
* A sequence of primitive float-valued elements supporting sequential and parallel
* aggregate operations. This is the {@code float} primitive specialization of
* {@link Stream}.
*
* The following example illustrates an aggregate operation using
* {@link Stream} and {@link FloatStream}, computing the sum of the weights of the
* red widgets:
*
*
{@code
* float sum = widgets.stream()
* .filter(w -> w.getColor() == RED)
* .mapToFloat(w -> w.getWeight())
* .sum();
* }
*
*
* @see Stream
*/
public abstract class FloatStream
extends StreamBase {
private static final FloatStream EMPTY = new ArrayFloatStream(N.EMPTY_FLOAT_ARRAY, true, null);
FloatStream(final boolean sorted, final Collection closeHandlers) {
super(sorted, null, closeHandlers);
}
/**
* Returns a stream consisting of the results of applying the given
* function to the elements of this stream.
*
* This is an intermediate
* operation.
*
* @param mapper a non-interfering,
* stateless
* function to apply to each element
* @return the new stream
*/
public abstract FloatStream map(FloatUnaryOperator mapper);
/**
* Returns an {@code IntStream} consisting of the results of applying the
* given function to the elements of this stream.
*
*
This is an intermediate
* operation.
*
* @param mapper a non-interfering,
* stateless
* function to apply to each element
* @return the new stream
*/
public abstract IntStream mapToInt(FloatToIntFunction mapper);
/**
* Returns a {@code LongStream} consisting of the results of applying the
* given function to the elements of this stream.
*
*
This is an intermediate
* operation.
*
* @param mapper a non-interfering,
* stateless
* function to apply to each element
* @return the new stream
*/
public abstract LongStream mapToLong(FloatToLongFunction mapper);
/**
* Returns a {@code DoubleStream} consisting of the results of applying the
* given function to the elements of this stream.
*
*
This is an intermediate
* operation.
*
* @param mapper a non-interfering,
* stateless
* function to apply to each element
* @return the new stream
*/
public abstract DoubleStream mapToDouble(FloatToDoubleFunction mapper);
/**
* Returns an object-valued {@code Stream} consisting of the results of
* applying the given function to the elements of this stream.
*
*
This is an
* intermediate operation.
*
* @param the element type of the new stream
* @param mapper a non-interfering,
* stateless
* function to apply to each element
* @return the new stream
*/
public abstract Stream mapToObj(FloatFunction mapper);
/**
* Returns a stream consisting of the results of replacing each element of
* this stream with the contents of a mapped stream produced by applying
* the provided mapping function to each element.
*
*
This is an intermediate
* operation.
*
* @param mapper a non-interfering,
* stateless
* function to apply to each element which produces a
* {@code FloatStream} of new values
* @return the new stream
* @see Stream#flatMap(Function)
*/
public abstract FloatStream flatMap(FloatFunction mapper);
public abstract FloatStream flattMap(FloatFunction mapper);
public abstract IntStream flatMapToInt(FloatFunction mapper);
public abstract LongStream flatMapToLong(FloatFunction mapper);
public abstract DoubleStream flatMapToDouble(FloatFunction mapper);
public abstract Stream flatMapToObj(FloatFunction> mapper);
public abstract Stream flattMapToObj(FloatFunction> mapper);
/**
* Merge series of adjacent elements which satisfy the given predicate using
* the merger function and return a new stream.
*
*
* This method only run sequentially, even in parallel stream.
*
* @param collapsible
* @param mergeFunction
* @return
*/
@SequentialOnly
public abstract FloatStream collapse(final FloatBiPredicate collapsible, final FloatBiFunction mergeFunction);
/**
* Returns a {@code Stream} produced by iterative application of a accumulation function
* to an initial element {@code seed} and next element of the current stream.
* Produces a {@code Stream} consisting of {@code seed}, {@code acc(seed, value1)},
* {@code acc(acc(seed, value1), value2)}, etc.
*
* This is an intermediate operation.
*
*
Example:
*
* accumulator: (a, b) -> a + b
* stream: [1, 2, 3, 4, 5]
* result: [1, 3, 6, 10, 15]
*
*
*
* This method only run sequentially, even in parallel stream.
*
* @param accumulator the accumulation function
* @return the new stream which has the extract same size as this stream.
*/
@SequentialOnly
public abstract FloatStream scan(final FloatBiFunction accumulator);
/**
* Returns a {@code Stream} produced by iterative application of a accumulation function
* to an initial element {@code seed} and next element of the current stream.
* Produces a {@code Stream} consisting of {@code seed}, {@code acc(seed, value1)},
* {@code acc(acc(seed, value1), value2)}, etc.
*
* This is an intermediate operation.
*
*
Example:
*
* seed:10
* accumulator: (a, b) -> a + b
* stream: [1, 2, 3, 4, 5]
* result: [11, 13, 16, 20, 25]
*
*
*
* This method only run sequentially, even in parallel stream.
*
* @param seed the initial value. it's only used once by accumulator to calculate the fist element in the returned stream.
* It will be ignored if this stream is empty and won't be the first element of the returned stream.
*
* @param accumulator the accumulation function
* @return the new stream which has the extract same size as this stream.
*/
@SequentialOnly
public abstract FloatStream scan(final float seed, final FloatBiFunction accumulator);
/**
*
* This method only run sequentially, even in parallel stream.
*
* @param n
* @return
*/
@SequentialOnly
public abstract FloatStream top(int n);
/**
*
* This method only run sequentially, even in parallel stream.
*
* @param n
* @return
*/
@SequentialOnly
public abstract FloatStream top(final int n, Comparator comparator);
public abstract FloatList toFloatList();
/**
*
* @param keyExtractor
* @param valueMapper
* @return
* @see Collectors#toMap(Function, Function)
*/
public abstract Map toMap(FloatFunction keyExtractor, FloatFunction valueMapper);
/**
*
* @param keyExtractor
* @param valueMapper
* @param mapFactory
* @return
* @see Collectors#toMap(Function, Function, Supplier)
*/
public abstract > M toMap(FloatFunction keyExtractor, FloatFunction valueMapper,
Supplier mapFactory);
/**
*
* @param keyExtractor
* @param valueMapper
* @param mergeFunction
* @return
* @see Collectors#toMap(Function, Function, BinaryOperator)
*/
public abstract Map toMap(FloatFunction keyExtractor, FloatFunction valueMapper, BinaryOperator mergeFunction);
/**
*
* @param keyExtractor
* @param valueMapper
* @param mergeFunction
* @param mapFactory
* @return
* @see Collectors#toMap(Function, Function, BinaryOperator, Supplier)
*/
public abstract > M toMap(FloatFunction keyExtractor, FloatFunction valueMapper,
BinaryOperator mergeFunction, Supplier mapFactory);
/**
*
* @param classifier
* @param downstream
* @return
* @see Collectors#groupingBy(Function, Collector)
*/
public abstract Map toMap(final FloatFunction classifier, final Collector downstream);
/**
*
* @param classifier
* @param downstream
* @param mapFactory
* @return
* @see Collectors#groupingBy(Function, Collector, Supplier)
*/
public abstract > M toMap(final FloatFunction classifier, final Collector downstream,
final Supplier mapFactory);
public abstract FloatMatrix toMatrix();
/**
* Performs a reduction on the
* elements of this stream, using the provided identity value and an
* associative
* accumulation function, and returns the reduced value. This is equivalent
* to:
* {@code
* float result = identity;
* for (float element : this stream)
* result = accumulator.applyAsFloat(result, element)
* return result;
* }
*
* but is not constrained to execute sequentially.
*
* The {@code identity} value must be an identity for the accumulator
* function. This means that for all {@code x},
* {@code accumulator.apply(identity, x)} is equal to {@code x}.
* The {@code accumulator} function must be an
* associative function.
*
*
This is a terminal
* operation.
*
* @apiNote Sum, min, max, and average are all special cases of reduction.
* Summing a stream of numbers can be expressed as:
*
{@code
* float sum = numbers.reduce(0, (a, b) -> a+b);
* }
*
* or more compactly:
*
* {@code
* float sum = numbers.reduce(0, Float::sum);
* }
*
* While this may seem a more roundabout way to perform an aggregation
* compared to simply mutating a running total in a loop, reduction
* operations parallelize more gracefully, without needing additional
* synchronization and with greatly reduced risk of data races.
*
* @param identity the identity value for the accumulating function
* @param op an associative,
* non-interfering,
* stateless
* function for combining two values
* @return the result of the reduction
* @see #sum()
* @see #min()
* @see #max()
* @see #average()
*/
public abstract float reduce(float identity, FloatBinaryOperator op);
/**
* Performs a reduction on the
* elements of this stream, using an
* associative accumulation
* function, and returns an {@code OptionalFloat} describing the reduced
* value, if any. This is equivalent to:
*
{@code
* boolean foundAny = false;
* float result = null;
* for (float element : this stream) {
* if (!foundAny) {
* foundAny = true;
* result = element;
* }
* else
* result = accumulator.applyAsFloat(result, element);
* }
* return foundAny ? OptionalFloat.of(result) : OptionalFloat.empty();
* }
*
* but is not constrained to execute sequentially.
*
* The {@code accumulator} function must be an
* associative function.
*
*
This is a terminal
* operation.
*
* @param op an associative,
* non-interfering,
* stateless
* function for combining two values
* @return the result of the reduction
* @see #reduce(float, FloatBinaryOperator)
*/
public abstract OptionalFloat reduce(FloatBinaryOperator op);
/**
* Performs a mutable
* reduction operation on the elements of this stream. A mutable
* reduction is one in which the reduced value is a mutable result container,
* such as an {@code ArrayList}, and elements are incorporated by updating
* the state of the result rather than by replacing the result. This
* produces a result equivalent to:
*
{@code
* R result = supplier.get();
* for (float element : this stream)
* accumulator.accept(result, element);
* return result;
* }
*
* Like {@link #reduce(float, FloatBinaryOperator)}, {@code collect}
* operations can be parallelized without requiring additional
* synchronization.
*
*
This is a terminal
* operation.
*
* @param type of the result
* @param supplier a function that creates a new result container. For a
* parallel execution, this function may be called
* multiple times and must return a fresh value each time.
* @param accumulator an associative,
* non-interfering,
* stateless
* function for incorporating an additional element into a result
* @param combiner an associative,
* non-interfering,
* stateless
* function for combining two values, which must be
* compatible with the accumulator function
* @return the result of the reduction
* @see Stream#collect(Supplier, BiConsumer, BiConsumer)
*/
public abstract R collect(Supplier supplier, ObjFloatConsumer accumulator, BiConsumer combiner);
/**
*
* @param supplier
* @param accumulator
* @return
*/
public abstract R collect(Supplier supplier, ObjFloatConsumer accumulator);
public abstract void forEach(final Try.FloatConsumer action) throws E;
public abstract boolean anyMatch(final Try.FloatPredicate predicate) throws E;
public abstract boolean allMatch(final Try.FloatPredicate predicate) throws E;
public abstract boolean noneMatch(final Try.FloatPredicate predicate) throws E;
public abstract OptionalFloat findFirst(final Try.FloatPredicate predicate) throws E;
public abstract OptionalFloat findLast(final Try.FloatPredicate predicate) throws E;
public abstract OptionalFloat findFirstOrLast(Try.FloatPredicate predicateForFirst,
Try.FloatPredicate predicateForLast) throws E, E2;
public abstract OptionalFloat findAny(final Try.FloatPredicate predicate) throws E;
/**
* Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead.
* Don't call any other methods with this stream after head() and tail() are called.
*
* @return
*/
public abstract OptionalFloat head();
/**
* Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead.
* Don't call any other methods with this stream after head() and tail() are called.
*
* @return
*/
public abstract FloatStream tail();
public abstract Pair headAndTail();
// /**
// * Headd and taill should be used by pair.
// * Don't call any other methods with this stream after headd() and taill() are called.
// *
// * @return
// * @deprecated
// */
// @Deprecated
// public abstract FloatStream headd();
//
// /**
// * Headd and taill should be used by pair.
// * Don't call any other methods with this stream after headd() and taill() are called.
// *
// * @return
// * @deprecated
// */
// @Deprecated
// public abstract OptionalFloat taill();
//
// /**
// *
// * @return
// * @deprecated
// */
// @Deprecated
// public abstract Pair headAndTaill();
/**
* Returns an {@code OptionalFloat} describing the minimum element of this
* stream, or an empty OptionalFloat if this stream is empty. The minimum
* element will be {@code Float.NaN} if any stream element was NaN. Unlike
* the numerical comparison operators, this method considers negative zero
* to be strictly smaller than positive zero. This is a special case of a
* reduction and is
* equivalent to:
* {@code
* return reduce(Float::min);
* }
*
* This is a terminal
* operation.
*
* @return an {@code OptionalFloat} containing the minimum element of this
* stream, or an empty optional if the stream is empty
*/
public abstract OptionalFloat min();
/**
* Returns an {@code OptionalFloat} describing the maximum element of this
* stream, or an empty OptionalFloat if this stream is empty. The maximum
* element will be {@code Float.NaN} if any stream element was NaN. Unlike
* the numerical comparison operators, this method considers negative zero
* to be strictly smaller than positive zero. This is a
* special case of a
* reduction and is
* equivalent to:
*
{@code
* return reduce(Float::max);
* }
*
* This is a terminal
* operation.
*
* @return an {@code OptionalFloat} containing the maximum element of this
* stream, or an empty optional if the stream is empty
*/
public abstract OptionalFloat max();
/**
*
* @param k
* @return OptionalByte.empty() if there is no element or count less than k, otherwise the kth largest element.
*/
public abstract OptionalFloat kthLargest(int k);
/**
* Returns the sum of elements in this stream.
*
* Summation is a special case of a reduction. If
* floating-point summation were exact, this method would be
* equivalent to:
*
*
{@code
* return reduce(0, Float::sum);
* }
*
* However, since floating-point summation is not exact, the above
* code is not necessarily equivalent to the summation computation
* done by this method.
*
* If any stream element is a NaN or the sum is at any point a NaN
* then the sum will be NaN.
*
* The value of a floating-point sum is a function both
* of the input values as well as the order of addition
* operations. The order of addition operations of this method is
* intentionally not defined to allow for implementation
* flexibility to improve the speed and accuracy of the computed
* result.
*
* In particular, this method may be implemented using compensated
* summation or other technique to reduce the error bound in the
* numerical sum compared to a simple summation of {@code float}
* values.
*
*
This is a terminal
* operation.
*
* @apiNote Elements sorted by increasing absolute magnitude tend
* to yield more accurate results.
*
* @return the sum of elements in this stream
*/
public abstract double sum();
/**
* Returns an {@code OptionalFloat} describing the arithmetic
* mean of elements of this stream, or an empty optional if this
* stream is empty.
*
* If any recorded value is a NaN or the sum is at any point a NaN
* then the average will be NaN.
*
*
The average returned can vary depending upon the order in
* which values are recorded.
*
* This method may be implemented using compensated summation or
* other technique to reduce the error bound in the {@link #sum
* numerical sum} used to compute the average.
*
*
The average is a special case of a reduction.
*
*
This is a terminal
* operation.
*
* @apiNote Elements sorted by increasing absolute magnitude tend
* to yield more accurate results.
*
* @return an {@code OptionalFloat} containing the average element of this
* stream, or an empty optional if the stream is empty
*/
public abstract OptionalDouble average();
public abstract FloatSummaryStatistics summarize();
public abstract Pair>> summarizze();
/**
*
* @param b
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public abstract FloatStream merge(final FloatStream b, final FloatBiFunction nextSelector);
public abstract FloatStream zipWith(FloatStream b, FloatBiFunction zipFunction);
public abstract FloatStream zipWith(FloatStream b, FloatStream c, FloatTriFunction zipFunction);
public abstract FloatStream zipWith(FloatStream b, float valueForNoneA, float valueForNoneB, FloatBiFunction zipFunction);
public abstract FloatStream zipWith(FloatStream b, FloatStream c, float valueForNoneA, float valueForNoneB, float valueForNoneC,
FloatTriFunction zipFunction);
/**
* Returns a {@code DoubleStream} consisting of the elements of this stream,
* converted to {@code double}.
*
* This is an intermediate
* operation.
*
* @return a {@code DoubleStream} consisting of the elements of this stream,
* converted to {@code double}
*/
public abstract DoubleStream asDoubleStream();
/**
* Returns a {@code Stream} consisting of the elements of this stream,
* boxed to {@code Float}.
*
*
This is an intermediate
* operation.
*
* @return a {@code Stream} consistent of the elements of this stream,
* each boxed to a {@code Float}
*/
public abstract Stream boxed();
@Override
public FloatIterator iterator() {
return iteratorEx();
}
abstract FloatIteratorEx iteratorEx();
@Override
public R __(Function transfer) {
return transfer.apply(this);
}
public static FloatStream empty() {
return EMPTY;
}
@SafeVarargs
public static FloatStream of(final float... a) {
return N.isNullOrEmpty(a) ? empty() : new ArrayFloatStream(a);
}
public static FloatStream of(final float[] a, final int startIndex, final int endIndex) {
return N.isNullOrEmpty(a) && (startIndex == 0 && endIndex == 0) ? empty() : new ArrayFloatStream(a, startIndex, endIndex);
}
public static FloatStream of(final float[][] a) {
return N.isNullOrEmpty(a) ? empty() : Stream.of(a).flatMapToFloat(new Function() {
@Override
public FloatStream apply(float[] t) {
return FloatStream.of(t);
}
});
}
public static FloatStream of(final float[][][] a) {
return N.isNullOrEmpty(a) ? empty() : Stream.of(a).flatMapToFloat(new Function() {
@Override
public FloatStream apply(float[][] t) {
return FloatStream.of(t);
}
});
}
public static FloatStream of(final Float[] a) {
return Stream.of(a).mapToFloat(Fn.unboxF());
}
public static FloatStream of(final Float[] a, final int startIndex, final int endIndex) {
return Stream.of(a, startIndex, endIndex).mapToFloat(Fn.unboxF());
}
public static FloatStream of(final Collection c) {
return Stream.of(c).mapToFloat(Fn.unboxF());
}
public static FloatStream of(final FloatIterator iterator) {
return iterator == null ? empty() : new IteratorFloatStream(iterator);
}
/**
* Lazy evaluation.
* @param supplier
* @return
*/
public static FloatStream of(final Supplier supplier) {
final FloatIterator iter = new FloatIteratorEx() {
private FloatIterator iterator = null;
@Override
public boolean hasNext() {
if (iterator == null) {
init();
}
return iterator.hasNext();
}
@Override
public float nextFloat() {
if (iterator == null) {
init();
}
return iterator.nextFloat();
}
private void init() {
final FloatList c = supplier.get();
if (N.isNullOrEmpty(c)) {
iterator = FloatIterator.empty();
} else {
iterator = c.iterator();
}
}
};
return of(iter);
}
public static FloatStream repeat(final float element, final long n) {
N.checkArgNotNegative(n, "n");
if (n == 0) {
return empty();
}
return new IteratorFloatStream(new FloatIteratorEx() {
private long cnt = n;
@Override
public boolean hasNext() {
return cnt > 0;
}
@Override
public float nextFloat() {
if (cnt-- <= 0) {
throw new NoSuchElementException();
}
return element;
}
@Override
public void skip(long n) {
cnt = n >= cnt ? 0 : cnt - (int) n;
}
@Override
public long count() {
return cnt;
}
@Override
public float[] toArray() {
final float[] result = new float[(int) cnt];
for (int i = 0; i < cnt; i++) {
result[i] = element;
}
cnt = 0;
return result;
}
});
}
public static FloatStream random() {
return generate(new FloatSupplier() {
@Override
public float getAsFloat() {
return RAND.nextFloat();
}
});
}
public static FloatStream iterate(final BooleanSupplier hasNext, final FloatSupplier next) {
N.checkArgNotNull(hasNext);
N.checkArgNotNull(next);
return new IteratorFloatStream(new FloatIteratorEx() {
private boolean hasNextVal = false;
@Override
public boolean hasNext() {
if (hasNextVal == false) {
hasNextVal = hasNext.getAsBoolean();
}
return hasNextVal;
}
@Override
public float nextFloat() {
if (hasNextVal == false && hasNext() == false) {
throw new NoSuchElementException();
}
hasNextVal = false;
return next.getAsFloat();
}
});
}
public static FloatStream iterate(final float seed, final BooleanSupplier hasNext, final FloatUnaryOperator f) {
N.checkArgNotNull(hasNext);
N.checkArgNotNull(f);
return new IteratorFloatStream(new FloatIteratorEx() {
private float t = 0;
private boolean isFirst = true;
private boolean hasNextVal = false;
@Override
public boolean hasNext() {
if (hasNextVal == false) {
hasNextVal = hasNext.getAsBoolean();
}
return hasNextVal;
}
@Override
public float nextFloat() {
if (hasNextVal == false && hasNext() == false) {
throw new NoSuchElementException();
}
hasNextVal = false;
if (isFirst) {
isFirst = false;
t = seed;
} else {
t = f.applyAsFloat(t);
}
return t;
}
});
}
/**
*
* @param seed
* @param hasNext test if has next by hasNext.test(seed) for first time and hasNext.test(f.apply(previous)) for remaining.
* @param f
* @return
*/
public static FloatStream iterate(final float seed, final FloatPredicate hasNext, final FloatUnaryOperator f) {
N.checkArgNotNull(hasNext);
N.checkArgNotNull(f);
return new IteratorFloatStream(new FloatIteratorEx() {
private float t = 0;
private float cur = 0;
private boolean isFirst = true;
private boolean hasMore = true;
private boolean hasNextVal = false;
@Override
public boolean hasNext() {
if (hasNextVal == false && hasMore) {
if (isFirst) {
isFirst = false;
hasNextVal = hasNext.test(cur = seed);
} else {
hasNextVal = hasNext.test(cur = f.applyAsFloat(t));
}
if (hasNextVal == false) {
hasMore = false;
}
}
return hasNextVal;
}
@Override
public float nextFloat() {
if (hasNextVal == false && hasNext() == false) {
throw new NoSuchElementException();
}
t = cur;
hasNextVal = false;
return t;
}
});
}
public static FloatStream iterate(final float seed, final FloatUnaryOperator f) {
N.checkArgNotNull(f);
return new IteratorFloatStream(new FloatIteratorEx() {
private float t = 0;
private boolean isFirst = true;
@Override
public boolean hasNext() {
return true;
}
@Override
public float nextFloat() {
if (isFirst) {
isFirst = false;
t = seed;
} else {
t = f.applyAsFloat(t);
}
return t;
}
});
}
public static FloatStream generate(final FloatSupplier s) {
N.checkArgNotNull(s);
return new IteratorFloatStream(new FloatIteratorEx() {
@Override
public boolean hasNext() {
return true;
}
@Override
public float nextFloat() {
return s.getAsFloat();
}
});
}
@SafeVarargs
public static FloatStream concat(final float[]... a) {
return N.isNullOrEmpty(a) ? empty() : new IteratorFloatStream(new FloatIteratorEx() {
private final Iterator iter = N.asList(a).iterator();
private FloatIterator cur;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && iter.hasNext()) {
cur = FloatIteratorEx.of(iter.next());
}
return cur != null && cur.hasNext();
}
@Override
public float nextFloat() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextFloat();
}
});
}
@SafeVarargs
public static FloatStream concat(final FloatIterator... a) {
return N.isNullOrEmpty(a) ? empty() : new IteratorFloatStream(new FloatIteratorEx() {
private final Iterator iter = N.asList(a).iterator();
private FloatIterator cur;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && iter.hasNext()) {
cur = iter.next();
}
return cur != null && cur.hasNext();
}
@Override
public float nextFloat() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextFloat();
}
});
}
@SafeVarargs
public static FloatStream concat(final FloatStream... a) {
return N.isNullOrEmpty(a) ? empty() : concat(N.asList(a));
}
public static FloatStream concat(final Collection c) {
return N.isNullOrEmpty(c) ? empty() : new IteratorFloatStream(new FloatIteratorEx() {
private final Iterator iter = c.iterator();
private FloatIterator cur;
@Override
public boolean hasNext() {
while ((cur == null || cur.hasNext() == false) && iter.hasNext()) {
cur = iter.next().iteratorEx();
}
return cur != null && cur.hasNext();
}
@Override
public float nextFloat() {
if ((cur == null || cur.hasNext() == false) && hasNext() == false) {
throw new NoSuchElementException();
}
return cur.nextFloat();
}
}).onClose(newCloseHandler(c));
}
/**
* Zip together the "a" and "b" arrays until one of them runs out of values.
* Each pair of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @return
*/
public static FloatStream zip(final float[] a, final float[] b, final FloatBiFunction zipFunction) {
return Stream.zip(a, b, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a", "b" and "c" arrays until one of them runs out of values.
* Each triple of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @return
*/
public static FloatStream zip(final float[] a, final float[] b, final float[] c, final FloatTriFunction zipFunction) {
return Stream.zip(a, b, c, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a" and "b" iterators until one of them runs out of values.
* Each pair of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @return
*/
public static FloatStream zip(final FloatIterator a, final FloatIterator b, final FloatBiFunction zipFunction) {
return Stream.zip(a, b, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a", "b" and "c" iterators until one of them runs out of values.
* Each triple of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @return
*/
public static FloatStream zip(final FloatIterator a, final FloatIterator b, final FloatIterator c, final FloatTriFunction zipFunction) {
return Stream.zip(a, b, c, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a" and "b" streams until one of them runs out of values.
* Each pair of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @return
*/
public static FloatStream zip(final FloatStream a, final FloatStream b, final FloatBiFunction zipFunction) {
return Stream.zip(a, b, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a", "b" and "c" streams until one of them runs out of values.
* Each triple of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @return
*/
public static FloatStream zip(final FloatStream a, final FloatStream b, final FloatStream c, final FloatTriFunction zipFunction) {
return Stream.zip(a, b, c, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the iterators until one of them runs out of values.
* Each array of values is combined into a single value using the supplied zipFunction function.
*
* @param c
* @param zipFunction
* @return
*/
public static FloatStream zip(final Collection c, final FloatNFunction zipFunction) {
return Stream.zip(c, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a" and "b" iterators until all of them runs out of values.
* Each pair of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @param valueForNoneA value to fill if "a" runs out of values first.
* @param valueForNoneB value to fill if "b" runs out of values first.
* @param zipFunction
* @return
*/
public static FloatStream zip(final float[] a, final float[] b, final float valueForNoneA, final float valueForNoneB,
final FloatBiFunction zipFunction) {
return Stream.zip(a, b, valueForNoneA, valueForNoneB, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a", "b" and "c" iterators until all of them runs out of values.
* Each triple of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @param c
* @param valueForNoneA value to fill if "a" runs out of values.
* @param valueForNoneB value to fill if "b" runs out of values.
* @param valueForNoneC value to fill if "c" runs out of values.
* @param zipFunction
* @return
*/
public static FloatStream zip(final float[] a, final float[] b, final float[] c, final float valueForNoneA, final float valueForNoneB,
final float valueForNoneC, final FloatTriFunction zipFunction) {
return Stream.zip(a, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a" and "b" iterators until all of them runs out of values.
* Each pair of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @param valueForNoneA value to fill if "a" runs out of values first.
* @param valueForNoneB value to fill if "b" runs out of values first.
* @param zipFunction
* @return
*/
public static FloatStream zip(final FloatIterator a, final FloatIterator b, final float valueForNoneA, final float valueForNoneB,
final FloatBiFunction zipFunction) {
return Stream.zip(a, b, valueForNoneA, valueForNoneB, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a", "b" and "c" iterators until all of them runs out of values.
* Each triple of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @param c
* @param valueForNoneA value to fill if "a" runs out of values.
* @param valueForNoneB value to fill if "b" runs out of values.
* @param valueForNoneC value to fill if "c" runs out of values.
* @param zipFunction
* @return
*/
public static FloatStream zip(final FloatIterator a, final FloatIterator b, final FloatIterator c, final float valueForNoneA, final float valueForNoneB,
final float valueForNoneC, final FloatTriFunction zipFunction) {
return Stream.zip(a, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a" and "b" iterators until all of them runs out of values.
* Each pair of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @param valueForNoneA value to fill if "a" runs out of values first.
* @param valueForNoneB value to fill if "b" runs out of values first.
* @param zipFunction
* @return
*/
public static FloatStream zip(final FloatStream a, final FloatStream b, final float valueForNoneA, final float valueForNoneB,
final FloatBiFunction zipFunction) {
return Stream.zip(a, b, valueForNoneA, valueForNoneB, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the "a", "b" and "c" iterators until all of them runs out of values.
* Each triple of values is combined into a single value using the supplied zipFunction function.
*
* @param a
* @param b
* @param c
* @param valueForNoneA value to fill if "a" runs out of values.
* @param valueForNoneB value to fill if "b" runs out of values.
* @param valueForNoneC value to fill if "c" runs out of values.
* @param zipFunction
* @return
*/
public static FloatStream zip(final FloatStream a, final FloatStream b, final FloatStream c, final float valueForNoneA, final float valueForNoneB,
final float valueForNoneC, final FloatTriFunction zipFunction) {
return Stream.zip(a, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
* Zip together the iterators until all of them runs out of values.
* Each array of values is combined into a single value using the supplied zipFunction function.
*
* @param c
* @param valuesForNone value to fill for any iterator runs out of values.
* @param zipFunction
* @return
*/
public static FloatStream zip(final Collection c, final float[] valuesForNone, final FloatNFunction zipFunction) {
return Stream.zip(c, valuesForNone, zipFunction).mapToFloat(ToFloatFunction.UNBOX);
}
/**
*
* @param a
* @param b
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public static FloatStream merge(final float[] a, final float[] b, final FloatBiFunction nextSelector) {
if (N.isNullOrEmpty(a)) {
return of(b);
} else if (N.isNullOrEmpty(b)) {
return of(a);
}
return new IteratorFloatStream(new FloatIteratorEx() {
private final int lenA = a.length;
private final int lenB = b.length;
private int cursorA = 0;
private int cursorB = 0;
@Override
public boolean hasNext() {
return cursorA < lenA || cursorB < lenB;
}
@Override
public float nextFloat() {
if (cursorA < lenA) {
if (cursorB < lenB) {
if (nextSelector.apply(a[cursorA], b[cursorB]) == Nth.FIRST) {
return a[cursorA++];
} else {
return b[cursorB++];
}
} else {
return a[cursorA++];
}
} else if (cursorB < lenB) {
return b[cursorB++];
} else {
throw new NoSuchElementException();
}
}
});
}
/**
*
* @param a
* @param b
* @param c
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public static FloatStream merge(final float[] a, final float[] b, final float[] c, final FloatBiFunction nextSelector) {
return merge(merge(a, b, nextSelector).iteratorEx(), FloatStream.of(c).iteratorEx(), nextSelector);
}
/**
*
* @param a
* @param b
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public static FloatStream merge(final FloatIterator a, final FloatIterator b, final FloatBiFunction nextSelector) {
if (a.hasNext() == false) {
return of(b);
} else if (b.hasNext() == false) {
return of(a);
}
return new IteratorFloatStream(new FloatIteratorEx() {
private float nextA = 0;
private float nextB = 0;
private boolean hasNextA = false;
private boolean hasNextB = false;
@Override
public boolean hasNext() {
return a.hasNext() || b.hasNext() || hasNextA || hasNextB;
}
@Override
public float nextFloat() {
if (hasNextA) {
if (b.hasNext()) {
if (nextSelector.apply(nextA, (nextB = b.nextFloat())) == Nth.FIRST) {
hasNextA = false;
hasNextB = true;
return nextA;
} else {
return nextB;
}
} else {
hasNextA = false;
return nextA;
}
} else if (hasNextB) {
if (a.hasNext()) {
if (nextSelector.apply((nextA = a.nextFloat()), nextB) == Nth.FIRST) {
return nextA;
} else {
hasNextA = true;
hasNextB = false;
return nextB;
}
} else {
hasNextB = false;
return nextB;
}
} else if (a.hasNext()) {
if (b.hasNext()) {
if (nextSelector.apply((nextA = a.nextFloat()), (nextB = b.nextFloat())) == Nth.FIRST) {
hasNextB = true;
return nextA;
} else {
hasNextA = true;
return nextB;
}
} else {
return a.nextFloat();
}
} else if (b.hasNext()) {
return b.nextFloat();
} else {
throw new NoSuchElementException();
}
}
});
}
/**
*
* @param a
* @param b
* @param c
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public static FloatStream merge(final FloatIterator a, final FloatIterator b, final FloatIterator c, final FloatBiFunction nextSelector) {
return merge(merge(a, b, nextSelector).iteratorEx(), c, nextSelector);
}
/**
*
* @param a
* @param b
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public static FloatStream merge(final FloatStream a, final FloatStream b, final FloatBiFunction nextSelector) {
return merge(a.iteratorEx(), b.iteratorEx(), nextSelector).onClose(newCloseHandler(N.asList(a, b)));
}
/**
*
* @param a
* @param b
* @param c
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public static FloatStream merge(final FloatStream a, final FloatStream b, final FloatStream c, final FloatBiFunction nextSelector) {
return merge(N.asList(a, b, c), nextSelector);
}
/**
*
* @param c
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public static FloatStream merge(final Collection c, final FloatBiFunction nextSelector) {
if (N.isNullOrEmpty(c)) {
return empty();
} else if (c.size() == 1) {
return c.iterator().next();
} else if (c.size() == 2) {
final Iterator iter = c.iterator();
return merge(iter.next(), iter.next(), nextSelector);
}
final Iterator iter = c.iterator();
FloatStream result = merge(iter.next().iteratorEx(), iter.next().iteratorEx(), nextSelector);
while (iter.hasNext()) {
result = merge(result.iteratorEx(), iter.next().iteratorEx(), nextSelector);
}
return result.onClose(newCloseHandler(c));
}
/**
*
* @param c
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @return
*/
public static FloatStream parallelMerge(final Collection c, final FloatBiFunction nextSelector) {
return parallelMerge(c, nextSelector, DEFAULT_MAX_THREAD_NUM);
}
/**
*
* @param c
* @param nextSelector first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
* @param maxThreadNum
* @return
*/
public static FloatStream parallelMerge(final Collection c, final FloatBiFunction nextSelector, final int maxThreadNum) {
checkMaxThreadNum(maxThreadNum);
if (N.isNullOrEmpty(c)) {
return empty();
} else if (c.size() == 1) {
return c.iterator().next();
} else if (c.size() == 2) {
final Iterator iter = c.iterator();
return merge(iter.next(), iter.next(), nextSelector);
} else if (maxThreadNum <= 1) {
return merge(c, nextSelector);
}
final Queue queue = N.newLinkedList();
for (FloatStream e : c) {
queue.add(e.iteratorEx());
}
final Holder eHolder = new Holder<>();
final MutableInt cnt = MutableInt.of(c.size());
final List> futureList = new ArrayList<>(c.size() - 1);
for (int i = 0, n = N.min(maxThreadNum, c.size() / 2 + 1); i < n; i++) {
futureList.add(asyncExecutor.execute(new Runnable() {
@Override
public void run() {
FloatIterator a = null;
FloatIterator b = null;
FloatIterator c = null;
try {
while (eHolder.value() == null) {
synchronized (queue) {
if (cnt.intValue() > 2 && queue.size() > 1) {
a = queue.poll();
b = queue.poll();
cnt.decrement();
} else {
break;
}
}
c = FloatIteratorEx.of(merge(a, b, nextSelector).toArray());
synchronized (queue) {
queue.offer(c);
}
}
} catch (Exception e) {
setError(eHolder, e);
}
}
}));
}
complete(futureList, eHolder);
// Should never happen.
if (queue.size() != 2) {
throw new AbacusException("Unknown error happened.");
}
return merge(queue.poll(), queue.poll(), nextSelector).onClose(newCloseHandler(c));
}
}