MathArrays
org.apache.commons.math3.util

Class MathArrays



  • public class MathArraysextends Object
    Arrays utilities.
    • Nested Class Summary

      Nested Classes 
      Modifier and TypeClass and Description
      static interface MathArrays.Function
      Real-valued function that operate on an array or a part of it.
      static class MathArrays.OrderDirection
      Specification of ordering direction.
      static class MathArrays.Position
      Specification for indicating that some operation applies before or after a given index.
    • Method Summary

      Methods 
      Modifier and TypeMethod and Description
      static <T> T[]buildArray(Field<T> field, int length)
      Build an array of elements.
      static <T> T[][]buildArray(Field<T> field, int rows, int columns)
      Build a double dimension array of elements.
      static voidcheckNonNegative(long[] in)
      Check that all entries of the input array are >= 0.
      static voidcheckNonNegative(long[][] in)
      Check all entries of the input array are >= 0.
      static voidcheckOrder(double[] val)
      Check that the given array is sorted in strictly increasing order.
      static voidcheckOrder(double[] val, MathArrays.OrderDirection dir, boolean strict)
      Check that the given array is sorted.
      static booleancheckOrder(double[] val, MathArrays.OrderDirection dir, boolean strict, boolean abort)
      Check that the given array is sorted.
      static voidcheckPositive(double[] in)
      Check that all entries of the input array are strictly positive.
      static voidcheckRectangular(long[][] in)
      Throws DimensionMismatchException if the input array is not rectangular.
      static double[]convolve(double[] x, double[] h)
      Calculates the convolution between two sequences.
      static double[]copyOf(double[] source)
      Creates a copy of the source array.
      static double[]copyOf(double[] source, int len)
      Creates a copy of the source array.
      static int[]copyOf(int[] source)
      Creates a copy of the source array.
      static int[]copyOf(int[] source, int len)
      Creates a copy of the source array.
      static doubledistance(double[] p1, double[] p2)
      Calculates the L2 (Euclidean) distance between two points.
      static doubledistance(int[] p1, int[] p2)
      Calculates the L2 (Euclidean) distance between two points.
      static doubledistance1(double[] p1, double[] p2)
      Calculates the L1 (sum of abs) distance between two points.
      static intdistance1(int[] p1, int[] p2)
      Calculates the L1 (sum of abs) distance between two points.
      static doubledistanceInf(double[] p1, double[] p2)
      Calculates the L (max of abs) distance between two points.
      static intdistanceInf(int[] p1, int[] p2)
      Calculates the L (max of abs) distance between two points.
      static double[]ebeAdd(double[] a, double[] b)
      Creates an array whose contents will be the element-by-element addition of the arguments.
      static double[]ebeDivide(double[] a, double[] b)
      Creates an array whose contents will be the element-by-element division of the first argument by the second.
      static double[]ebeMultiply(double[] a, double[] b)
      Creates an array whose contents will be the element-by-element multiplication of the arguments.
      static double[]ebeSubtract(double[] a, double[] b)
      Creates an array whose contents will be the element-by-element subtraction of the second argument from the first.
      static booleanequals(double[] x, double[] y)
      Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by Precision.equals(double,double).
      static booleanequals(float[] x, float[] y)
      Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by Precision.equals(float,float).
      static booleanequalsIncludingNaN(double[] x, double[] y)
      Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by this method.
      static booleanequalsIncludingNaN(float[] x, float[] y)
      Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by this method.
      static booleanisMonotonic(double[] val, MathArrays.OrderDirection dir, boolean strict)
      Check that an array is monotonically increasing or decreasing.
      static <T extends Comparable<? super T>> 
      boolean
      isMonotonic(T[] val, MathArrays.OrderDirection dir, boolean strict)
      Check that an array is monotonically increasing or decreasing.
      static doublelinearCombination(double[] a, double[] b)
      Compute a linear combination accurately.
      static doublelinearCombination(double a1, double b1, double a2, double b2)
      Compute a linear combination accurately.
      static doublelinearCombination(double a1, double b1, double a2, double b2, double a3, double b3)
      Compute a linear combination accurately.
      static doublelinearCombination(double a1, double b1, double a2, double b2, double a3, double b3, double a4, double b4)
      Compute a linear combination accurately.
      static int[]natural(int n)
      Returns an array representing the natural number n.
      static double[]normalizeArray(double[] values, double normalizedSum)
      Normalizes an array to make it sum to a specified value.
      static doublesafeNorm(double[] v)
      Returns the Cartesian norm (2-norm), handling both overflow and underflow.
      static double[]scale(double val, double[] arr)
      Create a copy of an array scaled by a value.
      static voidscaleInPlace(double val, double[] arr)
      Multiply each element of an array by a value.
      static voidshuffle(int[] list)
      Shuffle the entries of the given array.
      static voidshuffle(int[] list, int start, MathArrays.Position pos)
      Shuffle the entries of the given array.
      static voidshuffle(int[] list, int start, MathArrays.Position pos, RandomGenerator rng)
      Shuffle the entries of the given array, using the Fisher\xe2\x80\x93Yates algorithm.
      static voidshuffle(int[] list, RandomGenerator rng)
      Shuffle the entries of the given array.
      static voidsortInPlace(double[] x, double[]... yList)
      Sort an array in ascending order in place and perform the same reordering of entries on other arrays.
      static voidsortInPlace(double[] x, MathArrays.OrderDirection dir, double[]... yList)
      Sort an array in place and perform the same reordering of entries on other arrays.
      static booleanverifyValues(double[] values, double[] weights, int begin, int length)
      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.
      static booleanverifyValues(double[] values, double[] weights, int begin, int length, boolean allowEmpty)
      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.
      static booleanverifyValues(double[] values, int begin, int length)
      This method is used to verify that the input parameters designate a subarray of positive length.
      static booleanverifyValues(double[] values, int begin, int length, boolean allowEmpty)
      This method is used to verify that the input parameters designate a subarray of positive length.
    • Method Detail

      • scale

        public static double[] scale(double val,             double[] arr)
        Create a copy of an array scaled by a value.
        Parameters:
        arr - Array to scale.
        val - Scalar.
        Returns:
        scaled copy of array with each entry multiplied by val.
      • scaleInPlace

        public static void scaleInPlace(double val,                double[] arr)

        Multiply each element of an array by a value.

        The array is modified in place (no copy is created).

        Parameters:
        arr - Array to scale
        val - Scalar
      • ebeAdd

        public static double[] ebeAdd(double[] a,              double[] b)                       throws DimensionMismatchException
        Creates an array whose contents will be the element-by-element addition of the arguments.
        Parameters:
        a - First term of the addition.
        b - Second term of the addition.
        Returns:
        a new array r where r[i] = a[i] + b[i].
        Throws:
        DimensionMismatchException - if the array lengths differ.
      • ebeSubtract

        public static double[] ebeSubtract(double[] a,                   double[] b)                            throws DimensionMismatchException
        Creates an array whose contents will be the element-by-element subtraction of the second argument from the first.
        Parameters:
        a - First term.
        b - Element to be subtracted.
        Returns:
        a new array r where r[i] = a[i] - b[i].
        Throws:
        DimensionMismatchException - if the array lengths differ.
      • ebeMultiply

        public static double[] ebeMultiply(double[] a,                   double[] b)                            throws DimensionMismatchException
        Creates an array whose contents will be the element-by-element multiplication of the arguments.
        Parameters:
        a - First factor of the multiplication.
        b - Second factor of the multiplication.
        Returns:
        a new array r where r[i] = a[i] * b[i].
        Throws:
        DimensionMismatchException - if the array lengths differ.
      • ebeDivide

        public static double[] ebeDivide(double[] a,                 double[] b)                          throws DimensionMismatchException
        Creates an array whose contents will be the element-by-element division of the first argument by the second.
        Parameters:
        a - Numerator of the division.
        b - Denominator of the division.
        Returns:
        a new array r where r[i] = a[i] / b[i].
        Throws:
        DimensionMismatchException - if the array lengths differ.
      • distance1

        public static double distance1(double[] p1,               double[] p2)
        Calculates the L1 (sum of abs) distance between two points.
        Parameters:
        p1 - the first point
        p2 - the second point
        Returns:
        the L1 distance between the two points
      • distance1

        public static int distance1(int[] p1,            int[] p2)
        Calculates the L1 (sum of abs) distance between two points.
        Parameters:
        p1 - the first point
        p2 - the second point
        Returns:
        the L1 distance between the two points
      • distance

        public static double distance(double[] p1,              double[] p2)
        Calculates the L2 (Euclidean) distance between two points.
        Parameters:
        p1 - the first point
        p2 - the second point
        Returns:
        the L2 distance between the two points
      • distance

        public static double distance(int[] p1,              int[] p2)
        Calculates the L2 (Euclidean) distance between two points.
        Parameters:
        p1 - the first point
        p2 - the second point
        Returns:
        the L2 distance between the two points
      • distanceInf

        public static double distanceInf(double[] p1,                 double[] p2)
        Calculates the L (max of abs) distance between two points.
        Parameters:
        p1 - the first point
        p2 - the second point
        Returns:
        the L distance between the two points
      • distanceInf

        public static int distanceInf(int[] p1,              int[] p2)
        Calculates the L (max of abs) distance between two points.
        Parameters:
        p1 - the first point
        p2 - the second point
        Returns:
        the L distance between the two points
      • isMonotonic

        public static <T extends Comparable<? super T>> boolean isMonotonic(T[] val,                                                    MathArrays.OrderDirection dir,                                                    boolean strict)
        Check that an array is monotonically increasing or decreasing.
        Type Parameters:
        T - the type of the elements in the specified array
        Parameters:
        val - Values.
        dir - Ordering direction.
        strict - Whether the order should be strict.
        Returns:
        true if sorted, false otherwise.
      • isMonotonic

        public static boolean isMonotonic(double[] val,                  MathArrays.OrderDirection dir,                  boolean strict)
        Check that an array is monotonically increasing or decreasing.
        Parameters:
        val - Values.
        dir - Ordering direction.
        strict - Whether the order should be strict.
        Returns:
        true if sorted, false otherwise.
      • checkOrder

        public static boolean checkOrder(double[] val,                 MathArrays.OrderDirection dir,                 boolean strict,                 boolean abort)                          throws NonMonotonicSequenceException
        Check that the given array is sorted.
        Parameters:
        val - Values.
        dir - Ordering direction.
        strict - Whether the order should be strict.
        abort - Whether to throw an exception if the check fails.
        Returns:
        true if the array is sorted.
        Throws:
        NonMonotonicSequenceException - if the array is not sorted and abort is true.
      • checkPositive

        public static void checkPositive(double[] in)                          throws NotStrictlyPositiveException
        Check that all entries of the input array are strictly positive.
        Parameters:
        in - Array to be tested
        Throws:
        NotStrictlyPositiveException - if any entries of the array are not strictly positive.
      • checkNonNegative

        public static void checkNonNegative(long[] in)                             throws NotPositiveException
        Check that all entries of the input array are >= 0.
        Parameters:
        in - Array to be tested
        Throws:
        NotPositiveException - if any array entries are less than 0.
      • checkNonNegative

        public static void checkNonNegative(long[][] in)                             throws NotPositiveException
        Check all entries of the input array are >= 0.
        Parameters:
        in - Array to be tested
        Throws:
        NotPositiveException - if any array entries are less than 0.
      • safeNorm

        public static double safeNorm(double[] v)
        Returns the Cartesian norm (2-norm), handling both overflow and underflow. Translation of the minpack enorm subroutine. The redistribution policy for MINPACK is available here, for convenience, it is reproduced below.

        Minpack Copyright Notice (1999) University of Chicago. All rights reserved
        Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
        1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
        2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
        3. The end-user documentation included with the redistribution, if any, must include the following acknowledgment: This product includes software developed by the University of Chicago, as Operator of Argonne National Laboratory. Alternately, this acknowledgment may appear in the software itself, if and wherever such third-party acknowledgments normally appear.
        4. WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS" WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4) DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL BE CORRECTED.
        5. LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT, INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT (INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE, EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE POSSIBILITY OF SUCH LOSS OR DAMAGES.
          Parameters:
          v - Vector of doubles.
          Returns:
          the 2-norm of the vector.
        • sortInPlace

          public static void sortInPlace(double[] x,               double[]... yList)                        throws DimensionMismatchException,                               NullArgumentException
          Sort an array in ascending order in place and perform the same reordering of entries on other arrays. For example, if x = [3, 1, 2], y = [1, 2, 3] and z = [0, 5, 7], then sortInPlace(x, y, z) will update x to [1, 2, 3], y to [2, 3, 1] and z to [5, 7, 0].
          Parameters:
          x - Array to be sorted and used as a pattern for permutation of the other arrays.
          yList - Set of arrays whose permutations of entries will follow those performed on x.
          Throws:
          DimensionMismatchException - if any y is not the same size as x.
          NullArgumentException - if x or any y is null.
        • sortInPlace

          public static void sortInPlace(double[] x,               MathArrays.OrderDirection dir,               double[]... yList)                        throws NullArgumentException,                               DimensionMismatchException
          Sort an array in place and perform the same reordering of entries on other arrays. This method works the same as the other sortInPlace method, but allows the order of the sort to be provided in the dir parameter.
          Parameters:
          x - Array to be sorted and used as a pattern for permutation of the other arrays.
          dir - Order direction.
          yList - Set of arrays whose permutations of entries will follow those performed on x.
          Throws:
          DimensionMismatchException - if any y is not the same size as x.
          NullArgumentException - if x or any y is null
        • copyOf

          public static int[] copyOf(int[] source)
          Creates a copy of the source array.
          Parameters:
          source - Array to be copied.
          Returns:
          the copied array.
        • copyOf

          public static double[] copyOf(double[] source)
          Creates a copy of the source array.
          Parameters:
          source - Array to be copied.
          Returns:
          the copied array.
        • copyOf

          public static int[] copyOf(int[] source,           int len)
          Creates a copy of the source array.
          Parameters:
          source - Array to be copied.
          len - Number of entries to copy. If smaller then the source length, the copy will be truncated, if larger it will padded with zeroes.
          Returns:
          the copied array.
        • copyOf

          public static double[] copyOf(double[] source,              int len)
          Creates a copy of the source array.
          Parameters:
          source - Array to be copied.
          len - Number of entries to copy. If smaller then the source length, the copy will be truncated, if larger it will padded with zeroes.
          Returns:
          the copied array.
        • linearCombination

          public static double linearCombination(double[] a,                       double[] b)                                throws DimensionMismatchException
          Compute a linear combination accurately. This method computes the sum of the products ai bi to high accuracy. It does so by using specific multiplication and addition algorithms to preserve accuracy and reduce cancellation effects.
          It is based on the 2005 paper Accurate Sum and Dot Product by Takeshi Ogita, Siegfried M. Rump, and Shin\'ichi Oishi published in SIAM J. Sci. Comput.
          Parameters:
          a - Factors.
          b - Factors.
          Returns:
          Σi ai bi.
          Throws:
          DimensionMismatchException - if arrays dimensions don\'t match
        • linearCombination

          public static double linearCombination(double a1,                       double b1,                       double a2,                       double b2,                       double a3,                       double b3)
          Compute a linear combination accurately.

          This method computes a1×b1 + a2×b2 + a3×b3 to high accuracy. It does so by using specific multiplication and addition algorithms to preserve accuracy and reduce cancellation effects. It is based on the 2005 paper Accurate Sum and Dot Product by Takeshi Ogita, Siegfried M. Rump, and Shin\'ichi Oishi published in SIAM J. Sci. Comput.

          Parameters:
          a1 - first factor of the first term
          b1 - second factor of the first term
          a2 - first factor of the second term
          b2 - second factor of the second term
          a3 - first factor of the third term
          b3 - second factor of the third term
          Returns:
          a1×b1 + a2×b2 + a3×b3
          See Also:
          linearCombination(double, double, double, double), linearCombination(double, double, double, double, double, double, double, double)
        • linearCombination

          public static double linearCombination(double a1,                       double b1,                       double a2,                       double b2,                       double a3,                       double b3,                       double a4,                       double b4)
          Compute a linear combination accurately.

          This method computes a1×b1 + a2×b2 + a3×b3 + a4×b4 to high accuracy. It does so by using specific multiplication and addition algorithms to preserve accuracy and reduce cancellation effects. It is based on the 2005 paper Accurate Sum and Dot Product by Takeshi Ogita, Siegfried M. Rump, and Shin\'ichi Oishi published in SIAM J. Sci. Comput.

          Parameters:
          a1 - first factor of the first term
          b1 - second factor of the first term
          a2 - first factor of the second term
          b2 - second factor of the second term
          a3 - first factor of the third term
          b3 - second factor of the third term
          a4 - first factor of the third term
          b4 - second factor of the third term
          Returns:
          a1×b1 + a2×b2 + a3×b3 + a4×b4
          See Also:
          linearCombination(double, double, double, double), linearCombination(double, double, double, double, double, double)
        • equals

          public static boolean equals(float[] x,             float[] y)
          Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by Precision.equals(float,float).
          Parameters:
          x - first array
          y - second array
          Returns:
          true if the values are both null or have same dimension and equal elements.
        • equalsIncludingNaN

          public static boolean equalsIncludingNaN(float[] x,                         float[] y)
          Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by this method.
          Parameters:
          x - first array
          y - second array
          Returns:
          true if the values are both null or have same dimension and equal elements
        • equals

          public static boolean equals(double[] x,             double[] y)
          Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by Precision.equals(double,double).
          Parameters:
          x - First array.
          y - Second array.
          Returns:
          true if the values are both null or have same dimension and equal elements.
        • equalsIncludingNaN

          public static boolean equalsIncludingNaN(double[] x,                         double[] y)
          Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by this method.
          Parameters:
          x - First array.
          y - Second array.
          Returns:
          true if the values are both null or have same dimension and equal elements.
        • normalizeArray

          public static double[] normalizeArray(double[] values,                      double normalizedSum)                               throws MathIllegalArgumentException,                                      MathArithmeticException
          Normalizes an array to make it sum to a specified value. Returns the result of the transformation
              x |-> x * normalizedSum / sum 
          applied to each non-NaN element x of the input array, where sum is the sum of the non-NaN entries in the input array.

          Throws IllegalArgumentException if normalizedSum is infinite or NaN and ArithmeticException if the input array contains any infinite elements or sums to 0.

          Ignores (i.e., copies unchanged to the output array) NaNs in the input array.

          Parameters:
          values - Input array to be normalized
          normalizedSum - Target sum for the normalized array
          Returns:
          the normalized array.
          Throws:
          MathArithmeticException - if the input array contains infinite elements or sums to zero.
          MathIllegalArgumentException - if the target sum is infinite or NaN.
        • buildArray

          public static <T> T[] buildArray(Field<T> field,                 int length)
          Build an array of elements.

          Arrays are filled with field.getZero()

          Type Parameters:
          T - the type of the field elements
          Parameters:
          field - field to which array elements belong
          length - of the array
          Returns:
          a new array
        • buildArray

          public static <T> T[][] buildArray(Field<T> field,                   int rows,                   int columns)
          Build a double dimension array of elements.

          Arrays are filled with field.getZero()

          Type Parameters:
          T - the type of the field elements
          Parameters:
          field - field to which array elements belong
          rows - number of rows in the array
          columns - number of columns (may be negative to build partial arrays in the same way new Field[rows][] works)
          Returns:
          a new array
        • convolve

          public static double[] convolve(double[] x,                double[] h)                         throws NullArgumentException,                                NoDataException
          Calculates the convolution between two sequences.

          The solution is obtained via straightforward computation of the convolution sum (and not via FFT). Whenever the computation needs an element that would be located at an index outside the input arrays, the value is assumed to be zero.

          Parameters:
          x - First sequence. Typically, this sequence will represent an input signal to a system.
          h - Second sequence. Typically, this sequence will represent the impulse response of the system.
          Returns:
          the convolution of x and h. This array\'s length will be x.length + h.length - 1.
          Throws:
          NullArgumentException - if either x or h is null.
          NoDataException - if either x or h is empty.
        • shuffle

          public static void shuffle(int[] list,           int start,           MathArrays.Position pos)
          Shuffle the entries of the given array. The start and pos parameters select which portion of the array is randomized and which is left untouched.
          Parameters:
          list - Array whose entries will be shuffled (in-place).
          start - Index at which shuffling begins.
          pos - Shuffling is performed for index positions between start and either the end (if MathArrays.Position.TAIL) or the beginning (if MathArrays.Position.HEAD) of the array.
          See Also:
          shuffle(int[],int,Position,RandomGenerator)
        • shuffle

          public static void shuffle(int[] list,           int start,           MathArrays.Position pos,           RandomGenerator rng)
          Shuffle the entries of the given array, using the Fisher\xe2\x80\x93Yates algorithm. The start and pos parameters select which portion of the array is randomized and which is left untouched.
          Parameters:
          list - Array whose entries will be shuffled (in-place).
          start - Index at which shuffling begins.
          pos - Shuffling is performed for index positions between start and either the end (if MathArrays.Position.TAIL) or the beginning (if MathArrays.Position.HEAD) of the array.
          rng - Random number generator.
        • natural

          public static int[] natural(int n)
          Returns an array representing the natural number n.
          Parameters:
          n - Natural number.
          Returns:
          an array whose entries are the numbers 0, 1, ..., n-1. If n == 0, the returned array is empty.
        • verifyValues

          public static boolean verifyValues(double[] values,                   int begin,                   int length)                            throws MathIllegalArgumentException
          This method is used to verify that the input parameters designate a subarray of positive length.

          • returns true iff the parameters designate a subarray of positive length
          • throws MathIllegalArgumentException if the array is null or or the indices are invalid
          • returns false
          • if the array is non-null, but length is 0.

          Parameters:
          values - the input array
          begin - index of the first array element to include
          length - the number of elements to include
          Returns:
          true if the parameters are valid and designate a subarray of positive length
          Throws:
          MathIllegalArgumentException - if the indices are invalid or the array is null
        • verifyValues

          public static boolean verifyValues(double[] values,                   int begin,                   int length,                   boolean allowEmpty)                            throws MathIllegalArgumentException
          This method is used to verify that the input parameters designate a subarray of positive length.

          • returns true iff the parameters designate a subarray of non-negative length
          • throws IllegalArgumentException if the array is null or or the indices are invalid
          • returns false
          • if the array is non-null, but length is 0 unless allowEmpty is true

          Parameters:
          values - the input array
          begin - index of the first array element to include
          length - the number of elements to include
          allowEmpty - if true then zero length arrays are allowed
          Returns:
          true if the parameters are valid
          Throws:
          MathIllegalArgumentException - if the indices are invalid or the array is null
        • verifyValues

          public static boolean verifyValues(double[] values,                   double[] weights,                   int begin,                   int length)                            throws MathIllegalArgumentException
          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.

          • returns true iff the parameters designate a subarray of positive length and the weights array contains legitimate values.
          • throws IllegalArgumentException if any of the following are true:
            • the values array is null
            • the weights array is null
            • the weights array does not have the same length as the values array
            • the weights array contains one or more infinite values
            • the weights array contains one or more NaN values
            • the weights array contains negative values
            • the start and length arguments do not determine a valid array
          • returns false
          • if the array is non-null, but length is 0.

          Parameters:
          values - the input array
          weights - the weights array
          begin - index of the first array element to include
          length - the number of elements to include
          Returns:
          true if the parameters are valid and designate a subarray of positive length
          Throws:
          MathIllegalArgumentException - if the indices are invalid or the array is null
        • verifyValues

          public static boolean verifyValues(double[] values,                   double[] weights,                   int begin,                   int length,                   boolean allowEmpty)                            throws MathIllegalArgumentException
          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.

          • returns true iff the parameters designate a subarray of non-negative length and the weights array contains legitimate values.
          • throws MathIllegalArgumentException if any of the following are true:
            • the values array is null
            • the weights array is null
            • the weights array does not have the same length as the values array
            • the weights array contains one or more infinite values
            • the weights array contains one or more NaN values
            • the weights array contains negative values
            • the start and length arguments do not determine a valid array
          • returns false
          • if the array is non-null, but length is 0 unless allowEmpty is true.

          Parameters:
          values - the input array.
          weights - the weights array.
          begin - index of the first array element to include.
          length - the number of elements to include.
          allowEmpty - if true than allow zero length arrays to pass.
          Returns:
          true if the parameters are valid.
          Throws:
          NullArgumentException - if either of the arrays are null
          MathIllegalArgumentException - if the array indices are not valid, the weights array contains NaN, infinite or negative elements, or there are no positive weights.

    SCaVis 2.2 © jWork.ORG