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 */
017package org.apache.commons.math3.stat.descriptive;
018
019import org.apache.commons.math3.exception.MathIllegalStateException;
020import org.apache.commons.math3.exception.NullArgumentException;
021import org.apache.commons.math3.util.MathUtils;
022
023/**
024 * Implementation of
025 * {@link org.apache.commons.math3.stat.descriptive.SummaryStatistics} 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 *
033 * @since 1.2
034 * @version $Id: SynchronizedSummaryStatistics.java 1416643 2012-12-03 19:37:14Z tn $
035 */
036public class SynchronizedSummaryStatistics extends SummaryStatistics {
037
038    /** Serialization UID */
039    private static final long serialVersionUID = 1909861009042253704L;
040
041    /**
042     * Construct a SynchronizedSummaryStatistics instance
043     */
044    public SynchronizedSummaryStatistics() {
045        super();
046    }
047
048    /**
049     * A copy constructor. Creates a deep-copy of the {@code original}.
050     *
051     * @param original the {@code SynchronizedSummaryStatistics} instance to copy
052     * @throws NullArgumentException if original is null
053     */
054    public SynchronizedSummaryStatistics(SynchronizedSummaryStatistics original)
055    throws NullArgumentException {
056        copy(original, this);
057    }
058
059    /**
060     * {@inheritDoc}
061     */
062    @Override
063    public synchronized StatisticalSummary getSummary() {
064        return super.getSummary();
065    }
066
067    /**
068     * {@inheritDoc}
069     */
070    @Override
071    public synchronized void addValue(double value) {
072        super.addValue(value);
073    }
074
075    /**
076     * {@inheritDoc}
077     */
078    @Override
079    public synchronized long getN() {
080        return super.getN();
081    }
082
083    /**
084     * {@inheritDoc}
085     */
086    @Override
087    public synchronized double getSum() {
088        return super.getSum();
089    }
090
091    /**
092     * {@inheritDoc}
093     */
094    @Override
095    public synchronized double getSumsq() {
096        return super.getSumsq();
097    }
098
099    /**
100     * {@inheritDoc}
101     */
102    @Override
103    public synchronized double getMean() {
104        return super.getMean();
105    }
106
107    /**
108     * {@inheritDoc}
109     */
110    @Override
111    public synchronized double getStandardDeviation() {
112        return super.getStandardDeviation();
113    }
114
115    /**
116     * {@inheritDoc}
117     */
118    @Override
119    public synchronized double getVariance() {
120        return super.getVariance();
121    }
122
123    /**
124     * {@inheritDoc}
125     */
126    @Override
127    public synchronized double getPopulationVariance() {
128        return super.getPopulationVariance();
129    }
130
131    /**
132     * {@inheritDoc}
133     */
134    @Override
135    public synchronized double getMax() {
136        return super.getMax();
137    }
138
139    /**
140     * {@inheritDoc}
141     */
142    @Override
143    public synchronized double getMin() {
144        return super.getMin();
145    }
146
147    /**
148     * {@inheritDoc}
149     */
150    @Override
151    public synchronized double getGeometricMean() {
152        return super.getGeometricMean();
153    }
154
155    /**
156     * {@inheritDoc}
157     */
158    @Override
159    public synchronized String toString() {
160        return super.toString();
161    }
162
163    /**
164     * {@inheritDoc}
165     */
166    @Override
167    public synchronized void clear() {
168        super.clear();
169    }
170
171    /**
172     * {@inheritDoc}
173     */
174    @Override
175    public synchronized boolean equals(Object object) {
176        return super.equals(object);
177    }
178
179    /**
180     * {@inheritDoc}
181     */
182    @Override
183    public synchronized int hashCode() {
184        return super.hashCode();
185    }
186
187    /**
188     * {@inheritDoc}
189     */
190    @Override
191    public synchronized StorelessUnivariateStatistic getSumImpl() {
192        return super.getSumImpl();
193    }
194
195    /**
196     * {@inheritDoc}
197     */
198    @Override
199    public synchronized void setSumImpl(StorelessUnivariateStatistic sumImpl)
200    throws MathIllegalStateException {
201        super.setSumImpl(sumImpl);
202    }
203
204    /**
205     * {@inheritDoc}
206     */
207    @Override
208    public synchronized StorelessUnivariateStatistic getSumsqImpl() {
209        return super.getSumsqImpl();
210    }
211
212    /**
213     * {@inheritDoc}
214     */
215    @Override
216    public synchronized void setSumsqImpl(StorelessUnivariateStatistic sumsqImpl)
217    throws MathIllegalStateException {
218        super.setSumsqImpl(sumsqImpl);
219    }
220
221    /**
222     * {@inheritDoc}
223     */
224    @Override
225    public synchronized StorelessUnivariateStatistic getMinImpl() {
226        return super.getMinImpl();
227    }
228
229    /**
230     * {@inheritDoc}
231     */
232    @Override
233    public synchronized void setMinImpl(StorelessUnivariateStatistic minImpl)
234    throws MathIllegalStateException {
235        super.setMinImpl(minImpl);
236    }
237
238    /**
239     * {@inheritDoc}
240     */
241    @Override
242    public synchronized StorelessUnivariateStatistic getMaxImpl() {
243        return super.getMaxImpl();
244    }
245
246    /**
247     * {@inheritDoc}
248     */
249    @Override
250    public synchronized void setMaxImpl(StorelessUnivariateStatistic maxImpl)
251    throws MathIllegalStateException {
252        super.setMaxImpl(maxImpl);
253    }
254
255    /**
256     * {@inheritDoc}
257     */
258    @Override
259    public synchronized StorelessUnivariateStatistic getSumLogImpl() {
260        return super.getSumLogImpl();
261    }
262
263    /**
264     * {@inheritDoc}
265     */
266    @Override
267    public synchronized void setSumLogImpl(StorelessUnivariateStatistic sumLogImpl)
268    throws MathIllegalStateException {
269        super.setSumLogImpl(sumLogImpl);
270    }
271
272    /**
273     * {@inheritDoc}
274     */
275    @Override
276    public synchronized StorelessUnivariateStatistic getGeoMeanImpl() {
277        return super.getGeoMeanImpl();
278    }
279
280    /**
281     * {@inheritDoc}
282     */
283    @Override
284    public synchronized void setGeoMeanImpl(StorelessUnivariateStatistic geoMeanImpl)
285    throws MathIllegalStateException {
286        super.setGeoMeanImpl(geoMeanImpl);
287    }
288
289    /**
290     * {@inheritDoc}
291     */
292    @Override
293    public synchronized StorelessUnivariateStatistic getMeanImpl() {
294        return super.getMeanImpl();
295    }
296
297    /**
298     * {@inheritDoc}
299     */
300    @Override
301    public synchronized void setMeanImpl(StorelessUnivariateStatistic meanImpl)
302    throws MathIllegalStateException {
303        super.setMeanImpl(meanImpl);
304    }
305
306    /**
307     * {@inheritDoc}
308     */
309    @Override
310    public synchronized StorelessUnivariateStatistic getVarianceImpl() {
311        return super.getVarianceImpl();
312    }
313
314    /**
315     * {@inheritDoc}
316     */
317    @Override
318    public synchronized void setVarianceImpl(StorelessUnivariateStatistic varianceImpl)
319    throws MathIllegalStateException {
320        super.setVarianceImpl(varianceImpl);
321    }
322
323    /**
324     * Returns a copy of this SynchronizedSummaryStatistics instance with the
325     * same internal state.
326     *
327     * @return a copy of this
328     */
329    @Override
330    public synchronized SynchronizedSummaryStatistics copy() {
331        SynchronizedSummaryStatistics result =
332            new SynchronizedSummaryStatistics();
333        // No try-catch or advertised exception because arguments are guaranteed non-null
334        copy(this, result);
335        return result;
336    }
337
338    /**
339     * Copies source to dest.
340     * <p>Neither source nor dest can be null.</p>
341     * <p>Acquires synchronization lock on source, then dest before copying.</p>
342     *
343     * @param source SynchronizedSummaryStatistics to copy
344     * @param dest SynchronizedSummaryStatistics to copy to
345     * @throws NullArgumentException if either source or dest is null
346     */
347    public static void copy(SynchronizedSummaryStatistics source,
348                            SynchronizedSummaryStatistics dest)
349        throws NullArgumentException {
350        MathUtils.checkNotNull(source);
351        MathUtils.checkNotNull(dest);
352        synchronized (source) {
353            synchronized (dest) {
354                SummaryStatistics.copy(source, dest);
355            }
356        }
357    }
358
359}