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.inference;
018
019 import org.apache.commons.math3.distribution.ChiSquaredDistribution;
020 import org.apache.commons.math3.exception.DimensionMismatchException;
021 import org.apache.commons.math3.exception.MaxCountExceededException;
022 import org.apache.commons.math3.exception.NotPositiveException;
023 import org.apache.commons.math3.exception.NotStrictlyPositiveException;
024 import org.apache.commons.math3.exception.NullArgumentException;
025 import org.apache.commons.math3.exception.OutOfRangeException;
026 import org.apache.commons.math3.exception.ZeroException;
027 import org.apache.commons.math3.exception.util.LocalizedFormats;
028 import org.apache.commons.math3.util.FastMath;
029 import org.apache.commons.math3.util.MathArrays;
030
031 /**
032 * Implements Chi-Square test statistics.
033 *
034 * <p>This implementation handles both known and unknown distributions.</p>
035 *
036 * <p>Two samples tests can be used when the distribution is unknown <i>a priori</i>
037 * but provided by one sample, or when the hypothesis under test is that the two
038 * samples come from the same underlying distribution.</p>
039 *
040 * @version $Id: ChiSquareTest.java 1416643 2012-12-03 19:37:14Z tn $
041 */
042 public class ChiSquareTest {
043
044 /**
045 * Construct a ChiSquareTest
046 */
047 public ChiSquareTest() {
048 super();
049 }
050
051 /**
052 * Computes the <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda35f.htm">
053 * Chi-Square statistic</a> comparing <code>observed</code> and <code>expected</code>
054 * frequency counts.
055 * <p>
056 * This statistic can be used to perform a Chi-Square test evaluating the null
057 * hypothesis that the observed counts follow the expected distribution.</p>
058 * <p>
059 * <strong>Preconditions</strong>: <ul>
060 * <li>Expected counts must all be positive.
061 * </li>
062 * <li>Observed counts must all be ≥ 0.
063 * </li>
064 * <li>The observed and expected arrays must have the same length and
065 * their common length must be at least 2.
066 * </li></ul></p><p>
067 * If any of the preconditions are not met, an
068 * <code>IllegalArgumentException</code> is thrown.</p>
069 * <p><strong>Note: </strong>This implementation rescales the
070 * <code>expected</code> array if necessary to ensure that the sum of the
071 * expected and observed counts are equal.</p>
072 *
073 * @param observed array of observed frequency counts
074 * @param expected array of expected frequency counts
075 * @return chiSquare test statistic
076 * @throws NotPositiveException if <code>observed</code> has negative entries
077 * @throws NotStrictlyPositiveException if <code>expected</code> has entries that are
078 * not strictly positive
079 * @throws DimensionMismatchException if the arrays length is less than 2
080 */
081 public double chiSquare(final double[] expected, final long[] observed)
082 throws NotPositiveException, NotStrictlyPositiveException,
083 DimensionMismatchException {
084
085 if (expected.length < 2) {
086 throw new DimensionMismatchException(expected.length, 2);
087 }
088 if (expected.length != observed.length) {
089 throw new DimensionMismatchException(expected.length, observed.length);
090 }
091 MathArrays.checkPositive(expected);
092 MathArrays.checkNonNegative(observed);
093
094 double sumExpected = 0d;
095 double sumObserved = 0d;
096 for (int i = 0; i < observed.length; i++) {
097 sumExpected += expected[i];
098 sumObserved += observed[i];
099 }
100 double ratio = 1.0d;
101 boolean rescale = false;
102 if (FastMath.abs(sumExpected - sumObserved) > 10E-6) {
103 ratio = sumObserved / sumExpected;
104 rescale = true;
105 }
106 double sumSq = 0.0d;
107 for (int i = 0; i < observed.length; i++) {
108 if (rescale) {
109 final double dev = observed[i] - ratio * expected[i];
110 sumSq += dev * dev / (ratio * expected[i]);
111 } else {
112 final double dev = observed[i] - expected[i];
113 sumSq += dev * dev / expected[i];
114 }
115 }
116 return sumSq;
117
118 }
119
120 /**
121 * Returns the <i>observed significance level</i>, or <a href=
122 * "http://www.cas.lancs.ac.uk/glossary_v1.1/hyptest.html#pvalue">
123 * p-value</a>, associated with a
124 * <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda35f.htm">
125 * Chi-square goodness of fit test</a> comparing the <code>observed</code>
126 * frequency counts to those in the <code>expected</code> array.
127 * <p>
128 * The number returned is the smallest significance level at which one can reject
129 * the null hypothesis that the observed counts conform to the frequency distribution
130 * described by the expected counts.</p>
131 * <p>
132 * <strong>Preconditions</strong>: <ul>
133 * <li>Expected counts must all be positive.
134 * </li>
135 * <li>Observed counts must all be ≥ 0.
136 * </li>
137 * <li>The observed and expected arrays must have the same length and
138 * their common length must be at least 2.
139 * </li></ul></p><p>
140 * If any of the preconditions are not met, an
141 * <code>IllegalArgumentException</code> is thrown.</p>
142 * <p><strong>Note: </strong>This implementation rescales the
143 * <code>expected</code> array if necessary to ensure that the sum of the
144 * expected and observed counts are equal.</p>
145 *
146 * @param observed array of observed frequency counts
147 * @param expected array of expected frequency counts
148 * @return p-value
149 * @throws NotPositiveException if <code>observed</code> has negative entries
150 * @throws NotStrictlyPositiveException if <code>expected</code> has entries that are
151 * not strictly positive
152 * @throws DimensionMismatchException if the arrays length is less than 2
153 * @throws MaxCountExceededException if an error occurs computing the p-value
154 */
155 public double chiSquareTest(final double[] expected, final long[] observed)
156 throws NotPositiveException, NotStrictlyPositiveException,
157 DimensionMismatchException, MaxCountExceededException {
158
159 ChiSquaredDistribution distribution =
160 new ChiSquaredDistribution(expected.length - 1.0);
161 return 1.0 - distribution.cumulativeProbability(chiSquare(expected, observed));
162 }
163
164 /**
165 * Performs a <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda35f.htm">
166 * Chi-square goodness of fit test</a> evaluating the null hypothesis that the
167 * observed counts conform to the frequency distribution described by the expected
168 * counts, with significance level <code>alpha</code>. Returns true iff the null
169 * hypothesis can be rejected with 100 * (1 - alpha) percent confidence.
170 * <p>
171 * <strong>Example:</strong><br>
172 * To test the hypothesis that <code>observed</code> follows
173 * <code>expected</code> at the 99% level, use </p><p>
174 * <code>chiSquareTest(expected, observed, 0.01) </code></p>
175 * <p>
176 * <strong>Preconditions</strong>: <ul>
177 * <li>Expected counts must all be positive.
178 * </li>
179 * <li>Observed counts must all be ≥ 0.
180 * </li>
181 * <li>The observed and expected arrays must have the same length and
182 * their common length must be at least 2.
183 * <li> <code> 0 < alpha < 0.5 </code>
184 * </li></ul></p><p>
185 * If any of the preconditions are not met, an
186 * <code>IllegalArgumentException</code> is thrown.</p>
187 * <p><strong>Note: </strong>This implementation rescales the
188 * <code>expected</code> array if necessary to ensure that the sum of the
189 * expected and observed counts are equal.</p>
190 *
191 * @param observed array of observed frequency counts
192 * @param expected array of expected frequency counts
193 * @param alpha significance level of the test
194 * @return true iff null hypothesis can be rejected with confidence
195 * 1 - alpha
196 * @throws NotPositiveException if <code>observed</code> has negative entries
197 * @throws NotStrictlyPositiveException if <code>expected</code> has entries that are
198 * not strictly positive
199 * @throws DimensionMismatchException if the arrays length is less than 2
200 * @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
201 * @throws MaxCountExceededException if an error occurs computing the p-value
202 */
203 public boolean chiSquareTest(final double[] expected, final long[] observed,
204 final double alpha)
205 throws NotPositiveException, NotStrictlyPositiveException,
206 DimensionMismatchException, OutOfRangeException, MaxCountExceededException {
207
208 if ((alpha <= 0) || (alpha > 0.5)) {
209 throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUND_SIGNIFICANCE_LEVEL,
210 alpha, 0, 0.5);
211 }
212 return chiSquareTest(expected, observed) < alpha;
213
214 }
215
216 /**
217 * Computes the Chi-Square statistic associated with a
218 * <a href="http://www.itl.nist.gov/div898/handbook/prc/section4/prc45.htm">
219 * chi-square test of independence</a> based on the input <code>counts</code>
220 * array, viewed as a two-way table.
221 * <p>
222 * The rows of the 2-way table are
223 * <code>count[0], ... , count[count.length - 1] </code></p>
224 * <p>
225 * <strong>Preconditions</strong>: <ul>
226 * <li>All counts must be ≥ 0.
227 * </li>
228 * <li>The count array must be rectangular (i.e. all count[i] subarrays
229 * must have the same length).
230 * </li>
231 * <li>The 2-way table represented by <code>counts</code> must have at
232 * least 2 columns and at least 2 rows.
233 * </li>
234 * </li></ul></p><p>
235 * If any of the preconditions are not met, an
236 * <code>IllegalArgumentException</code> is thrown.</p>
237 *
238 * @param counts array representation of 2-way table
239 * @return chiSquare test statistic
240 * @throws NullArgumentException if the array is null
241 * @throws DimensionMismatchException if the array is not rectangular
242 * @throws NotPositiveException if {@code counts} has negative entries
243 */
244 public double chiSquare(final long[][] counts)
245 throws NullArgumentException, NotPositiveException,
246 DimensionMismatchException {
247
248 checkArray(counts);
249 int nRows = counts.length;
250 int nCols = counts[0].length;
251
252 // compute row, column and total sums
253 double[] rowSum = new double[nRows];
254 double[] colSum = new double[nCols];
255 double total = 0.0d;
256 for (int row = 0; row < nRows; row++) {
257 for (int col = 0; col < nCols; col++) {
258 rowSum[row] += counts[row][col];
259 colSum[col] += counts[row][col];
260 total += counts[row][col];
261 }
262 }
263
264 // compute expected counts and chi-square
265 double sumSq = 0.0d;
266 double expected = 0.0d;
267 for (int row = 0; row < nRows; row++) {
268 for (int col = 0; col < nCols; col++) {
269 expected = (rowSum[row] * colSum[col]) / total;
270 sumSq += ((counts[row][col] - expected) *
271 (counts[row][col] - expected)) / expected;
272 }
273 }
274 return sumSq;
275
276 }
277
278 /**
279 * Returns the <i>observed significance level</i>, or <a href=
280 * "http://www.cas.lancs.ac.uk/glossary_v1.1/hyptest.html#pvalue">
281 * p-value</a>, associated with a
282 * <a href="http://www.itl.nist.gov/div898/handbook/prc/section4/prc45.htm">
283 * chi-square test of independence</a> based on the input <code>counts</code>
284 * array, viewed as a two-way table.
285 * <p>
286 * The rows of the 2-way table are
287 * <code>count[0], ... , count[count.length - 1] </code></p>
288 * <p>
289 * <strong>Preconditions</strong>: <ul>
290 * <li>All counts must be ≥ 0.
291 * </li>
292 * <li>The count array must be rectangular (i.e. all count[i] subarrays must have
293 * the same length).
294 * </li>
295 * <li>The 2-way table represented by <code>counts</code> must have at least 2
296 * columns and at least 2 rows.
297 * </li>
298 * </li></ul></p><p>
299 * If any of the preconditions are not met, an
300 * <code>IllegalArgumentException</code> is thrown.</p>
301 *
302 * @param counts array representation of 2-way table
303 * @return p-value
304 * @throws NullArgumentException if the array is null
305 * @throws DimensionMismatchException if the array is not rectangular
306 * @throws NotPositiveException if {@code counts} has negative entries
307 * @throws MaxCountExceededException if an error occurs computing the p-value
308 */
309 public double chiSquareTest(final long[][] counts)
310 throws NullArgumentException, DimensionMismatchException,
311 NotPositiveException, MaxCountExceededException {
312
313 checkArray(counts);
314 double df = ((double) counts.length -1) * ((double) counts[0].length - 1);
315 ChiSquaredDistribution distribution;
316 distribution = new ChiSquaredDistribution(df);
317 return 1 - distribution.cumulativeProbability(chiSquare(counts));
318
319 }
320
321 /**
322 * Performs a <a href="http://www.itl.nist.gov/div898/handbook/prc/section4/prc45.htm">
323 * chi-square test of independence</a> evaluating the null hypothesis that the
324 * classifications represented by the counts in the columns of the input 2-way table
325 * are independent of the rows, with significance level <code>alpha</code>.
326 * Returns true iff the null hypothesis can be rejected with 100 * (1 - alpha) percent
327 * confidence.
328 * <p>
329 * The rows of the 2-way table are
330 * <code>count[0], ... , count[count.length - 1] </code></p>
331 * <p>
332 * <strong>Example:</strong><br>
333 * To test the null hypothesis that the counts in
334 * <code>count[0], ... , count[count.length - 1] </code>
335 * all correspond to the same underlying probability distribution at the 99% level, use</p>
336 * <p><code>chiSquareTest(counts, 0.01)</code></p>
337 * <p>
338 * <strong>Preconditions</strong>: <ul>
339 * <li>All counts must be ≥ 0.
340 * </li>
341 * <li>The count array must be rectangular (i.e. all count[i] subarrays must have the
342 * same length).</li>
343 * <li>The 2-way table represented by <code>counts</code> must have at least 2 columns and
344 * at least 2 rows.</li>
345 * </li></ul></p><p>
346 * If any of the preconditions are not met, an
347 * <code>IllegalArgumentException</code> is thrown.</p>
348 *
349 * @param counts array representation of 2-way table
350 * @param alpha significance level of the test
351 * @return true iff null hypothesis can be rejected with confidence
352 * 1 - alpha
353 * @throws NullArgumentException if the array is null
354 * @throws DimensionMismatchException if the array is not rectangular
355 * @throws NotPositiveException if {@code counts} has any negative entries
356 * @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
357 * @throws MaxCountExceededException if an error occurs computing the p-value
358 */
359 public boolean chiSquareTest(final long[][] counts, final double alpha)
360 throws NullArgumentException, DimensionMismatchException,
361 NotPositiveException, OutOfRangeException, MaxCountExceededException {
362
363 if ((alpha <= 0) || (alpha > 0.5)) {
364 throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUND_SIGNIFICANCE_LEVEL,
365 alpha, 0, 0.5);
366 }
367 return chiSquareTest(counts) < alpha;
368
369 }
370
371 /**
372 * <p>Computes a
373 * <a href="http://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/chi2samp.htm">
374 * Chi-Square two sample test statistic</a> comparing bin frequency counts
375 * in <code>observed1</code> and <code>observed2</code>. The
376 * sums of frequency counts in the two samples are not required to be the
377 * same. The formula used to compute the test statistic is</p>
378 * <code>
379 * ∑[(K * observed1[i] - observed2[i]/K)<sup>2</sup> / (observed1[i] + observed2[i])]
380 * </code> where
381 * <br/><code>K = &sqrt;[&sum(observed2 / ∑(observed1)]</code>
382 * </p>
383 * <p>This statistic can be used to perform a Chi-Square test evaluating the
384 * null hypothesis that both observed counts follow the same distribution.</p>
385 * <p>
386 * <strong>Preconditions</strong>: <ul>
387 * <li>Observed counts must be non-negative.
388 * </li>
389 * <li>Observed counts for a specific bin must not both be zero.
390 * </li>
391 * <li>Observed counts for a specific sample must not all be 0.
392 * </li>
393 * <li>The arrays <code>observed1</code> and <code>observed2</code> must have
394 * the same length and their common length must be at least 2.
395 * </li></ul></p><p>
396 * If any of the preconditions are not met, an
397 * <code>IllegalArgumentException</code> is thrown.</p>
398 *
399 * @param observed1 array of observed frequency counts of the first data set
400 * @param observed2 array of observed frequency counts of the second data set
401 * @return chiSquare test statistic
402 * @throws DimensionMismatchException the the length of the arrays does not match
403 * @throws NotPositiveException if any entries in <code>observed1</code> or
404 * <code>observed2</code> are negative
405 * @throws ZeroException if either all counts of <code>observed1</code> or
406 * <code>observed2</code> are zero, or if the count at some index is zero
407 * for both arrays
408 * @since 1.2
409 */
410 public double chiSquareDataSetsComparison(long[] observed1, long[] observed2)
411 throws DimensionMismatchException, NotPositiveException, ZeroException {
412
413 // Make sure lengths are same
414 if (observed1.length < 2) {
415 throw new DimensionMismatchException(observed1.length, 2);
416 }
417 if (observed1.length != observed2.length) {
418 throw new DimensionMismatchException(observed1.length, observed2.length);
419 }
420
421 // Ensure non-negative counts
422 MathArrays.checkNonNegative(observed1);
423 MathArrays.checkNonNegative(observed2);
424
425 // Compute and compare count sums
426 long countSum1 = 0;
427 long countSum2 = 0;
428 boolean unequalCounts = false;
429 double weight = 0.0;
430 for (int i = 0; i < observed1.length; i++) {
431 countSum1 += observed1[i];
432 countSum2 += observed2[i];
433 }
434 // Ensure neither sample is uniformly 0
435 if (countSum1 == 0 || countSum2 == 0) {
436 throw new ZeroException();
437 }
438 // Compare and compute weight only if different
439 unequalCounts = countSum1 != countSum2;
440 if (unequalCounts) {
441 weight = FastMath.sqrt((double) countSum1 / (double) countSum2);
442 }
443 // Compute ChiSquare statistic
444 double sumSq = 0.0d;
445 double dev = 0.0d;
446 double obs1 = 0.0d;
447 double obs2 = 0.0d;
448 for (int i = 0; i < observed1.length; i++) {
449 if (observed1[i] == 0 && observed2[i] == 0) {
450 throw new ZeroException(LocalizedFormats.OBSERVED_COUNTS_BOTTH_ZERO_FOR_ENTRY, i);
451 } else {
452 obs1 = observed1[i];
453 obs2 = observed2[i];
454 if (unequalCounts) { // apply weights
455 dev = obs1/weight - obs2 * weight;
456 } else {
457 dev = obs1 - obs2;
458 }
459 sumSq += (dev * dev) / (obs1 + obs2);
460 }
461 }
462 return sumSq;
463 }
464
465 /**
466 * <p>Returns the <i>observed significance level</i>, or <a href=
467 * "http://www.cas.lancs.ac.uk/glossary_v1.1/hyptest.html#pvalue">
468 * p-value</a>, associated with a Chi-Square two sample test comparing
469 * bin frequency counts in <code>observed1</code> and
470 * <code>observed2</code>.
471 * </p>
472 * <p>The number returned is the smallest significance level at which one
473 * can reject the null hypothesis that the observed counts conform to the
474 * same distribution.
475 * </p>
476 * <p>See {@link #chiSquareDataSetsComparison(long[], long[])} for details
477 * on the formula used to compute the test statistic. The degrees of
478 * of freedom used to perform the test is one less than the common length
479 * of the input observed count arrays.
480 * </p>
481 * <strong>Preconditions</strong>: <ul>
482 * <li>Observed counts must be non-negative.
483 * </li>
484 * <li>Observed counts for a specific bin must not both be zero.
485 * </li>
486 * <li>Observed counts for a specific sample must not all be 0.
487 * </li>
488 * <li>The arrays <code>observed1</code> and <code>observed2</code> must
489 * have the same length and
490 * their common length must be at least 2.
491 * </li></ul><p>
492 * If any of the preconditions are not met, an
493 * <code>IllegalArgumentException</code> is thrown.</p>
494 *
495 * @param observed1 array of observed frequency counts of the first data set
496 * @param observed2 array of observed frequency counts of the second data set
497 * @return p-value
498 * @throws DimensionMismatchException the the length of the arrays does not match
499 * @throws NotPositiveException if any entries in <code>observed1</code> or
500 * <code>observed2</code> are negative
501 * @throws ZeroException if either all counts of <code>observed1</code> or
502 * <code>observed2</code> are zero, or if the count at the same index is zero
503 * for both arrays
504 * @throws MaxCountExceededException if an error occurs computing the p-value
505 * @since 1.2
506 */
507 public double chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)
508 throws DimensionMismatchException, NotPositiveException, ZeroException,
509 MaxCountExceededException {
510
511 ChiSquaredDistribution distribution;
512 distribution = new ChiSquaredDistribution((double) observed1.length - 1);
513 return 1 - distribution.cumulativeProbability(
514 chiSquareDataSetsComparison(observed1, observed2));
515
516 }
517
518 /**
519 * <p>Performs a Chi-Square two sample test comparing two binned data
520 * sets. The test evaluates the null hypothesis that the two lists of
521 * observed counts conform to the same frequency distribution, with
522 * significance level <code>alpha</code>. Returns true iff the null
523 * hypothesis can be rejected with 100 * (1 - alpha) percent confidence.
524 * </p>
525 * <p>See {@link #chiSquareDataSetsComparison(long[], long[])} for
526 * details on the formula used to compute the Chisquare statistic used
527 * in the test. The degrees of of freedom used to perform the test is
528 * one less than the common length of the input observed count arrays.
529 * </p>
530 * <strong>Preconditions</strong>: <ul>
531 * <li>Observed counts must be non-negative.
532 * </li>
533 * <li>Observed counts for a specific bin must not both be zero.
534 * </li>
535 * <li>Observed counts for a specific sample must not all be 0.
536 * </li>
537 * <li>The arrays <code>observed1</code> and <code>observed2</code> must
538 * have the same length and their common length must be at least 2.
539 * </li>
540 * <li> <code> 0 < alpha < 0.5 </code>
541 * </li></ul><p>
542 * If any of the preconditions are not met, an
543 * <code>IllegalArgumentException</code> is thrown.</p>
544 *
545 * @param observed1 array of observed frequency counts of the first data set
546 * @param observed2 array of observed frequency counts of the second data set
547 * @param alpha significance level of the test
548 * @return true iff null hypothesis can be rejected with confidence
549 * 1 - alpha
550 * @throws DimensionMismatchException the the length of the arrays does not match
551 * @throws NotPositiveException if any entries in <code>observed1</code> or
552 * <code>observed2</code> are negative
553 * @throws ZeroException if either all counts of <code>observed1</code> or
554 * <code>observed2</code> are zero, or if the count at the same index is zero
555 * for both arrays
556 * @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
557 * @throws MaxCountExceededException if an error occurs performing the test
558 * @since 1.2
559 */
560 public boolean chiSquareTestDataSetsComparison(final long[] observed1,
561 final long[] observed2,
562 final double alpha)
563 throws DimensionMismatchException, NotPositiveException,
564 ZeroException, OutOfRangeException, MaxCountExceededException {
565
566 if (alpha <= 0 ||
567 alpha > 0.5) {
568 throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUND_SIGNIFICANCE_LEVEL,
569 alpha, 0, 0.5);
570 }
571 return chiSquareTestDataSetsComparison(observed1, observed2) < alpha;
572
573 }
574
575 /**
576 * Checks to make sure that the input long[][] array is rectangular,
577 * has at least 2 rows and 2 columns, and has all non-negative entries.
578 *
579 * @param in input 2-way table to check
580 * @throws NullArgumentException if the array is null
581 * @throws DimensionMismatchException if the array is not valid
582 * @throws NotPositiveException if the array contains any negative entries
583 */
584 private void checkArray(final long[][] in)
585 throws NullArgumentException, DimensionMismatchException,
586 NotPositiveException {
587
588 if (in.length < 2) {
589 throw new DimensionMismatchException(in.length, 2);
590 }
591
592 if (in[0].length < 2) {
593 throw new DimensionMismatchException(in[0].length, 2);
594 }
595
596 MathArrays.checkRectangular(in);
597 MathArrays.checkNonNegative(in);
598
599 }
600
601 }