001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.math3.stat.descriptive; 018 019 import org.apache.commons.math3.exception.DimensionMismatchException; 020 import org.apache.commons.math3.exception.MathIllegalStateException; 021 import org.apache.commons.math3.linear.RealMatrix; 022 023 /** 024 * Implementation of 025 * {@link org.apache.commons.math3.stat.descriptive.MultivariateSummaryStatistics} that 026 * is safe to use in a multithreaded environment. Multiple threads can safely 027 * operate on a single instance without causing runtime exceptions due to race 028 * conditions. In effect, this implementation makes modification and access 029 * methods atomic operations for a single instance. That is to say, as one 030 * thread is computing a statistic from the instance, no other thread can modify 031 * the instance nor compute another statistic. 032 * @since 1.2 033 * @version $Id: SynchronizedMultivariateSummaryStatistics.java 1416643 2012-12-03 19:37:14Z tn $ 034 */ 035 public class SynchronizedMultivariateSummaryStatistics 036 extends MultivariateSummaryStatistics { 037 038 /** Serialization UID */ 039 private static final long serialVersionUID = 7099834153347155363L; 040 041 /** 042 * Construct a SynchronizedMultivariateSummaryStatistics instance 043 * @param k dimension of the data 044 * @param isCovarianceBiasCorrected if true, the unbiased sample 045 * covariance is computed, otherwise the biased population covariance 046 * is computed 047 */ 048 public SynchronizedMultivariateSummaryStatistics(int k, boolean isCovarianceBiasCorrected) { 049 super(k, isCovarianceBiasCorrected); 050 } 051 052 /** 053 * {@inheritDoc} 054 */ 055 @Override 056 public synchronized void addValue(double[] value) throws DimensionMismatchException { 057 super.addValue(value); 058 } 059 060 /** 061 * {@inheritDoc} 062 */ 063 @Override 064 public synchronized int getDimension() { 065 return super.getDimension(); 066 } 067 068 /** 069 * {@inheritDoc} 070 */ 071 @Override 072 public synchronized long getN() { 073 return super.getN(); 074 } 075 076 /** 077 * {@inheritDoc} 078 */ 079 @Override 080 public synchronized double[] getSum() { 081 return super.getSum(); 082 } 083 084 /** 085 * {@inheritDoc} 086 */ 087 @Override 088 public synchronized double[] getSumSq() { 089 return super.getSumSq(); 090 } 091 092 /** 093 * {@inheritDoc} 094 */ 095 @Override 096 public synchronized double[] getSumLog() { 097 return super.getSumLog(); 098 } 099 100 /** 101 * {@inheritDoc} 102 */ 103 @Override 104 public synchronized double[] getMean() { 105 return super.getMean(); 106 } 107 108 /** 109 * {@inheritDoc} 110 */ 111 @Override 112 public synchronized double[] getStandardDeviation() { 113 return super.getStandardDeviation(); 114 } 115 116 /** 117 * {@inheritDoc} 118 */ 119 @Override 120 public synchronized RealMatrix getCovariance() { 121 return super.getCovariance(); 122 } 123 124 /** 125 * {@inheritDoc} 126 */ 127 @Override 128 public synchronized double[] getMax() { 129 return super.getMax(); 130 } 131 132 /** 133 * {@inheritDoc} 134 */ 135 @Override 136 public synchronized double[] getMin() { 137 return super.getMin(); 138 } 139 140 /** 141 * {@inheritDoc} 142 */ 143 @Override 144 public synchronized double[] getGeometricMean() { 145 return super.getGeometricMean(); 146 } 147 148 /** 149 * {@inheritDoc} 150 */ 151 @Override 152 public synchronized String toString() { 153 return super.toString(); 154 } 155 156 /** 157 * {@inheritDoc} 158 */ 159 @Override 160 public synchronized void clear() { 161 super.clear(); 162 } 163 164 /** 165 * {@inheritDoc} 166 */ 167 @Override 168 public synchronized boolean equals(Object object) { 169 return super.equals(object); 170 } 171 172 /** 173 * {@inheritDoc} 174 */ 175 @Override 176 public synchronized int hashCode() { 177 return super.hashCode(); 178 } 179 180 /** 181 * {@inheritDoc} 182 */ 183 @Override 184 public synchronized StorelessUnivariateStatistic[] getSumImpl() { 185 return super.getSumImpl(); 186 } 187 188 /** 189 * {@inheritDoc} 190 */ 191 @Override 192 public synchronized void setSumImpl(StorelessUnivariateStatistic[] sumImpl) 193 throws DimensionMismatchException, MathIllegalStateException { 194 super.setSumImpl(sumImpl); 195 } 196 197 /** 198 * {@inheritDoc} 199 */ 200 @Override 201 public synchronized StorelessUnivariateStatistic[] getSumsqImpl() { 202 return super.getSumsqImpl(); 203 } 204 205 /** 206 * {@inheritDoc} 207 */ 208 @Override 209 public synchronized void setSumsqImpl(StorelessUnivariateStatistic[] sumsqImpl) 210 throws DimensionMismatchException, MathIllegalStateException { 211 super.setSumsqImpl(sumsqImpl); 212 } 213 214 /** 215 * {@inheritDoc} 216 */ 217 @Override 218 public synchronized StorelessUnivariateStatistic[] getMinImpl() { 219 return super.getMinImpl(); 220 } 221 222 /** 223 * {@inheritDoc} 224 */ 225 @Override 226 public synchronized void setMinImpl(StorelessUnivariateStatistic[] minImpl) 227 throws DimensionMismatchException, MathIllegalStateException { 228 super.setMinImpl(minImpl); 229 } 230 231 /** 232 * {@inheritDoc} 233 */ 234 @Override 235 public synchronized StorelessUnivariateStatistic[] getMaxImpl() { 236 return super.getMaxImpl(); 237 } 238 239 /** 240 * {@inheritDoc} 241 */ 242 @Override 243 public synchronized void setMaxImpl(StorelessUnivariateStatistic[] maxImpl) 244 throws DimensionMismatchException, MathIllegalStateException{ 245 super.setMaxImpl(maxImpl); 246 } 247 248 /** 249 * {@inheritDoc} 250 */ 251 @Override 252 public synchronized StorelessUnivariateStatistic[] getSumLogImpl() { 253 return super.getSumLogImpl(); 254 } 255 256 /** 257 * {@inheritDoc} 258 */ 259 @Override 260 public synchronized void setSumLogImpl(StorelessUnivariateStatistic[] sumLogImpl) 261 throws DimensionMismatchException, MathIllegalStateException { 262 super.setSumLogImpl(sumLogImpl); 263 } 264 265 /** 266 * {@inheritDoc} 267 */ 268 @Override 269 public synchronized StorelessUnivariateStatistic[] getGeoMeanImpl() { 270 return super.getGeoMeanImpl(); 271 } 272 273 /** 274 * {@inheritDoc} 275 */ 276 @Override 277 public synchronized void setGeoMeanImpl(StorelessUnivariateStatistic[] geoMeanImpl) 278 throws DimensionMismatchException, MathIllegalStateException { 279 super.setGeoMeanImpl(geoMeanImpl); 280 } 281 282 /** 283 * {@inheritDoc} 284 */ 285 @Override 286 public synchronized StorelessUnivariateStatistic[] getMeanImpl() { 287 return super.getMeanImpl(); 288 } 289 290 /** 291 * {@inheritDoc} 292 */ 293 @Override 294 public synchronized void setMeanImpl(StorelessUnivariateStatistic[] meanImpl) 295 throws DimensionMismatchException, MathIllegalStateException { 296 super.setMeanImpl(meanImpl); 297 } 298 }