Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/util/DoubleSummaryStatistics.java
/* * Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.util; import java.util.function.DoubleConsumer; import java.util.stream.Collector; import java.util.stream.DoubleStream; /** * A state object for collecting statistics such as count, min, max, sum, and * average. * * <p>This class is designed to work with (though does not require) * {@linkplain java.util.stream streams}. For example, you can compute * summary statistics on a stream of doubles with: * <pre> {@code * DoubleSummaryStatistics stats = doubleStream.collect(DoubleSummaryStatistics::new, * DoubleSummaryStatistics::accept, * DoubleSummaryStatistics::combine); * }</pre> * * <p>{@code DoubleSummaryStatistics} can be used as a * {@linkplain java.util.stream.Stream#collect(Collector) reduction} * target for a {@linkplain java.util.stream.Stream stream}. For example: * * <pre> {@code * DoubleSummaryStatistics stats = people.stream() * .collect(Collectors.summarizingDouble(Person::getWeight)); *}</pre> * * This computes, in a single pass, the count of people, as well as the minimum, * maximum, sum, and average of their weights. * * @implNote This implementation is not thread safe. However, it is safe to use * {@link java.util.stream.Collectors#summarizingDouble(java.util.function.ToDoubleFunction) * Collectors.summarizingDouble()} on a parallel stream, because the parallel * implementation of {@link java.util.stream.Stream#collect Stream.collect()} * provides the necessary partitioning, isolation, and merging of results for * safe and efficient parallel execution. * @since 1.8 */ public class DoubleSummaryStatistics implements DoubleConsumer { private long count; private double sum; private double sumCompensation; // Low order bits of sum private double simpleSum; // Used to compute right sum for non-finite inputs private double min = Double.POSITIVE_INFINITY; private double max = Double.NEGATIVE_INFINITY; /** * Constructs an empty instance with zero count, zero sum, * {@code Double.POSITIVE_INFINITY} min, {@code Double.NEGATIVE_INFINITY} * max and zero average. */ public DoubleSummaryStatistics() { } /** * Constructs a non-empty instance with the specified {@code count}, * {@code min}, {@code max}, and {@code sum}. * * <p>If {@code count} is zero then the remaining arguments are ignored and * an empty instance is constructed. * * <p>If the arguments are inconsistent then an {@code IllegalArgumentException} * is thrown. The necessary consistent argument conditions are: * <ul> * <li>{@code count >= 0}</li> * <li>{@code (min <= max && !isNaN(sum)) || (isNaN(min) && isNaN(max) && isNaN(sum))}</li> * </ul> * @apiNote * The enforcement of argument correctness means that the retrieved set of * recorded values obtained from a {@code DoubleSummaryStatistics} source * instance may not be a legal set of arguments for this constructor due to * arithmetic overflow of the source's recorded count of values. * The consistent argument conditions are not sufficient to prevent the * creation of an internally inconsistent instance. An example of such a * state would be an instance with: {@code count} = 2, {@code min} = 1, * {@code max} = 2, and {@code sum} = 0. * * @param count the count of values * @param min the minimum value * @param max the maximum value * @param sum the sum of all values * @throws IllegalArgumentException if the arguments are inconsistent * @since 10 */ public DoubleSummaryStatistics(long count, double min, double max, double sum) throws IllegalArgumentException { if (count < 0L) { throw new IllegalArgumentException("Negative count value"); } else if (count > 0L) { if (min > max) throw new IllegalArgumentException("Minimum greater than maximum"); // All NaN or non NaN var ncount = DoubleStream.of(min, max, sum).filter(Double::isNaN).count(); if (ncount > 0 && ncount < 3) throw new IllegalArgumentException("Some, not all, of the minimum, maximum, or sum is NaN"); this.count = count; this.sum = sum; this.simpleSum = sum; this.sumCompensation = 0.0d; this.min = min; this.max = max; } // Use default field values if count == 0 } /** * Records another value into the summary information. * * @param value the input value */ @Override public void accept(double value) { ++count; simpleSum += value; sumWithCompensation(value); min = Math.min(min, value); max = Math.max(max, value); } /** * Combines the state of another {@code DoubleSummaryStatistics} into this * one. * * @param other another {@code DoubleSummaryStatistics} * @throws NullPointerException if {@code other} is null */ public void combine(DoubleSummaryStatistics other) { count += other.count; simpleSum += other.simpleSum; sumWithCompensation(other.sum); sumWithCompensation(other.sumCompensation); min = Math.min(min, other.min); max = Math.max(max, other.max); } /** * Incorporate a new double value using Kahan summation / * compensated summation. */ private void sumWithCompensation(double value) { double tmp = value - sumCompensation; double velvel = sum + tmp; // Little wolf of rounding error sumCompensation = (velvel - sum) - tmp; sum = velvel; } /** * Return the count of values recorded. * * @return the count of values */ public final long getCount() { return count; } /** * Returns the sum of values recorded, or zero if no values have been * recorded. * * <p> 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 double} * values. * * Because of the unspecified order of operations and the * possibility of using differing summation schemes, the output of * this method may vary on the same input values. * * <p>Various conditions can result in a non-finite sum being * computed. This can occur even if the all the recorded values * being summed are finite. If any recorded value is non-finite, * the sum will be non-finite: * * <ul> * * <li>If any recorded value is a NaN, then the final sum will be * NaN. * * <li>If the recorded values contain one or more infinities, the * sum will be infinite or NaN. * * <ul> * * <li>If the recorded values contain infinities of opposite sign, * the sum will be NaN. * * <li>If the recorded values contain infinities of one sign and * an intermediate sum overflows to an infinity of the opposite * sign, the sum may be NaN. * * </ul> * * </ul> * * It is possible for intermediate sums of finite values to * overflow into opposite-signed infinities; if that occurs, the * final sum will be NaN even if the recorded values are all * finite. * * If all the recorded values are zero, the sign of zero is * <em>not</em> guaranteed to be preserved in the final sum. * * @apiNote Values sorted by increasing absolute magnitude tend to yield * more accurate results. * * @return the sum of values, or zero if none */ public final double getSum() { // Better error bounds to add both terms as the final sum double tmp = sum + sumCompensation; if (Double.isNaN(tmp) && Double.isInfinite(simpleSum)) // If the compensated sum is spuriously NaN from // accumulating one or more same-signed infinite values, // return the correctly-signed infinity stored in // simpleSum. return simpleSum; else return tmp; } /** * Returns the minimum recorded value, {@code Double.NaN} if any recorded * value was NaN or {@code Double.POSITIVE_INFINITY} if no values were * recorded. Unlike the numerical comparison operators, this method * considers negative zero to be strictly smaller than positive zero. * * @return the minimum recorded value, {@code Double.NaN} if any recorded * value was NaN or {@code Double.POSITIVE_INFINITY} if no values were * recorded */ public final double getMin() { return min; } /** * Returns the maximum recorded value, {@code Double.NaN} if any recorded * value was NaN or {@code Double.NEGATIVE_INFINITY} if no values were * recorded. Unlike the numerical comparison operators, this method * considers negative zero to be strictly smaller than positive zero. * * @return the maximum recorded value, {@code Double.NaN} if any recorded * value was NaN or {@code Double.NEGATIVE_INFINITY} if no values were * recorded */ public final double getMax() { return max; } /** * Returns the arithmetic mean of values recorded, or zero if no * values have been recorded. * * <p> The computed average can vary numerically and have the * special case behavior as computing the sum; see {@link #getSum} * for details. * * @apiNote Values sorted by increasing absolute magnitude tend to yield * more accurate results. * * @return the arithmetic mean of values, or zero if none */ public final double getAverage() { return getCount() > 0 ? getSum() / getCount() : 0.0d; } /** * Returns a non-empty string representation of this object suitable for * debugging. The exact presentation format is unspecified and may vary * between implementations and versions. */ @Override public String toString() { return String.format( "%s{count=%d, sum=%f, min=%f, average=%f, max=%f}", this.getClass().getSimpleName(), getCount(), getSum(), getMin(), getAverage(), getMax()); } }
⏎ java/util/DoubleSummaryStatistics.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 205079👍, 0💬
Popular Posts:
JAX-WS is an API for building web services and clients. It is the next generation Web Services API r...
Jackson is "the Java JSON library" or "the best JSON parser for Java". Or simply as "JSON for Java"....
How to download and install ojdbc7.jar for Oracle 12c R1? ojdbc8.jar for Oracle 12c R1 is a Java 7 a...
What is the sax\Counter.java provided in the Apache Xerces package? I have Apache Xerces 2.11.0 inst...
How to download and install Apache XMLBeans Source Package? The source package contains Java source ...