Java Code Examples for org.apache.commons.math3.exception.util.LocalizedFormats#NEGATIVE_ELEMENT_AT_INDEX
The following examples show how to use
org.apache.commons.math3.exception.util.LocalizedFormats#NEGATIVE_ELEMENT_AT_INDEX .
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
| Source File: MathArrays.java From astor with GNU General Public License v2.0 | 5 votes |
|
/**
* This method is used
* to verify that the begin and length parameters designate a subarray of positive length
* and the weights are all non-negative, non-NaN, finite, and not all zero.
* <p>
* <ul>
* <li>returns <code>true</code> iff the parameters designate a subarray of
* non-negative length and the weights array contains legitimate values.</li>
* <li>throws <code>MathIllegalArgumentException</code> if any of the following are true:
* <ul><li>the values array is null</li>
* <li>the weights array is null</li>
* <li>the weights array does not have the same length as the values array</li>
* <li>the weights array contains one or more infinite values</li>
* <li>the weights array contains one or more NaN values</li>
* <li>the weights array contains negative values</li>
* <li>the start and length arguments do not determine a valid array</li></ul>
* </li>
* <li>returns <code>false</li> if the array is non-null, but
* <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
* </ul></p>
*
* @param values the input array.
* @param weights the weights array.
* @param begin index of the first array element to include.
* @param length the number of elements to include.
* @param allowEmpty if {@code true} than allow zero length arrays to pass.
* @return {@code true} if the parameters are valid.
* @throws NullArgumentException if either of the arrays are null
* @throws MathIllegalArgumentException if the array indices are not valid,
* the weights array contains NaN, infinite or negative elements, or there
* are no positive weights.
* @since 3.3
*/
public static boolean verifyValues(final double[] values, final double[] weights,
final int begin, final int length, final boolean allowEmpty) throws MathIllegalArgumentException {
if (weights == null || values == null) {
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
}
if (weights.length != values.length) {
throw new DimensionMismatchException(weights.length, values.length);
}
boolean containsPositiveWeight = false;
for (int i = begin; i < begin + length; i++) {
final double weight = weights[i];
if (Double.isNaN(weight)) {
throw new MathIllegalArgumentException(LocalizedFormats.NAN_ELEMENT_AT_INDEX, Integer.valueOf(i));
}
if (Double.isInfinite(weight)) {
throw new MathIllegalArgumentException(LocalizedFormats.INFINITE_ARRAY_ELEMENT, Double.valueOf(weight), Integer.valueOf(i));
}
if (weight < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.NEGATIVE_ELEMENT_AT_INDEX, Integer.valueOf(i), Double.valueOf(weight));
}
if (!containsPositiveWeight && weight > 0.0) {
containsPositiveWeight = true;
}
}
if (!containsPositiveWeight) {
throw new MathIllegalArgumentException(LocalizedFormats.WEIGHT_AT_LEAST_ONE_NON_ZERO);
}
return verifyValues(values, begin, length, allowEmpty);
}
Example 2
| Source File: AbstractUnivariateStatistic.java From astor with GNU General Public License v2.0 | 5 votes |
|
/**
* This method is used by <code>evaluate(double[], double[], int, int)</code> methods
* to verify that the begin and length parameters designate a subarray of positive length
* and the weights are all non-negative, non-NaN, finite, and not all zero.
* <p>
* <ul>
* <li>returns <code>true</code> iff the parameters designate a subarray of
* non-negative length and the weights array contains legitimate values.</li>
* <li>throws <code>MathIllegalArgumentException</code> if any of the following are true:
* <ul><li>the values array is null</li>
* <li>the weights array is null</li>
* <li>the weights array does not have the same length as the values array</li>
* <li>the weights array contains one or more infinite values</li>
* <li>the weights array contains one or more NaN values</li>
* <li>the weights array contains negative values</li>
* <li>the start and length arguments do not determine a valid array</li></ul>
* </li>
* <li>returns <code>false</li> if the array is non-null, but
* <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
* </ul></p>
*
* @param values the input array.
* @param weights the weights array.
* @param begin index of the first array element to include.
* @param length the number of elements to include.
* @param allowEmpty if {@code true} than allow zero length arrays to pass.
* @return {@code true} if the parameters are valid.
* @throws NullArgumentException if either of the arrays are null
* @throws MathIllegalArgumentException if the array indices are not valid,
* the weights array contains NaN, infinite or negative elements, or there
* are no positive weights.
* @since 3.0
*/
protected boolean test(final double[] values, final double[] weights,
final int begin, final int length, final boolean allowEmpty) throws MathIllegalArgumentException {
if (weights == null || values == null) {
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
}
if (weights.length != values.length) {
throw new DimensionMismatchException(weights.length, values.length);
}
boolean containsPositiveWeight = false;
for (int i = begin; i < begin + length; i++) {
if (Double.isNaN(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.NAN_ELEMENT_AT_INDEX, i);
}
if (Double.isInfinite(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.INFINITE_ARRAY_ELEMENT, weights[i], i);
}
if (weights[i] < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.NEGATIVE_ELEMENT_AT_INDEX, i, weights[i]);
}
if (!containsPositiveWeight && weights[i] > 0.0) {
containsPositiveWeight = true;
}
}
if (!containsPositiveWeight) {
throw new MathIllegalArgumentException(LocalizedFormats.WEIGHT_AT_LEAST_ONE_NON_ZERO);
}
return test(values, begin, length, allowEmpty);
}
Example 3
| Source File: AbstractUnivariateStatistic.java From astor with GNU General Public License v2.0 | 5 votes |
|
/**
* This method is used by <code>evaluate(double[], double[], int, int)</code> methods
* to verify that the begin and length parameters designate a subarray of positive length
* and the weights are all non-negative, non-NaN, finite, and not all zero.
* <p>
* <ul>
* <li>returns <code>true</code> iff the parameters designate a subarray of
* non-negative length and the weights array contains legitimate values.</li>
* <li>throws <code>IllegalArgumentException</code> if any of the following are true:
* <ul><li>the values array is null</li>
* <li>the weights array is null</li>
* <li>the weights array does not have the same length as the values array</li>
* <li>the weights array contains one or more infinite values</li>
* <li>the weights array contains one or more NaN values</li>
* <li>the weights array contains negative values</li>
* <li>the start and length arguments do not determine a valid array</li></ul>
* </li>
* <li>returns <code>false</li> if the array is non-null, but
* <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
* </ul></p>
*
* @param values the input array.
* @param weights the weights array.
* @param begin index of the first array element to include.
* @param length the number of elements to include.
* @param allowEmpty if {@code true} than allow zero length arrays to pass.
* @return {@code true} if the parameters are valid.
* @throws IllegalArgumentException if the indices are invalid or the array
* is {@code null}.
* @since 3.0
*/
protected boolean test(final double[] values, final double[] weights, final int begin, final int length, final boolean allowEmpty){
if (weights == null) {
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
}
if (weights.length != values.length) {
throw new DimensionMismatchException(weights.length, values.length);
}
boolean containsPositiveWeight = false;
for (int i = begin; i < begin + length; i++) {
if (Double.isNaN(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.NAN_ELEMENT_AT_INDEX, i);
}
if (Double.isInfinite(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.INFINITE_ARRAY_ELEMENT, weights[i], i);
}
if (weights[i] < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.NEGATIVE_ELEMENT_AT_INDEX, i, weights[i]);
}
if (!containsPositiveWeight && weights[i] > 0.0) {
containsPositiveWeight = true;
}
}
if (!containsPositiveWeight) {
throw new MathIllegalArgumentException(LocalizedFormats.WEIGHT_AT_LEAST_ONE_NON_ZERO);
}
return test(values, begin, length, allowEmpty);
}
Example 4
| Source File: AbstractUnivariateStatistic.java From astor with GNU General Public License v2.0 | 5 votes |
|
/**
* This method is used by <code>evaluate(double[], double[], int, int)</code> methods
* to verify that the begin and length parameters designate a subarray of positive length
* and the weights are all non-negative, non-NaN, finite, and not all zero.
* <p>
* <ul>
* <li>returns <code>true</code> iff the parameters designate a subarray of
* non-negative length and the weights array contains legitimate values.</li>
* <li>throws <code>MathIllegalArgumentException</code> if any of the following are true:
* <ul><li>the values array is null</li>
* <li>the weights array is null</li>
* <li>the weights array does not have the same length as the values array</li>
* <li>the weights array contains one or more infinite values</li>
* <li>the weights array contains one or more NaN values</li>
* <li>the weights array contains negative values</li>
* <li>the start and length arguments do not determine a valid array</li></ul>
* </li>
* <li>returns <code>false</li> if the array is non-null, but
* <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
* </ul></p>
*
* @param values the input array.
* @param weights the weights array.
* @param begin index of the first array element to include.
* @param length the number of elements to include.
* @param allowEmpty if {@code true} than allow zero length arrays to pass.
* @return {@code true} if the parameters are valid.
* @throws NullArgumentException if either of the arrays are null
* @throws MathIllegalArgumentException if the array indices are not valid,
* the weights array contains NaN, infinite or negative elements, or there
* are no positive weights.
* @since 3.0
*/
protected boolean test(final double[] values, final double[] weights,
final int begin, final int length, final boolean allowEmpty) throws MathIllegalArgumentException {
if (weights == null || values == null) {
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
}
if (weights.length != values.length) {
throw new DimensionMismatchException(weights.length, values.length);
}
boolean containsPositiveWeight = false;
for (int i = begin; i < begin + length; i++) {
if (Double.isNaN(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.NAN_ELEMENT_AT_INDEX, i);
}
if (Double.isInfinite(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.INFINITE_ARRAY_ELEMENT, weights[i], i);
}
if (weights[i] < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.NEGATIVE_ELEMENT_AT_INDEX, i, weights[i]);
}
if (!containsPositiveWeight && weights[i] > 0.0) {
containsPositiveWeight = true;
}
}
if (!containsPositiveWeight) {
throw new MathIllegalArgumentException(LocalizedFormats.WEIGHT_AT_LEAST_ONE_NON_ZERO);
}
return test(values, begin, length, allowEmpty);
}
Example 5
| Source File: AbstractUnivariateStatistic.java From astor with GNU General Public License v2.0 | 5 votes |
|
/**
* This method is used by <code>evaluate(double[], double[], int, int)</code> methods
* to verify that the begin and length parameters designate a subarray of positive length
* and the weights are all non-negative, non-NaN, finite, and not all zero.
* <p>
* <ul>
* <li>returns <code>true</code> iff the parameters designate a subarray of
* non-negative length and the weights array contains legitimate values.</li>
* <li>throws <code>IllegalArgumentException</code> if any of the following are true:
* <ul><li>the values array is null</li>
* <li>the weights array is null</li>
* <li>the weights array does not have the same length as the values array</li>
* <li>the weights array contains one or more infinite values</li>
* <li>the weights array contains one or more NaN values</li>
* <li>the weights array contains negative values</li>
* <li>the start and length arguments do not determine a valid array</li></ul>
* </li>
* <li>returns <code>false</li> if the array is non-null, but
* <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
* </ul></p>
*
* @param values the input array.
* @param weights the weights array.
* @param begin index of the first array element to include.
* @param length the number of elements to include.
* @param allowEmpty if {@code true} than allow zero length arrays to pass.
* @return {@code true} if the parameters are valid.
* @throws IllegalArgumentException if the indices are invalid or the array
* is {@code null}.
* @since 3.0
*/
protected boolean test(final double[] values, final double[] weights, final int begin, final int length, final boolean allowEmpty){
if (weights == null) {
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
}
if (weights.length != values.length) {
throw new DimensionMismatchException(weights.length, values.length);
}
boolean containsPositiveWeight = false;
for (int i = begin; i < begin + length; i++) {
if (Double.isNaN(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.NAN_ELEMENT_AT_INDEX, i);
}
if (Double.isInfinite(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.INFINITE_ARRAY_ELEMENT, weights[i], i);
}
if (weights[i] < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.NEGATIVE_ELEMENT_AT_INDEX, i, weights[i]);
}
if (!containsPositiveWeight && weights[i] > 0.0) {
containsPositiveWeight = true;
}
}
if (!containsPositiveWeight) {
throw new MathIllegalArgumentException(LocalizedFormats.WEIGHT_AT_LEAST_ONE_NON_ZERO);
}
return test(values, begin, length, allowEmpty);
}
Example 6
| Source File: AbstractUnivariateStatistic.java From astor with GNU General Public License v2.0 | 5 votes |
|
/**
* This method is used by <code>evaluate(double[], double[], int, int)</code> methods
* to verify that the begin and length parameters designate a subarray of positive length
* and the weights are all non-negative, non-NaN, finite, and not all zero.
* <p>
* <ul>
* <li>returns <code>true</code> iff the parameters designate a subarray of
* non-negative length and the weights array contains legitimate values.</li>
* <li>throws <code>MathIllegalArgumentException</code> if any of the following are true:
* <ul><li>the values array is null</li>
* <li>the weights array is null</li>
* <li>the weights array does not have the same length as the values array</li>
* <li>the weights array contains one or more infinite values</li>
* <li>the weights array contains one or more NaN values</li>
* <li>the weights array contains negative values</li>
* <li>the start and length arguments do not determine a valid array</li></ul>
* </li>
* <li>returns <code>false</li> if the array is non-null, but
* <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
* </ul></p>
*
* @param values the input array.
* @param weights the weights array.
* @param begin index of the first array element to include.
* @param length the number of elements to include.
* @param allowEmpty if {@code true} than allow zero length arrays to pass.
* @return {@code true} if the parameters are valid.
* @throws NullArgumentException if either of the arrays are null
* @throws MathIllegalArgumentException if the array indices are not valid,
* the weights array contains NaN, infinite or negative elements, or there
* are no positive weights.
* @since 3.0
*/
protected boolean test(final double[] values, final double[] weights,
final int begin, final int length, final boolean allowEmpty) throws MathIllegalArgumentException {
if (weights == null || values == null) {
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
}
if (weights.length != values.length) {
throw new DimensionMismatchException(weights.length, values.length);
}
boolean containsPositiveWeight = false;
for (int i = begin; i < begin + length; i++) {
if (Double.isNaN(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.NAN_ELEMENT_AT_INDEX, i);
}
if (Double.isInfinite(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.INFINITE_ARRAY_ELEMENT, weights[i], i);
}
if (weights[i] < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.NEGATIVE_ELEMENT_AT_INDEX, i, weights[i]);
}
if (!containsPositiveWeight && weights[i] > 0.0) {
containsPositiveWeight = true;
}
}
if (!containsPositiveWeight) {
throw new MathIllegalArgumentException(LocalizedFormats.WEIGHT_AT_LEAST_ONE_NON_ZERO);
}
return test(values, begin, length, allowEmpty);
}
Example 7
| Source File: AbstractUnivariateStatistic.java From astor with GNU General Public License v2.0 | 5 votes |
|
/**
* This method is used by <code>evaluate(double[], double[], int, int)</code> methods
* to verify that the begin and length parameters designate a subarray of positive length
* and the weights are all non-negative, non-NaN, finite, and not all zero.
* <p>
* <ul>
* <li>returns <code>true</code> iff the parameters designate a subarray of
* non-negative length and the weights array contains legitimate values.</li>
* <li>throws <code>MathIllegalArgumentException</code> if any of the following are true:
* <ul><li>the values array is null</li>
* <li>the weights array is null</li>
* <li>the weights array does not have the same length as the values array</li>
* <li>the weights array contains one or more infinite values</li>
* <li>the weights array contains one or more NaN values</li>
* <li>the weights array contains negative values</li>
* <li>the start and length arguments do not determine a valid array</li></ul>
* </li>
* <li>returns <code>false</li> if the array is non-null, but
* <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
* </ul></p>
*
* @param values the input array.
* @param weights the weights array.
* @param begin index of the first array element to include.
* @param length the number of elements to include.
* @param allowEmpty if {@code true} than allow zero length arrays to pass.
* @return {@code true} if the parameters are valid.
* @throws NullArgumentException if either of the arrays are null
* @throws MathIllegalArgumentException if the array indices are not valid,
* the weights array contains NaN, infinite or negative elements, or there
* are no positive weights.
* @since 3.0
*/
protected boolean test(final double[] values, final double[] weights,
final int begin, final int length, final boolean allowEmpty) throws MathIllegalArgumentException {
if (weights == null || values == null) {
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
}
if (weights.length != values.length) {
throw new DimensionMismatchException(weights.length, values.length);
}
boolean containsPositiveWeight = false;
for (int i = begin; i < begin + length; i++) {
if (Double.isNaN(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.NAN_ELEMENT_AT_INDEX, i);
}
if (Double.isInfinite(weights[i])) {
throw new MathIllegalArgumentException(LocalizedFormats.INFINITE_ARRAY_ELEMENT, weights[i], i);
}
if (weights[i] < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.NEGATIVE_ELEMENT_AT_INDEX, i, weights[i]);
}
if (!containsPositiveWeight && weights[i] > 0.0) {
containsPositiveWeight = true;
}
}
if (!containsPositiveWeight) {
throw new MathIllegalArgumentException(LocalizedFormats.WEIGHT_AT_LEAST_ONE_NON_ZERO);
}
return test(values, begin, length, allowEmpty);
}
Example 8
| Source File: MathArrays.java From astor with GNU General Public License v2.0 | 5 votes |
|
/**
* This method is used
* to verify that the begin and length parameters designate a subarray of positive length
* and the weights are all non-negative, non-NaN, finite, and not all zero.
* <p>
* <ul>
* <li>returns <code>true</code> iff the parameters designate a subarray of
* non-negative length and the weights array contains legitimate values.</li>
* <li>throws <code>MathIllegalArgumentException</code> if any of the following are true:
* <ul><li>the values array is null</li>
* <li>the weights array is null</li>
* <li>the weights array does not have the same length as the values array</li>
* <li>the weights array contains one or more infinite values</li>
* <li>the weights array contains one or more NaN values</li>
* <li>the weights array contains negative values</li>
* <li>the start and length arguments do not determine a valid array</li></ul>
* </li>
* <li>returns <code>false</li> if the array is non-null, but
* <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
* </ul></p>
*
* @param values the input array.
* @param weights the weights array.
* @param begin index of the first array element to include.
* @param length the number of elements to include.
* @param allowEmpty if {@code true} than allow zero length arrays to pass.
* @return {@code true} if the parameters are valid.
* @throws NullArgumentException if either of the arrays are null
* @throws MathIllegalArgumentException if the array indices are not valid,
* the weights array contains NaN, infinite or negative elements, or there
* are no positive weights.
* @since 3.3
*/
public static boolean verifyValues(final double[] values, final double[] weights,
final int begin, final int length, final boolean allowEmpty) throws MathIllegalArgumentException {
if (weights == null || values == null) {
throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
}
if (weights.length != values.length) {
throw new DimensionMismatchException(weights.length, values.length);
}
boolean containsPositiveWeight = false;
for (int i = begin; i < begin + length; i++) {
final double weight = weights[i];
if (Double.isNaN(weight)) {
throw new MathIllegalArgumentException(LocalizedFormats.NAN_ELEMENT_AT_INDEX, Integer.valueOf(i));
}
if (Double.isInfinite(weight)) {
throw new MathIllegalArgumentException(LocalizedFormats.INFINITE_ARRAY_ELEMENT, Double.valueOf(weight), Integer.valueOf(i));
}
if (weight < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.NEGATIVE_ELEMENT_AT_INDEX, Integer.valueOf(i), Double.valueOf(weight));
}
if (!containsPositiveWeight && weight > 0.0) {
containsPositiveWeight = true;
}
}
if (!containsPositiveWeight) {
throw new MathIllegalArgumentException(LocalizedFormats.WEIGHT_AT_LEAST_ONE_NON_ZERO);
}
return verifyValues(values, begin, length, allowEmpty);
}
