Package org.apache.sysds.runtime.codegen

Class LibSpoofPrimitives

java.lang.Object
org.apache.sysds.runtime.codegen.LibSpoofPrimitives
public class LibSpoofPrimitives extends Object
This library contains all vector primitives that are used in generated source code for fused operators. For primitives that exist in LibMatrixMult, these calls are simply forwarded to ensure consistency in performance and result correctness.

  • Constructor Summary

    Constructors
    Constructor
    Description
    LibSpoofPrimitives()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static SparseRowVector
    allocSparseVector(int len)
     
    static double[]
    allocVector(int len, boolean reset)
     
    static double
    bwAnd(double in1, double in2)
     
    static void
    cleanupSparseThreadLocalMemory()
     
    static void
    cleanupThreadLocalMemory()
     
    static double
    dotProduct(double[] a, double[] b, int[] aix, int ai, int bi, int len)
     
    static double
    dotProduct(double[] a, double[] b, int ai, int bi, int len)
     
    static double
    intDiv(double in1, double in2)
     
    static boolean
    isFlipOuter(int len1, int len2)
     
    static double
    mod(double in1, double in2)
     
    static double
    rowMaxsVectMult(double[] a, double[] b, int[] aix, int ai, int bi, int len)
     
    static double
    rowMaxsVectMult(double[] a, double[] b, int ai, int bi, int len)
     
    static double
    rowMaxsVectMultVectorAPI(double[] a, double[] b, int[] aix, int ai, int bi, int len)
     
    static double
    scalarvectMin(double[] a, int ai, int len)
     
    static void
    setupSparseThreadLocalMemory(int numVectors, int len, int len2)
     
    static void
    setupThreadLocalMemory(int numVectors, int len)
     
    static void
    setupThreadLocalMemory(int numVectors, int len, int len2)
     
    static void
    vectAbsAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectAbsAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectAbsWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectAbsWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectAbsWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectAcosAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectAcosAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectAcosWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectAcosWrite(double[] a, int ai, int len)
     
    static void
    vectAsinAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectAsinAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectAsinWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectAsinWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectAsinWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectAtanAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectAtanAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectAtanWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectAtanWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectAtanWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectAvgpoolWrite(double[] avals, int[] aix, int ai, int alen, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)
     
    static double[]
    vectAvgpoolWrite(double[] a, int ai, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)
     
    static double[]
    vectBiasaddWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectBiasaddWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectBiasmultWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectBiasmultWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectBitwandWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectBitwandWrite(double[] a, double[] b, int ai, int[] aix, int bi, int alen, int len)
     
    static double[]
    vectBitwandWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectBitwandWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectBitwandWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectBitwandWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectBitwandWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectBitwandWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectBitwandWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectBitwandWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectCbindAdd(double[] a, double b, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static double[]
    vectCbindAdd(double[] a, double b, double[] c, int ai, int ci, int len)
     
    static double[]
    vectCbindWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int alen2, int blen)
     
    static double[]
    vectCbindWrite(double[] a, double[] b, int ai, int bi, int alen, int blen)
     
    static double[]
    vectCbindWrite(double[] a, double b, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectCbindWrite(double[] a, double b, int aix, int len)
     
    static double[]
    vectCbindWrite(double a, double b)
     
    static void
    vectCeilAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectCeilAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectCeilWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectCeilWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectCeilWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectConv2dmmWrite(double[] a, double[] b, int ai, int bi, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)
     
    static void
    vectCosAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectCosAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static void
    vectCoshAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectCoshAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectCoshWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectCoshWrite(double[] a, int ai, int len)
     
    static double[]
    vectCosWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectCosWrite(double[] a, int ai, int len)
     
    static double
    vectCountnnz(double[] avals, int[] aix, int ai, int alen, int len)
     
    static double
    vectCountnnz(double[] a, int ai, int len)
     
    static void
    vectCummaxAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectCummaxAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectCummaxWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectCummaxWrite(double[] a, int ai, int len)
     
    static void
    vectCumminAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectCumminAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectCumminWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectCumminWrite(double[] a, int ai, int len)
     
    static void
    vectCumsumAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectCumsumAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectCumsumWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectCumsumWrite(double[] a, int ai, int len)
     
    static void
    vectDivAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectDivAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectDivAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectDivAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static void
    vectDivAddVectorAPI(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectDivAddVectorAPI(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static double[]
    vectDivWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectDivWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectDivWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectDivWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectDivWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectDivWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectDivWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectDivWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectDivWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectDivWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectDivWriteB(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static double[]
    vectDivWriteVectorAPI(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectDivWriteVectorAPI(double[] a, double bval, int ai, int len)
     
    static double[]
    vectDivWriteVectorAPI(double bval, double[] a, int ai, int len)
     
    static void
    vectEqualAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectEqualAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectEqualAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectEqualAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectEqualWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectEqualWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectEqualWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectEqualWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectEqualWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectEqualWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectEqualWrite(double bval, double[] a, int ai, int len)
     
    static double[]
    vectEqualWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectEqualWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectEqualWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectExpAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectExpAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectExpWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectExpWrite(double[] a, int ai, int len)
     
    static void
    vectFloorAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectFloorAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectFloorWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectFloorWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectFloorWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectGreaterAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectGreaterAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectGreaterAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectGreaterAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static void
    vectGreaterequalAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectGreaterequalAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectGreaterequalAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectGreaterequalAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectGreaterequalWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectGreaterequalWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectGreaterequalWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectGreaterequalWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectGreaterequalWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectGreaterequalWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectGreaterequalWrite(double bval, double[] a, int ai, int len)
     
    static double[]
    vectGreaterequalWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectGreaterequalWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectGreaterequalWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectGreaterWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectGreaterWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectGreaterWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectGreaterWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectGreaterWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectGreaterWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectGreaterWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectGreaterWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectGreaterWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectGreaterWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectGreaterWriteVectorAPI(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectIm2colWrite(double[] avals, int[] aix, int ai, int alen, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)
     
    static double[]
    vectIm2colWrite(double[] a, int ai, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)
     
    static void
    vectLessAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectLessAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectLessAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectLessAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static void
    vectLessequalAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectLessequalAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectLessequalAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectLessequalAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectLessequalWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectLessequalWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectLessequalWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectLessequalWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectLessequalWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectLessequalWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectLessequalWrite(double bval, double[] a, int ai, int len)
     
    static double[]
    vectLessequalWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectLessequalWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectLessequalWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectLessWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectLessWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectLessWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectLessWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectLessWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectLessWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectLessWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectLessWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectLessWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectLessWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectLogAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectLogAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectLogWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectLogWrite(double[] a, int ai, int len)
     
    static double[]
    vectMatrixMult(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectMatrixMult(double[] a, double[] b, int ai, int bi, int len)
     
    static double
    vectMax(double[] avals, int[] aix, int ai, int alen, int len)
     
    static double
    vectMax(double[] a, int ai, int len)
     
    static void
    vectMaxAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMaxAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectMaxAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMaxAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectMaxpoolWrite(double[] avals, int[] aix, int ai, int alen, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)
     
    static double[]
    vectMaxpoolWrite(double[] a, int ai, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)
     
    static double[]
    vectMaxWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectMaxWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectMaxWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectMaxWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMaxWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectMaxWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMaxWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectMaxWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectMaxWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectMaxWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static double
    vectMean(double[] avals, int[] aix, int ai, int alen, int len)
     
    static double
    vectMean(double[] a, int ai, int len)
     
    static double
    vectMin(double[] avals, int[] aix, int ai, int alen, int len)
     
    static double
    vectMin(double[] a, int ai, int len)
     
    static void
    vectMinAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMinAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectMinAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMinAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static void
    vectMinusAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMinusAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectMinusAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMinusAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectMinusWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectMinusWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectMinusWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectMinusWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMinusWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectMinusWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMinusWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectMinusWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectMinusWriteB(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static double[]
    vectMinWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectMinWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectMinWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectMinWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMinWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectMinWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMinWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectMinWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectMinWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectMinWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectMult2Add(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMult2Add(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectMult2Write(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMult2Write(double[] a, int ai, int len)
     
    static void
    vectMultAdd(double[] a, double[] b, double[] c, int bi, int ci, int len)
     
    static void
    vectMultAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMultAdd(double[] a, double bval, double[] c, int bi, int ci, int len)
     
    static void
    vectMultAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectMultAdd(double bval, double[] a, double[] c, int bi, int ci, int len)
     
    static double[]
    vectMultWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectMultWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectMultWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectMultWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMultWrite(double[] a, double bval, int bi, int len)
     
    static double[]
    vectMultWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectMultWrite(double bval, double[] a, int bi, int len)
     
    static SparseRowVector
    vectMultWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectMultWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
    Vector primitives with SparseRowVector intermediates Changes: - Changed method signature to avoid method duplicate conflicts e.g.
    static SparseRowVector
    vectMultWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectMultWriteB(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static void
    vectNotequalAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectNotequalAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectNotequalAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectNotequalAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectNotequalWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectNotequalWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectNotequalWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectNotequalWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectNotequalWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectNotequalWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectNotequalWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectNotequalWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectNotequalWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectNotequalWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectNotequalWriteVectorAPI(double[] a, double[] b, int ai, int bi, int len)
     
    static void
    vectOuterMultAdd(double[] a, double[] b, double[] c, int[] aix, int ai, int bi, int ci, int alen, int len1, int len2)
     
    static void
    vectOuterMultAdd(double[] a, double[] b, double[] c, int ai, int[] bix, int bi, int ci, int blen, int len1, int len2)
     
    static void
    vectOuterMultAdd(double[] a, double[] b, double[] c, int ai, int bi, int ci, int len1, int len2)
     
    static void
    vectPlusAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectPlusAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectPlusAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectPlusAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectPlusWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectPlusWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)
     
    static double[]
    vectPlusWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectPlusWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectPlusWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectPlusWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectPlusWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectPlusWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static void
    vectPow2Add(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectPow2Add(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectPow2Write(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectPow2Write(double[] a, int ai, int len)
     
    static void
    vectPowAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectPowAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
     
    static void
    vectPowAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectPowAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectPowWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectPowWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectPowWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectPowWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectPowWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectPowWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static void
    vectRoundAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectRoundAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectRoundWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectRoundWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectRoundWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectSigmoidAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectSigmoidAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectSigmoidWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectSigmoidWrite(double[] a, int ai, int len)
     
    static void
    vectSignAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectSignAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectSignWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectSignWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectSignWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectSinAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectSinAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static void
    vectSinhAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectSinhAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectSinhWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectSinhWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectSinhWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectSinWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectSinWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectSinWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static void
    vectSpropAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectSpropAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectSpropWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectSpropWrite(double[] a, int ai, int len)
     
    static void
    vectSqrtAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectSqrtAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectSqrtWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectSqrtWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectSqrtWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static double
    vectSum(double[] avals, int[] aix, int ai, int alen, int len)
     
    static double
    vectSum(double[] a, int ai, int len)
    Computes c = sum(A), where A is a dense vectors.
    static double
    vectSumsq(double[] avals, int[] aix, int ai, int alen, int len)
     
    static double
    vectSumsq(double[] a, int ai, int len)
     
    static double
    vectSumVectorAPI(double[] a, int ai, int len)
     
    static void
    vectTanAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectTanAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static void
    vectTanhAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectTanhAdd(double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectTanhWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectTanhWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectTanhWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static double[]
    vectTanWrite(double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectTanWrite(double[] a, int ai, int len)
     
    static SparseRowVector
    vectTanWrite(int len, double[] a, int[] aix, int ai, int alen)
     
    static double
    vectVar(double[] avals, int[] aix, int ai, int alen, int len)
     
    static double
    vectVar(double[] a, int ai, int len)
     
    static void
    vectWrite(boolean[] a, boolean[] c, int[] aix)
     
    static void
    vectWrite(boolean[] a, boolean[] c, int[] aix, int ai, int ci, int alen)
     
    static void
    vectWrite(double[] a, double[] c, int[] aix, int ai, int ci, int alen)
     
    static void
    vectWrite(double[] a, double[] c, int ci, int len)
     
    static void
    vectWrite(double[] a, double[] c, int ai, int ci, int len)
     
    static void
    vectWrite(double[] a, int[] aix, double[] c, int ci, int len)
     
    static void
    vectXorAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectXorAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
    Computes c = xor(A,B)
    static void
    vectXorAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)
     
    static void
    vectXorAdd(double bval, double[] a, double[] c, int ai, int ci, int len)
     
    static double[]
    vectXorWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)
     
    static double[]
    vectXorWrite(double[] a, double[] b, int ai, int[] aix, int bi, int alen, int len)
     
    static double[]
    vectXorWrite(double[] a, double[] b, int ai, int bi, int len)
     
    static double[]
    vectXorWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectXorWrite(double[] a, double bval, int ai, int len)
     
    static double[]
    vectXorWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)
     
    static double[]
    vectXorWrite(double bval, double[] a, int ai, int len)
     
    static SparseRowVector
    vectXorWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)
     
    static SparseRowVector
    vectXorWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
     
    static SparseRowVector
    vectXorWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)
     

    Methods inherited from class java.lang.Object

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

  • Constructor Details

    • LibSpoofPrimitives

      public LibSpoofPrimitives()

  • Method Details

    • rowMaxsVectMult

      public static double rowMaxsVectMult(double[] a, double[] b, int ai, int bi, int len)

    • rowMaxsVectMult

      public static double rowMaxsVectMult(double[] a, double[] b, int[] aix, int ai, int bi, int len)

    • rowMaxsVectMultVectorAPI

      public static double rowMaxsVectMultVectorAPI(double[] a, double[] b, int[] aix, int ai, int bi, int len)

    • dotProduct

      public static double dotProduct(double[] a, double[] b, int ai, int bi, int len)

    • dotProduct

      public static double dotProduct(double[] a, double[] b, int[] aix, int ai, int bi, int len)

    • vectMatrixMult

      public static double[] vectMatrixMult(double[] a, double[] b, int ai, int bi, int len)

    • vectMatrixMult

      public static double[] vectMatrixMult(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectOuterMultAdd

      public static void vectOuterMultAdd(double[] a, double[] b, double[] c, int ai, int bi, int ci, int len1, int len2)

    • vectOuterMultAdd

      public static void vectOuterMultAdd(double[] a, double[] b, double[] c, int[] aix, int ai, int bi, int ci, int alen, int len1, int len2)

    • vectOuterMultAdd

      public static void vectOuterMultAdd(double[] a, double[] b, double[] c, int ai, int[] bix, int bi, int ci, int blen, int len1, int len2)

    • vectMultAdd

      public static void vectMultAdd(double[] a, double bval, double[] c, int bi, int ci, int len)

    • vectMultAdd

      public static void vectMultAdd(double bval, double[] a, double[] c, int bi, int ci, int len)

    • vectMultAdd

      public static void vectMultAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMultAdd

      public static void vectMultAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMultAdd

      public static void vectMultAdd(double[] a, double[] b, double[] c, int bi, int ci, int len)

    • vectMultWrite

      public static double[] vectMultWrite(double[] a, double bval, int bi, int len)

    • vectMultWrite

      public static double[] vectMultWrite(double bval, double[] a, int bi, int len)

    • vectMultWrite

      public static double[] vectMultWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectMultWrite

      public static double[] vectMultWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectMultWrite

      public static double[] vectMultWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectMultWrite

      public static double[] vectMultWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectMultWrite

      public static double[] vectMultWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectWrite

      public static void vectWrite(double[] a, double[] c, int ci, int len)

    • vectWrite

      public static void vectWrite(double[] a, double[] c, int ai, int ci, int len)

    • vectWrite

      public static void vectWrite(boolean[] a, boolean[] c, int[] aix)

    • vectWrite

      public static void vectWrite(boolean[] a, boolean[] c, int[] aix, int ai, int ci, int alen)

    • vectCbindAdd

      public static double[] vectCbindAdd(double[] a, double b, double[] c, int ai, int ci, int len)

    • vectCbindAdd

      public static double[] vectCbindAdd(double[] a, double b, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectCbindWrite

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

    • vectCbindWrite

      public static double[] vectCbindWrite(double[] a, double b, int aix, int len)

    • vectCbindWrite

      public static double[] vectCbindWrite(double[] a, double b, int[] aix, int ai, int alen, int len)

    • vectCbindWrite

      public static double[] vectCbindWrite(double[] a, double[] b, int ai, int bi, int alen, int blen)

    • vectCbindWrite

      public static double[] vectCbindWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int alen2, int blen)

    • vectSum

      public static double vectSum(double[] a, int ai, int len)
      Computes c = sum(A), where A is a dense vectors.
      Parameters:
      a - dense input vector A
      ai - start position in A
      len - number of processed elements
      Returns:
      sum value

    • vectSumVectorAPI

      public static double vectSumVectorAPI(double[] a, int ai, int len)

    • vectSum

      public static double vectSum(double[] avals, int[] aix, int ai, int alen, int len)

    • vectSumsq

      public static double vectSumsq(double[] a, int ai, int len)

    • vectSumsq

      public static double vectSumsq(double[] avals, int[] aix, int ai, int alen, int len)

    • scalarvectMin

      public static double scalarvectMin(double[] a, int ai, int len)

    • vectMin

      public static double vectMin(double[] a, int ai, int len)

    • vectMin

      public static double vectMin(double[] avals, int[] aix, int ai, int alen, int len)

    • vectMax

      public static double vectMax(double[] a, int ai, int len)

    • vectMax

      public static double vectMax(double[] avals, int[] aix, int ai, int alen, int len)

    • vectCountnnz

      public static double vectCountnnz(double[] a, int ai, int len)

    • vectCountnnz

      public static double vectCountnnz(double[] avals, int[] aix, int ai, int alen, int len)

    • vectMean

      public static double vectMean(double[] a, int ai, int len)

    • vectMean

      public static double vectMean(double[] avals, int[] aix, int ai, int alen, int len)

    • vectDivAdd

      public static void vectDivAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectDivAdd

      public static void vectDivAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectDivAdd

      public static void vectDivAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectDivAddVectorAPI

      public static void vectDivAddVectorAPI(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectDivAdd

      public static void vectDivAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectDivAddVectorAPI

      public static void vectDivAddVectorAPI(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectDivWrite

      public static double[] vectDivWrite(double[] a, double bval, int ai, int len)

    • vectDivWriteVectorAPI

      public static double[] vectDivWriteVectorAPI(double[] a, double bval, int ai, int len)

    • vectDivWrite

      public static double[] vectDivWrite(double bval, double[] a, int ai, int len)

    • vectDivWriteVectorAPI

      public static double[] vectDivWriteVectorAPI(double bval, double[] a, int ai, int len)

    • vectDivWrite

      public static double[] vectDivWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectDivWriteVectorAPI

      public static double[] vectDivWriteVectorAPI(double[] a, double[] b, int ai, int bi, int len)

    • vectDivWrite

      public static double[] vectDivWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectDivWrite

      public static double[] vectDivWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectDivWrite

      public static double[] vectDivWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectDivWrite

      public static double[] vectDivWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectMinusAdd

      public static void vectMinusAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectMinusAdd

      public static void vectMinusAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectMinusAdd

      public static void vectMinusAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMinusAdd

      public static void vectMinusAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMinusWrite

      public static double[] vectMinusWrite(double[] a, double bval, int ai, int len)

    • vectMinusWrite

      public static double[] vectMinusWrite(double bval, double[] a, int ai, int len)

    • vectMinusWrite

      public static double[] vectMinusWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectMinusWrite

      public static double[] vectMinusWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectMinusWrite

      public static double[] vectMinusWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectMinusWrite

      public static double[] vectMinusWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectMinusWrite

      public static double[] vectMinusWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectPlusAdd

      public static void vectPlusAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectPlusAdd

      public static void vectPlusAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectPlusAdd

      public static void vectPlusAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectPlusAdd

      public static void vectPlusAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectPlusWrite

      public static double[] vectPlusWrite(double[] a, double bval, int ai, int len)

    • vectPlusWrite

      public static double[] vectPlusWrite(double bval, double[] a, int ai, int len)

    • vectPlusWrite

      public static double[] vectPlusWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectPlusWrite

      public static double[] vectPlusWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectPlusWrite

      public static double[] vectPlusWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectPlusWrite

      public static double[] vectPlusWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectPlusWrite

      public static double[] vectPlusWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectXorAdd

      public static void vectXorAdd(double[] a, double bval, double[] c, int ai, int ci, int len)
      Computes c = xor(A,B)
      Parameters:
      a - dense input vector A
      bval - scalar value
      c - resultant vector
      ai - start position in A
      ci - index of c
      len - number of processed elements

    • vectXorAdd

      public static void vectXorAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectXorAdd

      public static void vectXorAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectXorAdd

      public static void vectXorAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectXorWrite

      public static double[] vectXorWrite(double[] a, double bval, int ai, int len)

    • vectXorWrite

      public static double[] vectXorWrite(double bval, double[] a, int ai, int len)

    • vectXorWrite

      public static double[] vectXorWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectXorWrite

      public static double[] vectXorWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectXorWrite

      public static double[] vectXorWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectXorWrite

      public static double[] vectXorWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectXorWrite

      public static double[] vectXorWrite(double[] a, double[] b, int ai, int[] aix, int bi, int alen, int len)

    • vectPowAdd

      public static void vectPowAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectPowAdd

      public static void vectPowAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectPowAdd

      public static void vectPowAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectPowAdd

      public static void vectPowAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectPowWrite

      public static double[] vectPowWrite(double[] a, double bval, int ai, int len)

    • vectPowWrite

      public static double[] vectPowWrite(double bval, double[] a, int ai, int len)

    • vectPowWrite

      public static double[] vectPowWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectPowWrite

      public static double[] vectPowWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectPowWrite

      public static double[] vectPowWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectMinAdd

      public static void vectMinAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectMinAdd

      public static void vectMinAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectMinAdd

      public static void vectMinAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMinAdd

      public static void vectMinAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMinWrite

      public static double[] vectMinWrite(double[] a, double bval, int ai, int len)

    • vectMinWrite

      public static double[] vectMinWrite(double bval, double[] a, int ai, int len)

    • vectMinWrite

      public static double[] vectMinWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectMinWrite

      public static double[] vectMinWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectMinWrite

      public static double[] vectMinWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectMinWrite

      public static double[] vectMinWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectMinWrite

      public static double[] vectMinWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectMaxAdd

      public static void vectMaxAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectMaxAdd

      public static void vectMaxAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectMaxAdd

      public static void vectMaxAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMaxAdd

      public static void vectMaxAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMaxWrite

      public static double[] vectMaxWrite(double[] a, double bval, int ai, int len)

    • vectMaxWrite

      public static double[] vectMaxWrite(double bval, double[] a, int ai, int len)

    • vectMaxWrite

      public static double[] vectMaxWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectMaxWrite

      public static double[] vectMaxWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectMaxWrite

      public static double[] vectMaxWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectMaxWrite

      public static double[] vectMaxWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectMaxWrite

      public static double[] vectMaxWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectExpAdd

      public static void vectExpAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectExpAdd

      public static void vectExpAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectExpWrite

      public static double[] vectExpWrite(double[] a, int ai, int len)

    • vectExpWrite

      public static double[] vectExpWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectCumsumAdd

      public static void vectCumsumAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectCumsumAdd

      public static void vectCumsumAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectCumsumWrite

      public static double[] vectCumsumWrite(double[] a, int ai, int len)

    • vectCumsumWrite

      public static double[] vectCumsumWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectCumminAdd

      public static void vectCumminAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectCumminAdd

      public static void vectCumminAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectCumminWrite

      public static double[] vectCumminWrite(double[] a, int ai, int len)

    • vectCumminWrite

      public static double[] vectCumminWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectCummaxAdd

      public static void vectCummaxAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectCummaxAdd

      public static void vectCummaxAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectCummaxWrite

      public static double[] vectCummaxWrite(double[] a, int ai, int len)

    • vectCummaxWrite

      public static double[] vectCummaxWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectLogAdd

      public static void vectLogAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectLogAdd

      public static void vectLogAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectLogWrite

      public static double[] vectLogWrite(double[] a, int ai, int len)

    • vectLogWrite

      public static double[] vectLogWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectAbsAdd

      public static void vectAbsAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectAbsAdd

      public static void vectAbsAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectAbsWrite

      public static double[] vectAbsWrite(double[] a, int ai, int len)

    • vectAbsWrite

      public static double[] vectAbsWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectRoundAdd

      public static void vectRoundAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectRoundAdd

      public static void vectRoundAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectRoundWrite

      public static double[] vectRoundWrite(double[] a, int ai, int len)

    • vectRoundWrite

      public static double[] vectRoundWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectCeilAdd

      public static void vectCeilAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectCeilAdd

      public static void vectCeilAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectCeilWrite

      public static double[] vectCeilWrite(double[] a, int ai, int len)

    • vectCeilWrite

      public static double[] vectCeilWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectFloorAdd

      public static void vectFloorAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectFloorAdd

      public static void vectFloorAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectFloorWrite

      public static double[] vectFloorWrite(double[] a, int ai, int len)

    • vectFloorWrite

      public static double[] vectFloorWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectSinAdd

      public static void vectSinAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectSinAdd

      public static void vectSinAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectSinWrite

      public static double[] vectSinWrite(double[] a, int ai, int len)

    • vectSinWrite

      public static double[] vectSinWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectCosAdd

      public static void vectCosAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectCosAdd

      public static void vectCosAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectCosWrite

      public static double[] vectCosWrite(double[] a, int ai, int len)

    • vectCosWrite

      public static double[] vectCosWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectTanAdd

      public static void vectTanAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectTanAdd

      public static void vectTanAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectTanWrite

      public static double[] vectTanWrite(double[] a, int ai, int len)

    • vectTanWrite

      public static double[] vectTanWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectAsinAdd

      public static void vectAsinAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectAsinAdd

      public static void vectAsinAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectAsinWrite

      public static double[] vectAsinWrite(double[] a, int ai, int len)

    • vectAsinWrite

      public static double[] vectAsinWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectAcosAdd

      public static void vectAcosAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectAcosAdd

      public static void vectAcosAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectAcosWrite

      public static double[] vectAcosWrite(double[] a, int ai, int len)

    • vectAcosWrite

      public static double[] vectAcosWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectAtanAdd

      public static void vectAtanAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectAtanAdd

      public static void vectAtanAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectAtanWrite

      public static double[] vectAtanWrite(double[] a, int ai, int len)

    • vectAtanWrite

      public static double[] vectAtanWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectSinhAdd

      public static void vectSinhAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectSinhAdd

      public static void vectSinhAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectSinhWrite

      public static double[] vectSinhWrite(double[] a, int ai, int len)

    • vectSinhWrite

      public static double[] vectSinhWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectCoshAdd

      public static void vectCoshAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectCoshAdd

      public static void vectCoshAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectCoshWrite

      public static double[] vectCoshWrite(double[] a, int ai, int len)

    • vectCoshWrite

      public static double[] vectCoshWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectTanhAdd

      public static void vectTanhAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectTanhAdd

      public static void vectTanhAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectTanhWrite

      public static double[] vectTanhWrite(double[] a, int ai, int len)

    • vectTanhWrite

      public static double[] vectTanhWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectSignAdd

      public static void vectSignAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectSignAdd

      public static void vectSignAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectSignWrite

      public static double[] vectSignWrite(double[] a, int ai, int len)

    • vectSignWrite

      public static double[] vectSignWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectPow2Add

      public static void vectPow2Add(double[] a, double[] c, int ai, int ci, int len)

    • vectPow2Add

      public static void vectPow2Add(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectPow2Write

      public static double[] vectPow2Write(double[] a, int ai, int len)

    • vectPow2Write

      public static double[] vectPow2Write(double[] a, int[] aix, int ai, int alen, int len)

    • vectMult2Add

      public static void vectMult2Add(double[] a, double[] c, int ai, int ci, int len)

    • vectMult2Add

      public static void vectMult2Add(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectMult2Write

      public static double[] vectMult2Write(double[] a, int ai, int len)

    • vectMult2Write

      public static double[] vectMult2Write(double[] a, int[] aix, int ai, int alen, int len)

    • vectSqrtAdd

      public static void vectSqrtAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectSqrtAdd

      public static void vectSqrtAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectSqrtWrite

      public static double[] vectSqrtWrite(double[] a, int ai, int len)

    • vectSqrtWrite

      public static double[] vectSqrtWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectSpropAdd

      public static void vectSpropAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectSpropAdd

      public static void vectSpropAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectSpropWrite

      public static double[] vectSpropWrite(double[] a, int ai, int len)

    • vectSpropWrite

      public static double[] vectSpropWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectSigmoidAdd

      public static void vectSigmoidAdd(double[] a, double[] c, int ai, int ci, int len)

    • vectSigmoidAdd

      public static void vectSigmoidAdd(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectSigmoidWrite

      public static double[] vectSigmoidWrite(double[] a, int ai, int len)

    • vectSigmoidWrite

      public static double[] vectSigmoidWrite(double[] a, int[] aix, int ai, int alen, int len)

    • vectEqualAdd

      public static void vectEqualAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectEqualAdd

      public static void vectEqualAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectEqualAdd

      public static void vectEqualAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectEqualAdd

      public static void vectEqualAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectEqualWrite

      public static double[] vectEqualWrite(double[] a, double bval, int ai, int len)

    • vectEqualWrite

      public static double[] vectEqualWrite(double bval, double[] a, int ai, int len)

    • vectEqualWrite

      public static double[] vectEqualWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectEqualWrite

      public static double[] vectEqualWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectEqualWrite

      public static double[] vectEqualWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectEqualWrite

      public static double[] vectEqualWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectEqualWrite

      public static double[] vectEqualWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectNotequalAdd

      public static void vectNotequalAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectNotequalAdd

      public static void vectNotequalAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectNotequalAdd

      public static void vectNotequalAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectNotequalAdd

      public static void vectNotequalAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectNotequalWrite

      public static double[] vectNotequalWrite(double[] a, double bval, int ai, int len)

    • vectNotequalWrite

      public static double[] vectNotequalWrite(double bval, double[] a, int ai, int len)

    • vectNotequalWrite

      public static double[] vectNotequalWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectNotequalWriteVectorAPI

      public static double[] vectNotequalWriteVectorAPI(double[] a, double[] b, int ai, int bi, int len)

    • vectNotequalWrite

      public static double[] vectNotequalWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectNotequalWrite

      public static double[] vectNotequalWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectNotequalWrite

      public static double[] vectNotequalWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectNotequalWrite

      public static double[] vectNotequalWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectLessAdd

      public static void vectLessAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectLessAdd

      public static void vectLessAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectLessAdd

      public static void vectLessAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectLessAdd

      public static void vectLessAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectLessWrite

      public static double[] vectLessWrite(double[] a, double bval, int ai, int len)

    • vectLessWrite

      public static double[] vectLessWrite(double bval, double[] a, int ai, int len)

    • vectLessWrite

      public static double[] vectLessWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectLessWrite

      public static double[] vectLessWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectLessWrite

      public static double[] vectLessWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectLessWrite

      public static double[] vectLessWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectLessWrite

      public static double[] vectLessWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectLessequalAdd

      public static void vectLessequalAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectLessequalAdd

      public static void vectLessequalAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectLessequalAdd

      public static void vectLessequalAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectLessequalAdd

      public static void vectLessequalAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectLessequalWrite

      public static double[] vectLessequalWrite(double[] a, double bval, int ai, int len)

    • vectLessequalWrite

      public static double[] vectLessequalWrite(double bval, double[] a, int ai, int len)

    • vectLessequalWrite

      public static double[] vectLessequalWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectLessequalWrite

      public static double[] vectLessequalWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectLessequalWrite

      public static double[] vectLessequalWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectLessequalWrite

      public static double[] vectLessequalWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectLessequalWrite

      public static double[] vectLessequalWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectGreaterAdd

      public static void vectGreaterAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectGreaterAdd

      public static void vectGreaterAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectGreaterAdd

      public static void vectGreaterAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectGreaterAdd

      public static void vectGreaterAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectGreaterWrite

      public static double[] vectGreaterWrite(double[] a, double bval, int ai, int len)

    • vectGreaterWrite

      public static double[] vectGreaterWrite(double bval, double[] a, int ai, int len)

    • vectGreaterWrite

      public static double[] vectGreaterWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectGreaterWriteVectorAPI

      public static double[] vectGreaterWriteVectorAPI(double[] a, double[] b, int ai, int bi, int len)

    • vectGreaterWrite

      public static double[] vectGreaterWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectGreaterWrite

      public static double[] vectGreaterWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectGreaterWrite

      public static double[] vectGreaterWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectGreaterWrite

      public static double[] vectGreaterWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectGreaterequalAdd

      public static void vectGreaterequalAdd(double[] a, double bval, double[] c, int ai, int ci, int len)

    • vectGreaterequalAdd

      public static void vectGreaterequalAdd(double bval, double[] a, double[] c, int ai, int ci, int len)

    • vectGreaterequalAdd

      public static void vectGreaterequalAdd(double[] a, double bval, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectGreaterequalAdd

      public static void vectGreaterequalAdd(double bval, double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len)

    • vectGreaterequalWrite

      public static double[] vectGreaterequalWrite(double[] a, double bval, int ai, int len)

    • vectGreaterequalWrite

      public static double[] vectGreaterequalWrite(double bval, double[] a, int ai, int len)

    • vectGreaterequalWrite

      public static double[] vectGreaterequalWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectGreaterequalWrite

      public static double[] vectGreaterequalWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectGreaterequalWrite

      public static double[] vectGreaterequalWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectGreaterequalWrite

      public static double[] vectGreaterequalWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectGreaterequalWrite

      public static double[] vectGreaterequalWrite(double[] a, double[] b, int ai, int[] bix, int bi, int blen, int len)

    • vectBitwandWrite

      public static double[] vectBitwandWrite(double[] a, double bval, int ai, int len)

    • vectBitwandWrite

      public static double[] vectBitwandWrite(double bval, double[] a, int ai, int len)

    • vectBitwandWrite

      public static double[] vectBitwandWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectBitwandWrite

      public static double[] vectBitwandWrite(double[] a, double bval, int[] aix, int ai, int alen, int len)

    • vectBitwandWrite

      public static double[] vectBitwandWrite(double bval, double[] a, int[] aix, int ai, int alen, int len)

    • vectBitwandWrite

      public static double[] vectBitwandWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectBitwandWrite

      public static double[] vectBitwandWrite(double[] a, double[] b, int ai, int[] aix, int bi, int alen, int len)

    • vectBiasaddWrite

      public static double[] vectBiasaddWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectBiasaddWrite

      public static double[] vectBiasaddWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectBiasmultWrite

      public static double[] vectBiasmultWrite(double[] a, double[] b, int ai, int bi, int len)

    • vectBiasmultWrite

      public static double[] vectBiasmultWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len)

    • vectMaxpoolWrite

      public static double[] vectMaxpoolWrite(double[] a, int ai, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)

    • vectMaxpoolWrite

      public static double[] vectMaxpoolWrite(double[] avals, int[] aix, int ai, int alen, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)

    • vectAvgpoolWrite

      public static double[] vectAvgpoolWrite(double[] a, int ai, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)

    • vectAvgpoolWrite

      public static double[] vectAvgpoolWrite(double[] avals, int[] aix, int ai, int alen, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)

    • vectIm2colWrite

      public static double[] vectIm2colWrite(double[] a, int ai, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)

    • vectIm2colWrite

      public static double[] vectIm2colWrite(double[] avals, int[] aix, int ai, int alen, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)

    • vectConv2dmmWrite

      public static double[] vectConv2dmmWrite(double[] a, double[] b, int ai, int bi, int len, int rix, int C, int P, int Q, int K, int R, int S, int H, int W)

    • vectVar

      public static double vectVar(double[] a, int ai, int len)

    • vectVar

      public static double vectVar(double[] avals, int[] aix, int ai, int alen, int len)

    • vectMultWrite

      public static SparseRowVector vectMultWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)
      Vector primitives with SparseRowVector intermediates Changes: - Changed method signature to avoid method duplicate conflicts e.g. (double[], double, int[], int, int, int) --> (int, double[], double, int[], int, int) - Added blen for vector - vector calculations to be able to use both vectors as SparseRowVectors - Implemented a new SparseVectorBuffer class that creates a ring buffer for SparseRowVectors in different sizes

    • vectMultWrite

      public static SparseRowVector vectMultWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectMultWriteB

      public static SparseRowVector vectMultWriteB(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectMultWrite

      public static SparseRowVector vectMultWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectWrite

      public static void vectWrite(double[] a, int[] aix, double[] c, int ci, int len)

    • vectWrite

      public static void vectWrite(double[] a, double[] c, int[] aix, int ai, int ci, int alen)

    • vectDivWrite

      public static SparseRowVector vectDivWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectDivWrite

      public static SparseRowVector vectDivWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectDivWriteB

      public static SparseRowVector vectDivWriteB(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectDivWrite

      public static SparseRowVector vectDivWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectMinusWriteB

      public static SparseRowVector vectMinusWriteB(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectMinusWrite

      public static SparseRowVector vectMinusWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectPlusWrite

      public static SparseRowVector vectPlusWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectXorWrite

      public static SparseRowVector vectXorWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectXorWrite

      public static SparseRowVector vectXorWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectXorWrite

      public static SparseRowVector vectXorWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectPowWrite

      public static SparseRowVector vectPowWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectMinWrite

      public static SparseRowVector vectMinWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectMinWrite

      public static SparseRowVector vectMinWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectMinWrite

      public static SparseRowVector vectMinWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectMaxWrite

      public static SparseRowVector vectMaxWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectMaxWrite

      public static SparseRowVector vectMaxWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectMaxWrite

      public static SparseRowVector vectMaxWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectEqualWrite

      public static SparseRowVector vectEqualWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectEqualWrite

      public static SparseRowVector vectEqualWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectEqualWrite

      public static double[] vectEqualWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectNotequalWrite

      public static SparseRowVector vectNotequalWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectNotequalWrite

      public static SparseRowVector vectNotequalWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectNotequalWrite

      public static SparseRowVector vectNotequalWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectLessWrite

      public static SparseRowVector vectLessWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectLessWrite

      public static SparseRowVector vectLessWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectLessWrite

      public static SparseRowVector vectLessWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectLessequalWrite

      public static SparseRowVector vectLessequalWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectLessequalWrite

      public static SparseRowVector vectLessequalWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectLessequalWrite

      public static double[] vectLessequalWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectGreaterWrite

      public static SparseRowVector vectGreaterWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectGreaterWrite

      public static SparseRowVector vectGreaterWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectGreaterWrite

      public static SparseRowVector vectGreaterWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectGreaterequalWrite

      public static SparseRowVector vectGreaterequalWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectGreaterequalWrite

      public static SparseRowVector vectGreaterequalWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectGreaterequalWrite

      public static double[] vectGreaterequalWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectBitwandWrite

      public static SparseRowVector vectBitwandWrite(int len, double[] a, double bval, int[] aix, int ai, int alen)

    • vectBitwandWrite

      public static SparseRowVector vectBitwandWrite(int len, double bval, double[] a, int[] aix, int ai, int alen)

    • vectBitwandWrite

      public static SparseRowVector vectBitwandWrite(int len, double[] a, double[] b, int[] aix, int[] bix, int ai, int bi, int alen, int blen)

    • vectSqrtWrite

      public static SparseRowVector vectSqrtWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectAbsWrite

      public static SparseRowVector vectAbsWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectRoundWrite

      public static SparseRowVector vectRoundWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectCeilWrite

      public static SparseRowVector vectCeilWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectFloorWrite

      public static SparseRowVector vectFloorWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectSinWrite

      public static SparseRowVector vectSinWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectTanWrite

      public static SparseRowVector vectTanWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectAsinWrite

      public static SparseRowVector vectAsinWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectAtanWrite

      public static SparseRowVector vectAtanWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectSinhWrite

      public static SparseRowVector vectSinhWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectTanhWrite

      public static SparseRowVector vectTanhWrite(int len, double[] a, int[] aix, int ai, int alen)

    • vectSignWrite

      public static SparseRowVector vectSignWrite(int len, double[] a, int[] aix, int ai, int alen)

    • intDiv

      public static double intDiv(double in1, double in2)

    • mod

      public static double mod(double in1, double in2)

    • bwAnd

      public static double bwAnd(double in1, double in2)

    • isFlipOuter

      public static boolean isFlipOuter(int len1, int len2)

    • setupThreadLocalMemory

      public static void setupThreadLocalMemory(int numVectors, int len)

    • setupThreadLocalMemory

      public static void setupThreadLocalMemory(int numVectors, int len, int len2)

    • setupSparseThreadLocalMemory

      public static void setupSparseThreadLocalMemory(int numVectors, int len, int len2)

    • cleanupThreadLocalMemory

      public static void cleanupThreadLocalMemory()

    • cleanupSparseThreadLocalMemory

      public static void cleanupSparseThreadLocalMemory()

    • allocVector

      public static double[] allocVector(int len, boolean reset)

    • allocSparseVector

      public static SparseRowVector allocSparseVector(int len)