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 and Description
    `LibSpoofPrimitives()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static double[]` | `allocVector(int len, boolean reset)`
    `static double` | `bwAnd(double in1, double in2)`
    `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 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 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 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 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 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 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 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 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 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 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[]` | `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 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[]` | `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 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 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 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 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 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 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 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 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 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 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 double[]` | `vectSinWrite(double[] a, int[] aix, int ai, int alen, int len)`
    `static double[]` | `vectSinWrite(double[] a, int ai, int len)`
    `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 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 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 double[]` | `vectTanWrite(double[] a, int[] aix, int ai, int alen, int len)`
    `static double[]` | `vectTanWrite(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 ci, int len)`
    `static void` | `vectWrite(double[] a, double[] c, int ai, 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)`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### LibSpoofPrimitives

          public LibSpoofPrimitives()

  - ### Method Detail

    - #### 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

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

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

    - #### vectDivAdd

          public static void vectDivAdd(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)

    - #### vectDivWrite

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

    - #### vectDivWrite

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

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

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

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

    - #### cleanupThreadLocalMemory

          public static void cleanupThreadLocalMemory()

    - #### allocVector

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

Copyright © 2021 The Apache Software Foundation. All rights reserved.