ArrayUtils (h2o-core 3.42.0 API)

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 class ArrayUtils.CopyArrayToFrame

static class ArrayUtils.FrameToArray

Nested Classes
Modifier and Type	Class and Description
`static class`	`ArrayUtils.CopyArrayToFrame`
`static class`	`ArrayUtils.FrameToArray`

Constructor Summary

Constructors
Constructor and Description

ArrayUtils()

Constructors
Constructor and Description
`ArrayUtils()`

Method Summary

All Methods Static Methods Concrete 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)`
`static double[]`	`add(double[] a, double[] b, double[] c)`
`static float[][]`	`add(float[][] a, float[][] b)`
`static float[]`	`add(float[] a, float[] b)`
`static float[]`	`add(float ca, float[] a, float cb, float[] b)`
`static int[][]`	`add(int[][] a, int[][] 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 byte[]`	`append(byte[] a, byte... b)`
`static double[][]`	`append(double[][] a, double[][] b)`
`static double[]`	`append(double[] a, double b)`
`static double[]`	`append(double[] a, double[] b)`
`static int[]`	`append(int[] a, int b)`
`static int[]`	`append(int[] a, int[] b)`
`static long[]`	`append(long[] a, long[] b)`
`static java.lang.String[]`	`append(java.lang.String[] a, java.lang.String[] b)`
`static <T> T[]`	`append(T[] a, T... b)`
`static java.lang.String`	`arrayToString(int[] ary)`
`static double`	`avg(double[] nums)`
`static double`	`avg(long[] nums)`
`static java.lang.Character[]`	`box(char[] arr)` Convert an array of primitive types into an array of corresponding boxed types.
`static <T> T[]`	`cloneOrNull(T[] ary)`
`static byte[]`	`constAry(int len, byte b)`
`static double[]`	`constAry(int len, double c)`
`static boolean`	`contains(byte[] a, byte d)`
`static boolean`	`contains(int[] a, int d)`
`static <T> boolean`	`contains(T[] arr, T target)`
`static double[][]`	`convertTo2DMatrix(double[] x, int N)`
`static double[]`	`copyAndFillOf(double[] original, int newLength, double padding)`
`static int[]`	`copyAndFillOf(int[] original, int newLength, int padding)`
`static long[]`	`copyAndFillOf(long[] original, int newLength, long padding)`
`static <T> T[]`	`copyAndFillOf(T[] original, int newLength, T padding)`
`static double[]`	`copyFromIntArray(int[] a)`
`static int`	`countNonzeros(double[] beta)`
`static <K,V> int`	`crossProductSize(java.util.Map<K,V[]> hyperSpace)`
`static int[]`	`cumsum(int[] from)`
`static byte[]`	`decodeAsInt(int what, byte[] bs, int at)`
`static double[][]`	`deepClone(double[][] ary)`
`static <T extends Iced> T[]`	`deepClone(T[] ary)`
`static <T extends Iced> T[][]`	`deepClone(T[][] ary)`
`static double[]`	`diagArray(double[][] ary)`
`static int[]`	`difference(int[] a, int[] b)`
`static java.lang.String[]`	`difference(java.lang.String[] a, java.lang.String[] b)`
`static long[]`	`distinctLongs(int n, long bound, java.util.Random rng)` Generates a random array of n distinct non-negative long values.
`static double[][]`	`div(double[][] ds, double[] n)`
`static double[][]`	`div(double[][] ds, long[] n)`
`static double[]`	`div(double[] nums, double n)`
`static double[]`	`div(double[] ds, 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 int`	`encodeAsInt(byte[] b)`
`static int`	`encodeAsInt(byte[] bs, int at)`
`static long`	`encodeAsLong(byte[] b)`
`static long`	`encodeAsLong(byte[] b, int off, int len)`
`static boolean`	`equalsAny(long value, long... lhs)`
`static double[]`	`expandAndScatter(double[] ary, int N, int[] ids)`
`static double[][]`	`expandArray(double[][] ary, int newColNum)`
`static double[]`	`extractCol(int i, double[][] ary)`
`static int`	`find(int[] ls, int elem)`
`static int`	`find(long[] ls, long elem)`
`static <T> int`	`find(T[] ts, T elem)`
`static <T> int`	`find(T[] ts, T elem, int off)`
`static java.lang.String`	`findLongestCommonPrefix(java.lang.String[] inputArray)`
`static int`	`findWithPrefix(java.lang.String[] array, java.lang.String prefix)` Find an element with prefix with linear search & return it's index if find exactly, -index-2 if find first occurrence with prefix or -1
`static int`	`findWithPrefix(java.lang.String[] array, java.lang.String prefix, int off)` Find an element with prefix with linear search & return it's index if find exactly, -index-2 if find first occurrence with prefix or -1
`static <T> T[]`	`flat(T[][] arr)` Flatenize given array (skips null arrays) Example: [[1,2], null, [3,null], [4]] -> [1,2,3,null,4]
`static double[][]`	`formGram(double[][] x)`
`static double[][]`	`formGram(double[][] x, boolean transpose)` Given a n by k matrix X, form its Gram matrix
`static Frame`	`frame(double[]... rows)`
`static Frame`	`frame(Key<Frame> key, java.lang.String[] names, double[]... rows)` Create a new frame based on given row data.
`static Frame`	`frame(java.lang.String[] names, double[]... rows)`
`static Frame`	`frame(java.lang.String name, Vec vec)`
`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[]`	`gaussianVector(int n, java.util.Random random)` Make a new array initialized to random Gaussian N(0,1) values with the given seed.
`static double[]`	`gaussianVector(long seed, double[] vseed)` Remove the array allocation in this one
`static double[][]`	`generateLineSearchVecs(double[] srcVec, double[] gradient, int n, double step)`
`static boolean`	`hasNaNs(double[] ary)`
`static boolean`	`hasNaNsOrInfs(double[] ary)`
`static boolean`	`hasNaNsOrInfs(float[] ary)`
`static boolean`	`hasNzs(double[] x)`
`static double`	`innerProduct(double[] x, double[] y)`
`static double`	`innerProductPartial(double[] x, int[] x_index, double[] y)`
`static java.lang.String[]`	`insert(java.lang.String[] a, java.lang.String[] b, int pos)`
`static void`	`interpolateLinear(double[] array)`
`static java.lang.Double[]`	`interval(java.lang.Double start, java.lang.Double end, java.lang.Double step)`
`static java.lang.Float[]`	`interval(java.lang.Float start, java.lang.Float end, java.lang.Float step)`
`static java.lang.Integer[]`	`interval(java.lang.Integer start, java.lang.Integer end)`
`static java.lang.Integer[]`	`interval(java.lang.Integer start, java.lang.Integer end, java.lang.Integer step)`
`static double[]`	`invert(double[] ary)`
`static boolean`	`isInstance(java.lang.Object object, java.lang.Class[] comparedClasses)`
`static boolean`	`isInt(java.lang.String... ary)`
`static boolean`	`isSorted(double[] vals)`
`static boolean`	`isSorted(int[] vals)`
`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, double[][] y)`
`static double`	`l2norm(double[] x, boolean skipLast)`
`static double`	`l2norm(double[] x, double[] y)`
`static double`	`l2norm2(double[] x)`
`static double`	`l2norm2(double[][] xs, boolean skipLast)`
`static double`	`l2norm2(double[][] x, double[][] y)`
`static double`	`l2norm2(double[] x, boolean skipLast)`
`static double`	`l2norm2(double[] x, double[] y)`
`static double[]`	`limitToRange(double[] sortedSplitPoints, double min, double maxEx)`
`static int`	`linearSearch(double[] vals, double v)`
`static double`	`linfnorm(double[] x, boolean skipLast)`
`static int`	`locate(double[] arr, double val, double tol)` Return the index of an element val that is less than tol array from an element of the array arr.
`static double[]`	`makeUniqueAndLimitToRange(double[] splitPoints, double min, double maxEx)`
`static int`	`maxIndex(double[] from)`
`static int`	`maxIndex(double[] from, java.util.Random rand)`
`static int`	`maxIndex(float[] 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 int`	`maxIndex(long[] from, int off)`
`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 int`	`maxValue(int[] from)`
`static int`	`maxValue(java.lang.Integer[] from)`
`static long`	`maxValue(long[] from)`
`static int`	`minIndex(double[] from)`
`static int`	`minIndex(float[] from)`
`static int`	`minIndex(int[] from)`
`static double[]`	`minMaxValue(double[] from)` Find minimum and maximum in array in the same time
`static double`	`minValue(double[] from)`
`static double`	`minValue(double[] ary, int from, int to)`
`static float`	`minValue(float[] from)`
`static long`	`minValue(int[] from)`
`static long`	`minValue(long[] from)`
`static double[]`	`mmul(double[][] M, double[] V)`
`static double[][]`	`mult(double[][] ary, double n)`
`static double[][]`	`mult(double[][] ds, double[] n)`
`static double[]`	`mult(double[] nums, double n)`
`static double[]`	`mult(double[] nums, double[] nums2)`
`static float[]`	`mult(float[] nums, float n)`
`static double[][]`	`multArrArr(double[][] ary1, double[][] ary2)`
`static double[][]`	`multArrArr(double[][] ary1, double[][] ary2, double[][] res)`
`static double[]`	`multArrVec(double[][] ary, double[] nums)`
`static double[]`	`multArrVec(double[][] ary, double[] nums, double[] res)`
`static double[]`	`multArrVecPartial(double[][] ary, double[] nums, int[] numColInd)`
`static double[]`	`multVecArr(double[] nums, double[][] ary)`
`static int`	`numInts(java.lang.String... a)` Returns number of strings which represents a number.
`static int`	`occurrenceCount(byte[] array, byte element)` Count number of occurrences of element in given array.
`static boolean[]`	`or(boolean[] a, boolean[] b)`
`static double[][]`	`outerProduct(double[][] result, double[] x, double[] y)`
`static double[][]`	`outerProduct(double[] x, double[] y)`
`static double[]`	`padUniformly(double[] origPoints, int newLength)`
`static double[]`	`permute(double[] vec, int[] idx)`
`static double[][]`	`permuteCols(double[][] ary, int[] idx)`
`static double[][]`	`permuteRows(double[][] ary, 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 int[]`	`range(int start, int end)` Provide array from start to end in steps of 1
`static float[]`	`reduceMax(float[] a, float[] b)`
`static float[]`	`reduceMin(float[] a, float[] b)`
`static byte[]`	`remove(byte[] ary, int id)`
`static int[]`	`remove(int[] ary, int id)`
`static long[]`	`remove(long[] ary, int id)`
`static java.lang.String[]`	`remove(java.lang.String[] ary, java.lang.String s)`
`static <T> T[]`	`remove(T[] ary, int id)`
`static double[]`	`removeIds(double[] x, int[] ids)`
`static int[]`	`removeIds(int[] x, int[] ids)`
`static int[]`	`removeSorted(int[] a, int[] b)` Remove b from a, both a,b are assumed to be sorted.
`static double`	`rNorm(double[][] arr, char type)` Like the R norm for matrices, this function will calculate the maximum absolute col sum if type='o' or return the maximum absolute row sum otherwise
`static byte[]`	`select(byte[] array, int[] idxs)`
`static double[]`	`select(double[] ary, int[] idxs)`
`static int[]`	`select(int[] ary, int[] idxs)`
`static java.lang.String[]`	`select(java.lang.String[] ary, byte[] idxs)`
`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(int[] a, java.util.Random rng)`
`static void`	`sort(int[] idxs, double[] values)` Sort an integer array of indices based on values Updates indices in place, keeps values the same
`static void`	`sort(int[] idxs, double[] values, int cutoff)`
`static void`	`sort(int[] idxs, double[] values, int cutoff, int increasing)`
`static int[]`	`sorted_set_diff(int[] x, int[] y)`
`static double[]`	`sortedMerge(double[] a, double[] b)`
`static void`	`sortedMerge(int[] aIds, double[] aVals, int[] bIds, double[] bVals, int[] resIds, double[] resVals)`
`static int[]`	`sortedMerge(int[] a, int[] b)`
`static double[]`	`sqrtArr(double[] x)`
`static double`	`subAndMul(double[] data, double[] p, double[] n)`
`static byte[]`	`subarray(byte[] a, int off, int len)`
`static <T> T[]`	`subarray(T[] a, int off, int len)`
`static <T> T[][]`	`subarray2DLazy(T[][] a, int columnOffset, int len)`
`static double[][]`	`subtract(double[][] a, double[][] b)`
`static double[]`	`subtract(double[] a, double[] b)`
`static double[]`	`subtract(double[] a, double[] b, double[] c)`
`static int[]`	`subtract(int[] a, int[] b)`
`static long[]`	`subtract(long n, long[] nums)`
`static double`	`sum(double[] from)`
`static float`	`sum(float[] from)`
`static int`	`sum(int[] from)`
`static long`	`sum(long[] from)`
`static long`	`sum(long[] from, int startIdx, int endIdx)`
`static long`	`suml(int[] from)`
`static byte[]`	`toByteArray(int[] ary)`
`static byte[]`	`toByteArray(long... nums)` Transform given long numbers into byte array.
`static double[]`	`toDouble(float[] floats)`
`static double[]`	`toDouble(int[] ints)`
`static int[]`	`toInt(java.lang.Integer[] a, int off, int len)`
`static int[]`	`toInt(java.lang.String[] a, int off, int len)`
`static java.lang.Integer[]`	`toIntegers(int[] a, int off, int len)`
`static int[]`	`toPrimitive(java.util.ArrayList<java.lang.Integer> arr)` Convert an ArrayList of Integers to a primitive int[] array.
`static java.lang.String[]`	`toString(int[] dom)`
`static java.lang.String[]`	`toString(long[] dom)`
`static java.lang.String[]`	`toString(java.lang.Object[] ary)`
`static java.lang.String`	`toStringQuotedElements(java.lang.Object[] a)`
`static java.lang.String`	`toStringQuotedElements(java.lang.Object[] a, int maxItems)`
`static double[][]`	`transpose(double[][] ary)`
`static <T> T[][]`	`transpose(T[][] ary)`
`static double[][]`	`transposeTriangular(double[][] ary, boolean upperTriangular)` This function will perform transpose of triangular matrices only.
`static double[]`	`uniformDistFromArray(double[][] array, long seed)`
`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)`
`static double[]`	`wadd(double[] a, double[] b, double[] c, double w)`
`static java.lang.Object[][]`	`zip(java.lang.Object[] a, java.lang.Object[] b)`

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

cumsum

public static int[] cumsum(int[] from)

sum
```
public static long sum(long[] from)
```

sum

public static long sum(long[] from,
                       int startIdx,
                       int endIdx)

sum
```
public static int sum(int[] from)
```

suml
```
public static long suml(int[] from)
```

sum

public static float sum(float[] from)

sum

public static double sum(double[] from)

reduceMin

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

reduceMax

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

innerProduct

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

innerProductPartial

public static double innerProductPartial(double[] x,
                                         int[] x_index,
                                         double[] y)

mmul

public static double[] mmul(double[][] M,
                            double[] V)

outerProduct

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

outerProduct

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

sqrtArr

public static double[] sqrtArr(double[] x)

l2norm2

public static double l2norm2(double[] x)

l2norm2

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

l2norm2

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

l2norm2

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

l2norm2

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

l1norm

public static double l1norm(double[] x)

l1norm

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

rNorm
```
public static double rNorm(double[][] arr,
                           char type)
```
Like the R norm for matrices, this function will calculate the maximum absolute col sum if type='o' or return the maximum absolute row sum otherwise

Parameters:

arr -

type -

Returns:

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)

l2norm

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

l2norm

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

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 ca,
                          float[] a,
                          float cb,
                          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)

deepClone

public static <T extends Iced> T[][] deepClone(T[][] ary)

deepClone

public static <T extends Iced> T[] deepClone(T[] ary)

add

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

add

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

add

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

wadd

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

wadd

public static double[] wadd(double[] a,
                            double[] b,
                            double[] c,
                            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,
                             double[] n)

div

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

div

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

mult

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

mult

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

mult

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

mult

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

mult

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

subAndMul

public static double subAndMul(double[] data,
                               double[] p,
                               double[] n)

Parameters:: data - vector (1 x n); p - vector (1 x n); n - vector (1 x n)
Returns:: Result of matrix operation (data - p) * n

invert

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

multArrVec

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

multArrVecPartial

public static double[] multArrVecPartial(double[][] ary,
                                         double[] nums,
                                         int[] numColInd)

diagArray

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

locate
```
public static int locate(double[] arr,
                         double val,
                         double tol)
```
Return the index of an element val that is less than tol array from an element of the array arr. Note that arr does not need to be sorted.

Parameters:

arr: - double array possibly containing an element of interest.

val: - val to be found in array arr

tol: - maximum difference between value of interest val and an element of array

Returns:

the index of element that is within tol away from val or -1 if not found

multArrVec

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

multVecArr

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

multArrArr

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

multArrArr

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

transpose

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

expandArray

public static double[][] expandArray(double[][] ary,
                                     int newColNum)

transposeTriangular
```
public static double[][] transposeTriangular(double[][] ary,
                                             boolean upperTriangular)
```
This function will perform transpose of triangular matrices only. If the original matrix is lower triangular, the return matrix will be upper triangular and vice versa.

Parameters:

ary -

Returns:

cloneOrNull

public static <T> T[] cloneOrNull(T[] ary)

transpose

public static <T> T[][] transpose(T[][] ary)

range
```
public static int[] range(int start,
                          int end)
```
Provide array from start to end in steps of 1

Parameters:

start - beginning value (inclusive)

end - ending value (inclusive)

Returns:

specified range of integers

formGram
```
public static double[][] formGram(double[][] x,
                                  boolean transpose)
```
Given a n by k matrix X, form its Gram matrix

Parameters:

x - Matrix of real numbers

transpose - If true, compute n by n Gram of rows = XX' If false, compute k by k Gram of cols = X'X

Returns:

A symmetric positive semi-definite Gram matrix

formGram

public static double[][] formGram(double[][] x)

permute

public static double[] permute(double[] vec,
                               int[] idx)

permuteCols

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

permuteRows

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

generateLineSearchVecs

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

arrayToString

public static java.lang.String arrayToString(int[] ary)

toString

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

toString

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

toString

public static java.lang.String[] toString(java.lang.Object[] ary)

toStringQuotedElements

public static java.lang.String toStringQuotedElements(java.lang.Object[] a)

toStringQuotedElements

public static java.lang.String toStringQuotedElements(java.lang.Object[] a,
                                                      int maxItems)

contains

public static <T> boolean contains(T[] arr,
                                   T target)

contains

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

contains

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

subarray

public static byte[] subarray(byte[] a,
                              int off,
                              int len)

subarray

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

subarray2DLazy

public static <T> T[][] subarray2DLazy(T[][] a,
                                       int columnOffset,
                                       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(double[] from,
                           java.util.Random rand)

maxIndex

public static int maxIndex(int[] from)

maxIndex

public static int maxIndex(long[] from)

maxIndex

public static int maxIndex(long[] from,
                           int off)

maxIndex

public static int maxIndex(float[] from)

maxIndex

public static int maxIndex(double[] from)

minIndex

public static int minIndex(int[] from)

minIndex

public static int minIndex(float[] from)

minIndex

public static int minIndex(double[] 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[] ary,
                              int from,
                              int to)

minValue

public static double minValue(double[] from)

minMaxValue
```
public static double[] minMaxValue(double[] from)
```
Find minimum and maximum in array in the same time

Returns:

Array with 2 fields. First field is minimum and second field is maximum.

maxValue

public static long maxValue(long[] from)

maxValue

public static int maxValue(java.lang.Integer[] from)

maxValue

public static int maxValue(int[] from)

minValue

public static long minValue(long[] from)

minValue

public static long minValue(int[] from)

find

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

find

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

findWithPrefix
```
public static int findWithPrefix(java.lang.String[] array,
                                 java.lang.String prefix)
```
Find an element with prefix with linear search & return it's index if find exactly, -index-2 if find first occurrence with prefix or -1

findWithPrefix

public static int findWithPrefix(java.lang.String[] array,
                                 java.lang.String prefix,
                                 int off)

Find an element with prefix with linear search & return it's index if find exactly, -index-2 if find first occurrence with prefix or -1

find

public static int find(long[] ls,
                       long elem)

find

public static int find(int[] ls,
                       int elem)

linearSearch

public static int linearSearch(double[] vals,
                               double v)

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(int[] a,
                                java.util.Random rng)

distinctLongs
```
public static long[] distinctLongs(int n,
                                   long bound,
                                   java.util.Random rng)
```
Generates a random array of n distinct non-negative long values. Values are sorted for reproducibility.

Parameters:

n - desired size of the array

bound - (exclusive) upper bound of maximum long-value that can be included

rng - random generator

Returns:

long array of length n holding values [0, bound)

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)

gaussianVector
```
public static double[] gaussianVector(int n,
                                      java.util.Random random)
```
Make a new array initialized to random Gaussian N(0,1) values with the given seed.

Parameters:

n - length of generated vector

Returns:

array with gaussian values. Randomly selected zeroNum item values are zeros.

gaussianVector

public static double[] gaussianVector(long seed,
                                      double[] vseed)

Remove the array allocation in this one

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... ary)

toInt

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

toIntegers

public static java.lang.Integer[] toIntegers(int[] a,
                                             int off,
                                             int len)

toInt

public static int[] toInt(java.lang.Integer[] 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 // TODO: add tests

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 boolean hasNaNsOrInfs(double[] ary)

hasNaNs

public static boolean hasNaNs(double[] ary)

hasNaNsOrInfs

public static 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 byte[] append(byte[] a,
                            byte... b)

append

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

append

public static long[] append(long[] a,
                            long[] 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)

insert

public static java.lang.String[] insert(java.lang.String[] a,
                                        java.lang.String[] b,
                                        int pos)

append

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

append

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

append

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

prepend

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

copyAndFillOf

public static <T> T[] copyAndFillOf(T[] original,
                                    int newLength,
                                    T padding)

copyAndFillOf

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

copyAndFillOf

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

copyAndFillOf

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

copyFromIntArray

public static double[] copyFromIntArray(int[] a)

sortedMerge

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

sortedMerge

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

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)

select

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

select

public static double[] select(double[] ary,
                              int[] idxs)

select

public static int[] select(int[] ary,
                           int[] idxs)

select

public static byte[] select(byte[] array,
                            int[] idxs)

expandAndScatter

public static double[] expandAndScatter(double[] ary,
                                        int N,
                                        int[] ids)

sort
```
public static void sort(int[] idxs,
                        double[] values)
```
Sort an integer array of indices based on values Updates indices in place, keeps values the same

Parameters:

idxs - indices

values - values

sort

public static void sort(int[] idxs,
                        double[] values,
                        int cutoff)

sort

public static void sort(int[] idxs,
                        double[] values,
                        int cutoff,
                        int increasing)

subtract

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

subtract

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

subtract

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

subtract

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

flat
```
public static <T> T[] flat(T[][] arr)
```
Flatenize given array (skips null arrays) Example: [[1,2], null, [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

convertTo2DMatrix

public static double[][] convertTo2DMatrix(double[] x,
                                           int N)

zip

public static java.lang.Object[][] zip(java.lang.Object[] a,
                                       java.lang.Object[] b)

crossProductSize

public static <K,V> int crossProductSize(java.util.Map<K,V[]> hyperSpace)

interval

public static java.lang.Integer[] interval(java.lang.Integer start,
                                           java.lang.Integer end)

interval

public static java.lang.Integer[] interval(java.lang.Integer start,
                                           java.lang.Integer end,
                                           java.lang.Integer step)

interval

public static java.lang.Float[] interval(java.lang.Float start,
                                         java.lang.Float end,
                                         java.lang.Float step)

interval

public static java.lang.Double[] interval(java.lang.Double start,
                                          java.lang.Double end,
                                          java.lang.Double step)

remove

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

sorted_set_diff

public static int[] sorted_set_diff(int[] x,
                                    int[] y)

frame
```
public static Frame frame(Key<Frame> key,
                          java.lang.String[] names,
                          double[]... rows)
```
Create a new frame based on given row data.

Parameters:

key - Key for the frame

names - names of frame columns

rows - data given in the form of rows

Returns:

new frame which contains columns named according given names and including given data

frame

public static Frame frame(double[]... rows)

frame

public static Frame frame(java.lang.String[] names,
                          double[]... rows)

frame

public static Frame frame(java.lang.String name,
                          Vec vec)

removeSorted

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

Remove b from a, both a,b are assumed to be sorted.

removeIds

public static int[] removeIds(int[] x,
                              int[] ids)

removeIds

public static double[] removeIds(double[] x,
                                 int[] ids)

hasNzs

public static boolean hasNzs(double[] x)

countNonzeros

public static int countNonzeros(double[] beta)

subtract

public static long[] subtract(long n,
                              long[] nums)

remove

public static <T> T[] remove(T[] ary,
                             int id)

remove

public static byte[] remove(byte[] ary,
                            int id)

remove

public static int[] remove(int[] ary,
                           int id)

remove

public static long[] remove(long[] ary,
                            int id)

padUniformly

public static double[] padUniformly(double[] origPoints,
                                    int newLength)

makeUniqueAndLimitToRange

public static double[] makeUniqueAndLimitToRange(double[] splitPoints,
                                                 double min,
                                                 double maxEx)

limitToRange

public static double[] limitToRange(double[] sortedSplitPoints,
                                    double min,
                                    double maxEx)

extractCol

public static double[] extractCol(int i,
                                  double[][] ary)

encodeAsLong

public static long encodeAsLong(byte[] b)

encodeAsLong

public static long encodeAsLong(byte[] b,
                                int off,
                                int len)

encodeAsInt

public static int encodeAsInt(byte[] b)

encodeAsInt

public static int encodeAsInt(byte[] bs,
                              int at)

decodeAsInt

public static byte[] decodeAsInt(int what,
                                 byte[] bs,
                                 int at)

toByteArray
```
public static byte[] toByteArray(long... nums)
```
Transform given long numbers into byte array. Highest 8-bits of the first long will stored in the first field of returned byte array. Example: 0xff18000000000000L -> new byte[] { 0xff, 0x18, 0, 0, 0, 0, 0, 0}

toByteArray

public static byte[] toByteArray(int[] ary)

equalsAny

public static boolean equalsAny(long value,
                                long... lhs)

box
```
public static java.lang.Character[] box(char[] arr)
```
Convert an array of primitive types into an array of corresponding boxed types. Due to quirks of Java language this cannot be done in any generic way -- there should be a separate function for each use case...

Parameters:

arr - input array of `char`s

Returns:

output array of `Character`s

toPrimitive

public static int[] toPrimitive(java.util.ArrayList<java.lang.Integer> arr)

Convert an ArrayList of Integers to a primitive int[] array.

isSorted

public static boolean isSorted(int[] vals)

isSorted

public static boolean isSorted(double[] vals)

constAry

public static byte[] constAry(int len,
                              byte b)

constAry

public static double[] constAry(int len,
                                double c)

toDouble

public static double[] toDouble(float[] floats)

toDouble

public static double[] toDouble(int[] ints)

isInstance

public static boolean isInstance(java.lang.Object object,
                                 java.lang.Class[] comparedClasses)

occurrenceCount
```
public static int occurrenceCount(byte[] array,
                                  byte element)
```
Count number of occurrences of element in given array.

Parameters:

array - array in which number of occurrences should be counted.

element - element whose occurrences should be counted.

Returns:

number of occurrences of element in given array.

findLongestCommonPrefix

public static java.lang.String findLongestCommonPrefix(java.lang.String[] inputArray)

uniformDistFromArray
```
public static double[] uniformDistFromArray(double[][] array,
                                            long seed)
```
Returns:

Array dimension of array.length with values from uniform distribution with bounds taken from array. For example first value of the result is from Unif(First column min value, First column max value)

interpolateLinear

public static void interpolateLinear(double[] array)

Class ArrayUtils

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ArrayUtils

Method Detail

cumsum

sum

sum

sum

suml

sum

sum

reduceMin

reduceMax

innerProduct

innerProductPartial

mmul

outerProduct

outerProduct

sqrtArr

l2norm2

l2norm2

l2norm2

l2norm2

l2norm2

l1norm

l1norm

rNorm

linfnorm

l2norm

l2norm

l2norm

l2norm

add

add

add

add

add

add

add

add

add

or

deepClone

deepClone

deepClone

add

add

add

wadd

wadd

add

add

add

avg

avg

add

div

div

div

div

div

div

div

mult

mult

mult

mult

mult

subAndMul

invert

multArrVec

multArrVecPartial

diagArray

locate

multArrVec

multVecArr