Documentation of 'mikera.vectorz.util.DoubleArrays' Java class
DoubleArrays
Skip navigation links
mikera.vectorz.util

Class DoubleArrays


  • public final class DoubleArrays
extends java.lang.Object

    • Field Summary

      Fields 
      Modifier and Type Field and Description
      static double[] EMPTY 

    • Method Summary

      All Methods Static Methods Concrete Methods 
      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[] create(int size)
      Create a new double array.
      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, 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) 
      static double visitNonZero(IndexedElementVisitor elementVisitor, double[] data, int offset, int length)
      Calls the specified element visitor for each non-zero element in a double array segment
      static double visitNonZero(IndexedElementVisitor elementVisitor, double[] data, int offset, int length, int stride)
      Calls the specified element visitor for each non-zero element in a strided double array segment

      • Methods inherited from class java.lang.Object

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

    • Field Detail

      • EMPTY

        public static final double[] EMPTY

    • 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,
                                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)

      • create

        public static double[] create(int size)
        Create a new double array. Uses the EMPTY array if the required size is zero
        Parameters:
        initialCapacity -
        Returns:

      • visitNonZero

        public static double visitNonZero(IndexedElementVisitor elementVisitor,
                                  double[] data,
                                  int offset,
                                  int length)
        Calls the specified element visitor for each non-zero element in a double array segment
        Parameters:
        elementVisitor -
        data -
        offset -
        length -
        Returns:

      • visitNonZero

        public static double visitNonZero(IndexedElementVisitor elementVisitor,
                                  double[] data,
                                  int offset,
                                  int length,
                                  int stride)
        Calls the specified element visitor for each non-zero element in a strided double array segment
        Parameters:
        elementVisitor -
        data -
        offset -
        length -
        Returns:
Skip navigation links

DMelt 3.0 © DataMelt by jWork.ORG

You see the box below because you did not login.