    All Packages  Class Hierarchy  This Package  Previous  Next  Index

# Class JSci.maths.ArrayMath

    java.lang.Object
       |
       +----JSci.maths.AbstractMath
               |
               +----JSci.maths.ArrayMath

public final class ArrayMath
extends AbstractMath

Arrays are faster than object so this class is there to take full advantage of arrays without encapsulation. All methods here are safe, that is, they create copies of arrays whenever necessary. This makes for slower methods, but the programmer can always define his own methods optimized for performance.

##

abs(double[])
  Takes the absolute value of each component of an array
abs(double[][])
  Takes the absolute value of each component of an array.
abs(int[])
  Takes the absolute value of each component of an array
abs(int[][])
  Takes the absolute value of each component of an array
add(double[], double)
  add a scalar to every element in the array
add(double[], double, double[], int)
  add to an array w, a time v where a is a scalar...
add(double[], double[])
  Add the two arrays together (componentwise)
add(int[], double, int[], int)
  add to an array w, a time v where a is a scalar...
add(int[], int)
  add a scalar to every element in the array
add(int[], int[])
  Add the two arrays together (componentwise)
apply(Mapping, Complex[])
  apply a map to every component of an array.
apply(Mapping, Complex[][])
  apply a map to every component of an array.
apply(Mapping, double[])
  apply a map to every component of an array.
apply(Mapping, double[][])
  apply a map to every component of an array.
copy(double[])
  Return a copy of the array
copy(double[][])
  Return a copy of the array
copy(int[])
  Return a copy of the array
copy(int[][])
  Return a copy of the array
correlation(double[], double[])
  Compute the (linear) correlation between two arrays.
correlation(int[], int[])
  Compute the (linear) correlation between two arrays.
covariance(double[], double[])
  Compute the covariance.
covariance(int[], int[])
  Compute the covariance.
equals(double[], double[])
  Check if two arrays are equal with a tolerance.
equals(int[], int[])
  Check if two arrays are equal
extract(int, int, double[])
  Extract a sub-array (will invert the resulting array if k0 > k1).
extract(int, int, int[])
  Extract a sub-array (will invert the resulting array if k0 > k1).
invert(double[])
  Invert an array from left to right
invert(int[])
  Invert an array from left to right
mass(double[])
  Return the sum of the elements of the array
mass(int[])
  Return the sum of the elements of the array
max(double[])
  Return the maximum of an array.
max(double[][])
  Return the maximum of an array.
max(int[])
  Return the maximum of an array
max(int[][])
  Return the maximum of an array
mean(double[])
  Compute the mean.
mean(int[])
  Compute the mean
median(double[])
  Compute the median of an array.
median(int[])
  Compute the median of an array
min(double[])
  Return the minimum of an array.
min(double[][])
  Return the minimum of an array.
min(int[])
  Return the minimum of an array
min(int[][])
  Return the minimum of an array
mod(Complex[])
  Return the componentwise modulus of an array of Complex numbers.
mod(Complex[][])
  Return the componentwise modulus of an array of Complex numbers.
norm(double[])
  Compute the L2 norm of an array (Euclidean norm or "length")
norm(int[])
  Compute the L2 norm of an array (Euclidean norm or "length")
normalize(double[])
  Renormalize the array so that its L2 norm is 1 (up to computational errors)
padding(int, int, double[])
  fills in with zero to get to the desired length; original array with be at the specified position
padding(int, int, int[])
  fills in with zeroes to get to the specified length; original array with be at the specified position
percentile(double[], double)
  Gives the percentile of an array
percentile(int[], double)
  Gives the percentile of an array
print(double[])
  Print to screen an array.
print(double[][])
  Print to screen an array.
print(int[])
  Print to screen an array.
print(int[][])
  Print to screen an array.
range(double)
  Generate an array going for 0 to b with steps of size 1.
range(double, double)
  Generate an array going for a to b inclusively with steps of size 1.
range(double, double, double)
  Generate an array going for a to b with steps of size step.
range(int)
  Generate an array going for 0 to b with steps of size 1.
range(int, int)
  Generate an array going for a to b with steps of size 1.
range(int, int, int)
  Generate an array going for a to b with steps of size step.
scalarMultiply(double, double[])
  multiply every component of an array by a scalar
scalarMultiply(double, int[])
  multiply every component of an array by a scalar
scalarMultiplyFast(double, double[])
  Fast scalar multiplication for sparse arrays.
scalarMultiplyFast(double, int[])
  Fast scalar multiplication for sparse arrays
scalarProduct(double[], double[])
  Compute the scalar product of two array as if they were vectors
scalarProduct(double[][], double[][])
  Compute the scalar product of two array as if they were matrices
scalarProduct(int[], int[])
  Compute the scalar product of two array as if they were vectors
scalarProduct(int[][], int[][])
  Compute the scalar product of two array as if they were matrices
setLengthFromBeginning(double[], int)
  Set an array to the specified length scraping or padding the end if necessary
setLengthFromBeginning(int[], int)
  Set an array to the specified length scraping or padding the end if necessary
setLengthFromEnd(double[], int)
  Set an array to the specified length scraping or padding the beginning if necessary
setLengthFromEnd(int[], int)
  Set an array to the specified length scraping or padding the beginning if necessary
sortMaxToMin(double[])
  Return a sorted array from the maximum to the minimum value.
sortMaxToMin(int[])
  return a sorted array from the maximum to the minimum value.
sortMinToMax(double[])
  Return a sorted array from the minimum to the maximum value.
sortMinToMax(int[])
  return a sorted array from the minimum to the maximum value.
standardDeviation(double[])
  Compute the standard deviation of an array.
standardDeviation(int[])
  Return the standard deviation of an array
subtract(double[], double[])
  Subtract the two arrays together (componentwise)
subtract(int[], int[])
  Subtract the two arrays together (componentwise)
sumSquares(double[])
  Sum the squares of all components; also called the energy of the array.
sumSquares(double[][])
  Sum the squares of all components; also called the energy of the array.
sumSquares(int[])
  Sum the squares of all components; also called the energy of the array
sumSquares(int[][])
  Sum the squares of all components; also called the energy of the array
toString(double[])
  Returns a comma delimited string representing the value of the array.
toString(double[][])
  Returns a comma delimited string representing the value of the array.
toString(int[])
  Returns a comma delimited string representing the value of the array.
toString(int[][])
  Returns a comma delimited string representing the value of the array.
transpose(double[][])
  Takes the transpose of an array (like the matrix operation)
transpose(int[][])
  Takes the transpose of an array (like the matrix operation)
variance(double[])
  Compute the variance.
variance(int[])
  Compute the variance.

##

apply

     public static double[] apply(Mapping m,
                                  double v[])

  apply a map to every component of an array.

apply

     public static double[][] apply(Mapping m,
                                    double v[][])

  apply a map to every component of an array.

apply

     public static Complex[] apply(Mapping m,
                                   Complex v[])

  apply a map to every component of an array.

apply

     public static Complex[][] apply(Mapping m,
                                     Complex v[][])

  apply a map to every component of an array.

normalize

     public static double[] normalize(double v[])

  Renormalize the array so that its L2 norm is 1 (up to computational errors)

setLengthFromEnd

     public static double[] setLengthFromEnd(double data[],
                                             int length)

  Set an array to the specified length scraping or padding the beginning if necessary

setLengthFromBeginning

     public static double[] setLengthFromBeginning(double data[],
                                                   int length)

  Set an array to the specified length scraping or padding the end if necessary

copy

     public static double[] copy(double v[])

  Return a copy of the array

copy

     public static double[][] copy(double v[][])

  Return a copy of the array

variance

     public static double variance(double v[])

  Compute the variance.

covariance

     public static double covariance(double v1[],
                                     double v2[])

  Compute the covariance.

correlation

     public static double correlation(double v1[],
                                      double v2[])

  Compute the (linear) correlation between two arrays. Squaring this result and multiply by 100 gives you the percentage of correlation.

mean

     public static double mean(double v[])

  Compute the mean.

standardDeviation

     public static double standardDeviation(double v[])

  Compute the standard deviation of an array.

sortMinToMax

     public static double[] sortMinToMax(double v[])

  Return a sorted array from the minimum to the maximum value.

sortMaxToMin

     public static double[] sortMaxToMin(double v[])

  Return a sorted array from the maximum to the minimum value.

percentile

     public static double percentile(double v[],
                                     double p)

  Gives the percentile of an array

  Parameters:
    p - percentile, must be between 0 and 1.
  Throws: IllegalArgumentException
    if parameter p is not between 0 and 1

median

     public static double median(double v[])

  Compute the median of an array.

equals

     public static boolean equals(double a[],
                                  double b[])

  Check if two arrays are equal with a tolerance.

abs

     public static double[] abs(double v[])

  Takes the absolute value of each component of an array

abs

     public static double[][] abs(double v[][])

  Takes the absolute value of each component of an array.

max

     public static double max(double v[])

  Return the maximum of an array.

max

     public static double max(double v[][])

  Return the maximum of an array.

min

     public static double min(double v[])

  Return the minimum of an array.

min

     public static double min(double v[][])

  Return the minimum of an array.

mod

     public static double[] mod(Complex v[])

  Return the componentwise modulus of an array of Complex numbers.

mod

     public static double[][] mod(Complex v[][])

  Return the componentwise modulus of an array of Complex numbers.

norm

     public static double norm(double data[])

  Compute the L2 norm of an array (Euclidean norm or "length")

sumSquares

     public static double sumSquares(double data[])

  Sum the squares of all components; also called the energy of the array.

sumSquares

     public static double sumSquares(double data[][])

  Sum the squares of all components; also called the energy of the array.

scalarProduct

     public static double scalarProduct(double w0[],
                                        double w1[])

  Compute the scalar product of two array as if they were vectors

  Throws: IllegalArgumentException
    if the don't have the same length

scalarProduct

     public static double scalarProduct(double w0[][],
                                        double w1[][])

  Compute the scalar product of two array as if they were matrices

  Throws: IllegalArgumentException
    if the don't have the same length

extract

     public static double[] extract(int k0,
                                    int k1,
                                    double invect[])

  Extract a sub-array (will invert the resulting array if k0 > k1).

  Parameters:
    k0 - location of the first component
    k1 - location of the last component

invert

     public static double[] invert(double v[])

  Invert an array from left to right

padding

     public static double[] padding(int n0,
                                    int pos,
                                    double v[])

  fills in with zero to get to the desired length; original array with be at the specified position

  Parameters:
    n0 - length of the new array
    pos - position of the old array

add

     public static double[] add(double w[],
                                double a,
                                double v[],
                                int p)

  add to an array w, a time v where a is a scalar... since v can be smaller then w, we must specified the position at which v will be added.

  Parameters:
    a - scalar
    p - position

add

     public static double[] add(double w[],
                                double a)

  add a scalar to every element in the array

transpose

     public static double[][] transpose(double M[][])

  Takes the transpose of an array (like the matrix operation)

  Throws: IllegalArgumentException
    if the array is not a matrix

range

     public static double[] range(double a,
                                  double b,
                                  double step)

  Generate an array going for a to b with steps of size step. If it can't get to the value b in a finite number of steps, it gets as close as possible (a can be larger or smaller than b)

  Parameters:
    step - size of steps, must be positive
    a - first value of array
    b - last value of array
  Throws: IllegalArgumentException
    if step is negative or if a=b.

range

     public static double[] range(double a,
                                  double b)

  Generate an array going for a to b inclusively with steps of size 1. a can be smaller or larger than b.

range

     public static double[] range(double b)

  Generate an array going for 0 to b with steps of size 1. 0 can be smaller or larger than b.

add

     public static double[] add(double a[],
                                double b[])

  Add the two arrays together (componentwise)

  Throws: IllegalArgumentException
    if the two arrays don't have the same length

subtract

     public static double[] subtract(double a[],
                                     double b[])

  Subtract the two arrays together (componentwise)

  Throws: IllegalArgumentException
    if the two arrays don't have the same length

scalarMultiply

     public static double[] scalarMultiply(double a,
                                           double v[])

  multiply every component of an array by a scalar

toString

     public static String toString(double array[])

  Returns a comma delimited string representing the value of the array.

toString

     public static String toString(double array[][])

  Returns a comma delimited string representing the value of the array.

mass

     public static double mass(double v[])

  Return the sum of the elements of the array

scalarMultiplyFast

     public static double[] scalarMultiplyFast(double a,
                                               double v[])

  Fast scalar multiplication for sparse arrays.

print

     public static void print(double v[])

  Print to screen an array.

print

     public static void print(double v[][])

  Print to screen an array.

setLengthFromEnd

     public static int[] setLengthFromEnd(int data[],
                                          int length)

  Set an array to the specified length scraping or padding the beginning if necessary

setLengthFromBeginning

     public static int[] setLengthFromBeginning(int data[],
                                                int length)

  Set an array to the specified length scraping or padding the end if necessary

copy

     public static int[] copy(int v[])

  Return a copy of the array

copy

     public static int[][] copy(int v[][])

  Return a copy of the array

variance

     public static double variance(int v[])

  Compute the variance.

covariance

     public static double covariance(int v1[],
                                     int v2[])

  Compute the covariance.

correlation

     public static double correlation(int v1[],
                                      int v2[])

  Compute the (linear) correlation between two arrays. Squaring this result and multiply by 100 gives you the percentage of correlation.

mean

     public static double mean(int v[])

  Compute the mean

standardDeviation

     public static double standardDeviation(int v[])

  Return the standard deviation of an array

sortMinToMax

     public static int[] sortMinToMax(int v[])

  return a sorted array from the minimum to the maximum value.

sortMaxToMin

     public static int[] sortMaxToMin(int v[])

  return a sorted array from the maximum to the minimum value.

toString

     public static String toString(int array[])

  Returns a comma delimited string representing the value of the array.

toString

     public static String toString(int array[][])

  Returns a comma delimited string representing the value of the array.

percentile

     public static double percentile(int v[],
                                     double p)

  Gives the percentile of an array

  Parameters:
    p - percentile, must be between 0 and 1.
  Throws: IllegalArgumentException
    if parameter p is not between 0 and 1

median

     public static double median(int v[])

  Compute the median of an array

equals

     public static boolean equals(int a[],
                                  int b[])

  Check if two arrays are equal

abs

     public static int[] abs(int v[])

  Takes the absolute value of each component of an array

abs

     public static int[][] abs(int v[][])

  Takes the absolute value of each component of an array

max

     public static int max(int v[])

  Return the maximum of an array

max

     public static int max(int v[][])

  Return the maximum of an array

min

     public static int min(int v[])

  Return the minimum of an array

min

     public static int min(int v[][])

  Return the minimum of an array

norm

     public static double norm(int data[])

  Compute the L2 norm of an array (Euclidean norm or "length")

sumSquares

     public static int sumSquares(int data[])

  Sum the squares of all components; also called the energy of the array

sumSquares

     public static int sumSquares(int data[][])

  Sum the squares of all components; also called the energy of the array

scalarProduct

     public static int scalarProduct(int w0[],
                                     int w1[])

  Compute the scalar product of two array as if they were vectors

  Throws: IllegalArgumentException
    if the don't have the same length

scalarProduct

     public static double scalarProduct(int w0[][],
                                        int w1[][])

  Compute the scalar product of two array as if they were matrices

  Throws: IllegalArgumentException
    if the don't have the same length

extract

     public static int[] extract(int k0,
                                 int k1,
                                 int invect[])

  Extract a sub-array (will invert the resulting array if k0 > k1).

  Parameters:
    k0 - location of the first component
    k1 - location of the last component

invert

     public static int[] invert(int v[])

  Invert an array from left to right

padding

     public static int[] padding(int n0,
                                 int pos,
                                 int v[])

  fills in with zeroes to get to the specified length; original array with be at the specified position

  Parameters:
    n0 - length of the new array
    pos - position of the old array

add

     public static int[] add(int w[],
                             double a,
                             int v[],
                             int p)

  add to an array w, a time v where a is a scalar... since v can be smaller then w, we must specified the position at which v will be added.

  Parameters:
    a - scalar
    p - position
    w - longer array
    v - shorter array
  Throws: IllegalArgumentException
    if the second array is not shorter than the first one

add

     public static int[] add(int w[],
                             int a)

  add a scalar to every element in the array

range

     public static int[] range(int a,
                               int b)

  Generate an array going for a to b with steps of size 1. a can be smaller or larger than b.

range

     public static int[] range(int b)

  Generate an array going for 0 to b with steps of size 1. 0 can be smaller or larger than b.

range

     public static int[] range(int a,
                               int b,
                               int step)

  Generate an array going for a to b with steps of size step. If it can't get to the value b in a finite number of steps, it gets as close as possible (a can be larger or smaller than b)

  Parameters:
    step - size of steps, must be positive
    a - first value of array
    b - last value of array
  Throws: IllegalArgumentException
    if step is negative or if a=b.

transpose

     public static int[][] transpose(int M[][])

  Takes the transpose of an array (like the matrix operation)

  Throws: IllegalArgumentException
    if the array is not a matrix

add

     public static int[] add(int a[],
                             int b[])

  Add the two arrays together (componentwise)

  Throws: IllegalArgumentException
    if the two arrays don't have the same length

subtract

     public static int[] subtract(int a[],
                                  int b[])

  Subtract the two arrays together (componentwise)

  Throws: IllegalArgumentException
    if the two arrays don't have the same length

mass

     public static int mass(int v[])

  Return the sum of the elements of the array

scalarMultiply

     public static double[] scalarMultiply(double a,
                                           int v[])

  multiply every component of an array by a scalar

scalarMultiplyFast

     public static double[] scalarMultiplyFast(double a,
                                               int v[])

  Fast scalar multiplication for sparse arrays

print

     public static void print(int v[])

  Print to screen an array.

print

     public static void print(int v[][])

  Print to screen an array.

    All Packages  Class Hierarchy  This Package  Previous  Next  Index