Max.java
- /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
- /*
- * This is not the original file distributed by the Apache Software Foundation
- * It has been modified by the Hipparchus project
- */
- package org.hipparchus.stat.descriptive.rank;
- import java.io.Serializable;
- import org.hipparchus.exception.MathIllegalArgumentException;
- import org.hipparchus.exception.NullArgumentException;
- import org.hipparchus.stat.descriptive.AbstractStorelessUnivariateStatistic;
- import org.hipparchus.stat.descriptive.AggregatableStatistic;
- import org.hipparchus.util.MathArrays;
- import org.hipparchus.util.MathUtils;
- /**
- * Returns the maximum of the available values.
- * <ul>
- * <li>The result is <code>NaN</code> iff all values are <code>NaN</code>
- * (i.e. <code>NaN</code> values have no impact on the value of the statistic).</li>
- * <li>If any of the values equals <code>Double.POSITIVE_INFINITY</code>,
- * the result is <code>Double.POSITIVE_INFINITY.</code></li>
- * </ul>
- * <p>
- * <strong>Note that this implementation is not synchronized.</strong> If
- * multiple threads access an instance of this class concurrently, and at least
- * one of the threads invokes the <code>increment()</code> or
- * <code>clear()</code> method, it must be synchronized externally.
- */
- public class Max extends AbstractStorelessUnivariateStatistic
- implements AggregatableStatistic<Max>, Serializable {
- /** Serializable version identifier */
- private static final long serialVersionUID = 20150412L;
- /** Number of values that have been added */
- private long n;
- /** Current value of the statistic */
- private double value;
- /**
- * Create a Max instance.
- */
- public Max() {
- n = 0;
- value = Double.NaN;
- }
- /**
- * Copy constructor, creates a new {@code Max} identical
- * to the {@code original}.
- *
- * @param original the {@code Max} instance to copy
- * @throws NullArgumentException if original is null
- */
- public Max(Max original) throws NullArgumentException {
- MathUtils.checkNotNull(original);
- this.n = original.n;
- this.value = original.value;
- }
- /** {@inheritDoc} */
- @Override
- public void increment(final double d) {
- if (d > value || Double.isNaN(value)) {
- value = d;
- }
- n++;
- }
- /** {@inheritDoc} */
- @Override
- public void clear() {
- value = Double.NaN;
- n = 0;
- }
- /** {@inheritDoc} */
- @Override
- public double getResult() {
- return value;
- }
- /** {@inheritDoc} */
- @Override
- public long getN() {
- return n;
- }
- /** {@inheritDoc} */
- @Override
- public void aggregate(Max other) {
- MathUtils.checkNotNull(other);
- if (other.n > 0) {
- if (other.value > this.value || Double.isNaN(this.value)) {
- this.value = other.value;
- }
- this.n += other.n;
- }
- }
- /**
- * Returns the maximum of the entries in the specified portion of
- * the input array, or <code>Double.NaN</code> if the designated subarray
- * is empty.
- * <p>
- * Throws <code>MathIllegalArgumentException</code> if the array is null or
- * the array index parameters are not valid.
- * </p>
- * <ul>
- * <li>The result is <code>NaN</code> iff all values are <code>NaN</code>
- * (i.e. <code>NaN</code> values have no impact on the value of the statistic).</li>
- * <li>If any of the values equals <code>Double.POSITIVE_INFINITY</code>,
- * the result is <code>Double.POSITIVE_INFINITY.</code></li>
- * </ul>
- *
- * @param values the input array
- * @param begin index of the first array element to include
- * @param length the number of elements to include
- * @return the maximum of the values or Double.NaN if length = 0
- * @throws MathIllegalArgumentException if the array is null or the array index
- * parameters are not valid
- */
- @Override
- public double evaluate(final double[] values, final int begin, final int length)
- throws MathIllegalArgumentException {
- double max = Double.NaN;
- if (MathArrays.verifyValues(values, begin, length)) {
- max = values[begin];
- for (int i = begin; i < begin + length; i++) {
- if (!Double.isNaN(values[i])) {
- max = (max > values[i]) ? max : values[i];
- }
- }
- }
- return max;
- }
- /** {@inheritDoc} */
- @Override
- public Max copy() {
- return new Max(this);
- }
- }