LibSpoofPrimitives (SystemML 0.15.0 API)

java.lang.Object
- org.apache.sysml.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()

Constructors
Constructor and Description
`LibSpoofPrimitives()`

Method Summary

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

Methods inherited from class java.lang.Object
clone, equals, finalize, 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)

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)

vectWrite

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

vectWrite

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

intDiv

public static double intDiv(double in1,
                            double in2)

mod

public static double mod(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

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

allocVector

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

Methods inherited from class java.lang.Object

LibSpoofPrimitives

dotProduct

dotProduct

vectMatrixMult

vectMatrixMult

vectOuterMultAdd

vectOuterMultAdd

vectMultAdd

vectMultAdd

vectMultAdd

vectMultAdd

vectMultAdd

vectMultWrite

vectMultWrite

vectMultWrite

vectMultWrite

vectMultWrite

vectMultWrite

vectWrite

vectWrite

vectSum

vectSum

vectMin

vectMin

vectMax

vectMax

vectDivAdd

vectDivAdd

vectDivAdd

vectDivAdd

vectDivWrite

vectDivWrite

vectDivWrite

vectDivWrite

vectDivWrite

vectDivWrite

vectMinusAdd

vectMinusAdd

vectMinusAdd

vectMinusAdd

vectMinusWrite

vectMinusWrite

vectMinusWrite

vectMinusWrite

vectMinusWrite

vectMinusWrite

vectPlusAdd

vectPlusAdd

vectPlusAdd

vectPlusAdd

vectPlusWrite

vectPlusWrite

vectPlusWrite

vectPlusWrite

vectPlusWrite

vectPlusWrite

vectPowAdd

vectPowAdd

vectPowAdd

vectPowAdd

vectPowWrite

vectPowWrite

vectPowWrite

vectPowWrite

vectPowWrite

vectMinAdd

vectMinAdd

vectMinAdd

vectMinAdd

vectMinWrite

vectMinWrite

vectMinWrite

vectMinWrite

vectMinWrite

vectMinWrite

vectMaxAdd

vectMaxAdd

vectMaxAdd

vectMaxAdd