360 public final DoubleStream distinct() { 361 // While functional and quick to implement, this approach is not very efficient. 362 // An efficient version requires a double-specific map/set implementation. 363 return boxed().distinct().mapToDouble(i -> (double) i); 364 } 365 366 // Terminal ops from DoubleStream 367 368 @Override 369 public void forEach(DoubleConsumer consumer) { 370 evaluate(ForEachOps.makeDouble(consumer, false)); 371 } 372 373 @Override 374 public void forEachOrdered(DoubleConsumer consumer) { 375 evaluate(ForEachOps.makeDouble(consumer, true)); 376 } 377 378 @Override 379 public final double sum() { 380 // TODO: better algorithm to compensate for errors 381 return reduce(0.0, Double::sum); 382 } 383 384 @Override 385 public final OptionalDouble min() { 386 return reduce(Math::min); 387 } 388 389 @Override 390 public final OptionalDouble max() { 391 return reduce(Math::max); 392 } 393 394 @Override 395 public final OptionalDouble average() { 396 double[] avg = collect(() -> new double[2], 397 (ll, i) -> { 398 ll[0]++; 399 ll[1] += i; 400 }, 401 (ll, rr) -> { 402 ll[0] += rr[0]; 403 ll[1] += rr[1]; 404 }); 405 return avg[0] > 0 406 ? OptionalDouble.of(avg[1] / avg[0]) 407 : OptionalDouble.empty(); 408 } 409 410 @Override 411 public final long count() { 412 return mapToObj(e -> null).mapToInt(e -> 1).sum(); 413 } 414 415 @Override 416 public final DoubleSummaryStatistics summaryStatistics() { 417 return collect(DoubleSummaryStatistics::new, DoubleSummaryStatistics::accept, 418 DoubleSummaryStatistics::combine); 419 } 420 421 @Override 422 public final double reduce(double identity, DoubleBinaryOperator op) { 423 return evaluate(ReduceOps.makeDouble(identity, op)); 424 } 425 426 @Override | 360 public final DoubleStream distinct() { 361 // While functional and quick to implement, this approach is not very efficient. 362 // An efficient version requires a double-specific map/set implementation. 363 return boxed().distinct().mapToDouble(i -> (double) i); 364 } 365 366 // Terminal ops from DoubleStream 367 368 @Override 369 public void forEach(DoubleConsumer consumer) { 370 evaluate(ForEachOps.makeDouble(consumer, false)); 371 } 372 373 @Override 374 public void forEachOrdered(DoubleConsumer consumer) { 375 evaluate(ForEachOps.makeDouble(consumer, true)); 376 } 377 378 @Override 379 public final double sum() { 380 double[] summation = collect(() -> new double[2], 381 (ll, d) -> { 382 Collectors.sumWithCompensation(ll, d); 383 }, 384 (ll, rr) -> { 385 Collectors.sumWithCompensation(ll, rr[0]); 386 Collectors.sumWithCompensation(ll, rr[1]); 387 }); 388 return summation[0]; 389 } 390 391 @Override 392 public final OptionalDouble min() { 393 return reduce(Math::min); 394 } 395 396 @Override 397 public final OptionalDouble max() { 398 return reduce(Math::max); 399 } 400 401 @Override 402 public final OptionalDouble average() { 403 double[] avg = collect(() -> new double[3], 404 (ll, d) -> { 405 ll[2]++; 406 Collectors.sumWithCompensation(ll, d); 407 }, 408 (ll, rr) -> { 409 Collectors.sumWithCompensation(ll, rr[0]); 410 Collectors.sumWithCompensation(ll, rr[1]); 411 ll[2] += rr[2]; 412 }); 413 return avg[0] > 0 414 ? OptionalDouble.of(avg[0] / avg[2]) 415 : OptionalDouble.empty(); 416 } 417 418 @Override 419 public final long count() { 420 return mapToObj(e -> null).mapToInt(e -> 1).sum(); 421 } 422 423 @Override 424 public final DoubleSummaryStatistics summaryStatistics() { 425 return collect(DoubleSummaryStatistics::new, DoubleSummaryStatistics::accept, 426 DoubleSummaryStatistics::combine); 427 } 428 429 @Override 430 public final double reduce(double identity, DoubleBinaryOperator op) { 431 return evaluate(ReduceOps.makeDouble(identity, op)); 432 } 433 434 @Override |