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)