ArrayUtils (h2o-core version 3.10.0.3 API)

java.lang.Object
- water.util.ArrayUtils

public class ArrayUtils
extends java.lang.Object

Constructor Summary

Constructors
Constructor and Description

ArrayUtils()

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)`
`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 byte[]`	`append(byte[] a, byte[] b)`
`static double[][]`	`append(double[][] a, double[][] b)`
`static double[]`	`append(double[] a, double[] b)`
`static int[]`	`append(int[] a, int 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 boolean`	`contains(int[] a, int d)`
`static boolean`	`contains(java.lang.String[] names, java.lang.String name)`
`static double[][]`	`convertTo2DMatrix(double[] x, int N)`
`static double[]`	`copyAndFillOf(double[] original, int newLength, double 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 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 int`	`encodeAsInt(byte[] b)`
`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[]`	`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 double[]`	`flat(double[][] arr)`
`static <T> T[]`	`flat(T[][] arr)` Flatenize given array.
`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 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)`
`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 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`	`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, 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 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, 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(int[] from)`
`static long`	`maxValue(long[] from)`
`static int`	`minIndex(double[] from)`
`static int`	`minIndex(float[] from)`
`static int`	`minIndex(int[] from)`
`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[] 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[]`	`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[]`	`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 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[]`	`select(double[] ary, int[] 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`	`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 double[]`	`subtract(double[] a, double[] b, double[] c)`
`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 byte[]`	`toByteArray(int[] ary)`
`static byte[]`	`toByteArray(long... nums)` Transform given long numbers into byte array.
`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 java.lang.String[]`	`toString(java.lang.Object[] ary)`
`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)`
`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

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)

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)

mmul

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

outerProduct

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

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)

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[][] 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)

add

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

mult

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

mult

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

mult

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

mult

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

invert

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

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)

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 (exclusive)

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)

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(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(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)

maxValue

public static long maxValue(long[] from)

maxValue

public static long 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)

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)

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)

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)

hasNaNs

public static final boolean hasNaNs(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 byte[] append(byte[] a,
            byte[] 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)

append

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

copyFromIntArray

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

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 double[] select(double[] ary,
              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)

subtract

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

subtract

public static double[] 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

convertTo2DMatrix

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

flat

public static double[] flat(double[][] arr)

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)

frame
```
public static Frame frame(Key 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)

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)

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)

Class ArrayUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ArrayUtils

Method Detail

sum

sum

sum

sum

reduceMin

reduceMax

innerProduct

mmul

outerProduct

l2norm2

l2norm2

l2norm2

l2norm2

l2norm2

l1norm

l1norm

linfnorm

l2norm

l2norm

l2norm

l2norm

add

add

add

add

add

add

add

add

or

deepClone

add

add

wadd

wadd

add

add

add

avg

avg

add

div

div

div

div

div

mult

mult

mult

mult

invert

multArrVec

multVecArr

multArrArr

transpose

range

formGram

formGram

permute

permuteCols

permuteRows

generateLineSearchVecs

arrayToString

toString

toString

toString

contains

contains

subarray

maxIndex

maxIndex

maxIndex

maxIndex