1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 package org.apache.commons.math3.stat.descriptive.rank; 18 19 import java.io.Serializable; 20 21 import org.apache.commons.math3.exception.MathIllegalArgumentException; 22 import org.apache.commons.math3.exception.NullArgumentException; 23 import org.apache.commons.math3.stat.descriptive.AbstractStorelessUnivariateStatistic; 24 import org.apache.commons.math3.util.MathUtils; 25 26 /** 27 * Returns the minimum of the available values. 28 * <p> 29 * <ul> 30 * <li>The result is <code>NaN</code> iff all values are <code>NaN</code> 31 * (i.e. <code>NaN</code> values have no impact on the value of the statistic).</li> 32 * <li>If any of the values equals <code>Double.NEGATIVE_INFINITY</code>, 33 * the result is <code>Double.NEGATIVE_INFINITY.</code></li> 34 * </ul></p> 35 * <p> 36 * <strong>Note that this implementation is not synchronized.</strong> If 37 * multiple threads access an instance of this class concurrently, and at least 38 * one of the threads invokes the <code>increment()</code> or 39 * <code>clear()</code> method, it must be synchronized externally.</p> 40 * 41 */ 42 public class Min extends AbstractStorelessUnivariateStatistic implements Serializable { 43 44 /** Serializable version identifier */ 45 private static final long serialVersionUID = -2941995784909003131L; 46 47 /**Number of values that have been added */ 48 private long n; 49 50 /**Current value of the statistic */ 51 private double value; 52 53 /** 54 * Create a Min instance 55 */ Min()56 public Min() { 57 n = 0; 58 value = Double.NaN; 59 } 60 61 /** 62 * Copy constructor, creates a new {@code Min} identical 63 * to the {@code original} 64 * 65 * @param original the {@code Min} instance to copy 66 * @throws NullArgumentException if original is null 67 */ Min(Min original)68 public Min(Min original) throws NullArgumentException { 69 copy(original, this); 70 } 71 72 /** 73 * {@inheritDoc} 74 */ 75 @Override increment(final double d)76 public void increment(final double d) { 77 if (d < value || Double.isNaN(value)) { 78 value = d; 79 } 80 n++; 81 } 82 83 /** 84 * {@inheritDoc} 85 */ 86 @Override clear()87 public void clear() { 88 value = Double.NaN; 89 n = 0; 90 } 91 92 /** 93 * {@inheritDoc} 94 */ 95 @Override getResult()96 public double getResult() { 97 return value; 98 } 99 100 /** 101 * {@inheritDoc} 102 */ getN()103 public long getN() { 104 return n; 105 } 106 107 /** 108 * Returns the minimum of the entries in the specified portion of 109 * the input array, or <code>Double.NaN</code> if the designated subarray 110 * is empty. 111 * <p> 112 * Throws <code>MathIllegalArgumentException</code> if the array is null or 113 * the array index parameters are not valid.</p> 114 * <p> 115 * <ul> 116 * <li>The result is <code>NaN</code> iff all values are <code>NaN</code> 117 * (i.e. <code>NaN</code> values have no impact on the value of the statistic).</li> 118 * <li>If any of the values equals <code>Double.NEGATIVE_INFINITY</code>, 119 * the result is <code>Double.NEGATIVE_INFINITY.</code></li> 120 * </ul> </p> 121 * 122 * @param values the input array 123 * @param begin index of the first array element to include 124 * @param length the number of elements to include 125 * @return the minimum of the values or Double.NaN if length = 0 126 * @throws MathIllegalArgumentException if the array is null or the array index 127 * parameters are not valid 128 */ 129 @Override evaluate(final double[] values,final int begin, final int length)130 public double evaluate(final double[] values,final int begin, final int length) 131 throws MathIllegalArgumentException { 132 double min = Double.NaN; 133 if (test(values, begin, length)) { 134 min = values[begin]; 135 for (int i = begin; i < begin + length; i++) { 136 if (!Double.isNaN(values[i])) { 137 min = (min < values[i]) ? min : values[i]; 138 } 139 } 140 } 141 return min; 142 } 143 144 /** 145 * {@inheritDoc} 146 */ 147 @Override copy()148 public Min copy() { 149 Min result = new Min(); 150 // No try-catch or advertised exception - args are non-null 151 copy(this, result); 152 return result; 153 } 154 155 /** 156 * Copies source to dest. 157 * <p>Neither source nor dest can be null.</p> 158 * 159 * @param source Min to copy 160 * @param dest Min to copy to 161 * @throws NullArgumentException if either source or dest is null 162 */ copy(Min source, Min dest)163 public static void copy(Min source, Min dest) 164 throws NullArgumentException { 165 MathUtils.checkNotNull(source); 166 MathUtils.checkNotNull(dest); 167 dest.setData(source.getDataRef()); 168 dest.n = source.n; 169 dest.value = source.value; 170 } 171 } 172