mikera.vectorz.util

Class DoubleArrays

java.lang.Object

mikera.vectorz.util.DoubleArrays

public final class DoubleArrays
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
static double[]	EMPTY

Constructor Summary

Constructors

Constructor and Description
DoubleArrays()

Method Summary

Modifier and Type	Method and Description
static void	abs(double[] data)
static void	abs(double[] data, int offset, int length)
static void	add(double[] data, double value)
static void	add(double[] dest, double[] src)
static void	add(double[] src, int srcOffset, double[] dest, int destOffset, int length)
static void	add(double[] data, int offset, int length, double value)
static void	add(double[] src, int srcOffset, int srcStride, double[] dest, int destOffset, int length)
static void	add2(double[] dest, double[] aData, double[] bData)
static void	add2(double[] dest, int destOffset, double[] aData, int aOffset, double[] bData, int bOffset, int len) Simultaneously adds two arrays to a target array
static void	addMultiple(double[] dest, double[] src, double factor)
static void	addMultiple(double[] dest, double[] src, int srcOffset, double factor)
static void	addMultiple(double[] dest, int offset, double[] src, int srcOffset, int length, double factor)
static void	addMultiple(double[] dest, int destOffset, double[] src, int srcOffset, int srcStride, int length, double factor)
static void	addProduct(double[] dest, int offset, double[] src1, int src1Offset, double[] src2, int src2Offset, int length, double factor)
static void	addResult(double[] dest, double[] as, double[] bs) Performs addition of two double arrays and stores the result in the destination array
static void	arraydivide(double[] src, int srcOffset, double[] dest, int destOffset, int length)
static void	arraymultiply(double[] src, int srcOffset, double[] dest, int destOffset, int length)
static void	clamp(double[] data, double min, double max)
static void	clamp(double[] data, int offset, int length, double min, double max)
static void	copy(double[] src, int srcOffset, int srcStride, double[] dest, int destOffset, int length)
static double[]	copyOf(double[] data) Fast double array copy operation.
static double[]	copyOf(double[] data, int start, int length)
static double[]	createStorage(int rowCount, int columnCount) Creates a storage double[] array for a matrix of the specifid shape
static double[]	createStorageArray(int... shape) Creates a double[] storage array of the specified shape
static void	divide(double[] data, int offset, int length, double value)
static double	dotProduct(double[] a, int aOffset, double[] b, int bOffset, int length)
static double	dotProduct(double[] a, int aOffset, double[] b, int bOffset, int bStride, int length) Compute a dot product between array data and strided array data.
static double	dotProduct(double[] a, int aOffset, int aStride, double[] b, int bOffset, int bStride, int length) Compute a dot product between two sets of strided array data.
static double	elementAbsPowSum(double[] data, int offset, int length, double exponent)
static double	elementMax(double[] data)
static double	elementMax(double[] data, int offset, int length)
static double	elementMaxAbs(double[] data)
static double	elementMaxAbs(double[] data, int offset, int length)
static int	elementMaxAbsIndex(double[] data, int offset, int length)
static int	elementMaxIndex(double[] data, int offset, int length)
static double	elementMin(double[] data)
static double	elementMin(double[] data, int offset, int length)
static int	elementMinIndex(double[] data, int offset, int length)
static double	elementPowSum(double[] data, int offset, int length, double exponent)
static double	elementProduct(double[] data, int offset, int length)
static boolean	elementsEqual(double[] data, int offset, int length, double value)
static double	elementSquaredSum(double[] data)
static double	elementSquaredSum(double[] data, int offset, int length)
static double	elementSquaredSum(double[] data, int offset, int length, int stride)
static double	elementSum(double[] data)
static double	elementSum(double[] data, int offset, int length)
static double	elementSum(double[] data, int offset, int stride, int length)
static boolean	equals(double[] as, double[] bs)
static boolean	equals(double[] as, double[] bs, int length)
static boolean	equals(double[] as, int aOffset, double[] bs, int bOffset, int length)
static void	exp(double[] data)
static void	exp(double[] data, int offset, int length)
static double[]	insert(double[] data, int position, double value)
static boolean	isBoolean(double[] data)
static boolean	isBoolean(double[] data, int offset, int length)
static boolean	isZero(double[] data)
static boolean	isZero(double[] data, int offset, int length)
static boolean	isZero(double[] data, int offset, int length, int stride)
static void	log(double[] data)
static void	log(double[] data, int offset, int length)
static void	logistic(double[] ds)
static void	logistic(double[] ds, int offset, int length)
static void	multiply(double[] data, double value)
static void	multiply(double[] dest, double[] src)
static void	multiply(double[] data, int offset, int length, double value)
static double[]	multiplyCopy(double[] src, double factor)
static void	negate(double[] data)
static void	negate(double[] data, int offset, int length)
static int	nonZeroCount(double[] data)
static int	nonZeroCount(double[] data, int offset, int length)
static int[]	nonZeroIndices(double[] data, int offset, int length) Finds the non-zero indices as offsets within a range of a double array
static void	pow(double[] data, double exponent)
static void	pow(double[] data, int offset, int length, double exponent)
static void	reciprocal(double[] data)
static void	reciprocal(double[] data, int offset, int length)
static double	reduce(Op2 op, double[] data, int offset, int length)
static double	reduce(Op2 op, double[] data, int offset, int length, int stride)
static void	scaleAdd(double[] data, double factor, double constant)
static void	scaleAdd(double[] data, int offset, int length, double factor, double constant)
static void	scaleCopy(double[] dest, double[] src, double factor)
static void	signum(double[] ds)
static void	signum(double[] ds, int offset, int length)
static void	sqrt(double[] data, int offset, int length)
static void	square(double[] ds)
static void	square(double[] ds, int offset, int length)
static void	sub(double[] data, double value)
static void	sub(double[] data, int offset, int length, double value)
static void	tanh(double[] ds)
static void	tanh(double[] ds, int offset, int length)

Methods inherited from class java.lang.Object

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

Field Detail

EMPTY

public static final double[] EMPTY

Constructor Detail

DoubleArrays

public DoubleArrays()

Method Detail

elementSum

public static final double elementSum(double[] data)

elementSum

public static final double elementSum(double[] data,
                                      int offset,
                                      int length)

elementSum

public static final double elementSum(double[] data,
                                      int offset,
                                      int stride,
                                      int length)

elementProduct

public static final double elementProduct(double[] data,
                                          int offset,
                                          int length)

elementMin

public static final double elementMin(double[] data,
                                      int offset,
                                      int length)

elementMax

public static final double elementMax(double[] data,
                                      int offset,
                                      int length)

elementMaxAbs

public static double elementMaxAbs(double[] data,
                                   int offset,
                                   int length)

elementMin

public static final double elementMin(double[] data)

elementMax

public static final double elementMax(double[] data)

elementMaxAbs

public static final double elementMaxAbs(double[] data)

elementMaxIndex

public static int elementMaxIndex(double[] data,
                                  int offset,
                                  int length)

elementMinIndex

public static int elementMinIndex(double[] data,
                                  int offset,
                                  int length)

elementMaxAbsIndex

public static int elementMaxAbsIndex(double[] data,
                                     int offset,
                                     int length)

elementSquaredSum

public static double elementSquaredSum(double[] data)

elementSquaredSum

public static double elementSquaredSum(double[] data,
                                       int offset,
                                       int length)

elementSquaredSum

public static double elementSquaredSum(double[] data,
                                       int offset,
                                       int length,
                                       int stride)

elementPowSum

public static double elementPowSum(double[] data,
                                   int offset,
                                   int length,
                                   double exponent)

elementAbsPowSum

public static double elementAbsPowSum(double[] data,
                                      int offset,
                                      int length,
                                      double exponent)

nonZeroCount

public static int nonZeroCount(double[] data)

nonZeroCount

public static int nonZeroCount(double[] data,
                               int offset,
                               int length)

multiply

public static void multiply(double[] data,
                            int offset,
                            int length,
                            double value)

multiply

public static void multiply(double[] data,
                            double value)

multiply

public static void multiply(double[] dest,
                            double[] src)

square

public static void square(double[] ds)

square

public static void square(double[] ds,
                          int offset,
                          int length)

tanh

public static void tanh(double[] ds)

tanh

public static void tanh(double[] ds,
                        int offset,
                        int length)

logistic

public static void logistic(double[] ds)

logistic

public static void logistic(double[] ds,
                            int offset,
                            int length)

signum

public static void signum(double[] ds)

signum

public static void signum(double[] ds,
                          int offset,
                          int length)

divide

public static void divide(double[] data,
                          int offset,
                          int length,
                          double value)

add

public static void add(double[] data,
                       int offset,
                       int length,
                       double value)

add

public static void add(double[] data,
                       double value)

addMultiple

public static void addMultiple(double[] dest,
                               int offset,
                               double[] src,
                               int srcOffset,
                               int length,
                               double factor)

addMultiple

public static void addMultiple(double[] dest,
                               int destOffset,
                               double[] src,
                               int srcOffset,
                               int srcStride,
                               int length,
                               double factor)

addProduct

public static void addProduct(double[] dest,
                              int offset,
                              double[] src1,
                              int src1Offset,
                              double[] src2,
                              int src2Offset,
                              int length,
                              double factor)

sub

public static void sub(double[] data,
                       double value)

sub

public static void sub(double[] data,
                       int offset,
                       int length,
                       double value)

arraymultiply

public static void arraymultiply(double[] src,
                                 int srcOffset,
                                 double[] dest,
                                 int destOffset,
                                 int length)

arraydivide

public static void arraydivide(double[] src,
                               int srcOffset,
                               double[] dest,
                               int destOffset,
                               int length)

dotProduct

public static double dotProduct(double[] a,
                                int aOffset,
                                double[] b,
                                int bOffset,
                                int length)

dotProduct

public static double dotProduct(double[] a,
                                int aOffset,
                                double[] b,
                                int bOffset,
                                int bStride,
                                int length)

Compute a dot product between array data and strided array data.

Parameters:

a -

aOffset -

b -

bOffset -

bStride -

length -

Returns:

dotProduct

public static double dotProduct(double[] a,
                                int aOffset,
                                int aStride,
                                double[] b,
                                int bOffset,
                                int bStride,
                                int length)

Compute a dot product between two sets of strided array data.

Parameters:

a -

aOffset -

b -

bOffset -

bStride -

length -

Returns:

add

public static void add(double[] src,
                       int srcOffset,
                       double[] dest,
                       int destOffset,
                       int length)

add

public static void add(double[] src,
                       int srcOffset,
                       int srcStride,
                       double[] dest,
                       int destOffset,
                       int length)

clamp

public static void clamp(double[] data,
                         double min,
                         double max)

clamp

public static void clamp(double[] data,
                         int offset,
                         int length,
                         double min,
                         double max)

pow

public static void pow(double[] data,
                       double exponent)

pow

public static void pow(double[] data,
                       int offset,
                       int length,
                       double exponent)

reciprocal

public static void reciprocal(double[] data)

reciprocal

public static void reciprocal(double[] data,
                              int offset,
                              int length)

scaleAdd

public static void scaleAdd(double[] data,
                            double factor,
                            double constant)

scaleAdd

public static void scaleAdd(double[] data,
                            int offset,
                            int length,
                            double factor,
                            double constant)

abs

public static void abs(double[] data)

abs

public static void abs(double[] data,
                       int offset,
                       int length)

exp

public static void exp(double[] data)

exp

public static void exp(double[] data,
                       int offset,
                       int length)

log

public static void log(double[] data)

log

public static void log(double[] data,
                       int offset,
                       int length)

sqrt

public static void sqrt(double[] data,
                        int offset,
                        int length)

negate

public static void negate(double[] data)

negate

public static void negate(double[] data,
                          int offset,
                          int length)

equals

public static boolean equals(double[] as,
                             double[] bs)

equals

public static boolean equals(double[] as,
                             double[] bs,
                             int length)

add

public static void add(double[] dest,
                       double[] src)

equals

public static boolean equals(double[] as,
                             int aOffset,
                             double[] bs,
                             int bOffset,
                             int length)

isBoolean

public static boolean isBoolean(double[] data)

isBoolean

public static boolean isBoolean(double[] data,
                                int offset,
                                int length)

isZero

public static boolean isZero(double[] data)

isZero

public static boolean isZero(double[] data,
                             int offset,
                             int length)

isZero

public static boolean isZero(double[] data,
                             int offset,
                             int length,
                             int stride)

elementsEqual

public static boolean elementsEqual(double[] data,
                                    int offset,
                                    int length,
                                    double value)

insert

public static double[] insert(double[] data,
                              int position,
                              double value)

copyOf

public static final double[] copyOf(double[] data)

Fast double array copy operation. Appears to be faster than data.clone() ?? this is debatable, needs more rigorous benchmarking

Parameters:

data -

Returns:

copyOf

public static double[] copyOf(double[] data,
                              int start,
                              int length)

nonZeroIndices

public static int[] nonZeroIndices(double[] data,
                                   int offset,
                                   int length)

Finds the non-zero indices as offsets within a range of a double array

Parameters:

data -

offset -

length -

Returns:

add2

public static void add2(double[] dest,
                        double[] aData,
                        double[] bData)

add2

public static void add2(double[] dest,
                        int destOffset,
                        double[] aData,
                        int aOffset,
                        double[] bData,
                        int bOffset,
                        int len)

Simultaneously adds two arrays to a target array

addMultiple

public static void addMultiple(double[] dest,
                               double[] src,
                               double factor)

addMultiple

public static void addMultiple(double[] dest,
                               double[] src,
                               int srcOffset,
                               double factor)

addResult

public static void addResult(double[] dest,
                             double[] as,
                             double[] bs)

Performs addition of two double arrays and stores the result in the destination array

scaleCopy

public static void scaleCopy(double[] dest,
                             double[] src,
                             double factor)

multiplyCopy

public static double[] multiplyCopy(double[] src,
                                    double factor)

copy

public static void copy(double[] src,
                        int srcOffset,
                        int srcStride,
                        double[] dest,
                        int destOffset,
                        int length)

createStorageArray

public static double[] createStorageArray(int... shape)

Creates a double[] storage array of the specified shape

Parameters:

shape -

Returns:

createStorage

public static double[] createStorage(int rowCount,
                                     int columnCount)

Creates a storage double[] array for a matrix of the specifid shape

Parameters:

rowCount -

columnCount -

Returns:

reduce

public static double reduce(Op2 op,
                            double[] data,
                            int offset,
                            int length)

reduce

public static double reduce(Op2 op,
                            double[] data,
                            int offset,
                            int length,
                            int stride)