Пример #1
0
 /**
  * Calculates the average of this elements. Returns {@code None} if this is empty, otherwise
  * {@code Some(average)}. Supported component types are {@code Byte}, {@code Double}, {@code
  * Float}, {@code Integer}, {@code Long}, {@code Short}, {@code BigInteger} and {@code
  * BigDecimal}.
  *
  * <p>Examples:
  *
  * <pre>
  * <code>
  * List.empty().average()              // = None
  * List.of(1, 2, 3).average()          // = Some(2.0)
  * List.of(0.1, 0.2, 0.3).average()    // = Some(0.2)
  * List.of("apple", "pear").average()  // throws
  * </code>
  * </pre>
  *
  * @return {@code Some(average)} or {@code None}, if there are no elements
  * @throws UnsupportedOperationException if this elements are not numeric
  */
 @SuppressWarnings("unchecked")
 default Option<Double> average() {
   if (isEmpty()) {
     return None.instance();
   } else {
     final TraversableOnce<?> objects = isTraversableAgain() ? this : toStream();
     final Object head = objects.head();
     final double d;
     if (head instanceof Integer || head instanceof Short || head instanceof Byte) {
       d =
           ((TraversableOnce<Number>) objects)
               .toJavaStream()
               .mapToInt(Number::intValue)
               .average()
               .getAsDouble();
     } else if (head instanceof Double || head instanceof Float || head instanceof BigDecimal) {
       d =
           ((TraversableOnce<Number>) objects)
               .toJavaStream()
               .mapToDouble(Number::doubleValue)
               .average()
               .getAsDouble();
     } else if (head instanceof Long || head instanceof BigInteger) {
       d =
           ((TraversableOnce<Number>) objects)
               .toJavaStream()
               .mapToLong(Number::longValue)
               .average()
               .getAsDouble();
     } else {
       throw new UnsupportedOperationException("not numeric");
     }
     return new Some<>(d);
   }
 }
Пример #2
0
 /**
  * Calculates the minimum of this elements within the co-domain of a specific function.
  *
  * @param f A function that maps this elements to comparable elements
  * @param <U> The type where elements are compared
  * @return The element of type T which is the minimum within U
  */
 default <U extends Comparable<? super U>> Option<T> minBy(Function<? super T, ? extends U> f) {
   Objects.requireNonNull(f, "f is null");
   if (isEmpty()) {
     return None.instance();
   } else {
     return minBy((t1, t2) -> f.apply(t1).compareTo(f.apply(t2)));
   }
 }
Пример #3
0
 @Override
 public Option<HashMap<K, V>> tailOption() {
   if (trie.isEmpty()) {
     return None.instance();
   } else {
     return new Some<>(tail());
   }
 }
Пример #4
0
 @Override
 public Option<HashMap<K, V>> initOption() {
   if (isEmpty()) {
     return None.instance();
   } else {
     return new Some<>(init());
   }
 }
Пример #5
0
 @Override
 public Option<? extends Vector<T>> initOption() {
   if (isEmpty()) {
     return None.instance();
   } else {
     return new Some<>(init());
   }
 }
Пример #6
0
 @Override
 public Option<T> headOption() {
   if (isEmpty()) {
     return None.instance();
   } else {
     return new Some<>(get(0));
   }
 }
Пример #7
0
 /**
  * Calculates the minimum of this elements using a specific comparator.
  *
  * @param comparator A non-null element comparator
  * @return {@code Some(minimum)} of this elements or {@code None} if this is empty
  * @throws NullPointerException if {@code comparator} is null
  */
 default Option<T> minBy(Comparator<? super T> comparator) {
   Objects.requireNonNull(comparator, "comparator is null");
   if (isEmpty()) {
     return None.instance();
   } else {
     final T value = reduce((t1, t2) -> comparator.compare(t1, t2) <= 0 ? t1 : t2);
     return new Some<>(value);
   }
 }
Пример #8
0
 /**
  * Calculates the minimum of this elements according to their natural order.
  *
  * @return {@code Some(minimum)} of this elements or {@code None} if this is empty or this
  *     elements are not comparable
  */
 @SuppressWarnings("unchecked")
 default Option<T> min() {
   final Stream<T> stream = Stream.ofAll(iterator());
   if (isEmpty() || !(stream.head() instanceof Comparable)) {
     return None.instance();
   } else {
     return stream.minBy((o1, o2) -> ((Comparable<T>) o1).compareTo(o2));
   }
 }
Пример #9
0
 @Override
 public Option<Vector<T>> tailOption() {
   if (isEmpty()) {
     return None.instance();
   }
   HashArrayMappedTrie<Integer, T> trie = HashArrayMappedTrie.empty();
   for (int i = 1; i < length(); i++) {
     trie = trie.put(i - 1, get(i));
   }
   return new Some<>(trie.isEmpty() ? empty() : new Vector<>(trie));
 }
Пример #10
0
 /**
  * Dual of {@linkplain #headOption()}, returning the last element as {@code Opiton}.
  *
  * @return {@code Some(element)} or {@code None} if this is empty.
  */
 default Option<T> lastOption() {
   return isEmpty() ? None.instance() : new Some<>(last());
 }
Пример #11
0
 @Override
 public Option<Tuple2<K, V>> headOption() {
   return isEmpty() ? None.instance() : new Some<>(head());
 }