water.util

Class ArrayUtils

java.lang.Object

water.util.ArrayUtils

public class ArrayUtils
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	ArrayUtils.IntComparator

Constructor Summary

Constructors

Constructor and Description
ArrayUtils()

Method Summary

Methods

Modifier and Type	Method and Description
static byte[]	add(byte[] a, byte[] b)
static double[][][]	add(double[][][] a, double[][][] b)
static double[][]	add(double[][] a, double[][] b)
static double[]	add(double[] a, double[] b)
static double[]	add(double[] a, double[] b, double[] c)
static float[][]	add(float[][] a, float[][] b)
static float[]	add(float[] a, float[] b)
static int[][]	add(int[][] a, int[][] b)
static int[]	add(int[] a, int[] b)
static long[][][]	add(long[][][] a, long[][][] b)
static long[][]	add(long[][] a, long[][] b)
static long[]	add(long[] nums, long a)
static long[]	add(long[] a, long[] b)
static double[][]	append(double[][] a, double[][] b)
static double[]	append(double[] a, double[] b)
static java.lang.String[]	append(java.lang.String[] a, java.lang.String[] b)
static <T> T[]	append(T[] a, T... b)
static double	avg(double[] nums)
static double	avg(long[] nums)
static boolean	contains(int[] a, int d)
static boolean	contains(java.lang.String[] names, java.lang.String name)
static double[]	copyAndFillOf(double[] original, int newLength, double padding)
static long[]	copyAndFillOf(long[] original, int newLength, long padding)
static double[][]	deepClone(double[][] ary)
static int[]	difference(int[] a, int[] b)
static java.lang.String[]	difference(java.lang.String[] a, java.lang.String[] b)
static double[][]	div(double[][] ds, long[] n)
static double[]	div(double[] nums, double n)
static double[]	div(double[] ds, long[] n)
static float[]	div(float[] nums, float n)
static float[]	div(float[] nums, int n)
static java.lang.String[]	domainUnion(java.lang.String[] a, java.lang.String[] b) Clever union of String arrays.
static <T> int	find(T[] ts, T elem)
static <T> T[]	flat(T[][] arr) Flatenize given array.
static double[][]	gaussianArray(int n, int m)
static double[][]	gaussianArray(int n, int m, long seed)
static double[]	gaussianVector(int n)
static double[]	gaussianVector(int n, long seed)
static double[][]	generateLineSearchVecs(double[] srcVec, double[] gradient, int n, double step)
static boolean	hasNaNsOrInfs(double[] ary)
static boolean	hasNaNsOrInfs(float[] ary)
static double	innerProduct(double[] x, double[] y)
static boolean	isInt(java.lang.String s)
static float[]	join(float[] a, float[] b)
static long[]	join(long[] a, long[] b)
static <T> T[]	join(T[] a, T[] b)
static double	l1norm(double[] x)
static double	l1norm(double[] x, boolean skipLast)
static double	l2norm(double[] x)
static double	l2norm(double[] x, boolean skipLast)
static double	l2norm2(double[] x)
static double	l2norm2(double[] x, boolean skipLast)
static double	linfnorm(double[] x, boolean skipLast)
static int	maxIndex(double[] from)
static int	maxIndex(float[] from, java.util.Random rand)
static int	maxIndex(int[] from)
static int	maxIndex(int[] from, java.util.Random rand) Returns the index of the largest value in the array.
static int	maxIndex(long[] from)
static double	maxValue(double[] ary)
static double	maxValue(double[] ary, int from, int to)
static float	maxValue(float[] ary)
static float	maxValue(float[] ary, int from, int to)
static long	maxValue(long[] from)
static int	minIndex(float[] from)
static int	minIndex(int[] from)
static double	minValue(double[] from)
static float	minValue(float[] from)
static long	minValue(long[] from)
static double[]	mult(double[] nums, double n)
static float[]	mult(float[] nums, float n)
static double[][]	multArrArr(double[][] ary1, double[][] ary2)
static double[]	multArrVec(double[][] ary, double[] nums)
static double[]	multVecArr(double[] nums, double[][] ary)
static int	numInts(java.lang.String... a) Returns number of strings which represents a number.
static boolean[]	or(boolean[] a, boolean[] b)
static double[][]	outerProduct(double[] x, double[] y)
static double[][]	permuteCols(double[][] ary, int[] idx)
static java.lang.String[]	permuteCols(java.lang.String[] vec, int[] idx)
static java.lang.String	pprint(double[][] arr)
static java.lang.String	pprint(double[][] arr, java.text.DecimalFormat dformat)
static java.lang.String[]	prepend(java.lang.String[] ary, java.lang.String s)
static java.lang.String[]	select(java.lang.String[] ary, int[] idxs)
static int[]	seq(int start, int stop) Generates sequence (start, stop) of integers: (start, start+1, ...., stop-1)
static int[]	shuffleArray(int[] a, int n, int[] result, long seed, int startIndex) Extract a shuffled array of integers
static void	shuffleArray(long[] a, long seed)
static void	sort(int[] data, ArrayUtils.IntComparator comparator)
static void	sortedMerge(int[] aIds, double[] aVals, int[] bIds, double[] bVals, int[] resIds, double[] resVals)
static <T> T[]	subarray(T[] a, int off, int len)
static double[]	subtract(double[] a, double[] b)
static void	subtract(double[] a, double[] b, double[] c)
static double	sum(double[] from)
static float	sum(float[] from)
static int	sum(int[] from)
static long	sum(long[] from)
static int[]	toInt(java.lang.String[] a, int off, int len)
static java.lang.String[]	toString(int[] dom)
static java.lang.String[]	toString(long[] dom)
static double[][]	transpose(double[][] ary)
static int[]	union(int[] a, int[] b) Returns a union of given sorted arrays.
static java.lang.String[]	union(java.lang.String[] a, java.lang.String[] b, boolean lexo) Union of given String arrays.
static java.lang.String[]	union(java.lang.String[] a, java.lang.String[] b, int aoff, int alen, int boff, int blen, boolean lexo)
static int[]	unpackInts(long... longs)
static double[]	wadd(double[] a, double[] b, double w)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ArrayUtils

public ArrayUtils()

Method Detail

sum

public static long sum(long[] from)

sum

public static int sum(int[] from)

sum

public static float sum(float[] from)

sum

public static double sum(double[] from)

innerProduct

public static double innerProduct(double[] x,
                  double[] y)

outerProduct

public static double[][] outerProduct(double[] x,
                      double[] y)

l2norm2

public static double l2norm2(double[] x)

l2norm2

public static double l2norm2(double[] x,
             boolean skipLast)

l1norm

public static double l1norm(double[] x)

l1norm

public static double l1norm(double[] x,
            boolean skipLast)

linfnorm

public static double linfnorm(double[] x,
              boolean skipLast)

l2norm

public static double l2norm(double[] x)

l2norm

public static double l2norm(double[] x,
            boolean skipLast)

add

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

add

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

add

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

add

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

add

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

add

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

add

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

add

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

or

public static boolean[] or(boolean[] a,
           boolean[] b)

deepClone

public static double[][] deepClone(double[][] ary)

add

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

wadd

public static double[] wadd(double[] a,
            double[] b,
            double w)

add

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

add

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

add

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

avg

public static double avg(double[] nums)

avg

public static double avg(long[] nums)

add

public static long[] add(long[] nums,
         long a)

div

public static float[] div(float[] nums,
          int n)

div

public static float[] div(float[] nums,
          float n)

div

public static double[] div(double[] nums,
           double n)

div

public static double[][] div(double[][] ds,
             long[] n)

div

public static double[] div(double[] ds,
           long[] n)

mult

public static float[] mult(float[] nums,
           float n)

mult

public static double[] mult(double[] nums,
            double n)

multArrVec

public static double[] multArrVec(double[][] ary,
                  double[] nums)

multVecArr

public static double[] multVecArr(double[] nums,
                  double[][] ary)

multArrArr

public static double[][] multArrArr(double[][] ary1,
                    double[][] ary2)

transpose

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

permuteCols

public static java.lang.String[] permuteCols(java.lang.String[] vec,
                             int[] idx)

permuteCols

public static double[][] permuteCols(double[][] ary,
                     int[] idx)

generateLineSearchVecs

public static double[][] generateLineSearchVecs(double[] srcVec,
                                double[] gradient,
                                int n,
                                double step)

toString

public static java.lang.String[] toString(long[] dom)

toString

public static java.lang.String[] toString(int[] dom)

contains

public static boolean contains(java.lang.String[] names,
               java.lang.String name)

contains

public static boolean contains(int[] a,
               int d)

subarray

public static <T> T[] subarray(T[] a,
               int off,
               int len)

maxIndex

public static int maxIndex(int[] from,
           java.util.Random rand)

Returns the index of the largest value in the array. In case of a tie, an the index is selected randomly.

maxIndex

public static int maxIndex(float[] from,
           java.util.Random rand)

maxIndex

public static int maxIndex(int[] from)

maxIndex

public static int maxIndex(long[] from)

maxIndex

public static int maxIndex(double[] from)

minIndex

public static int minIndex(int[] from)

minIndex

public static int minIndex(float[] from)

maxValue

public static double maxValue(double[] ary)

maxValue

public static double maxValue(double[] ary,
              int from,
              int to)

maxValue

public static float maxValue(float[] ary)

maxValue

public static float maxValue(float[] ary,
             int from,
             int to)

minValue

public static float minValue(float[] from)

minValue

public static double minValue(double[] from)

maxValue

public static long maxValue(long[] from)

minValue

public static long minValue(long[] from)

find

public static <T> int find(T[] ts,
           T elem)

pprint

public static java.lang.String pprint(double[][] arr)

pprint

public static java.lang.String pprint(double[][] arr,
                      java.text.DecimalFormat dformat)

unpackInts

public static int[] unpackInts(long... longs)

shuffleArray

public static int[] shuffleArray(int[] a,
                 int n,
                 int[] result,
                 long seed,
                 int startIndex)

Extract a shuffled array of integers

Parameters:

a - input array

n - number of elements to extract

result - array to store the results into (will be of size n)

seed - random number seed

startIndex - offset into a

Returns:

result

shuffleArray

public static void shuffleArray(long[] a,
                long seed)

gaussianArray

public static double[][] gaussianArray(int n,
                       int m)

gaussianArray

public static double[][] gaussianArray(int n,
                       int m,
                       long seed)

gaussianVector

public static double[] gaussianVector(int n)

gaussianVector

public static double[] gaussianVector(int n,
                      long seed)

numInts

public static int numInts(java.lang.String... a)

Returns number of strings which represents a number.

isInt

public static boolean isInt(java.lang.String s)

toInt

public static int[] toInt(java.lang.String[] a,
          int off,
          int len)

domainUnion

public static java.lang.String[] domainUnion(java.lang.String[] a,
                             java.lang.String[] b)

Clever union of String arrays. For union of numeric arrays (strings represent integers) it is expecting numeric ordering. For pure string domains it is expecting lexicographical ordering. For mixed domains it always expects lexicographical ordering since such a domain were produce by a parser which sort string with Array.sort(). PRECONDITION - string domain was sorted by Array.sort(String[]), integer domain by Array.sort(int[]) and switched to Strings !!!

Parameters:

a - a set of strings

b - a set of strings

Returns:

union of arrays

union

public static java.lang.String[] union(java.lang.String[] a,
                       java.lang.String[] b,
                       boolean lexo)

Union of given String arrays. The method expects ordering of domains in given order (lexicographical, numeric)

Parameters:

a - first array

b - second array

lexo - - true if domains are sorted in lexicographical order or false for numeric domains

Returns:

union of values in given arrays. precondition lexo ? a,b are lexicographically sorted : a,b are sorted numerically precondition a!=null && b!=null

union

public static java.lang.String[] union(java.lang.String[] a,
                       java.lang.String[] b,
                       int aoff,
                       int alen,
                       int boff,
                       int blen,
                       boolean lexo)

union

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

Returns a union of given sorted arrays.

join

public static long[] join(long[] a,
          long[] b)

join

public static float[] join(float[] a,
           float[] b)

join

public static <T> T[] join(T[] a,
           T[] b)

hasNaNsOrInfs

public static final boolean hasNaNsOrInfs(double[] ary)

hasNaNsOrInfs

public static final boolean hasNaNsOrInfs(float[] ary)

seq

public static int[] seq(int start,
        int stop)

Generates sequence (start, stop) of integers: (start, start+1, ...., stop-1)

difference

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

difference

public static java.lang.String[] difference(java.lang.String[] a,
                            java.lang.String[] b)

append

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

append

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

append

public static java.lang.String[] append(java.lang.String[] a,
                        java.lang.String[] b)

append

public static <T> T[] append(T[] a,
             T... b)

prepend

public static java.lang.String[] prepend(java.lang.String[] ary,
                         java.lang.String s)

copyAndFillOf

public static double[] copyAndFillOf(double[] original,
                     int newLength,
                     double padding)

copyAndFillOf

public static long[] copyAndFillOf(long[] original,
                   int newLength,
                   long padding)

sortedMerge

public static void sortedMerge(int[] aIds,
               double[] aVals,
               int[] bIds,
               double[] bVals,
               int[] resIds,
               double[] resVals)

select

public static java.lang.String[] select(java.lang.String[] ary,
                        int[] idxs)

sort

public static void sort(int[] data,
        ArrayUtils.IntComparator comparator)

subtract

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

subtract

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

flat

public static <T> T[] flat(T[][] arr)

Flatenize given array. Example: [[1,2], [3,null], [4]] -> [1,2,3,null,4]

Type Parameters:

T - any type

Parameters:

arr - array of arrays

Returns:

flattened array, if input was null return null, if input was empty return null