/** * このベクトルに対して二項演算を行う。 * * <p>デフォルトの実装では、渡された演算をそれぞれの次元に適用し、得られた値を{@link #set(Object, Object, Object, Object)}に委譲します。 * * @param operator 現在の設定値を受け取り、新しい設定値を返す関数。 * @param x 右辺となるx成分の値。 * @param y 右辺となるy成分の値。 * @param z 右辺となるz成分の値。 * @param w 右辺となるw成分の値。 */ default void calculate(BinaryOperator<T> operator, T x, T y, T z, T w) { set( operator.apply(getX(), x), operator.apply(getY(), y), operator.apply(getZ(), z), operator.apply(getW(), w)); }
private T evaluate(int level) { Deque<T> q = elements[level]; BinaryOperator<T> op = operations[level]; T result = q.pollFirst(); while (!q.isEmpty()) { result = op.apply(result, q.pollFirst()); } return result; }
// l + <first|acc|last> + r private R connectOne(T first, R acc, T last) { synchronized (root) { Connector<T, R> l = left; if (l == null) { return pushRight(acc, last); } if (l.acc == NONE) { l.acc = acc; l.left = first; l.right = last; return connectEmpty(); } T laright = l.right; if (mergeable.test(laright, first)) { l.acc = combiner.apply(l.acc, acc); l.right = last; return connectEmpty(); } left = null; l.rhs = null; l.right = none(); if (l.left != NONE) { return pushRight(acc, last); } acc = pushRight(acc, last); if (acc != NONE) left = new Connector<>(null, acc, this); return l.drain(); } }
// <?|acc|last> + r private R pushRight(R acc, T last) { cur = none(); if (right == null) return acc; synchronized (root) { Connector<T, R> r = right; if (r == null) return acc; right = null; r.lhs = null; T raleft = r.left; r.left = none(); if (r.acc == NONE) { if (acc == NONE) { r.drain(); } else { r.acc = acc; r.right = last; } return none(); } if (acc == NONE) { return r.drainRight(); } if (mergeable.test(last, raleft)) { r.acc = combiner.apply(acc, r.acc); return r.drainRight(); } if (r.right == NONE) right = new Connector<>(this, r.drain(), null); return acc; } }
default U reduce(U identity, BinaryOperator<U> accumulator) { if (getLastActive().isSequential()) { Object[] result = {identity}; forEach( r -> { if (result[0] == null) result[0] = r; else { result[0] = accumulator.apply((U) result[0], r); } }); return (U) result[0]; } Function<FastFuture, U> safeJoin = (FastFuture cf) -> (U) BlockingStreamHelper.getSafe(cf, getErrorHandler()); IncrementalReducer<U> collector = new IncrementalReducer( this.getLazyCollector().get().withResults(new ArrayList<>()), this, getParallelReduction()); Object[] result = {identity}; try { this.getLastActive() .injectFutures() .forEach( next -> { collector.getConsumer().accept(next); result[0] = collector.reduce(safeJoin, (U) result[0], accumulator); }); } catch (SimpleReactProcessingException e) { } return collector.reduceResults( collector.getConsumer().getAllResults(), safeJoin, (U) result[0], accumulator); }
// l + r private R connectEmpty() { synchronized (root) { Connector<T, R> l = left, r = right; if (l == null) { return pushRight(none(), none()); } left = right = null; l.rhs = null; T laright = l.right; l.right = none(); if (l.acc == NONE) { if (r == null) l.drain(); else { if (l.lhs != null) { l.lhs.right = r; r.lhs = l.lhs; } } return none(); } if (r == null) { return l.drainLeft(); } r.lhs = null; if (r.acc == NONE) { if (r.rhs != null) { r.rhs.left = l; l.rhs = r.rhs; l.right = laright; } return none(); } T raleft = r.left; r.left = none(); if (mergeable.test(laright, raleft)) { R acc = combiner.apply(l.acc, r.acc); if (l.left == NONE && r.right == NONE) { l.drain(); r.drain(); return acc; } l.acc = acc; l.right = r.right; if (r.rhs != null) { r.rhs.left = l; l.rhs = r.rhs; } return none(); } if (l.left == NONE) { if (r.right == NONE) right = new Connector<>(this, r.drain(), null); return l.drain(); } return r.drainRight(); } }
@Test public void binary_operatior_test() throws Exception { BinaryOperator.maxBy( new Comparator<String>() { @Override public int compare(String o1, String o2) { return 0; // Does not matter. } }) .apply("hello", "world"); }
@Override public Set<Integer> onIntermediateResult(Address address, R results) { if (results != null) { synchronized (this) { if (currentValue != null) { currentValue = binaryOperator.apply(currentValue, results); } else { currentValue = results; } } } return null; }
public static void main(String[] args) { final List<Person> people = Arrays.asList( new Person("Robert", 49), new Person("John", 20), new Person("Sara", 21), new Person("Chloe", 18), new Person("Jane", 21), new Person("Greg", 35)); List<Person> olderThan20_a = new ArrayList<>(); people.stream().filter(person -> person.age > 20).forEach(person -> olderThan20_a.add(person)); printPeople("don't trust olderThan20_a", olderThan20_a); List<Person> olderThan20_b = people .stream() .filter(person -> person.age > 20) .collect(ArrayList::new, ArrayList::add, ArrayList::addAll); printPeople("don't trust olderThan20_b", olderThan20_b); List<Person> olderThan20_c = people.stream().filter(person -> person.age > 20).collect(Collectors.toList()); printPeople("don't trust olderThan20_c", olderThan20_c); Map<Integer, List<Person>> peopleByAge = people.stream().collect(Collectors.groupingBy(person -> person.age)); System.out.println("Grouped by age: " + peopleByAge); Map<Integer, List<String>> nameOfPeopleByAge = people .stream() .collect( Collectors.groupingBy( person -> person.age, Collectors.mapping(person -> person.name, Collectors.toList()))); System.out.println("People grouped by age: " + nameOfPeopleByAge); // Group the names by their first char and then get the oldest person in // each group Comparator<Person> byAge = Comparator.comparing(person -> person.age); Map<Character, Optional<Person>> oldestPersonOfEachLetter = people .stream() .collect( Collectors.groupingBy( person -> person.name.charAt(0), Collectors.reducing(BinaryOperator.maxBy(byAge)))); System.out.println("Oldest person of each letter:"); System.out.println(oldestPersonOfEachLetter); }
public static void main(String[] args) { final List<Person> people = Arrays.asList( new Person("John", 20), new Person("Sara", 21), new Person("Jane", 21), new Person("Greg", 35)); List<Person> olderThan20 = people .stream() .filter(person -> person.getAge() > 20) .collect(ArrayList::new, ArrayList::add, ArrayList::addAll); System.out.println("People older than 20: " + olderThan20); List<Person> olderThan20_1 = people.stream().filter(person -> person.getAge() > 20).collect(Collectors.toList()); System.out.println("People older than 20: " + olderThan20_1); Map<Integer, List<Person>> peopleByAge = people.stream().collect(Collectors.groupingBy(Person::getAge)); System.out.println("Grouped by age: " + peopleByAge); Map<Integer, List<String>> nameOfPeopleByAge = people .stream() .collect( Collectors.groupingBy( Person::getAge, Collectors.mapping(Person::getName, Collectors.toList()))); System.out.println("People name grouped by age: " + nameOfPeopleByAge); Comparator<Person> byAge = Comparator.comparing(Person::getAge); Map<Character, Optional<Person>> oldestPersonOfEachCharacter = people .stream() .collect( Collectors.groupingBy( person -> person.getName().charAt(0), Collectors.reducing(BinaryOperator.maxBy(byAge)))); System.out.println("Oldest person of each letter: " + oldestPersonOfEachCharacter); }
default Optional<U> reduce(BinaryOperator<U> accumulator) { if (getLastActive().isSequential()) { Object[] result = {null}; forEach( r -> { if (result[0] == null) result[0] = r; else { result[0] = accumulator.apply((U) result[0], r); } }); return (Optional) Optional.ofNullable(result[0]); } Function<FastFuture, U> safeJoin = (FastFuture cf) -> (U) BlockingStreamHelper.getSafe(cf, getErrorHandler()); IncrementalReducer<U> collector = new IncrementalReducer( this.getLazyCollector().get().withResults(new ArrayList<>()), this, getParallelReduction()); Optional[] result = {Optional.empty()}; try { this.getLastActive() .injectFutures() .forEach( next -> { collector.getConsumer().accept(next); if (!result[0].isPresent()) result[0] = collector.reduce(safeJoin, accumulator); else result[0] = result[0].map(v -> collector.reduce(safeJoin, (U) v, accumulator)); }); } catch (SimpleReactProcessingException e) { } if (result[0].isPresent()) return result[0].map( v -> collector.reduceResults( collector.getConsumer().getAllResults(), safeJoin, (U) v, accumulator)); return collector.reduceResults(collector.getConsumer().getAllResults(), safeJoin, accumulator); }
public static <T> Aggregator<T, T, ?> minBy(Comparator<? super T> comparator) { return reducing(BinaryOperator.minBy(comparator)); }
public void test() { BinaryOperator<Long> operator = (l1, l2) -> l1 + l2; System.out.println(operator.apply(1L, 2L)); }