You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@systemml.apache.org by mb...@apache.org on 2017/06/27 00:34:52 UTC
systemml git commit: [SYSTEMML-1732] Fix codegen vector primitives,
incl new full testsuite
Repository: systemml
Updated Branches:
refs/heads/master e42133fec -> db13eac1a
[SYSTEMML-1732] Fix codegen vector primitives, incl new full testsuite
This patch adds a new testsuite for codegen vector primitives in order
to test correctness of vector-scalar, scalar-vector, and vector-vector
operations for combinations of dense and sparse vectors in a brute force
manner. Furthermore, this also includes fixes for all issues found so
far (div, exp, plus, min, max, !=, <, <=, >, >=).
Project: http://git-wip-us.apache.org/repos/asf/systemml/repo
Commit: http://git-wip-us.apache.org/repos/asf/systemml/commit/db13eac1
Tree: http://git-wip-us.apache.org/repos/asf/systemml/tree/db13eac1
Diff: http://git-wip-us.apache.org/repos/asf/systemml/diff/db13eac1
Branch: refs/heads/master
Commit: db13eac1a3cae1286df1793f2aab57b305f1673a
Parents: e42133f
Author: Matthias Boehm <mb...@gmail.com>
Authored: Mon Jun 26 17:16:37 2017 -0700
Committer: Matthias Boehm <mb...@gmail.com>
Committed: Mon Jun 26 17:16:37 2017 -0700
----------------------------------------------------------------------
src/main/java/org/apache/sysml/hops/Hop.java | 6 +-
.../runtime/codegen/LibSpoofPrimitives.java | 51 +-
.../codegen/CPlanVectorPrimitivesTest.java | 708 +++++++++++++++++++
.../org/apache/sysml/test/utils/TestUtils.java | 7 +-
.../functions/codegen/ZPackageSuite.java | 1 +
5 files changed, 750 insertions(+), 23 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/systemml/blob/db13eac1/src/main/java/org/apache/sysml/hops/Hop.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/sysml/hops/Hop.java b/src/main/java/org/apache/sysml/hops/Hop.java
index 9a71e7c..81c4cdc 100644
--- a/src/main/java/org/apache/sysml/hops/Hop.java
+++ b/src/main/java/org/apache/sysml/hops/Hop.java
@@ -1354,7 +1354,7 @@ public abstract class Hop
HopsOpOp2String.put(OpOp2.LESS, "<");
HopsOpOp2String.put(OpOp2.GREATEREQUAL, ">=");
HopsOpOp2String.put(OpOp2.GREATER, ">");
- HopsOpOp2String.put(OpOp2.EQUAL, "=");
+ HopsOpOp2String.put(OpOp2.EQUAL, "==");
HopsOpOp2String.put(OpOp2.NOTEQUAL, "!=");
HopsOpOp2String.put(OpOp2.OR, "|");
HopsOpOp2String.put(OpOp2.AND, "&");
@@ -1373,6 +1373,10 @@ public abstract class Hop
HopsOpOp2String.put(OpOp2.RBIND, "rbind");
HopsOpOp2String.put(OpOp2.SOLVE, "solve");
}
+
+ public static String getBinaryOpCode(OpOp2 op) {
+ return HopsOpOp2String.get(op);
+ }
protected static final HashMap<Hop.OpOp3, String> HopsOpOp3String;
static {
http://git-wip-us.apache.org/repos/asf/systemml/blob/db13eac1/src/main/java/org/apache/sysml/runtime/codegen/LibSpoofPrimitives.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/sysml/runtime/codegen/LibSpoofPrimitives.java b/src/main/java/org/apache/sysml/runtime/codegen/LibSpoofPrimitives.java
index 8fe35ff..ad2530d 100644
--- a/src/main/java/org/apache/sysml/runtime/codegen/LibSpoofPrimitives.java
+++ b/src/main/java/org/apache/sysml/runtime/codegen/LibSpoofPrimitives.java
@@ -221,7 +221,7 @@ public class LibSpoofPrimitives
return c;
}
- public static double[] vectDivWrite(double[] a, double[] b, int ai, int bi, int alen, int len) {
+ public static double[] vectDivWrite(double[] a, double[] b, int ai, int bi, int len) {
double[] c = allocVector(len, false);
for( int j = 0; j < len; j++)
c[j] = a[ai + j] / b[bi + j];
@@ -229,14 +229,16 @@ public class LibSpoofPrimitives
}
public static double[] vectDivWrite(double[] a, double bval, int[] aix, int ai, int alen, int len) {
- double[] c = allocVector(len, true);
+ double init = (bval != 0) ? 0 : Double.NaN;
+ double[] c = allocVector(len, true, init);
for( int j = ai; j < ai+alen; j++ )
c[aix[j]] = a[j] / bval;
return c;
}
public static double[] vectDivWrite(double bval, double[] a, int[] aix, int ai, int alen, int len) {
- double[] c = allocVector(len, true);
+ double init = (bval != 0) ? Double.POSITIVE_INFINITY : Double.NaN;
+ double[] c = allocVector(len, true, init);
for( int j = ai; j < ai+alen; j++ )
c[aix[j]] = bval / a[j];
return c;
@@ -244,6 +246,9 @@ public class LibSpoofPrimitives
public static double[] vectDivWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len) {
double[] c = allocVector(len, false);
+ for( int j = 0; j < len; j++ )
+ if( b[bi + j] == 0 ) //prep 0/0=NaN
+ c[j] = Double.NaN;
for( int j = ai; j < ai+alen; j++ )
c[aix[j]] = a[j] / b[bi+aix[j]];
return c;
@@ -350,7 +355,7 @@ public class LibSpoofPrimitives
}
public static double[] vectPlusWrite(double bval, double[] a, int ai, int len) {
- return vectPlusWrite(bval, a, ai, len);
+ return vectPlusWrite(a, bval, ai, len);
}
public static double[] vectPlusWrite(double[] a, double[] b, int ai, int bi, int len) {
@@ -484,7 +489,8 @@ public class LibSpoofPrimitives
}
public static double[] vectMinWrite(double[] a, double bval, int[] aix, int ai, int alen, int len) {
- double[] c = allocVector(len, true, bval);
+ double init = (bval < 0) ? bval : 0;
+ double[] c = allocVector(len, true, init);
for( int j = ai; j < ai+alen; j++ )
c[aix[j]] = Math.min(a[j], bval);
return c;
@@ -496,9 +502,10 @@ public class LibSpoofPrimitives
public static double[] vectMinWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len) {
double[] c = allocVector(len, false);
- System.arraycopy(b, bi, c, 0, len);
+ for( int j = 0; j < len; j++ )
+ c[j] = Math.min(b[bi + j], 0);
for( int j = ai; j < ai+alen; j++ )
- c[aix[j]] = Math.min(a[j], c[aix[j]]);
+ c[aix[j]] = Math.min(a[j], b[bi + aix[j]]);
return c;
}
@@ -544,7 +551,8 @@ public class LibSpoofPrimitives
}
public static double[] vectMaxWrite(double[] a, double bval, int[] aix, int ai, int alen, int len) {
- double[] c = allocVector(len, true, bval);
+ double init = (bval > 0) ? bval : 0;
+ double[] c = allocVector(len, true, init);
for( int j = ai; j < ai+alen; j++ )
c[aix[j]] = Math.max(a[j], bval);
return c;
@@ -556,9 +564,10 @@ public class LibSpoofPrimitives
public static double[] vectMaxWrite(double[] a, double[] b, int[] aix, int ai, int bi, int alen, int len) {
double[] c = allocVector(len, false);
- System.arraycopy(b, bi, c, 0, len);
+ for( int j = 0; j < len; j++ )
+ c[j] = Math.max(b[bi + j], 0);
for( int j = ai; j < ai+alen; j++ )
- c[aix[j]] = Math.max(a[j], c[aix[j]]);
+ c[aix[j]] = Math.max(a[j], b[bi + aix[j]]);
return c;
}
@@ -585,8 +594,8 @@ public class LibSpoofPrimitives
public static double[] vectExpWrite(double[] a, int[] aix, int ai, int alen, int len) {
double[] c = allocVector(len, true, 1); //exp(0)=1
- for( int j = ai; j < ai+alen; j++ )
- c[aix[j]] = FastMath.exp(a[j]) - 1;
+ for( int j = ai; j < ai+alen; j++ ) //overwrite
+ c[aix[j]] = FastMath.exp(a[j]);
return c;
}
@@ -778,7 +787,7 @@ public class LibSpoofPrimitives
for( int j = ai; j < ai+len; j++, ci++)
c[ci] += a[j] + a[j];
}
-
+
public static void vectMult2Add(double[] a, double[] c, int[] aix, int ai, int ci, int alen, int len) {
for( int j = ai; j < ai+alen; j++ )
c[ci + aix[j]] += a[j] + a[j];
@@ -790,7 +799,7 @@ public class LibSpoofPrimitives
c[j] = a[ai] + a[ai];
return c;
}
-
+
public static double[] vectMult2Write(double[] a, int[] aix, int ai, int alen, int len) {
double[] c = allocVector(len, true);
for( int j = ai; j < ai+alen; j++ )
@@ -934,7 +943,7 @@ public class LibSpoofPrimitives
double init = (bval != 0) ? 1 : 0;
double[] c = allocVector(len, true, init);
for( int j = ai; j < ai+alen; j++ )
- c[aix[j]] = ((a[j] != bval) ? 1 : 0) - init;
+ c[aix[j]] = ((a[j] != bval) ? 1 : 0);
return c;
}
@@ -997,7 +1006,7 @@ public class LibSpoofPrimitives
double init = (bval > 0) ? 1 : 0;
double[] c = allocVector(len, true, init);
for( int j = ai; j < ai+alen; j++ )
- c[aix[j]] = (a[j] < bval) ? 1 : 0 - init;
+ c[aix[j]] = (a[j] < bval) ? 1 : 0;
return c;
}
@@ -1059,8 +1068,8 @@ public class LibSpoofPrimitives
public static double[] vectLessequalWrite(double[] a, double bval, int[] aix, int ai, int alen, int len) {
double init = (bval >= 0) ? 1 : 0;
double[] c = allocVector(len, true, init);
- for( int j = ai; j < ai+len; j++ )
- c[aix[j]] = ((a[j] <= bval) ? 1 : 0) - init;
+ for( int j = ai; j < ai+alen; j++ )
+ c[aix[j]] = ((a[j] <= bval) ? 1 : 0);
return c;
}
@@ -1109,7 +1118,7 @@ public class LibSpoofPrimitives
}
public static double[] vectGreaterWrite(double bval, double[] a, int ai, int len) {
- return vectGreaterWrite(a, bval, ai, len);
+ return vectLessWrite(a, bval, ai, len);
}
public static double[] vectGreaterWrite(double[] a, double[] b, int ai, int bi, int len) {
@@ -1123,7 +1132,7 @@ public class LibSpoofPrimitives
double init = (bval < 0) ? 1 : 0;
double[] c = allocVector(len, true, init);
for( int j = ai; j < ai+alen; j++ )
- c[aix[j]] = ((a[j] > bval) ? 1 : 0) - init;
+ c[aix[j]] = ((a[j] > bval) ? 1 : 0);
return c;
}
@@ -1185,7 +1194,7 @@ public class LibSpoofPrimitives
public static double[] vectGreaterequalWrite(double[] a, double bval, int[] aix, int ai, int alen, int len) {
double init = (bval < 0) ? 1 : 0;
double[] c = allocVector(len, true, init);
- for( int j = ai; j < ai+len; j++ )
+ for( int j = ai; j < ai+alen; j++ )
c[aix[j]] = ((a[j] >= bval) ? 1 : 0) - init;
return c;
}
http://git-wip-us.apache.org/repos/asf/systemml/blob/db13eac1/src/test/java/org/apache/sysml/test/integration/functions/codegen/CPlanVectorPrimitivesTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/sysml/test/integration/functions/codegen/CPlanVectorPrimitivesTest.java b/src/test/java/org/apache/sysml/test/integration/functions/codegen/CPlanVectorPrimitivesTest.java
new file mode 100644
index 0000000..15d4eb0
--- /dev/null
+++ b/src/test/java/org/apache/sysml/test/integration/functions/codegen/CPlanVectorPrimitivesTest.java
@@ -0,0 +1,708 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sysml.test.integration.functions.codegen;
+
+import java.lang.reflect.Method;
+
+import org.junit.Test;
+import org.apache.hadoop.util.StringUtils;
+import org.apache.sysml.hops.Hop;
+import org.apache.sysml.hops.Hop.OpOp2;
+import org.apache.sysml.hops.codegen.cplan.CNodeBinary.BinType;
+import org.apache.sysml.hops.codegen.cplan.CNodeUnary.UnaryType;
+import org.apache.sysml.runtime.codegen.LibSpoofPrimitives;
+import org.apache.sysml.runtime.functionobjects.Builtin;
+import org.apache.sysml.runtime.instructions.InstructionUtils;
+import org.apache.sysml.runtime.matrix.data.MatrixBlock;
+import org.apache.sysml.runtime.matrix.operators.BinaryOperator;
+import org.apache.sysml.runtime.matrix.operators.ScalarOperator;
+import org.apache.sysml.runtime.matrix.operators.UnaryOperator;
+import org.apache.sysml.runtime.util.DataConverter;
+import org.apache.sysml.test.integration.AutomatedTestBase;
+import org.apache.sysml.test.utils.TestUtils;
+
+public class CPlanVectorPrimitivesTest extends AutomatedTestBase
+{
+ private static final int m = 3;
+ private static final int n = 1191;
+ private static final double sparsity1 = 0.9;
+ private static final double sparsity2 = 0.09;
+ private static final double eps = Math.pow(10, -10);
+
+ private enum InputType {
+ SCALAR,
+ VECTOR_DENSE,
+ VECTOR_SPARSE,
+ }
+
+ @Override
+ public void setUp() {
+ TestUtils.clearAssertionInformation();
+ }
+
+ //support aggregate vector primitives
+
+ @Test
+ public void testVectorSumDense() {
+ testVectorAggPrimitive(UnaryType.ROW_SUMS, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorSumSparse() {
+ testVectorAggPrimitive(UnaryType.ROW_SUMS, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorMinDense() {
+ testVectorAggPrimitive(UnaryType.ROW_MINS, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorMinSparse() {
+ testVectorAggPrimitive(UnaryType.ROW_MINS, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorMaxDense() {
+ testVectorAggPrimitive(UnaryType.ROW_MAXS, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorMaxSparse() {
+ testVectorAggPrimitive(UnaryType.ROW_MAXS, InputType.VECTOR_SPARSE);
+ }
+
+ //support unary vector primitives (pow2/mult2 current excluded because not unary)
+
+ @Test
+ public void testVectorExpDense() {
+ testVectorUnaryPrimitive(UnaryType.VECT_EXP, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorExpSparse() {
+ testVectorUnaryPrimitive(UnaryType.VECT_EXP, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorSqrtDense() {
+ testVectorUnaryPrimitive(UnaryType.VECT_SQRT, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorSqrtSparse() {
+ testVectorUnaryPrimitive(UnaryType.VECT_SQRT, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorLogDense() {
+ testVectorUnaryPrimitive(UnaryType.VECT_LOG, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorLogSparse() {
+ testVectorUnaryPrimitive(UnaryType.VECT_LOG, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorAbsDense() {
+ testVectorUnaryPrimitive(UnaryType.VECT_ABS, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorAbsSparse() {
+ testVectorUnaryPrimitive(UnaryType.VECT_ABS, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorRoundDense() {
+ testVectorUnaryPrimitive(UnaryType.VECT_ROUND, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorRoundSparse() {
+ testVectorUnaryPrimitive(UnaryType.VECT_ROUND, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorCeilDense() {
+ testVectorUnaryPrimitive(UnaryType.VECT_CEIL, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorCeilSparse() {
+ testVectorUnaryPrimitive(UnaryType.VECT_CEIL, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorFloorDense() {
+ testVectorUnaryPrimitive(UnaryType.VECT_FLOOR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorFloorSparse() {
+ testVectorUnaryPrimitive(UnaryType.VECT_FLOOR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorSignDense() {
+ testVectorUnaryPrimitive(UnaryType.VECT_SIGN, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorSignSparse() {
+ testVectorUnaryPrimitive(UnaryType.VECT_SIGN, InputType.VECTOR_SPARSE);
+ }
+
+ //support unary vector primitives (pow currently only on vector-scalars)
+
+ @Test
+ public void testVectorScalarMultDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MULT_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarMultSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_MULT_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorMultDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MULT_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorMultSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_MULT_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorMultDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MULT, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorMultSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MULT, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarDivDense() {
+ testVectorBinaryPrimitive(BinType.VECT_DIV_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarDivSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_DIV_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorDivDense() {
+ testVectorBinaryPrimitive(BinType.VECT_DIV_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorDivSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_DIV_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorDivDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_DIV, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorDivSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_DIV, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarPlusDense() {
+ testVectorBinaryPrimitive(BinType.VECT_PLUS_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarPlusSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_PLUS_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorPlusDense() {
+ testVectorBinaryPrimitive(BinType.VECT_PLUS_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorPlusSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_PLUS_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorPlusDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_PLUS, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorPlusSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_PLUS, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarMinusDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MINUS_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarMinusSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_MINUS_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorMinusDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MINUS_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorMinusSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_MINUS_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorMinusDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MINUS, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorMinusSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MINUS, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarMinDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MIN_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarMinSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_MIN_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorMinDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MIN_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorMinSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_MIN_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorMinDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MIN, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorMinSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MIN, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarMaxDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MAX_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarMaxSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_MAX_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorMaxDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MAX_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorMaxSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_MAX_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorMaxDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MAX, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorMaxSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_MAX, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarPowDense() {
+ testVectorBinaryPrimitive(BinType.VECT_POW_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarPowSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_POW_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorPowDense() {
+ testVectorBinaryPrimitive(BinType.VECT_POW_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorPowSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_POW_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ //TODO pow vector-vector operations
+
+ @Test
+ public void testVectorScalarEqualDense() {
+ testVectorBinaryPrimitive(BinType.VECT_EQUAL_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarEqualSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_EQUAL_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorEqualDense() {
+ testVectorBinaryPrimitive(BinType.VECT_EQUAL_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorEqualSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_EQUAL_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorEqualDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_EQUAL, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorEqualSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_EQUAL, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarNotEqualDense() {
+ testVectorBinaryPrimitive(BinType.VECT_NOTEQUAL_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarNotEqualSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_NOTEQUAL_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorNotEqualDense() {
+ testVectorBinaryPrimitive(BinType.VECT_NOTEQUAL_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorNotEqualSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_NOTEQUAL_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorNotEqualDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_NOTEQUAL, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorNotEqualSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_NOTEQUAL, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarLessDense() {
+ testVectorBinaryPrimitive(BinType.VECT_LESS_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarLessSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_LESS_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorLessDense() {
+ testVectorBinaryPrimitive(BinType.VECT_LESS_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorLessSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_LESS_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorLessDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_LESS, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorLessSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_LESS, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarLessEqualDense() {
+ testVectorBinaryPrimitive(BinType.VECT_LESSEQUAL_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarLessEqualSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_LESSEQUAL_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorLessEqualDense() {
+ testVectorBinaryPrimitive(BinType.VECT_LESSEQUAL_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorLessEqualSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_LESSEQUAL_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorLessEqualDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_LESSEQUAL, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorLessEqualSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_LESSEQUAL, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarGreaterDense() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATER_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarGreaterSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATER_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorGreaterDense() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATER_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorGreaterSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATER_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorGreaterDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATER, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorGreaterSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATER, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorScalarGreaterEqualDense() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATEREQUAL_SCALAR, InputType.VECTOR_DENSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testVectorScalarGreaterEqualSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATEREQUAL_SCALAR, InputType.VECTOR_SPARSE, InputType.SCALAR);
+ }
+
+ @Test
+ public void testScalarVectorGreaterEqualDense() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATEREQUAL_SCALAR, InputType.SCALAR, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testScalarVectorGreaterEqualSparse() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATEREQUAL_SCALAR, InputType.SCALAR, InputType.VECTOR_SPARSE);
+ }
+
+ @Test
+ public void testVectorVectorGreaterEqualDenseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATEREQUAL, InputType.VECTOR_DENSE, InputType.VECTOR_DENSE);
+ }
+
+ @Test
+ public void testVectorVectorGreaterEqualSparseDense() {
+ testVectorBinaryPrimitive(BinType.VECT_GREATEREQUAL, InputType.VECTOR_SPARSE, InputType.VECTOR_DENSE);
+ }
+
+ @SuppressWarnings("incomplete-switch")
+ private void testVectorAggPrimitive(UnaryType aggtype, InputType type1)
+ {
+ try {
+ //generate input data
+ double sparsity = (type1 == InputType.VECTOR_DENSE) ? sparsity1 : sparsity2;
+ MatrixBlock in = MatrixBlock.randOperations(m, n, sparsity, -1, 1, "uniform", 7);
+
+ //get vector primitive via reflection
+ String meName = "vect"+StringUtils.camelize(aggtype.name().split("_")[1].substring(0, 3));
+ Method me = (type1 == InputType.VECTOR_DENSE) ?
+ LibSpoofPrimitives.class.getMethod(meName, new Class[]{double[].class, int.class, int.class}) :
+ LibSpoofPrimitives.class.getMethod(meName, new Class[]{double[].class, int[].class, int.class, int.class, int.class});
+
+ for( int i=0; i<m; i++ ) {
+ //execute vector primitive via reflection
+ Double ret1 = (Double) ((type1 == InputType.VECTOR_DENSE) ?
+ me.invoke(null, in.getDenseBlock(), i*n, n) :
+ me.invoke(null, in.getSparseBlock().values(i), in.getSparseBlock().indexes(i),
+ in.getSparseBlock().pos(i), in.getSparseBlock().size(i), n));
+
+ //execute comparison operation
+ MatrixBlock in2 = in.sliceOperations(i, i, 0, n-1, new MatrixBlock());
+ Double ret2 = -1d;
+ switch( aggtype ) {
+ case ROW_SUMS: ret2 = in2.sum(); break;
+ case ROW_MAXS: ret2 = in2.max(); break;
+ case ROW_MINS: ret2 = in2.min(); break;
+ }
+
+ //compare results
+ TestUtils.compareCellValue(ret1, ret2, eps, false);
+ }
+ }
+ catch( Exception ex ) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ private void testVectorUnaryPrimitive(UnaryType utype, InputType type1)
+ {
+ try {
+ //generate input data
+ double sparsity = (type1 == InputType.VECTOR_DENSE) ? sparsity1 : sparsity2;
+ MatrixBlock in = MatrixBlock.randOperations(m, n, sparsity, -1, 1, "uniform", 7);
+
+ //get vector primitive via reflection
+ String meName = "vect"+StringUtils.camelize(utype.name().split("_")[1])+"Write";
+ Method me = (type1 == InputType.VECTOR_DENSE) ?
+ LibSpoofPrimitives.class.getMethod(meName, new Class[]{double[].class, int.class, int.class}) :
+ LibSpoofPrimitives.class.getMethod(meName, new Class[]{double[].class, int[].class, int.class, int.class, int.class});
+
+ for( int i=0; i<m; i++ ) {
+ //execute vector primitive via reflection
+ double[] ret1 = (double[]) ((type1 == InputType.VECTOR_DENSE) ?
+ me.invoke(null, in.getDenseBlock(), i*n, n) :
+ me.invoke(null, in.getSparseBlock().values(i), in.getSparseBlock().indexes(i),
+ in.getSparseBlock().pos(i), in.getSparseBlock().size(i), n));
+
+ //execute comparison operation
+ String opcode = utype.name().split("_")[1].toLowerCase();
+ UnaryOperator uop = new UnaryOperator(Builtin.getBuiltinFnObject(opcode));
+ double[] ret2 = DataConverter.convertToDoubleVector(((MatrixBlock)in
+ .sliceOperations(i, i, 0, n-1, new MatrixBlock())
+ .unaryOperations(uop, new MatrixBlock())));
+
+ //compare results
+ TestUtils.compareMatrices(ret1, ret2, eps);
+ }
+ }
+ catch( Exception ex ) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ private void testVectorBinaryPrimitive(BinType bintype, InputType type1, InputType type2)
+ {
+ try {
+ //generate input data (scalar later derived if needed)
+ double sparsityA = (type1 == InputType.VECTOR_DENSE) ? sparsity1 : sparsity2;
+ MatrixBlock inA = MatrixBlock.randOperations(m, n, sparsityA, -5, 5, "uniform", 3);
+ double sparsityB = (type2 == InputType.VECTOR_DENSE) ? sparsity1 : sparsity2;
+ MatrixBlock inB = MatrixBlock.randOperations(m, n, sparsityB, -5, 5, "uniform", 7);
+
+ //get vector primitive via reflection
+ String meName = "vect"+StringUtils.camelize(bintype.name().split("_")[1])+"Write";
+ Method me = null;
+ if( type1==InputType.SCALAR && type2==InputType.VECTOR_DENSE )
+ me = LibSpoofPrimitives.class.getMethod(meName, new Class[]{double.class, double[].class, int.class, int.class});
+ else if( type1==InputType.VECTOR_DENSE && type2==InputType.SCALAR )
+ me = LibSpoofPrimitives.class.getMethod(meName, new Class[]{double[].class, double.class, int.class, int.class});
+ else if( type1==InputType.VECTOR_DENSE && type2==InputType.VECTOR_DENSE )
+ me = LibSpoofPrimitives.class.getMethod(meName, new Class[]{double[].class, double[].class, int.class, int.class, int.class});
+ else if( type1==InputType.VECTOR_SPARSE && type2==InputType.SCALAR )
+ me = LibSpoofPrimitives.class.getMethod(meName, new Class[]{double[].class, double.class, int[].class, int.class, int.class, int.class});
+ else if( type1==InputType.SCALAR && type2==InputType.VECTOR_SPARSE )
+ me = LibSpoofPrimitives.class.getMethod(meName, new Class[]{double.class, double[].class, int[].class, int.class, int.class, int.class});
+ else if( type1==InputType.VECTOR_SPARSE && type2==InputType.VECTOR_DENSE )
+ me = LibSpoofPrimitives.class.getMethod(meName, new Class[]{double[].class, double[].class, int[].class, int.class, int.class, int.class, int.class});
+
+ for( int i=0; i<m; i++ ) {
+ //execute vector primitive via reflection
+ double[] ret1 = null;
+ if( type1==InputType.SCALAR && type2==InputType.VECTOR_DENSE )
+ ret1 = (double[]) me.invoke(null, inA.max(), inB.getDenseBlock(), i*n, n);
+ else if( type1==InputType.VECTOR_DENSE && type2==InputType.SCALAR )
+ ret1 = (double[]) me.invoke(null, inA.getDenseBlock(), inB.max(), i*n, n);
+ else if( type1==InputType.VECTOR_DENSE && type2==InputType.VECTOR_DENSE )
+ ret1 = (double[]) me.invoke(null, inA.getDenseBlock(), inB.getDenseBlock(), i*n, i*n, n);
+ else if( type1==InputType.VECTOR_SPARSE && type2==InputType.SCALAR )
+ ret1 = (double[]) me.invoke(null, inA.getSparseBlock().values(i), inB.max(), inA.getSparseBlock().indexes(i),
+ inA.getSparseBlock().pos(i), inA.getSparseBlock().size(i), n);
+ else if( type1==InputType.SCALAR && type2==InputType.VECTOR_SPARSE )
+ ret1 = (double[]) me.invoke(null, inA.max(), inB.getSparseBlock().values(i),
+ inB.getSparseBlock().indexes(i), inB.getSparseBlock().pos(i), inB.getSparseBlock().size(i), n);
+ else if( type1==InputType.VECTOR_SPARSE && type2==InputType.VECTOR_DENSE )
+ ret1 = (double[]) me.invoke(null, inA.getSparseBlock().values(i), inB.getDenseBlock(),
+ inA.getSparseBlock().indexes(i), inA.getSparseBlock().pos(i), i*n, inA.getSparseBlock().size(i), n);
+
+ //execute comparison operation
+ String opcode = Hop.getBinaryOpCode(OpOp2.valueOf(bintype.name().split("_")[1]));
+ MatrixBlock in1 = inA.sliceOperations(i, i, 0, n-1, new MatrixBlock());
+ MatrixBlock in2 = inB.sliceOperations(i, i, 0, n-1, new MatrixBlock());
+ double[] ret2 = null;
+ if( type1 == InputType.SCALAR ) {
+ ScalarOperator bop = InstructionUtils.parseScalarBinaryOperator(opcode, true);
+ bop.setConstant(inA.max());
+ ret2 = DataConverter.convertToDoubleVector((MatrixBlock)
+ in2.scalarOperations(bop, new MatrixBlock()));
+ }
+ else if( type2 == InputType.SCALAR ) {
+ ScalarOperator bop = InstructionUtils.parseScalarBinaryOperator(opcode, false);
+ bop.setConstant(inB.max());
+ ret2 = DataConverter.convertToDoubleVector((MatrixBlock)
+ in1.scalarOperations(bop, new MatrixBlock()));
+ }
+ else { //vector-vector
+ BinaryOperator bop = InstructionUtils.parseBinaryOperator(opcode);
+ ret2 = DataConverter.convertToDoubleVector((MatrixBlock)
+ in1.binaryOperations(bop, in2, new MatrixBlock()));
+ }
+
+ //compare results
+ TestUtils.compareMatrices(ret1, ret2, eps);
+ }
+ }
+ catch( Exception ex ) {
+ throw new RuntimeException(ex);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/systemml/blob/db13eac1/src/test/java/org/apache/sysml/test/utils/TestUtils.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/sysml/test/utils/TestUtils.java b/src/test/java/org/apache/sysml/test/utils/TestUtils.java
index beb19a3..2ea3760 100644
--- a/src/test/java/org/apache/sysml/test/utils/TestUtils.java
+++ b/src/test/java/org/apache/sysml/test/utils/TestUtils.java
@@ -633,7 +633,12 @@ public class TestUtils
}
return Math.abs(v1 - v2) <= t;
}
-
+
+ public static void compareMatrices(double[] expectedMatrix, double[] actualMatrix, double epsilon) {
+ compareMatrices(new double[][]{expectedMatrix},
+ new double[][]{actualMatrix}, 1, expectedMatrix.length, epsilon);
+ }
+
/**
* <p>
* Compares two matrices in array format.
http://git-wip-us.apache.org/repos/asf/systemml/blob/db13eac1/src/test_suites/java/org/apache/sysml/test/integration/functions/codegen/ZPackageSuite.java
----------------------------------------------------------------------
diff --git a/src/test_suites/java/org/apache/sysml/test/integration/functions/codegen/ZPackageSuite.java b/src/test_suites/java/org/apache/sysml/test/integration/functions/codegen/ZPackageSuite.java
index a422823..a7d45bf 100644
--- a/src/test_suites/java/org/apache/sysml/test/integration/functions/codegen/ZPackageSuite.java
+++ b/src/test_suites/java/org/apache/sysml/test/integration/functions/codegen/ZPackageSuite.java
@@ -39,6 +39,7 @@ import org.junit.runners.Suite;
CompressedOuterProductTest.class,
CompressedRowAggregateTest.class,
CPlanComparisonTest.class,
+ CPlanVectorPrimitivesTest.class,
DAGCellwiseTmplTest.class,
MultiAggTmplTest.class,
OuterProdTmplTest.class,