This is an automated email from the ASF dual-hosted git repository.
mboehm7 pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/systemds.git
The following commit(s) were added to refs/heads/main by this push:
new f4e53ba17a [SYSTEMDS-3696] Performance improvements incremental slice
finding
f4e53ba17a is described below
commit f4e53ba17a4147ecfacb10b0c905f09397d7545b
Author: Matthias Boehm <[email protected]>
AuthorDate: Sun Sep 1 18:20:40 2024 +0200
[SYSTEMDS-3696] Performance improvements incremental slice finding
This patch is a performance fix-pack for incremental SliceLine, which
improved its runtime from 90.4 to 52.2s on a particular scenario with
the Adult dataset. In detail, the modifications include:
* vectorized one-hot encoding: O(m^2*n^2) -> O(m*n)
* vectorized scoring of previous top-k set
* vectorized pruning of unchanged slices
* vectorized removal of deleted tuples: O(n^2) -> O(n)
Furthermore, this patch also cleans up the wrong formatting (spaces
instead of tabs) of the incremental slice finder tests.
---
scripts/builtin/incSliceLine.dml | 188 +-
.../builtin/part2/BuiltinIncSliceLineTest.java | 2532 ++++++++++----------
2 files changed, 1349 insertions(+), 1371 deletions(-)
diff --git a/scripts/builtin/incSliceLine.dml b/scripts/builtin/incSliceLine.dml
index f9c34127d0..2c0cae6c4f 100644
--- a/scripts/builtin/incSliceLine.dml
+++ b/scripts/builtin/incSliceLine.dml
@@ -22,7 +22,7 @@
# This builtin function implements incSliceLine, a linear-algebra-based
# ML model debugging technique for finding the top-k data slices where
# a trained models performs significantly worse than on the overall
-# dataset. IncSliceLine is designed for scenarios in which training data is
updated incrementally.
+# dataset. IncSliceLine is designed for scenarios in which training data is
updated incrementally.
# For a detailed description of the SliceLine algorithm and experimental
results, see:
# Svetlana Sagadeeva, Matthias Boehm: SliceLine: Fast, Linear-Algebra-based
Slice Finding for ML Model Debugging.(SIGMOD 2021)
#
@@ -51,7 +51,7 @@
# prevStats previous statistics whole lattice (for incremental updates)
# prevTK previous top-k slices (for incremental updates)
# prevTKC previous top-k scores (for incremental updates)
-# encodeLat flag for encoding output lattice for less memory
consumption
+# encodeLat flag for encoding output lattice for less memory consumption
#
---------------------------------------------------------------------------------------
#
# OUTPUT:
@@ -70,27 +70,27 @@
#
-----------------------------------------------------------------------------------------
m_incSliceLine = function(
- Matrix[Double] addedX, Matrix[Double] oldX = matrix(0, 0, 0),
- Matrix[Double] oldE = matrix(0, 0, 0), Matrix[Double] addedE,
+ Matrix[Double] addedX, Matrix[Double] oldX = matrix(0, 0, 0),
+ Matrix[Double] oldE = matrix(0, 0, 0), Matrix[Double] addedE,
Int k = 4, Int maxL = 0, Int minSup = 32, Double alpha = 0.5,
- Boolean tpEval = TRUE, Int tpBlksz = 16, Boolean selFeat = FALSE,
+ Boolean tpEval = TRUE, Int tpBlksz = 16, Boolean selFeat = FALSE,
Matrix[Double] indicesRemoved = matrix(0,0,0),
- Boolean verbose = FALSE, list[unknown] params = list(),
+ Boolean verbose = FALSE, list[unknown] params = list(),
Matrix[Double] prevFoffb = matrix(0,0,0), Matrix[Double] prevFoffe =
matrix(0,0,0),
- list[unknown] prevLattice = list(), list[unknown] metaPrevLattice =
list(),
- list[unknown] prevStats = list(), Matrix[Double] prevTK = matrix(0,0,0),
+ list[unknown] prevLattice = list(), list[unknown] metaPrevLattice = list(),
+ list[unknown] prevStats = list(), Matrix[Double] prevTK = matrix(0,0,0),
Matrix[Double] prevTKC = matrix(0,0,0), Boolean encodeLat = TRUE)
return(
- Matrix[Double] TK, Matrix[Double] TKC, Matrix[Double] D,
+ Matrix[Double] TK, Matrix[Double] TKC, Matrix[Double] D,
list[unknown] L, list[unknown] metaLattice,
- list[unknown] Stats, Matrix[Double] Xout, Matrix[Double] eOut,
+ list[unknown] Stats, Matrix[Double] Xout, Matrix[Double] eOut,
Matrix[Double] foffb, Matrix[Double] foffe, list[unknown] params)
{
- # for incremental updates a params list storing previous parameters is
required
+ # for incremental updates a params list storing previous parameters is
required
# to ensure consistent parameters over all runs
- # the params list is automatically generated from the first run's params and
only needs to be passed on.
- if(length(prevLattice) > 0 &
- ((length(prevStats) == 0 | length(params) == 0 | nrow(prevFoffb) == 0 |
nrow(prevFoffe) == 0 |
+ # the params list is automatically generated from the first run's params and
only needs to be passed on.
+ if(length(prevLattice) > 0 &
+ ((length(prevStats) == 0 | length(params) == 0 | nrow(prevFoffb) == 0 |
nrow(prevFoffe) == 0 |
nrow(oldX) == 0 | nrow(oldE) == 0) | (encodeLat &
length(metaPrevLattice) == 0)))
{
[TK, TKC, D, L, Stats, Xout, eOut, foffb, foffe, metaLattice, params] =
throwNoParamsError();
@@ -105,12 +105,10 @@ m_incSliceLine = function(
D = matrix(0, 0, 5);
# combine old and added feature matrices and error vectors
- if(nrow(oldX) == 0) {
+ if(nrow(oldX) == 0 | nrow(oldE) == 0) {
oldX = matrix(0,0,ncol(addedX));
- }
- if(nrow(oldE) == 0) {
oldE = matrix(0,0,ncol(addedE));
- }
+ }
removedTuples = matrix(0,0,ncol(oldX));
if(length(indicesRemoved) > 0 & nrow(oldX) > 0){
@@ -138,7 +136,7 @@ m_incSliceLine = function(
rix = matrix(seq(1,m)%*%matrix(1,1,n), m*n, 1)
cix = matrix(totalX + foffb, m*n, 1);
X2 = table(rix, cix, 1, m, as.scalar(foffe[,n]), FALSE); #one-hot encoded
-
+
#inititalize booleans
differentOffsets = TRUE;
if(nrow(prevFoffb) > 0){
@@ -169,7 +167,7 @@ m_incSliceLine = function(
}else{
prevTK2 = prevTK;
}
-
+
# initialize statistics and basic slices
n2 = ncol(X2); # one-hot encoded features
eAvgOld = sum(oldE) / nrow(oldX); # average error
@@ -180,7 +178,7 @@ m_incSliceLine = function(
minsc = -Inf;
if( nrow(prevTK2) > 0 ) {
[minsc] = computeLowestPrevTK (prevTK2, X2, totalE, eAvg, alpha, minsc)
- }
+ }
# create and score basic slices (conjunctions of 1 feature)
[S, R, selCols] = createAndScoreBasicSlices(X2, changedX2, prevTK2, totalE,
eAvg, eAvgOld, eAvgNew, minSup, alpha, minsc, verbose);
@@ -235,7 +233,7 @@ m_incSliceLine = function(
L = append(L, Lrep);
# load one hot encoded previous lattice for the current level
- prevLattice2 = preparePrevLattice(prevLattice, metaPrevLattice, prevFoffb,
+ prevLattice2 = preparePrevLattice(prevLattice, metaPrevLattice, prevFoffb,
prevFoffe, foffb, foffe, level, encodeLat, differentOffsets)
if(selFeat){
@@ -248,7 +246,7 @@ m_incSliceLine = function(
if(verbose) {
print("\nincSliceLine: level "+level+":")
}
-
+
# prune unchanged slices with slice size < minSup
if(level <= length(prevStats)){
[S, S2] = pruneUnchangedSlices(S, S2, prevLattice2, prevStats,
changedX2, minSup, verbose, level);
@@ -324,7 +322,7 @@ createAndScoreBasicSlices = function(Matrix[Double] X2,
Matrix[Double] changedX2
TKCCnts = matrix(0, 0, 0);
if ( length (prevTK2) > 0 ) {
TKCCnts = t(colSums(prevTK2));
- }
+ }
# working set of active slices (#attr x #slices) and top k
# only consider slices that have been changed (addedCCnts != 0) with cCnts
>= minSup and non-zero err.
@@ -481,7 +479,7 @@ getPairedCandidates = function(Matrix[Double] S, Double
minsc,
# prepare IDs for deduplication and pruning
[ID, M] = transformSlicesToIDs(P, foffb, foffe);
-
+
# size pruning, with rowMin-rowMax transform
# to avoid densification (ignored zeros)
map = table(ID, seq(1,nrow(P)), max(ID), nrow(P))
@@ -554,34 +552,28 @@ decodeOneHot = function(Matrix[Double] M, Matrix[Double]
foffb, Matrix[Double] f
}
# function to oneHotEncode but with predefined feature offsets, to facilitate
the same encoding for different datasets
+# note: this version needs to deal with zeros while the preprocessing encoding
does not
oneHotEncodeUsingOffsets = function(Matrix[Double] A, Matrix[Double] foffb,
Matrix[Double] foffe)
- return(Matrix[Double] A_encoded)
+ return(Matrix[Double] A2)
{
m = nrow(A);
n = ncol(A);
- numFeatures = ncol(foffb);
-
- maxDomainSize = as.scalar(foffe[1, ncol(foffe)]);
- A_encoded = matrix(0, m, maxDomainSize);
-
- for (j in 1:numFeatures) {
- beg = as.scalar(foffb[1, j]) + 1;
- end = as.scalar(foffe[1, j]);
-
- for (i in 1:m) {
- value = as.scalar(A[i, j]);
- if (value > 0) {
- A_encoded[i, beg + value - 1] = 1;
- }
- }
+ rix = matrix(seq(1,m)%*%matrix(1,1,n), m*n, 1)
+ cix = matrix((A!=0)*(A + foffb), m*n, 1);
+ if( sum(cix!=0) < m*n ) {
+ ix = cix != 0;
+ rix = removeEmpty(target=rix, margin="rows", select=ix);
+ cix = removeEmpty(target=cix, margin="rows", select=ix);
}
+ # actual one-hot encoding
+ A2 = table(rix, cix, 1, m, as.scalar(foffe[,n]), FALSE);
}
-# throws an error if no params are provided for incremental updates.
+# throws an error if no params are provided for incremental updates.
# in case only individual parameters are entered they will be overwritten to
ensure consistency
-throwNoParamsError = function()
+throwNoParamsError = function()
return(Matrix[Double] TK, Matrix[Double] TKC, Matrix[Double] D,
list[unknown] L,
- list[unknown] Stats, Matrix[Double] Xout, Matrix[Double] eOut,
Matrix[Double] foffb,
+ list[unknown] Stats, Matrix[Double] Xout, Matrix[Double] eOut,
Matrix[Double] foffb,
Matrix[Double] foffe, list[unknown] metaLattice, list[unknown] params) {
print("incSliceLine: wrong or no parameters provided for incremental update.
Please provide all parameters.");
print(" -- necessary parameters: params, prevLattice, prevStats, prevFoffb,
prevFoffe, prevTK, prevTKC, oldX, oldE. ");
@@ -600,13 +592,13 @@ throwNoParamsError = function()
}
# store parameters for next run and overwrite params if provided
-storeParams = function(Integer k, Integer maxL, Integer minSup, Double alpha,
Boolean tpEval,
+storeParams = function(Integer k, Integer maxL, Integer minSup, Double alpha,
Boolean tpEval,
Integer tpBlksz, Boolean selFeat, Boolean encodeLat, list[unknown] params)
- return(list[unknown] params, Integer k, Integer maxL, Integer minSup,
+ return(list[unknown] params, Integer k, Integer maxL, Integer minSup,
Double alpha, Boolean tpEval, Integer tpBlksz, Boolean selFeat, Boolean
encodeLat)
{
if(length(params) == 0) {
- params = list(as.double(k), as.double(maxL), as.double(minSup),
+ params = list(as.double(k), as.double(maxL), as.double(minSup),
alpha, as.double(tpEval), as.double(tpBlksz), as.double(selFeat),
as.double(encodeLat));
} else {
k = as.scalar(params[1]);
@@ -623,37 +615,30 @@ storeParams = function(Integer k, Integer maxL, Integer
minSup, Double alpha, Bo
determineUnchangedSlices = function(Matrix[Double] prevStatsAtLevel,
Matrix[Double] prevLatAtLevel, Matrix[Double] changedX2, Integer level)
return(Matrix[Double] unchangedS, Matrix[Double] unchangedR)
{
- # only computing unchanged slices for levels 2 and above,
- # Imat has a 1 where a slice in changedX2 belongs to a slice in
prevLatAtLevel
- Imat = (changedX2 %*% t(prevLatAtLevel) == level);
- unchangedSlicesI = colSums(Imat) == 0;
- unchangedS = removeEmpty(target=prevLatAtLevel, margin="rows",
select=unchangedSlicesI);
- unchangedR = removeEmpty(target=prevStatsAtLevel, margin="rows",
select=unchangedSlicesI);
+ # only computing unchanged slices for levels 2 and above,
+ # Imat has a 1 where a slice in changedX2 belongs to a slice in
prevLatAtLevel
+ Imat = (changedX2 %*% t(prevLatAtLevel) == level);
+ unchangedSlicesI = colSums(Imat) == 0;
+ unchangedS = removeEmpty(target=prevLatAtLevel, margin="rows",
select=unchangedSlicesI);
+ unchangedR = removeEmpty(target=prevStatsAtLevel, margin="rows",
select=unchangedSlicesI);
}
-computeLowestPrevTK = function(Matrix[Double] prevTK2, Matrix[Double]
X2,Matrix[Double] totalE, Double eAvg, Double alpha, Double minsc)
+computeLowestPrevTK = function(Matrix[Double] prevTK2, Matrix[Double] X2,
+ Matrix[Double] totalE, Double eAvg, Double alpha, Double minsc)
return(Double minsc)
{
+ # extract and evaluate candidate slices
+ l = t(rowSums(prevTK2));
- minsc = Inf;
- for(i in 1: nrow(prevTK2)){
- # extract and evaluate candidate slices
- curSlice = prevTK2[i,];
- l = rowSums(curSlice[1,]);
-
- # compute slice stats of curSlice within whole feature matrix X2.
- I = (X2 %*% t(curSlice)) == l; # slice indicator
- ss = t(colSums(I)); # absolute slice size (nnz)
- se = t(t(totalE) %*% I); # absolute slice error
- sm = t(colMaxs(I * totalE)); # maximum tuple error in slice
-
- # score slice and if applicable set min score for pruning
- sc = score(ss, se, eAvg, alpha, nrow(X2));
- minsc2 = as.scalar(sc[1,1]);
- if(minsc2 < minsc){
- minsc = minsc2;
- }
- }
+ # compute slice stats of curSlice within whole feature matrix X2.
+ I = (X2 %*% t(prevTK2)) == l; # slice indicator
+ ss = t(colSums(I)); # absolute slice size (nnz)
+ se = t(t(totalE) %*% I); # absolute slice error
+ sm = t(colMaxs(I * totalE)); # maximum tuple error in slice
+
+ # score slice and if applicable set min score for pruning
+ sc = score(ss, se, eAvg, alpha, nrow(X2));
+ minsc = min(sc);
}
pruneUnchangedSlices = function(Matrix[Double] S, Matrix[Double] S2,
Matrix[Double] prevLattice2, list[unknown] prevStats, Matrix[Double] changedX2,
Int minSup, Boolean verbose, Integer level)
@@ -670,23 +655,20 @@ pruneUnchangedSlices = function(Matrix[Double] S,
Matrix[Double] S2, Matrix[Doub
unchangedMat = (S2 %*% t(unchangedS)) == level;
levStats = unchangedR;
levSs = levStats[, 1];
- unchangedAndBelowMinSupI = matrix(0, nrow(S2), 1);
+ unchangedAndBelowMinSup = matrix(0, nrow(S2), 1);
if(nrow(unchangedMat) > 0 & ncol(unchangedMat) > 0 & nrow(levSs) > 0){
- for( i in 1:ncol(unchangedMat)){
- # by multiplying the columns of the unchanged mat with the sizes
- # from the previous lattice we get vectors indicating the sizes
- # of each unchanged slice (and 0 if it was changed)
- unchangedSizes = (unchangedMat[, i] * levSs[i])
- unchangedAndBelowMinSup = unchangedSizes < minSup & unchangedSizes > 0;
- unchangedAndBelowMinSupI = unchangedAndBelowMinSupI |
unchangedAndBelowMinSup;
- }
+ # by multiplying the columns of the unchanged mat with the sizes
+ # from the previous lattice we get vectors indicating the sizes
+ # of each unchanged slice (and 0 if it was changed)
+ unchangedSizes = unchangedMat * t(levSs)
+ unchangedAndBelowMinSup = rowSums(unchangedSizes < minSup &
unchangedSizes > 0) != 0;
}
- if(sum(unchangedAndBelowMinSupI) > 0){
- S2 = removeEmpty(target=S2, margin="rows",
select=unchangedAndBelowMinSupI == 0);
- S = removeEmpty(target=S, margin="rows", select=unchangedAndBelowMinSupI
== 0);
+ if(sum(unchangedAndBelowMinSup) > 0){
+ S2 = removeEmpty(target=S2, margin="rows",
select=unchangedAndBelowMinSup == 0);
+ S = removeEmpty(target=S, margin="rows", select=unchangedAndBelowMinSup
== 0);
if(verbose) {
- print(" -- Pruning " + sum(unchangedAndBelowMinSupI) +" slices that
are unchanged and below min sup.");
+ print(" -- Pruning " + sum(unchangedAndBelowMinSup) +" slices that are
unchanged and below min sup.");
}
}
}
@@ -721,7 +703,7 @@ transformSlicesToIDs = function(Matrix[Double] S,
Matrix[Double] foffb, Matrix[D
# Function to decode IDs back into slices using domain size scaling reversal
transformIDsToSlices = function(Matrix[Double] ID, Matrix[Double] foffb,
Matrix[Double] foffe, frame[unknown] M)
return(Matrix[Double] S)
-{
+{
if(nrow(ID) > 0){
ID = transformdecode(target=ID, spec="{ids:true,recode:[1]}", meta=M);
ID = as.matrix(ID);
@@ -744,13 +726,13 @@ transformIDsToSlices = function(Matrix[Double] ID,
Matrix[Double] foffb, Matrix[
}
}
-preparePrevLattice = function(list[unknown] prevLattice, list[unknown]
metaPrevLattice,
- Matrix[Double] prevFoffb, Matrix[Double] prevFoffe, Matrix[Double] foffb,
+preparePrevLattice = function(list[unknown] prevLattice, list[unknown]
metaPrevLattice,
+ Matrix[Double] prevFoffb, Matrix[Double] prevFoffe, Matrix[Double] foffb,
Matrix[Double] foffe, Integer level, Boolean encodeLat, Boolean
differentOffsets)
return (Matrix[Double] prevLattice2) {
prevLattice2 = matrix(0,0,0);
- if( length(prevLattice) >= level ) {
+ if( length(prevLattice) >= level ) {
prevLattice2 = as.matrix(prevLattice[level]);
if(nrow(prevLattice2) > 0){
if(encodeLat) {
@@ -768,21 +750,13 @@ preparePrevLattice = function(list[unknown] prevLattice,
list[unknown] metaPrevL
# Function to remove rows from matrix M based on a list of indices
removeRowsByIndices = function(Matrix[Double] M, Matrix[Double] indices)
- return (Matrix[Double] MWithoutRemovedSlices, Matrix[Double] removedTuples)
-{
- MWithoutRemovedSlices = matrix(0, 0, ncol(M));
- removedTuples = matrix(0, 0, ncol(M));
- index = 1;
- for(i in 1:nrow(indices)){
- index2 = as.scalar(indices[i]);
- removedTuples = rbind(removedTuples, M[index2, ]);
- if(index == index2){
- index = index + 1;
- i = i + 1;
- } else {
- MWithoutRemovedSlices = rbind(MWithoutRemovedSlices,
M[index:(index2-1),]);
- index = index2+1;
- }
- }
- MWithoutRemovedSlices = rbind(MWithoutRemovedSlices, M[index:nrow(M),]);
+ return (Matrix[Double] remain, Matrix[Double] removed)
+{
+ P1 = table(seq(1,nrow(indices)), indices, nrow(indices), nrow(M))
+ removed = P1 %*% M;
+ CIX = removeEmpty(target=(table(indices,1,nrow(M),1)==0)*seq(1,nrow(M)),
margin="rows")
+ P2 = table(seq(1, nrow(CIX)), CIX, nrow(CIX), nrow(M))
+ remain = P2 %*% M;
+ while(FALSE){} #prevent inlining (TODO rewrite issue)
}
+
diff --git
a/src/test/java/org/apache/sysds/test/functions/builtin/part2/BuiltinIncSliceLineTest.java
b/src/test/java/org/apache/sysds/test/functions/builtin/part2/BuiltinIncSliceLineTest.java
index a115767fe3..a3e1854db1 100644
---
a/src/test/java/org/apache/sysds/test/functions/builtin/part2/BuiltinIncSliceLineTest.java
+++
b/src/test/java/org/apache/sysds/test/functions/builtin/part2/BuiltinIncSliceLineTest.java
@@ -31,1268 +31,1272 @@ import org.apache.sysds.test.TestConfiguration;
import org.apache.sysds.test.TestUtils;
public class BuiltinIncSliceLineTest extends AutomatedTestBase {
- private static final String PREP_NAME = "slicefinderPrep";
- private static final String TEST_NAME = "incSliceLine";
- private static final String TEST_NAME2 = "incSliceLineFull";
- private static final String TEST_DIR = "functions/builtin/";
- private static final String TEST_CLASS_DIR = TEST_DIR +
BuiltinIncSliceLineTest.class.getSimpleName() + "/";
- private static final boolean VERBOSE = true;
-
- private static final double[][] EXPECTED_TOPK = new double[][] {
- { 1.042, 69210699988.477, 11078019685.642, 18.000 },
- { 0.478, 92957580467.849, 11078019685.642, 39.000 },
- { 0.316, 40425449547.480, 11078019685.642, 10.000 },
- { 0.262, 67630559163.266, 7261504482.540, 29.000 },
- { 0.224, 202448990843.317, 11119010986.000, 125.000 },
- { 0.218, 68860581248.568, 7261504482.540, 31.000 },
- { 0.164, 206527445340.279, 11119010986.000, 135.000 },
- { 0.122, 68961886413.866, 7261504482.540, 34.000 },
- { 0.098, 360278523220.479, 11119010986.000, 266.000 },
- { 0.092, 73954209826.485, 11078019685.642, 39.000 }
- };
-
- @Override
- public void setUp() {
- addTestConfiguration(TEST_NAME, new TestConfiguration(TEST_CLASS_DIR,
TEST_NAME, new String[] { "R" }));
- addTestConfiguration(TEST_NAME2, new TestConfiguration(TEST_CLASS_DIR,
TEST_NAME2, new String[] { "R" }));
- }
-
- @Test
- public void testTop4HybridDP() {
- runIncSliceLineTest(4, "e", true, false, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDP() {
- runIncSliceLineTest(4, "e", true, false, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTP() {
- runIncSliceLineTest(4, "e", false, false, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTP() {
- runIncSliceLineTest(4, "e", false, false, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDP() {
- runIncSliceLineTest(10, "e", true, false, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDP() {
- runIncSliceLineTest(10, "e", true, false, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTP() {
- runIncSliceLineTest(10, "e", false, false, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTP() {
- runIncSliceLineTest(10, "e", false, false, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPSel() {
- runIncSliceLineTest(4, "e", true, true, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPSel() {
- runIncSliceLineTest(4, "e", true, true, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPSel() {
- runIncSliceLineTest(4, "e", false, true, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPSel() {
- runIncSliceLineTest(4, "e", false, true, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPSel() {
- runIncSliceLineTest(10, "e", true, true, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPSel() {
- runIncSliceLineTest(10, "e", true, true, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSel() {
- runIncSliceLineTest(10, "e", false, true, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSel() {
- runIncSliceLineTest(10, "e", false, true, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelE2() {
- runIncSliceLineTest(10, "oe", false, true, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelE2() {
- runIncSliceLineTest(10, "oe", false, true, ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPFullFewAdded() {
- runIncSliceLineTest(4, "e", true, false,2, 1, false, false,
true,ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPFullFewAdded() {
- runIncSliceLineTest(4, "e", true, false,2, 1, false, false,
true,ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPFullFewAdded() {
- runIncSliceLineTest(4, "e", false, false, 2,1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4HybridDPFullFewAddedRemoved() {
- runIncSliceLineTest(4, "e", true, false,2, 90, false, true,
true,ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPFullFewAddedRemoved() {
- runIncSliceLineTest(4, "e", true, false,2, 1, false, true,
true,ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPFullFewAddedRemoved() {
- runIncSliceLineTest(4, "e", false, false, 2,1, false, true, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPFullFewAdded() {
- runIncSliceLineTest(4, "e", false, false,2, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPFullFewAdded() {
- runIncSliceLineTest(10, "e", true, false,2, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPFullFewAdded() {
- runIncSliceLineTest(10, "e", true, false,2, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPFullFewAdded() {
- runIncSliceLineTest(10, "e", false, false,2, 1, false, false,
false,ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPFullFewAdded() {
- runIncSliceLineTest(10, "e", false, false,2, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPSelFullFewAdded() {
- runIncSliceLineTest(4, "e", true, true,2, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPSelFullFewAdded() {
- runIncSliceLineTest(4, "e", true, true,2, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPSelFullFewAdded() {
- runIncSliceLineTest(4, "e", false, true,2, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4HybridDPSelFullFewAddedRemoved() {
- runIncSliceLineTest(4, "e", true, true,2, 1, false, true, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPSelFullFewAddedRemoved() {
- runIncSliceLineTest(4, "e", true, true,2, 1, false, true, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPSelFullFewAddedRemoved() {
- runIncSliceLineTest(4, "e", false, true,2, 1, false, true, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPSelFullFewAdded() {
- runIncSliceLineTest(4, "e", false, true,4, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPSelFullFewAdded() {
- runIncSliceLineTest(10, "e", true, true, 2, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPSelFullFewAdded() {
- runIncSliceLineTest(10, "e", true, true, 1, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelFullFewAdded() {
- runIncSliceLineTest(10, "e", false, true, 2, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelFullFewAdded() {
- runIncSliceLineTest(10, "e", false, true, 2, 1, false, false, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelE2FullFewAdded() {
- runIncSliceLineTest(10, "oe", false, true, 2, 1, false, false, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelE2FullFewAdded() {
- runIncSliceLineTest(10, "oe", false, true, 2, 1, false, false, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10SinglenodeTPSelFullFewAddedRemoved() {
- runIncSliceLineTest(10, "e", false, true, 2, 1, false, true, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelE2FullFewAddedRemoved() {
- runIncSliceLineTest(10, "oe", false, true, 2, 1, false, true, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelE2FullFewAddedRemoved() {
- runIncSliceLineTest(10, "oe", false, true, 2, 1, false, true, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPFullManyAdded() {
- runIncSliceLineTest(4, "e", true, false,50, 1, false, false, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPFullManyAdded() {
- runIncSliceLineTest(4, "e", true, false,50, 1, false, false, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPFullManyAdded() {
- runIncSliceLineTest(4, "e", false, false, 50,1, false, false, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4HybridDPFullManyAddedRemoved() {
- runIncSliceLineTest(4, "e", true, false,50, 1, false, true, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPFullManyAddedRemoved() {
- runIncSliceLineTest(4, "e", true, false,50, 1, false, true, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPFullManyAddedRemoved() {
- runIncSliceLineTest(4, "e", false, false, 50,1, false, true, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPFullManyAdded() {
- runIncSliceLineTest(4, "e", false, false,60, 1, false, false, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPFullManyAdded() {
- runIncSliceLineTest(10, "e", true, false,50, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPFullManyAdded() {
- runIncSliceLineTest(10, "e", true, false,50, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPFullManyAdded() {
- runIncSliceLineTest(10, "e", false, false,90 , 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPFullManyAdded() {
- runIncSliceLineTest(10, "e", false, false,99 , 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPSelFullManyAdded() {
- runIncSliceLineTest(4, "e", true, true,50, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10HybridTPFullManyAddedRemoved() {
- runIncSliceLineTest(10, "e", false, false,90 , 1, false, true, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPFullManyAddedRemoved() {
- runIncSliceLineTest(10, "e", false, false,99 , 1, false, true, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPSelFullManyAddedRemoved() {
- runIncSliceLineTest(4, "e", true, true,50, 1, false, true, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPSelFullManyAdded() {
- runIncSliceLineTest(4, "e", true, true,50, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPSelFullManyAdded() {
- runIncSliceLineTest(4, "e", false, true,50, 1, false, false, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPSelFullManyAdded() {
- runIncSliceLineTest(4, "e", false, true,50, 1, false, false, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPSelFullManyAdded() {
- runIncSliceLineTest(10, "e", true, true, 50, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPSelFullManyAdded() {
- runIncSliceLineTest(10, "e", true, true, 50, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelFullManyAdded() {
- runIncSliceLineTest(10, "e", false, true, 50, 1, false, false, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelFullManyAdded() {
- runIncSliceLineTest(10, "e", false, true, 50, 1, false, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelE2FullManyAdded() {
- runIncSliceLineTest(10, "oe", false, true, 50, 1, false, false,
false, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10HybridTPSelFullManyAddedRemoved() {
- runIncSliceLineTest(10, "e", false, true, 50, 1, false, true, false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelFullManyAddedRemoved() {
- runIncSliceLineTest(10, "e", false, true, 50, 1, false, true, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelE2FullManyAddedRemoved() {
- runIncSliceLineTest(10, "oe", false, true, 50, 99, false, true,
false, ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelE2FullManyAdded() {
- runIncSliceLineTest(10, "oe", false, true, 50, 1, false, false, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPFullFewAddedOnlyNull() {
- runIncSliceLineTest(4, "e", true, false,2, 1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPFullFewAddedOnlyNull() {
- runIncSliceLineTest(4, "e", true, false,2, 1, true, false,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPFullFewAddedOnlyNull() {
- runIncSliceLineTest(4, "e", false, false, 2,1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPFullFewAddedOnlyNull() {
- runIncSliceLineTest(4, "e", false, false,2, 1, true, false,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4SinglenodeDPFullFewAddedOnlyNullRemoved() {
- runIncSliceLineTest(4, "e", true, false,2, 1, true, true,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPFullFewAddedOnlyNullRemoved() {
- runIncSliceLineTest(4, "e", false, false, 2,1, true, true,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPFullFewAddedOnlyNullRemoved() {
- runIncSliceLineTest(4, "e", false, false,2, 1, true, true,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPFullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "e", true, false,2, 1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPFullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "e", true, false,2, 1, true, false,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPFullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "e", false, false,2, 1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPFullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "e", false, false,2, 1, true, false,false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPSelFullFewAddedOnlyNull() {
- runIncSliceLineTest(4, "e", true, true,2, 1, true, false,false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPSelFullFewAddedOnlyNull() {
- runIncSliceLineTest(4, "e", true, true,2, 1, true, false,false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPSelFullFewAddedOnlyNull() {
- runIncSliceLineTest(4, "e", false, true,2, 1, true, false,false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPSelFullFewAddedOnlyNull() {
- runIncSliceLineTest(4, "e", false, true,4, 1, true, false,false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPSelFullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "e", true, true, 2, 1, true, false,false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPSelFullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "e", true, true, 1, 1, true, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelFullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "e", false, true, 2, 1, true, false,false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelFullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "e", false, true, 2, 1, true, false,false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelE2FullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "oe", false, true, 2, 1, true, false,false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelE2FullFewAddedOnlyNull() {
- runIncSliceLineTest(10, "oe", false, true, 2, 1, true, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPFullManyAddedOnlyNull() {
- runIncSliceLineTest(4, "e", true, false,50, 1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPFullManyAddedOnlyNull() {
- runIncSliceLineTest(4, "e", true, false,50, 1, true, false,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPFullManyAddedOnlyNull() {
- runIncSliceLineTest(4, "e", false, false, 50, 1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPFullManyAddedOnlyNull() {
- runIncSliceLineTest(4, "e", false, false,60, 1, true, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPFullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "e", true, false,50, 1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPFullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "e", true, false,50, 1, true, false,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPFullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "e", false, false,90 , 1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPFullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "e", false, false,99 , 1, true, false,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10SinglenodeDPFullManyAddedOnlyNullRemoved() {
- runIncSliceLineTest(10, "e", true, false,50, 1, true, true,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPFullManyAddedOnlyNullRemoved() {
- runIncSliceLineTest(10, "e", false, false,90 , 50, true, true,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPFullManyAddedOnlyNullRemoved() {
- runIncSliceLineTest(10, "e", false, false,99 , 1, true, true,true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridDPSelFullManyAddedOnlyNull() {
- runIncSliceLineTest(4, "e", true, true,50, 1, true, false, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeDPSelFullManyAddedOnlyNull() {
- runIncSliceLineTest(4, "e", true, true,50, 1, true, false,false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop4HybridTPSelFullManyAddedOnlyNull() {
- runIncSliceLineTest(4, "e", false, true,50, 1, true, false,false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop4SinglenodeTPSelFullManyAddedOnlyNull() {
- runIncSliceLineTest(4, "e", false, true,50, 1, true, false,false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridDPSelFullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "e", true, true, 50, 1, true, false,false,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeDPSelFullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "e", true, true, 50, 1, true, false, false,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelFullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "e", false, true, 50, 1, true, false,true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelFullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "e", false, true, 50, 1, true, false, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelE2FullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "oe", false, true, 50, 1, true, false, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelE2FullManyAddedOnlyNull() {
- runIncSliceLineTest(10, "oe", false, true, 50, 1, true, false, true,
ExecMode.SINGLE_NODE);
- }
-
-
- @Test
- public void testTop10SinglenodeTPSelFullManyAddedOnlyNullRemoved() {
- runIncSliceLineTest(10, "e", false, true, 50, 1, true, true, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testTop10HybridTPSelE2FullManyAddedOnlyNullRemoved() {
- runIncSliceLineTest(10, "oe", false, true, 50, 20, true, true, true,
ExecMode.HYBRID);
- }
-
- @Test
- public void testTop10SinglenodeTPSelE2FullManyAddedOnlyNullRemoved() {
- runIncSliceLineTest(10, "oe", false, true, 50, 40, true, true, true,
ExecMode.SINGLE_NODE);
- }
-
- @Test
- public void testIncSliceLineCustomInputs1() {
- double[][] newX = {
- { 2, 1, 1, 2, 3, 2, 3, 3, 1, 2 },
- { 2, 2, 2, 3, 4, 1, 2, 1, 3, 2 },
- { 2, 1, 3, 3, 2, 2, 3, 1, 1, 4 },
- { 1, 2, 2, 1, 3, 2, 3, 2, 2, 3 },
- { 3, 2, 3, 4, 3, 3, 4, 1, 1, 3 },
- { 4, 3, 2, 3, 4, 4, 3, 4, 1, 1 },
- { 2, 2, 2, 4, 3, 3, 2, 2, 1, 2 },
- { 1, 1, 2, 2, 3, 3, 2, 1, 1, 2 },
- { 4, 3, 2, 1, 3, 2, 4, 2, 4, 3 },
- { 1, 3, 1, 4, 1, 3, 3, 2, 3, 2 },
- { 2, 4, 3, 1, 2, 4, 1, 3, 2, 4 },
- { 3, 2, 4, 3, 1, 4, 2, 3, 4, 1 },
- { 4, 1, 2, 4, 3, 1, 4, 2, 1, 3 },
- { 1, 3, 4, 2, 4, 3, 1, 4, 2, 3 },
- { 2, 4, 1, 3, 2, 4, 3, 1, 4, 2 },
- { 3, 2, 4, 1, 3, 4, 2, 3, 1, 4 },
- { 4, 1, 3, 2, 4, 1, 4, 2, 3, 1 },
- { 1, 3, 2, 4, 1, 3, 4, 2, 4, 3 },
- { 2, 4, 1, 3, 2, 4, 3, 1, 2, 4 },
- { 2, 3, 3, 2, 1, 4, 2, 3, 2, 3 }
- };
- double[][] e = {
- { 0.159 }, { 0.588 }, { 0.414 }, { 0.305 }, { 0.193 }, { 0.195
}, { 0.878 }, { 0.149 }, { 0.835 },
- { 0.344 },
- { 0.123 }, { 0.456 }, { 0.789 }, { 0.987 }, { 0.654 }, { 0.321
}, { 0.246 }, { 0.135 }, { 0.579 },
- { 0.802 }
- };
- int K = 10;
- double[][] correctRes = {
- { 0.307, 2.807, 0.878, 4.000 },
- { 0.307, 2.807, 0.878, 4.000 },
- { 0.282, 2.759, 0.987, 4.000 },
- { 0.157, 4.046, 0.987, 7.000 },
- { 0.127, 2.956, 0.878, 5.000 },
- { 0.122, 2.942, 0.878, 5.000 },
- { 0.074, 3.298, 0.987, 6.000 },
- { 0.064, 4.197, 0.878, 8.000 },
- { 0.061, 2.796, 0.987, 5.000 },
- { 0.038, 3.194, 0.878, 6.000 }
- };
- testIncSliceLineCustomInputs(newX, e, K, correctRes);
- }
-
- @Test
- public void testIncSliceLineCustomInputs2() {
- double[][] newX = {
- { 2, 1, 1, 1, 3, 4, 2, 2, 1, 2 },
- { 3, 3, 3, 2, 1, 2, 3, 1, 4, 2 },
- { 3, 2, 3, 1, 1, 1, 4, 3, 4, 2 },
- { 1, 3, 2, 3, 2, 3, 2, 1, 2, 1 },
- { 4, 3, 1, 1, 1, 1, 1, 1, 3, 2 },
- { 2, 2, 3, 3, 2, 2, 2, 3, 4, 1 },
- { 3, 2, 2, 2, 4, 4, 2, 4, 1, 1 },
- { 1, 3, 3, 2, 1, 3, 1, 2, 4, 4 },
- { 2, 1, 2, 2, 3, 1, 2, 3, 2, 1 },
- { 4, 1, 3, 4, 1, 4, 2, 3, 4, 4 },
- { 4, 2, 4, 4, 2, 1, 2, 1, 1, 4 },
- { 4, 1, 1, 4, 1, 4, 3, 2, 4, 2 },
- { 2, 1, 2, 2, 3, 1, 4, 3, 3, 4 },
- { 4, 1, 3, 1, 3, 1, 2, 1, 3, 3 },
- { 2, 1, 3, 1, 1, 3, 1, 2, 1, 2 },
- { 1, 3, 4, 3, 1, 2, 2, 2, 1, 1 },
- { 2, 4, 4, 3, 4, 1, 2, 1, 2, 4 },
- { 3, 3, 3, 3, 3, 1, 2, 3, 4, 4 },
- { 3, 2, 2, 2, 4, 1, 4, 2, 3, 1 },
- { 1, 2, 3, 2, 4, 3, 2, 3, 2, 3 }
- };
-
- double[][] e = {
- { 0.591 }, { 0.858 }, { 0.144 }, { 0.350 }, { 0.931 }, { 0.951
}, { 0.788 }, { 0.491 }, { 0.358 },
- { 0.443 },
- { 0.231 }, { 0.564 }, { 0.897 }, { 0.879 }, { 0.546 }, { 0.132
}, { 0.462 }, { 0.153 }, { 0.759 },
- { 0.028 }
- };
- int K = 10;
- double[][] correctRes = {
- { 0.410, 3.466, 0.931, 4.000 },
- { 0.410, 3.466, 0.931, 4.000 },
- { 0.111, 2.802, 0.897, 4.000 },
- { 0.075, 3.805, 0.951, 6.000 },
- { 0.057, 4.278, 0.897, 7.000 },
- { 0.047, 3.711, 0.931, 6.000 },
- { 0.035, 3.152, 0.897, 5.000 },
- { 0.032, 4.179, 0.897, 7.000 },
- { 0.023, 3.634, 0.931, 6.000 },
- { 0.013, 3.091, 0.931, 5.000 }
- };
-
- testIncSliceLineCustomInputs(newX, e, K, correctRes);
- }
-
- @Test
- public void testIncSliceLineCustomInputs3() {
- double[][] newX = {
- { 2, 1, 1, 2, 3, 2, 3, 3, 1, 2 },
- { 2, 2, 2, 3, 4, 1, 2, 1, 3, 2 },
- { 2, 1, 3, 3, 2, 2, 3, 1, 1, 4 },
- { 1, 2, 2, 1, 3, 2, 3, 2, 2, 3 },
- { 3, 2, 3, 4, 3, 3, 4, 1, 1, 3 },
- { 4, 3, 2, 3, 4, 4, 3, 4, 1, 1 },
- { 2, 2, 2, 4, 3, 3, 2, 2, 1, 2 },
- { 1, 1, 2, 2, 3, 3, 2, 1, 1, 2 },
- { 4, 3, 2, 1, 3, 2, 4, 2, 4, 3 },
- { 1, 3, 1, 4, 1, 3, 3, 2, 3, 2 },
- { 2, 4, 3, 1, 2, 4, 1, 3, 2, 4 },
- { 3, 2, 4, 3, 1, 4, 2, 3, 4, 1 },
- { 4, 1, 2, 4, 3, 1, 4, 2, 1, 3 },
- { 1, 3, 4, 2, 4, 3, 1, 4, 2, 3 },
- { 2, 4, 1, 3, 2, 4, 3, 1, 4, 2 },
- { 3, 2, 4, 1, 3, 4, 2, 3, 1, 4 },
- { 4, 1, 3, 2, 4, 1, 4, 2, 3, 1 },
- { 1, 3, 2, 4, 1, 3, 4, 2, 4, 3 },
- { 2, 4, 1, 3, 2, 4, 3, 1, 2, 4 },
- { 2, 3, 3, 2, 1, 4, 2, 3, 2, 3 },
- { 2, 1, 1, 1, 3, 4, 2, 2, 1, 2 },
- { 3, 3, 3, 2, 1, 2, 3, 1, 4, 2 },
- { 3, 2, 3, 1, 1, 1, 4, 3, 4, 2 },
- { 1, 3, 2, 3, 2, 3, 2, 1, 2, 1 },
- { 4, 3, 1, 1, 1, 1, 1, 1, 3, 2 },
- { 2, 2, 3, 3, 2, 2, 2, 3, 4, 1 },
- { 3, 2, 2, 2, 4, 4, 2, 4, 1, 1 },
- { 1, 3, 3, 2, 1, 3, 1, 2, 4, 4 },
- { 2, 1, 2, 2, 3, 1, 2, 3, 2, 1 },
- { 4, 1, 3, 4, 1, 4, 2, 3, 4, 4 },
- { 4, 2, 4, 4, 2, 1, 2, 1, 1, 4 },
- { 4, 1, 1, 4, 1, 4, 3, 2, 4, 2 },
- { 2, 1, 2, 2, 3, 1, 4, 3, 3, 4 },
- { 4, 1, 3, 1, 3, 1, 2, 1, 3, 3 },
- { 2, 1, 3, 1, 1, 3, 1, 2, 1, 2 },
- { 1, 3, 4, 3, 1, 2, 2, 2, 1, 1 },
- { 2, 4, 4, 3, 4, 1, 2, 1, 2, 4 },
- { 3, 3, 3, 3, 3, 1, 2, 3, 4, 4 },
- { 3, 2, 2, 2, 4, 1, 4, 2, 3, 1 },
- { 1, 2, 3, 2, 4, 3, 2, 3, 2, 3 }
- };
- double[][] e = {
- { 0.159 }, { 0.588 }, { 0.414 }, { 0.305 }, { 0.193 }, { 0.195
}, { 0.878 }, { 0.149 }, { 0.835 },
- { 0.344 },
- { 0.123 }, { 0.456 }, { 0.789 }, { 0.987 }, { 0.654 }, { 0.321
}, { 0.246 }, { 0.135 }, { 0.579 },
- { 0.802 },
- { 0.591 }, { 0.858 }, { 0.144 }, { 0.350 }, { 0.931 }, { 0.951
}, { 0.788 }, { 0.491 }, { 0.358 },
- { 0.443 },
- { 0.231 }, { 0.564 }, { 0.897 }, { 0.879 }, { 0.546 }, { 0.132
}, { 0.462 }, { 0.153 }, { 0.759 },
- { 0.028 }
- };
- int K = 10;
- double[][] correctRes = {
- { 0.149, 4.300, 0.931, 6.000 },
- { 0.113, 3.138, 0.987, 4.000 },
- { 0.093, 4.644, 0.931, 7.000 },
- { 0.090, 4.630, 0.951, 7.000 },
- { 0.059, 8.002, 0.951, 14.000 },
- { 0.024, 2.954, 0.951, 4.000 },
- { 0.017, 3.415, 0.897, 5.000 },
- { 0.010, 3.398, 0.878, 5.000 },
- { 0.009, 2.923, 0.897, 4.000 },
- { 0.008, 3.391, 0.897, 5.000 }
- };
- testIncSliceLineCustomInputs(newX, e, K, correctRes);
- }
-
- @Test
- public void testIncSliceLineCustomInputs4() {
- double[][] oldX = {
- { 2, 1, 1, 2, 3, 2, 3, 3, 1, 2 },
- { 2, 2, 2, 3, 4, 1, 2, 1, 3, 2 },
- { 2, 1, 3, 3, 2, 2, 3, 1, 1, 4 },
- { 1, 2, 2, 1, 3, 2, 3, 2, 2, 3 },
- { 3, 2, 3, 4, 3, 3, 4, 1, 1, 3 },
- { 4, 3, 2, 3, 4, 4, 3, 4, 1, 1 },
- { 2, 2, 2, 4, 3, 3, 2, 2, 1, 2 },
- { 1, 1, 2, 2, 3, 3, 2, 1, 1, 2 },
- { 4, 3, 2, 1, 3, 2, 4, 2, 4, 3 },
- { 1, 3, 1, 4, 1, 3, 3, 2, 3, 2 },
- { 2, 4, 3, 1, 2, 4, 1, 3, 2, 4 },
- { 3, 2, 4, 3, 1, 4, 2, 3, 4, 1 },
- { 4, 1, 2, 4, 3, 1, 4, 2, 1, 3 },
- { 1, 3, 4, 2, 4, 3, 1, 4, 2, 3 },
- { 2, 4, 1, 3, 2, 4, 3, 1, 4, 2 },
- { 3, 2, 4, 1, 3, 4, 2, 3, 1, 4 },
- { 4, 1, 3, 2, 4, 1, 4, 2, 3, 1 },
- { 1, 3, 2, 4, 1, 3, 4, 2, 4, 3 },
- { 2, 4, 1, 3, 2, 4, 3, 1, 2, 4 },
- { 2, 3, 3, 2, 1, 4, 2, 3, 2, 3 },
- { 2, 1, 1, 1, 3, 4, 2, 2, 1, 2 },
- { 3, 3, 3, 2, 1, 2, 3, 1, 4, 2 },
- { 3, 2, 3, 1, 1, 1, 4, 3, 4, 2 },
- { 1, 3, 2, 3, 2, 3, 2, 1, 2, 1 },
- { 4, 3, 1, 1, 1, 1, 1, 1, 3, 2 },
- { 2, 2, 3, 3, 2, 2, 2, 3, 4, 1 },
- { 3, 2, 2, 2, 4, 4, 2, 4, 1, 1 },
- { 1, 3, 3, 2, 1, 3, 1, 2, 4, 4 },
- { 2, 1, 2, 2, 3, 1, 2, 3, 2, 1 },
- { 4, 1, 3, 4, 1, 4, 2, 3, 4, 4 },
- };
- double[][] addedX = {
- { 4, 2, 4, 4, 2, 1, 2, 1, 1, 4 },
- { 4, 1, 1, 4, 1, 4, 3, 2, 4, 2 },
- { 2, 1, 2, 2, 3, 1, 4, 3, 3, 4 },
- { 4, 1, 3, 1, 3, 1, 2, 1, 3, 3 },
- { 2, 1, 3, 1, 1, 3, 1, 2, 1, 2 },
- { 1, 3, 4, 3, 1, 2, 2, 4, 1, 1 },
- { 2, 4, 4, 3, 4, 1, 2, 1, 2, 4 },
- { 3, 3, 3, 3, 3, 1, 2, 3, 4, 4 },
- { 3, 2, 2, 2, 4, 1, 4, 2, 3, 1 },
- { 1, 2, 3, 2, 4, 3, 2, 3, 2, 3 }
- };
- double[][] oldE = {
- { 0.159 }, { 0.588 }, { 0.414 }, { 0.305 }, { 0.193 }, { 0.195
}, { 0.878 }, { 0.149 }, { 0.835 },
- { 0.344 },
- { 0.123 }, { 0.456 }, { 0.789 }, { 0.987 }, { 0.654 }, { 0.321
}, { 0.246 }, { 0.135 }, { 0.579 },
- { 0.802 },
- { 0.591 }, { 0.858 }, { 0.144 }, { 0.350 }, { 0.931 }, { 0.951
}, { 0.788 }, { 0.491 }, { 0.358 },
- { 0.443 },
- };
- double[][] addedE = {
- { 0.231 }, { 0.564 }, { 0.897 }, { 0.879 }, { 0.546 }, { 0.132
}, { 0.462 }, { 0.153 }, { 0.759 },
- { 0.028 }
- };
-
- int K = 10;
-
- double[][] correctRes = {
- { 0.149, 4.300, 0.931, 6.000 },
- { 0.113, 3.138, 0.987, 4.000 },
- { 0.093, 4.644, 0.931, 7.000 },
- { 0.090, 4.630, 0.951, 7.000 },
- { 0.059, 8.002, 0.951, 14.000 },
- { 0.024, 2.954, 0.951, 4.000 },
- { 0.017, 3.415, 0.897, 5.000 },
- { 0.010, 3.398, 0.878, 5.000 },
- { 0.009, 2.923, 0.897, 4.000 },
- { 0.008, 3.391, 0.897, 5.000 }
- };
-
- testIncSliceLineCustomInputsFull(addedX, oldX, oldE, addedE, K,
correctRes);
- }
-
-
- @Test
- public void testIncSliceLineCustomInputsFull() {
- double[][] newX = {
- {1, 1, 1, 1},
- {1, 2, 2, 2},
- {1, 3, 3, 3},
- {1, 4, 4, 4},
- {5, 2, 5, 5},
- {6, 2, 6, 6},
- {7, 2, 7, 7},
- {8, 2, 8, 8},
- {9, 9, 9, 9},
- {1, 1, 1, 1},
- {2, 2, 2, 2},
- {3, 3, 3, 3},
- {4, 4, 4, 4},
- {5, 5, 5, 5},
- {6, 6, 6, 6},
- {7, 7, 7, 7},
- {8, 8, 8, 8},
- {9, 9, 9, 9},
- {1, 1, 1, 1},
- {2, 2, 2, 2},
- {3, 3, 3, 3},
- {4, 4, 4, 4},
- {5, 5, 5, 5},
- {6, 6, 6, 6},
- {7, 7, 7, 7},
- {8, 8, 8, 8},
- {9, 9, 9, 9},
- {1, 1, 1, 1},
- {2, 2, 2, 2},
- {3, 3, 3, 3},
- {4, 4, 4, 4},
- {5, 5, 5, 5},
- {6, 6, 6, 6},
- {7, 7, 7, 7},
- {8, 8, 8, 8},
- {9, 9, 9, 9},
- {10, 10, 10, 10},
- {11, 11, 11, 11},
- {12, 12, 12, 12},
- {13, 13, 13, 13},
- {14, 14, 14, 14},
- {15, 15, 15, 15},
- {16, 16, 16, 16},
- {17, 17, 17, 17},
- {18, 18, 18, 18},
- {19, 19, 19, 19},
- {20, 20, 20, 20},
- {10, 10, 10, 10},
- {11, 11, 11, 11},
- {12, 12, 12, 12},
- {13, 13, 13, 13},
- {14, 14, 14, 14},
- {15, 15, 15, 15},
- {16, 16, 16, 16},
- {17, 17, 17, 17},
- {18, 18, 18, 18},
- {19, 19, 19, 19},
- {20, 20, 20, 20},
- {10, 10, 10, 10},
- {11, 11, 11, 11},
- {12, 12, 12, 12},
- {13, 13, 13, 13},
- {14, 14, 14, 14},
- {15, 15, 15, 15},
- {16, 16, 16, 16},
- {17, 17, 17, 17},
- {18, 18, 18, 18},
- {19, 19, 19, 19},
- {20, 20, 20, 20},
- {10, 10, 10, 10},
- {11, 11, 11, 11},
- {12, 12, 12, 12},
- {13, 13, 13, 13},
- {14, 14, 14, 14},
- {15, 15, 15, 15},
- {16, 16, 16, 20},
- {17, 17, 17, 20},
- {18, 18, 18, 20},
- {19, 19, 19, 20},
- {20, 20, 20, 20}
- };
-
- double[][] e = {
- {0.001}, {0.002}, {0.003}, {0.004}, {0.005}, {0.006}, {0.007},
{0.008}, {0.009}, {0.010},
- {0.011}, {0.012}, {0.013}, {0.014}, {0.015}, {0.016}, {0.017},
{0.018}, {0.019}, {0.020},
- {0.021}, {0.022}, {0.023}, {0.024}, {0.025}, {0.026}, {0.027},
{0.028}, {0.029}, {0.030},
- {0.031}, {0.032}, {0.033}, {0.034}, {0.035}, {0.036}, {0.037},
{0.038}, {0.039}, {0.040},
- {0.041}, {0.042}, {0.043}, {0.044}, {0.045}, {0.046}, {0.047},
{0.048}, {0.049}, {0.050},
- {0.051}, {0.052}, {0.053}, {0.054}, {0.055}, {0.056}, {0.057},
{0.058}, {0.059}, {0.060},
- {0.061}, {0.062}, {0.063}, {0.064}, {0.065}, {0.066}, {0.067},
{0.068}, {0.069}, {0.070},
- {0.071}, {0.072}, {0.073}, {0.074}, {0.075}, {0.076}, {0.077},
{0.078}, {0.079}, {0.080}
-
- };
-
- runIncSliceLineTest(newX, e, 10, "e", false, true, 50, 1, false,
false, true, ExecMode.SINGLE_NODE);
- }
-
- // @Test
- // public void testTop10SparkTP() {
- // runIncSliceLineTest(10, false, ExecMode.SPARK);
- // }
-
- private void runIncSliceLineTest(int K, String err, boolean dp, boolean
selCols, ExecMode mode) {
- ExecMode platformOld = setExecMode(mode);
- loadTestConfiguration(getTestConfiguration(TEST_NAME));
- String HOME = SCRIPT_DIR + TEST_DIR;
- String data = DATASET_DIR + "Salaries.csv";
-
- try {
- loadTestConfiguration(getTestConfiguration(TEST_NAME));
-
- // run data preparation
- fullDMLScriptName = HOME + PREP_NAME + ".dml";
- programArgs = new String[] { "-args", data, err, output("newX"),
output("e") };
- runTest(true, false, null, -1);
-
- // read output and store for dml and R
- double[][] newX =
TestUtils.convertHashMapToDoubleArray(readDMLMatrixFromOutputDir("newX"));
- double[][] e =
TestUtils.convertHashMapToDoubleArray(readDMLMatrixFromOutputDir("e"));
-
- writeInputMatrixWithMTD("newX", newX, true);
- writeInputMatrixWithMTD("e", e, true);
-
- // execute main test
- fullDMLScriptName = HOME + TEST_NAME + ".dml";
- programArgs = new String[] { "-args", input("newX"), input("e"),
String.valueOf(K),
- String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(),
- String.valueOf(VERBOSE).toUpperCase(), output("R") };
-
- runTest(true, false, null, -1);
-
- HashMap<CellIndex, Double> dmlfile =
readDMLMatrixFromOutputDir("R");
-
- // execute main test
- fullDMLScriptName = HOME + "slicefinder" + ".dml";
- programArgs = new String[] { "-args", input("newX"), input("e"),
String.valueOf(K),
- String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(),
- String.valueOf(VERBOSE).toUpperCase(), output("R") };
-
- runTest(true, false, null, -1);
-
- HashMap<CellIndex, Double> dmlfile2 =
readDMLMatrixFromOutputDir("R");
-
- TestUtils.compareMatrices(dmlfile, dmlfile2, 1e-2,
"Stat-IncSliceLine", "Stat-Slicefinder");
-
- // compare expected results
- if (err.equals("e")) {
- double[][] ret =
TestUtils.convertHashMapToDoubleArray(dmlfile);
- if (mode != ExecMode.SPARK) // TODO why only CP correct, but R
always matches? test framework?
- for (int i = 0; i < K; i++)
- TestUtils.compareMatrices(EXPECTED_TOPK[i], ret[i],
1e-2);
- }
-
- // ensure proper inlining, despite initially multiple calls and
large function
- Assert.assertFalse(heavyHittersContainsSubString("evalSlice"));
- } finally {
- rtplatform = platformOld;
- }
- }
-
- private void runIncSliceLineTest(int K, String err, boolean dp, boolean
selCols, int proportionOfTuplesAddedInPercent, int
proportionOfTuplesRemovedInPercent, boolean onlyNullEAdded, boolean
removeTuples, boolean encodeLat, ExecMode mode) {
-
- runIncSliceLineTest(null, null, K, err, dp, selCols,
proportionOfTuplesAddedInPercent, proportionOfTuplesRemovedInPercent,
onlyNullEAdded, removeTuples, encodeLat, mode);
-
- }
-
-
- private void runIncSliceLineTest(double[][] customX, double[][]
customE,int K, String err, boolean dp, boolean selCols, int
proportionOfTuplesAddedInPercent, int proportionOfTuplesRemovedInPercent,
boolean onlyNullEAdded, boolean removeTuples, boolean encodeLat, ExecMode mode)
{
-
- ExecMode platformOld = setExecMode(mode);
- loadTestConfiguration(getTestConfiguration(TEST_NAME2));
- String HOME = SCRIPT_DIR + TEST_DIR;
- String data = DATASET_DIR + "Salaries.csv";
-
- try {
- loadTestConfiguration(getTestConfiguration(TEST_NAME2));
-
-
- double[][] newX = null;
- double[][] e = null;
- // read output and store for dml and R
- if(customX != null && customE != null){
- newX = customX;
- e = customE;
- } else {
- // run data preparation
- fullDMLScriptName = HOME + PREP_NAME + ".dml";
- programArgs = new String[] { "-args", data, err,
output("newX"), output("e") };
- runTest(true, false, null, -1);
-
- newX =
TestUtils.convertHashMapToDoubleArray(readDMLMatrixFromOutputDir("newX"));
- e =
TestUtils.convertHashMapToDoubleArray(readDMLMatrixFromOutputDir("e"));
- }
- int numOfAddedTuples = (int) Math.round(newX.length *
proportionOfTuplesAddedInPercent / 100.0);
- int numOfRemovedTuples = (int) Math.round((newX.length -
numOfAddedTuples) * proportionOfTuplesRemovedInPercent / 100.0);
- if(numOfRemovedTuples == 0){
- numOfRemovedTuples = 1;
- }
-
- double[][] addedX = new double[numOfAddedTuples][newX[0].length];
- double[][] oldX = new double[newX.length -
numOfAddedTuples][newX[0].length];
- double[][] indicesRemoved = new double[numOfRemovedTuples][1];
-
- if(removeTuples){
- for (int i = 0; i < numOfRemovedTuples; i++) {
- indicesRemoved[i][0] = i +1;
- }
- } else {
- for (int i = 0; i < numOfRemovedTuples; i++) {
- indicesRemoved[i][0] = 0;
- }
- }
-
- for (int i = 0; i < numOfAddedTuples; i++) {
- addedX[i] = newX[i];
- }
-
- for (int i = numOfAddedTuples; i < newX.length; i++) {
- oldX[i - numOfAddedTuples] = newX[i];
- }
-
- double[][] addedE = new double[numOfAddedTuples][e[0].length];
- double[][] oldE = new double[e.length -
numOfAddedTuples][e[0].length];
- if(onlyNullEAdded){
- for (int i = 0; i < numOfAddedTuples; i++) {
- addedE[i][0] = 0;
- e[i][0] = 0;
- }
- } else {
- for (int i = 0; i < numOfAddedTuples; i++) {
- addedE[i] = e[i];
- }
- }
-
- for (int i = numOfAddedTuples; i < e.length; i++) {
- oldE[i - numOfAddedTuples] = e[i];
- }
-
- writeInputMatrixWithMTD("addedX", addedX, false);
- writeInputMatrixWithMTD("oldX", oldX, false);
- writeInputMatrixWithMTD("oldE", oldE, false);
- writeInputMatrixWithMTD("addedE", addedE, false);
- writeInputMatrixWithMTD("indicesRemoved", indicesRemoved, false);
-
- fullDMLScriptName = HOME + TEST_NAME2 + ".dml";
- programArgs = new String[] { "-args", input("addedX"),
input("oldX"), input("oldE"), input("addedE"), String.valueOf(K),
- String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(), String.valueOf(encodeLat).toUpperCase(),
input("indicesRemoved"),
- String.valueOf(VERBOSE).toUpperCase(), output("R1"),
output("R2") };
-
- runTest(true, false, null, -1);
-
- HashMap<CellIndex, Double> dmlfile1 =
readDMLMatrixFromOutputDir("R1");
- HashMap<CellIndex, Double> dmlfile2 =
readDMLMatrixFromOutputDir("R2");
- double[][] ret1 = TestUtils.convertHashMapToDoubleArray(dmlfile1);
- double[][] ret2 = TestUtils.convertHashMapToDoubleArray(dmlfile2);
-
- TestUtils.compareMatrices(ret1, ret2, 1e-2);
-
- // if removeTuples is true, then we need to remove the tuples from
the oldX and oldE
- if(removeTuples){
- double[][] tempOldX = new double[oldX.length -
numOfRemovedTuples][oldX[0].length];
- double[][] tempOldE = new double[oldE.length -
numOfRemovedTuples][oldE[0].length];
- int j = 0;
- for (int i = 0; i < oldX.length; i++) {
- if(j < indicesRemoved.length){
- if(i == (int) indicesRemoved[j][0] - 1){
- j++;
- } else {
- tempOldX[i-j] = oldX[i];
- tempOldE[i-j] = oldE[i];
- }
- } else {
- tempOldX[i-j] = oldX[i];
- tempOldE[i-j] = oldE[i];
- }
- }
- oldX = tempOldX;
- oldE = tempOldE;
-
- }
-
- // combine oldX and addedX and write it into newX
- newX = new double[oldX.length + addedX.length][oldX[0].length];
- for (int i = 0; i < oldX.length; i++) {
- newX[i] = oldX[i];
- }
- for (int i = 0; i < addedX.length; i++) {
- newX[oldX.length + i] = addedX[i];
- }
-
- // combine oldE and addedE and write it into e
- e = new double[oldE.length + addedE.length][oldE[0].length];
- for (int i = 0; i < oldE.length; i++) {
- e[i] = oldE[i];
- }
- for (int i = 0; i < addedE.length; i++) {
- e[oldE.length + i] = addedE[i];
- }
-
-
-
-
- if(customX != null && customE != null){
- newX = customX;
- e = customE;
- }
- // execute main test
- writeInputMatrixWithMTD("newX", newX, false);
- writeInputMatrixWithMTD("e", e, false);
- fullDMLScriptName = HOME + "slicefinder" + ".dml";
- programArgs = new String[] { "-args", input("newX"), input("e"),
String.valueOf(K),
- String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(),
- String.valueOf(VERBOSE).toUpperCase(), output("R") };
-
- runTest(true, false, null, -1);
-
- HashMap<CellIndex, Double> dmlfile3 =
readDMLMatrixFromOutputDir("R");
-
-
- TestUtils.compareMatrices(dmlfile1, dmlfile3, 1e-2, "R1", "R");
-
-
- // compare expected results
- if (err.equals("e") && customX == null && customE == null &&
!onlyNullEAdded && !removeTuples) {
- double[][] ret =
TestUtils.convertHashMapToDoubleArray(dmlfile1);
- if (mode != ExecMode.SPARK) // TODO why only CP correct, but R
always matches? test framework?
- for (int i = 0; i < K; i++)
- TestUtils.compareMatrices(EXPECTED_TOPK[i], ret[i],
1e-2);
- }
-
- // ensure proper inlining, despite initially multiple calls and
large function
- Assert.assertFalse(heavyHittersContainsSubString("evalSlice"));
- } finally {
- rtplatform = platformOld;
- }
- }
-
- public void testIncSliceLineCustomInputs(double[][] newX, double[][] e,
int K, double[][] correctRes) {
- boolean dp = true, selCols = false;
- ExecMode mode = ExecMode.SINGLE_NODE;
- ExecMode platformOld = setExecMode(mode);
- loadTestConfiguration(getTestConfiguration(TEST_NAME));
- String HOME = SCRIPT_DIR + TEST_DIR;
-
- try {
- loadTestConfiguration(getTestConfiguration(TEST_NAME));
-
- writeInputMatrixWithMTD("newX", newX, false);
- writeInputMatrixWithMTD("e", e, false);
-
- fullDMLScriptName = HOME + TEST_NAME + ".dml";
- programArgs = new String[] { "-args", input("newX"), input("e"),
String.valueOf(K),
- String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(),
- String.valueOf(VERBOSE).toUpperCase(), output("R") };
-
- runTest(true, false, null, -1);
-
- HashMap<CellIndex, Double> dmlfile =
readDMLMatrixFromOutputDir("R");
- double[][] ret = TestUtils.convertHashMapToDoubleArray(dmlfile);
- TestUtils.compareMatrices(correctRes, ret, 1e-2);
-
- Assert.assertFalse(heavyHittersContainsSubString("evalSlice"));
- } finally {
- rtplatform = platformOld;
- }
- }
-
- public void testIncSliceLineCustomInputsFull(double[][] addedX, double[][]
oldX, double[][] oldE, double[][] addedE, int K, double[][] correctRes) {
- boolean dp = true, selCols = false, encodeLat = true;
- ExecMode mode = ExecMode.SINGLE_NODE;
- ExecMode platformOld = setExecMode(mode);
- loadTestConfiguration(getTestConfiguration(TEST_NAME2));
- String HOME = SCRIPT_DIR + TEST_DIR;
-
- try {
- loadTestConfiguration(getTestConfiguration(TEST_NAME2));
-
- double[][] indicesRemoved = new double[1][1];
- indicesRemoved[0][0] = 0;
-
-
- writeInputMatrixWithMTD("addedX", addedX, false);
- writeInputMatrixWithMTD("oldX", oldX, false);
- writeInputMatrixWithMTD("oldE", oldE, false);
- writeInputMatrixWithMTD("addedE", addedE, false);
- writeInputMatrixWithMTD("indicesRemoved", indicesRemoved, false);
-
- fullDMLScriptName = HOME + TEST_NAME2 + ".dml";
- programArgs = new String[] { "-args", input("addedX"),
input("oldX"), input("oldE"), input("addedE"), String.valueOf(K),
- String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(), String.valueOf(encodeLat).toUpperCase(),
input("indicesRemoved"),
- String.valueOf(VERBOSE).toUpperCase(), output("R1"),
output("R2") };
-
- runTest(true, false, null, -1);
-
- HashMap<CellIndex, Double> dmlfile1 =
readDMLMatrixFromOutputDir("R1");
- HashMap<CellIndex, Double> dmlfile2 =
readDMLMatrixFromOutputDir("R2");
- double[][] ret1 = TestUtils.convertHashMapToDoubleArray(dmlfile1);
- double[][] ret2 = TestUtils.convertHashMapToDoubleArray(dmlfile2);
- TestUtils.compareMatrices(correctRes, ret2, 1e-2);
- TestUtils.compareMatrices(ret1, ret2, 1e-2);
-
- Assert.assertFalse(heavyHittersContainsSubString("evalSlice"));
- } finally {
- rtplatform = platformOld;
- }
- }
-
+ private static final String PREP_NAME = "slicefinderPrep";
+ private static final String TEST_NAME = "incSliceLine";
+ private static final String TEST_NAME2 = "incSliceLineFull";
+ private static final String TEST_DIR = "functions/builtin/";
+ private static final String TEST_CLASS_DIR = TEST_DIR +
BuiltinIncSliceLineTest.class.getSimpleName() + "/";
+ private static final boolean VERBOSE = true;
+
+ private static final double[][] EXPECTED_TOPK = new double[][] {
+ { 1.042, 69210699988.477, 11078019685.642, 18.000 },
+ { 0.478, 92957580467.849, 11078019685.642, 39.000 },
+ { 0.316, 40425449547.480, 11078019685.642, 10.000 },
+ { 0.262, 67630559163.266, 7261504482.540, 29.000 },
+ { 0.224, 202448990843.317, 11119010986.000, 125.000 },
+ { 0.218, 68860581248.568, 7261504482.540, 31.000 },
+ { 0.164, 206527445340.279, 11119010986.000, 135.000 },
+ { 0.122, 68961886413.866, 7261504482.540, 34.000 },
+ { 0.098, 360278523220.479, 11119010986.000, 266.000 },
+ { 0.092, 73954209826.485, 11078019685.642, 39.000 }
+ };
+
+ @Override
+ public void setUp() {
+ addTestConfiguration(TEST_NAME, new
TestConfiguration(TEST_CLASS_DIR, TEST_NAME, new String[] { "R" }));
+ addTestConfiguration(TEST_NAME2, new
TestConfiguration(TEST_CLASS_DIR, TEST_NAME2, new String[] { "R" }));
+ }
+
+ @Test
+ public void testTop4HybridDP() {
+ runIncSliceLineTest(4, "e", true, false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDP() {
+ runIncSliceLineTest(4, "e", true, false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTP() {
+ runIncSliceLineTest(4, "e", false, false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTP() {
+ runIncSliceLineTest(4, "e", false, false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDP() {
+ runIncSliceLineTest(10, "e", true, false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDP() {
+ runIncSliceLineTest(10, "e", true, false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTP() {
+ runIncSliceLineTest(10, "e", false, false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTP() {
+ runIncSliceLineTest(10, "e", false, false,
ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPSel() {
+ runIncSliceLineTest(4, "e", true, true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPSel() {
+ runIncSliceLineTest(4, "e", true, true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPSel() {
+ runIncSliceLineTest(4, "e", false, true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPSel() {
+ runIncSliceLineTest(4, "e", false, true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPSel() {
+ runIncSliceLineTest(10, "e", true, true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPSel() {
+ runIncSliceLineTest(10, "e", true, true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSel() {
+ runIncSliceLineTest(10, "e", false, true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSel() {
+ runIncSliceLineTest(10, "e", false, true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelE2() {
+ runIncSliceLineTest(10, "oe", false, true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelE2() {
+ runIncSliceLineTest(10, "oe", false, true,
ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPFullFewAdded() {
+ runIncSliceLineTest(4, "e", true, false,2, 1, false, false,
true,ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPFullFewAdded() {
+ runIncSliceLineTest(4, "e", true, false,2, 1, false, false,
true,ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPFullFewAdded() {
+ runIncSliceLineTest(4, "e", false, false, 2,1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4HybridDPFullFewAddedRemoved() {
+ runIncSliceLineTest(4, "e", true, false,2, 90, false, true,
true,ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPFullFewAddedRemoved() {
+ runIncSliceLineTest(4, "e", true, false,2, 1, false, true,
true,ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPFullFewAddedRemoved() {
+ runIncSliceLineTest(4, "e", false, false, 2,1, false, true,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPFullFewAdded() {
+ runIncSliceLineTest(4, "e", false, false,2, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPFullFewAdded() {
+ runIncSliceLineTest(10, "e", true, false,2, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPFullFewAdded() {
+ runIncSliceLineTest(10, "e", true, false,2, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPFullFewAdded() {
+ runIncSliceLineTest(10, "e", false, false,2, 1, false, false,
false,ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPFullFewAdded() {
+ runIncSliceLineTest(10, "e", false, false,2, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPSelFullFewAdded() {
+ runIncSliceLineTest(4, "e", true, true,2, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPSelFullFewAdded() {
+ runIncSliceLineTest(4, "e", true, true,2, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPSelFullFewAdded() {
+ runIncSliceLineTest(4, "e", false, true,2, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4HybridDPSelFullFewAddedRemoved() {
+ runIncSliceLineTest(4, "e", true, true,2, 1, false, true,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPSelFullFewAddedRemoved() {
+ runIncSliceLineTest(4, "e", true, true,2, 1, false, true,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPSelFullFewAddedRemoved() {
+ runIncSliceLineTest(4, "e", false, true,2, 1, false, true,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPSelFullFewAdded() {
+ runIncSliceLineTest(4, "e", false, true,4, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPSelFullFewAdded() {
+ runIncSliceLineTest(10, "e", true, true, 2, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPSelFullFewAdded() {
+ runIncSliceLineTest(10, "e", true, true, 1, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelFullFewAdded() {
+ runIncSliceLineTest(10, "e", false, true, 2, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelFullFewAdded() {
+ runIncSliceLineTest(10, "e", false, true, 2, 1, false, false,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelE2FullFewAdded() {
+ runIncSliceLineTest(10, "oe", false, true, 2, 1, false, false,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelE2FullFewAdded() {
+ runIncSliceLineTest(10, "oe", false, true, 2, 1, false, false,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelFullFewAddedRemoved() {
+ runIncSliceLineTest(10, "e", false, true, 2, 1, false, true,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelE2FullFewAddedRemoved() {
+ runIncSliceLineTest(10, "oe", false, true, 2, 1, false, true,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelE2FullFewAddedRemoved() {
+ runIncSliceLineTest(10, "oe", false, true, 2, 1, false, true,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPFullManyAdded() {
+ runIncSliceLineTest(4, "e", true, false,50, 1, false, false,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPFullManyAdded() {
+ runIncSliceLineTest(4, "e", true, false,50, 1, false, false,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPFullManyAdded() {
+ runIncSliceLineTest(4, "e", false, false, 50,1, false, false,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4HybridDPFullManyAddedRemoved() {
+ runIncSliceLineTest(4, "e", true, false,50, 1, false, true,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPFullManyAddedRemoved() {
+ runIncSliceLineTest(4, "e", true, false,50, 1, false, true,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPFullManyAddedRemoved() {
+ runIncSliceLineTest(4, "e", false, false, 50,1, false, true,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPFullManyAdded() {
+ runIncSliceLineTest(4, "e", false, false,60, 1, false, false,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPFullManyAdded() {
+ runIncSliceLineTest(10, "e", true, false,50, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPFullManyAdded() {
+ runIncSliceLineTest(10, "e", true, false,50, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPFullManyAdded() {
+ runIncSliceLineTest(10, "e", false, false,90 , 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPFullManyAdded() {
+ runIncSliceLineTest(10, "e", false, false,99 , 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPSelFullManyAdded() {
+ runIncSliceLineTest(4, "e", true, true,50, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10HybridTPFullManyAddedRemoved() {
+ runIncSliceLineTest(10, "e", false, false,90 , 1, false, true,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPFullManyAddedRemoved() {
+ runIncSliceLineTest(10, "e", false, false,99 , 1, false, true,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPSelFullManyAddedRemoved() {
+ runIncSliceLineTest(4, "e", true, true,50, 1, false, true,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPSelFullManyAdded() {
+ runIncSliceLineTest(4, "e", true, true,50, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPSelFullManyAdded() {
+ runIncSliceLineTest(4, "e", false, true,50, 1, false, false,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPSelFullManyAdded() {
+ runIncSliceLineTest(4, "e", false, true,50, 1, false, false,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPSelFullManyAdded() {
+ runIncSliceLineTest(10, "e", true, true, 50, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPSelFullManyAdded() {
+ runIncSliceLineTest(10, "e", true, true, 50, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelFullManyAdded() {
+ runIncSliceLineTest(10, "e", false, true, 50, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelFullManyAdded() {
+ runIncSliceLineTest(10, "e", false, true, 50, 1, false, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelE2FullManyAdded() {
+ runIncSliceLineTest(10, "oe", false, true, 50, 1, false, false,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10HybridTPSelFullManyAddedRemoved() {
+ runIncSliceLineTest(10, "e", false, true, 50, 1, false, true,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelFullManyAddedRemoved() {
+ runIncSliceLineTest(10, "e", false, true, 50, 1, false, true,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelE2FullManyAddedRemoved() {
+ runIncSliceLineTest(10, "oe", false, true, 50, 99, false, true,
false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelE2FullManyAdded() {
+ runIncSliceLineTest(10, "oe", false, true, 50, 1, false, false,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPFullFewAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", true, false,2, 1, true, false,true,
ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPFullFewAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", true, false,2, 1, true, false,true,
ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPFullFewAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", false, false, 2,1, true,
false,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPFullFewAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", false, false,2, 1, true,
false,true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPFullFewAddedOnlyNullRemoved() {
+ runIncSliceLineTest(4, "e", true, false,2, 1, true, true,true,
ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPFullFewAddedOnlyNullRemoved() {
+ runIncSliceLineTest(4, "e", false, false, 2,1, true, true,true,
ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPFullFewAddedOnlyNullRemoved() {
+ runIncSliceLineTest(4, "e", false, false,2, 1, true, true,true,
ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPFullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", true, false,2, 1, true,
false,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPFullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", true, false,2, 1, true,
false,true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPFullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", false, false,2, 1, true,
false,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPFullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", false, false,2, 1, true,
false,false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPSelFullFewAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", true, true,2, 1, true, false,false,
ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPSelFullFewAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", true, true,2, 1, true, false,false,
ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPSelFullFewAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", false, true,2, 1, true,
false,false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPSelFullFewAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", false, true,4, 1, true,
false,false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPSelFullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", true, true, 2, 1, true,
false,false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPSelFullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", true, true, 1, 1, true, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelFullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", false, true, 2, 1, true,
false,false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelFullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", false, true, 2, 1, true,
false,false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelE2FullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "oe", false, true, 2, 1, true,
false,false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelE2FullFewAddedOnlyNull() {
+ runIncSliceLineTest(10, "oe", false, true, 2, 1, true, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPFullManyAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", true, false,50, 1, true,
false,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPFullManyAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", true, false,50, 1, true,
false,true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPFullManyAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", false, false, 50, 1, true,
false,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPFullManyAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", false, false,60, 1, true, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPFullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", true, false,50, 1, true,
false,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPFullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", true, false,50, 1, true,
false,true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPFullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", false, false,90 , 1, true,
false,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPFullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", false, false,99 , 1, true,
false,true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPFullManyAddedOnlyNullRemoved() {
+ runIncSliceLineTest(10, "e", true, false,50, 1, true,
true,true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPFullManyAddedOnlyNullRemoved() {
+ runIncSliceLineTest(10, "e", false, false,90 , 50, true,
true,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPFullManyAddedOnlyNullRemoved() {
+ runIncSliceLineTest(10, "e", false, false,99 , 1, true,
true,true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridDPSelFullManyAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", true, true,50, 1, true, false,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeDPSelFullManyAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", true, true,50, 1, true,
false,false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop4HybridTPSelFullManyAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", false, true,50, 1, true,
false,false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop4SinglenodeTPSelFullManyAddedOnlyNull() {
+ runIncSliceLineTest(4, "e", false, true,50, 1, true,
false,false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridDPSelFullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", true, true, 50, 1, true,
false,false, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeDPSelFullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", true, true, 50, 1, true, false,
false, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelFullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", false, true, 50, 1, true,
false,true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelFullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "e", false, true, 50, 1, true, false,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelE2FullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "oe", false, true, 50, 1, true, false,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelE2FullManyAddedOnlyNull() {
+ runIncSliceLineTest(10, "oe", false, true, 50, 1, true, false,
true, ExecMode.SINGLE_NODE);
+ }
+
+
+ @Test
+ public void testTop10SinglenodeTPSelFullManyAddedOnlyNullRemoved() {
+ runIncSliceLineTest(10, "e", false, true, 50, 1, true, true,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testTop10HybridTPSelE2FullManyAddedOnlyNullRemoved() {
+ runIncSliceLineTest(10, "oe", false, true, 50, 20, true, true,
true, ExecMode.HYBRID);
+ }
+
+ @Test
+ public void testTop10SinglenodeTPSelE2FullManyAddedOnlyNullRemoved() {
+ runIncSliceLineTest(10, "oe", false, true, 50, 40, true, true,
true, ExecMode.SINGLE_NODE);
+ }
+
+ @Test
+ public void testIncSliceLineCustomInputs1() {
+ double[][] newX = {
+ { 2, 1, 1, 2, 3, 2, 3, 3, 1, 2 },
+ { 2, 2, 2, 3, 4, 1, 2, 1, 3, 2 },
+ { 2, 1, 3, 3, 2, 2, 3, 1, 1, 4 },
+ { 1, 2, 2, 1, 3, 2, 3, 2, 2, 3 },
+ { 3, 2, 3, 4, 3, 3, 4, 1, 1, 3 },
+ { 4, 3, 2, 3, 4, 4, 3, 4, 1, 1 },
+ { 2, 2, 2, 4, 3, 3, 2, 2, 1, 2 },
+ { 1, 1, 2, 2, 3, 3, 2, 1, 1, 2 },
+ { 4, 3, 2, 1, 3, 2, 4, 2, 4, 3 },
+ { 1, 3, 1, 4, 1, 3, 3, 2, 3, 2 },
+ { 2, 4, 3, 1, 2, 4, 1, 3, 2, 4 },
+ { 3, 2, 4, 3, 1, 4, 2, 3, 4, 1 },
+ { 4, 1, 2, 4, 3, 1, 4, 2, 1, 3 },
+ { 1, 3, 4, 2, 4, 3, 1, 4, 2, 3 },
+ { 2, 4, 1, 3, 2, 4, 3, 1, 4, 2 },
+ { 3, 2, 4, 1, 3, 4, 2, 3, 1, 4 },
+ { 4, 1, 3, 2, 4, 1, 4, 2, 3, 1 },
+ { 1, 3, 2, 4, 1, 3, 4, 2, 4, 3 },
+ { 2, 4, 1, 3, 2, 4, 3, 1, 2, 4 },
+ { 2, 3, 3, 2, 1, 4, 2, 3, 2, 3 }
+ };
+ double[][] e = {
+ { 0.159 }, { 0.588 }, { 0.414 }, { 0.305 }, {
0.193 }, { 0.195 }, { 0.878 }, { 0.149 }, { 0.835 },
+ { 0.344 },
+ { 0.123 }, { 0.456 }, { 0.789 }, { 0.987 }, {
0.654 }, { 0.321 }, { 0.246 }, { 0.135 }, { 0.579 },
+ { 0.802 }
+ };
+ int K = 10;
+ double[][] correctRes = {
+ { 0.307, 2.807, 0.878, 4.000 },
+ { 0.307, 2.807, 0.878, 4.000 },
+ { 0.282, 2.759, 0.987, 4.000 },
+ { 0.157, 4.046, 0.987, 7.000 },
+ { 0.127, 2.956, 0.878, 5.000 },
+ { 0.122, 2.942, 0.878, 5.000 },
+ { 0.074, 3.298, 0.987, 6.000 },
+ { 0.064, 4.197, 0.878, 8.000 },
+ { 0.061, 2.796, 0.987, 5.000 },
+ { 0.038, 3.194, 0.878, 6.000 }
+ };
+ testIncSliceLineCustomInputs(newX, e, K, correctRes);
+ }
+
+ @Test
+ public void testIncSliceLineCustomInputs2() {
+ double[][] newX = {
+ { 2, 1, 1, 1, 3, 4, 2, 2, 1, 2 },
+ { 3, 3, 3, 2, 1, 2, 3, 1, 4, 2 },
+ { 3, 2, 3, 1, 1, 1, 4, 3, 4, 2 },
+ { 1, 3, 2, 3, 2, 3, 2, 1, 2, 1 },
+ { 4, 3, 1, 1, 1, 1, 1, 1, 3, 2 },
+ { 2, 2, 3, 3, 2, 2, 2, 3, 4, 1 },
+ { 3, 2, 2, 2, 4, 4, 2, 4, 1, 1 },
+ { 1, 3, 3, 2, 1, 3, 1, 2, 4, 4 },
+ { 2, 1, 2, 2, 3, 1, 2, 3, 2, 1 },
+ { 4, 1, 3, 4, 1, 4, 2, 3, 4, 4 },
+ { 4, 2, 4, 4, 2, 1, 2, 1, 1, 4 },
+ { 4, 1, 1, 4, 1, 4, 3, 2, 4, 2 },
+ { 2, 1, 2, 2, 3, 1, 4, 3, 3, 4 },
+ { 4, 1, 3, 1, 3, 1, 2, 1, 3, 3 },
+ { 2, 1, 3, 1, 1, 3, 1, 2, 1, 2 },
+ { 1, 3, 4, 3, 1, 2, 2, 2, 1, 1 },
+ { 2, 4, 4, 3, 4, 1, 2, 1, 2, 4 },
+ { 3, 3, 3, 3, 3, 1, 2, 3, 4, 4 },
+ { 3, 2, 2, 2, 4, 1, 4, 2, 3, 1 },
+ { 1, 2, 3, 2, 4, 3, 2, 3, 2, 3 }
+ };
+
+ double[][] e = {
+ { 0.591 }, { 0.858 }, { 0.144 }, { 0.350 }, {
0.931 }, { 0.951 }, { 0.788 }, { 0.491 }, { 0.358 },
+ { 0.443 },
+ { 0.231 }, { 0.564 }, { 0.897 }, { 0.879 }, {
0.546 }, { 0.132 }, { 0.462 }, { 0.153 }, { 0.759 },
+ { 0.028 }
+ };
+ int K = 10;
+ double[][] correctRes = {
+ { 0.410, 3.466, 0.931, 4.000 },
+ { 0.410, 3.466, 0.931, 4.000 },
+ { 0.111, 2.802, 0.897, 4.000 },
+ { 0.075, 3.805, 0.951, 6.000 },
+ { 0.057, 4.278, 0.897, 7.000 },
+ { 0.047, 3.711, 0.931, 6.000 },
+ { 0.035, 3.152, 0.897, 5.000 },
+ { 0.032, 4.179, 0.897, 7.000 },
+ { 0.023, 3.634, 0.931, 6.000 },
+ { 0.013, 3.091, 0.931, 5.000 }
+ };
+
+ testIncSliceLineCustomInputs(newX, e, K, correctRes);
+ }
+
+ @Test
+ public void testIncSliceLineCustomInputs3() {
+ double[][] newX = {
+ { 2, 1, 1, 2, 3, 2, 3, 3, 1, 2 },
+ { 2, 2, 2, 3, 4, 1, 2, 1, 3, 2 },
+ { 2, 1, 3, 3, 2, 2, 3, 1, 1, 4 },
+ { 1, 2, 2, 1, 3, 2, 3, 2, 2, 3 },
+ { 3, 2, 3, 4, 3, 3, 4, 1, 1, 3 },
+ { 4, 3, 2, 3, 4, 4, 3, 4, 1, 1 },
+ { 2, 2, 2, 4, 3, 3, 2, 2, 1, 2 },
+ { 1, 1, 2, 2, 3, 3, 2, 1, 1, 2 },
+ { 4, 3, 2, 1, 3, 2, 4, 2, 4, 3 },
+ { 1, 3, 1, 4, 1, 3, 3, 2, 3, 2 },
+ { 2, 4, 3, 1, 2, 4, 1, 3, 2, 4 },
+ { 3, 2, 4, 3, 1, 4, 2, 3, 4, 1 },
+ { 4, 1, 2, 4, 3, 1, 4, 2, 1, 3 },
+ { 1, 3, 4, 2, 4, 3, 1, 4, 2, 3 },
+ { 2, 4, 1, 3, 2, 4, 3, 1, 4, 2 },
+ { 3, 2, 4, 1, 3, 4, 2, 3, 1, 4 },
+ { 4, 1, 3, 2, 4, 1, 4, 2, 3, 1 },
+ { 1, 3, 2, 4, 1, 3, 4, 2, 4, 3 },
+ { 2, 4, 1, 3, 2, 4, 3, 1, 2, 4 },
+ { 2, 3, 3, 2, 1, 4, 2, 3, 2, 3 },
+ { 2, 1, 1, 1, 3, 4, 2, 2, 1, 2 },
+ { 3, 3, 3, 2, 1, 2, 3, 1, 4, 2 },
+ { 3, 2, 3, 1, 1, 1, 4, 3, 4, 2 },
+ { 1, 3, 2, 3, 2, 3, 2, 1, 2, 1 },
+ { 4, 3, 1, 1, 1, 1, 1, 1, 3, 2 },
+ { 2, 2, 3, 3, 2, 2, 2, 3, 4, 1 },
+ { 3, 2, 2, 2, 4, 4, 2, 4, 1, 1 },
+ { 1, 3, 3, 2, 1, 3, 1, 2, 4, 4 },
+ { 2, 1, 2, 2, 3, 1, 2, 3, 2, 1 },
+ { 4, 1, 3, 4, 1, 4, 2, 3, 4, 4 },
+ { 4, 2, 4, 4, 2, 1, 2, 1, 1, 4 },
+ { 4, 1, 1, 4, 1, 4, 3, 2, 4, 2 },
+ { 2, 1, 2, 2, 3, 1, 4, 3, 3, 4 },
+ { 4, 1, 3, 1, 3, 1, 2, 1, 3, 3 },
+ { 2, 1, 3, 1, 1, 3, 1, 2, 1, 2 },
+ { 1, 3, 4, 3, 1, 2, 2, 2, 1, 1 },
+ { 2, 4, 4, 3, 4, 1, 2, 1, 2, 4 },
+ { 3, 3, 3, 3, 3, 1, 2, 3, 4, 4 },
+ { 3, 2, 2, 2, 4, 1, 4, 2, 3, 1 },
+ { 1, 2, 3, 2, 4, 3, 2, 3, 2, 3 }
+ };
+ double[][] e = {
+ { 0.159 }, { 0.588 }, { 0.414 }, { 0.305 }, {
0.193 }, { 0.195 }, { 0.878 }, { 0.149 }, { 0.835 },
+ { 0.344 },
+ { 0.123 }, { 0.456 }, { 0.789 }, { 0.987 }, {
0.654 }, { 0.321 }, { 0.246 }, { 0.135 }, { 0.579 },
+ { 0.802 },
+ { 0.591 }, { 0.858 }, { 0.144 }, { 0.350 }, {
0.931 }, { 0.951 }, { 0.788 }, { 0.491 }, { 0.358 },
+ { 0.443 },
+ { 0.231 }, { 0.564 }, { 0.897 }, { 0.879 }, {
0.546 }, { 0.132 }, { 0.462 }, { 0.153 }, { 0.759 },
+ { 0.028 }
+ };
+ int K = 10;
+ double[][] correctRes = {
+ { 0.149, 4.300, 0.931, 6.000 },
+ { 0.113, 3.138, 0.987, 4.000 },
+ { 0.093, 4.644, 0.931, 7.000 },
+ { 0.090, 4.630, 0.951, 7.000 },
+ { 0.059, 8.002, 0.951, 14.000 },
+ { 0.024, 2.954, 0.951, 4.000 },
+ { 0.017, 3.415, 0.897, 5.000 },
+ { 0.010, 3.398, 0.878, 5.000 },
+ { 0.009, 2.923, 0.897, 4.000 },
+ { 0.008, 3.391, 0.897, 5.000 }
+ };
+ testIncSliceLineCustomInputs(newX, e, K, correctRes);
+ }
+
+ @Test
+ public void testIncSliceLineCustomInputs4() {
+ double[][] oldX = {
+ { 2, 1, 1, 2, 3, 2, 3, 3, 1, 2 },
+ { 2, 2, 2, 3, 4, 1, 2, 1, 3, 2 },
+ { 2, 1, 3, 3, 2, 2, 3, 1, 1, 4 },
+ { 1, 2, 2, 1, 3, 2, 3, 2, 2, 3 },
+ { 3, 2, 3, 4, 3, 3, 4, 1, 1, 3 },
+ { 4, 3, 2, 3, 4, 4, 3, 4, 1, 1 },
+ { 2, 2, 2, 4, 3, 3, 2, 2, 1, 2 },
+ { 1, 1, 2, 2, 3, 3, 2, 1, 1, 2 },
+ { 4, 3, 2, 1, 3, 2, 4, 2, 4, 3 },
+ { 1, 3, 1, 4, 1, 3, 3, 2, 3, 2 },
+ { 2, 4, 3, 1, 2, 4, 1, 3, 2, 4 },
+ { 3, 2, 4, 3, 1, 4, 2, 3, 4, 1 },
+ { 4, 1, 2, 4, 3, 1, 4, 2, 1, 3 },
+ { 1, 3, 4, 2, 4, 3, 1, 4, 2, 3 },
+ { 2, 4, 1, 3, 2, 4, 3, 1, 4, 2 },
+ { 3, 2, 4, 1, 3, 4, 2, 3, 1, 4 },
+ { 4, 1, 3, 2, 4, 1, 4, 2, 3, 1 },
+ { 1, 3, 2, 4, 1, 3, 4, 2, 4, 3 },
+ { 2, 4, 1, 3, 2, 4, 3, 1, 2, 4 },
+ { 2, 3, 3, 2, 1, 4, 2, 3, 2, 3 },
+ { 2, 1, 1, 1, 3, 4, 2, 2, 1, 2 },
+ { 3, 3, 3, 2, 1, 2, 3, 1, 4, 2 },
+ { 3, 2, 3, 1, 1, 1, 4, 3, 4, 2 },
+ { 1, 3, 2, 3, 2, 3, 2, 1, 2, 1 },
+ { 4, 3, 1, 1, 1, 1, 1, 1, 3, 2 },
+ { 2, 2, 3, 3, 2, 2, 2, 3, 4, 1 },
+ { 3, 2, 2, 2, 4, 4, 2, 4, 1, 1 },
+ { 1, 3, 3, 2, 1, 3, 1, 2, 4, 4 },
+ { 2, 1, 2, 2, 3, 1, 2, 3, 2, 1 },
+ { 4, 1, 3, 4, 1, 4, 2, 3, 4, 4 },
+ };
+ double[][] addedX = {
+ { 4, 2, 4, 4, 2, 1, 2, 1, 1, 4 },
+ { 4, 1, 1, 4, 1, 4, 3, 2, 4, 2 },
+ { 2, 1, 2, 2, 3, 1, 4, 3, 3, 4 },
+ { 4, 1, 3, 1, 3, 1, 2, 1, 3, 3 },
+ { 2, 1, 3, 1, 1, 3, 1, 2, 1, 2 },
+ { 1, 3, 4, 3, 1, 2, 2, 4, 1, 1 },
+ { 2, 4, 4, 3, 4, 1, 2, 1, 2, 4 },
+ { 3, 3, 3, 3, 3, 1, 2, 3, 4, 4 },
+ { 3, 2, 2, 2, 4, 1, 4, 2, 3, 1 },
+ { 1, 2, 3, 2, 4, 3, 2, 3, 2, 3 }
+ };
+ double[][] oldE = {
+ { 0.159 }, { 0.588 }, { 0.414 }, { 0.305 }, {
0.193 }, { 0.195 }, { 0.878 }, { 0.149 }, { 0.835 },
+ { 0.344 },
+ { 0.123 }, { 0.456 }, { 0.789 }, { 0.987 }, {
0.654 }, { 0.321 }, { 0.246 }, { 0.135 }, { 0.579 },
+ { 0.802 },
+ { 0.591 }, { 0.858 }, { 0.144 }, { 0.350 }, {
0.931 }, { 0.951 }, { 0.788 }, { 0.491 }, { 0.358 },
+ { 0.443 },
+ };
+ double[][] addedE = {
+ { 0.231 }, { 0.564 }, { 0.897 }, { 0.879 }, {
0.546 }, { 0.132 }, { 0.462 }, { 0.153 }, { 0.759 },
+ { 0.028 }
+ };
+
+ int K = 10;
+
+ double[][] correctRes = {
+ { 0.149, 4.300, 0.931, 6.000 },
+ { 0.113, 3.138, 0.987, 4.000 },
+ { 0.093, 4.644, 0.931, 7.000 },
+ { 0.090, 4.630, 0.951, 7.000 },
+ { 0.059, 8.002, 0.951, 14.000 },
+ { 0.024, 2.954, 0.951, 4.000 },
+ { 0.017, 3.415, 0.897, 5.000 },
+ { 0.010, 3.398, 0.878, 5.000 },
+ { 0.009, 2.923, 0.897, 4.000 },
+ { 0.008, 3.391, 0.897, 5.000 }
+ };
+
+ testIncSliceLineCustomInputsFull(addedX, oldX, oldE, addedE, K,
correctRes);
+ }
+
+
+ @Test
+ public void testIncSliceLineCustomInputsFull() {
+ double[][] newX = {
+ {1, 1, 1, 1},
+ {1, 2, 2, 2},
+ {1, 3, 3, 3},
+ {1, 4, 4, 4},
+ {5, 2, 5, 5},
+ {6, 2, 6, 6},
+ {7, 2, 7, 7},
+ {8, 2, 8, 8},
+ {9, 9, 9, 9},
+ {1, 1, 1, 1},
+ {2, 2, 2, 2},
+ {3, 3, 3, 3},
+ {4, 4, 4, 4},
+ {5, 5, 5, 5},
+ {6, 6, 6, 6},
+ {7, 7, 7, 7},
+ {8, 8, 8, 8},
+ {9, 9, 9, 9},
+ {1, 1, 1, 1},
+ {2, 2, 2, 2},
+ {3, 3, 3, 3},
+ {4, 4, 4, 4},
+ {5, 5, 5, 5},
+ {6, 6, 6, 6},
+ {7, 7, 7, 7},
+ {8, 8, 8, 8},
+ {9, 9, 9, 9},
+ {1, 1, 1, 1},
+ {2, 2, 2, 2},
+ {3, 3, 3, 3},
+ {4, 4, 4, 4},
+ {5, 5, 5, 5},
+ {6, 6, 6, 6},
+ {7, 7, 7, 7},
+ {8, 8, 8, 8},
+ {9, 9, 9, 9},
+ {10, 10, 10, 10},
+ {11, 11, 11, 11},
+ {12, 12, 12, 12},
+ {13, 13, 13, 13},
+ {14, 14, 14, 14},
+ {15, 15, 15, 15},
+ {16, 16, 16, 16},
+ {17, 17, 17, 17},
+ {18, 18, 18, 18},
+ {19, 19, 19, 19},
+ {20, 20, 20, 20},
+ {10, 10, 10, 10},
+ {11, 11, 11, 11},
+ {12, 12, 12, 12},
+ {13, 13, 13, 13},
+ {14, 14, 14, 14},
+ {15, 15, 15, 15},
+ {16, 16, 16, 16},
+ {17, 17, 17, 17},
+ {18, 18, 18, 18},
+ {19, 19, 19, 19},
+ {20, 20, 20, 20},
+ {10, 10, 10, 10},
+ {11, 11, 11, 11},
+ {12, 12, 12, 12},
+ {13, 13, 13, 13},
+ {14, 14, 14, 14},
+ {15, 15, 15, 15},
+ {16, 16, 16, 16},
+ {17, 17, 17, 17},
+ {18, 18, 18, 18},
+ {19, 19, 19, 19},
+ {20, 20, 20, 20},
+ {10, 10, 10, 10},
+ {11, 11, 11, 11},
+ {12, 12, 12, 12},
+ {13, 13, 13, 13},
+ {14, 14, 14, 14},
+ {15, 15, 15, 15},
+ {16, 16, 16, 20},
+ {17, 17, 17, 20},
+ {18, 18, 18, 20},
+ {19, 19, 19, 20},
+ {20, 20, 20, 20}
+ };
+
+ double[][] e = {
+ {0.001}, {0.002}, {0.003}, {0.004}, {0.005},
{0.006}, {0.007}, {0.008}, {0.009}, {0.010},
+ {0.011}, {0.012}, {0.013}, {0.014}, {0.015},
{0.016}, {0.017}, {0.018}, {0.019}, {0.020},
+ {0.021}, {0.022}, {0.023}, {0.024}, {0.025},
{0.026}, {0.027}, {0.028}, {0.029}, {0.030},
+ {0.031}, {0.032}, {0.033}, {0.034}, {0.035},
{0.036}, {0.037}, {0.038}, {0.039}, {0.040},
+ {0.041}, {0.042}, {0.043}, {0.044}, {0.045},
{0.046}, {0.047}, {0.048}, {0.049}, {0.050},
+ {0.051}, {0.052}, {0.053}, {0.054}, {0.055},
{0.056}, {0.057}, {0.058}, {0.059}, {0.060},
+ {0.061}, {0.062}, {0.063}, {0.064}, {0.065},
{0.066}, {0.067}, {0.068}, {0.069}, {0.070},
+ {0.071}, {0.072}, {0.073}, {0.074}, {0.075},
{0.076}, {0.077}, {0.078}, {0.079}, {0.080}
+
+ };
+
+ runIncSliceLineTest(newX, e, 10, "e", false, true, 50, 1,
false, false, true, ExecMode.SINGLE_NODE);
+ }
+
+ // @Test
+ // public void testTop10SparkTP() {
+ // runIncSliceLineTest(10, false, ExecMode.SPARK);
+ // }
+
+ private void runIncSliceLineTest(int K, String err, boolean dp, boolean
selCols, ExecMode mode) {
+ ExecMode platformOld = setExecMode(mode);
+ loadTestConfiguration(getTestConfiguration(TEST_NAME));
+ String HOME = SCRIPT_DIR + TEST_DIR;
+ String data = DATASET_DIR + "Salaries.csv";
+
+ try {
+ loadTestConfiguration(getTestConfiguration(TEST_NAME));
+
+ // run data preparation
+ fullDMLScriptName = HOME + PREP_NAME + ".dml";
+ programArgs = new String[] { "-args", data, err,
output("newX"), output("e") };
+ runTest(true, false, null, -1);
+
+ // read output and store for dml and R
+ double[][] newX =
TestUtils.convertHashMapToDoubleArray(readDMLMatrixFromOutputDir("newX"));
+ double[][] e =
TestUtils.convertHashMapToDoubleArray(readDMLMatrixFromOutputDir("e"));
+
+ writeInputMatrixWithMTD("newX", newX, true);
+ writeInputMatrixWithMTD("e", e, true);
+
+ // execute main test
+ fullDMLScriptName = HOME + TEST_NAME + ".dml";
+ programArgs = new String[] { "-args", input("newX"),
input("e"), String.valueOf(K),
+ String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(),
+ String.valueOf(VERBOSE).toUpperCase(),
output("R") };
+
+ runTest(true, false, null, -1);
+
+ HashMap<CellIndex, Double> dmlfile =
readDMLMatrixFromOutputDir("R");
+
+ // execute main test
+ fullDMLScriptName = HOME + "slicefinder" + ".dml";
+ programArgs = new String[] { "-args", input("newX"),
input("e"), String.valueOf(K),
+ String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(),
+ String.valueOf(VERBOSE).toUpperCase(),
output("R") };
+
+ runTest(true, false, null, -1);
+
+ HashMap<CellIndex, Double> dmlfile2 =
readDMLMatrixFromOutputDir("R");
+
+ TestUtils.compareMatrices(dmlfile, dmlfile2, 1e-2,
"Stat-IncSliceLine", "Stat-Slicefinder");
+
+ // compare expected results
+ if (err.equals("e")) {
+ double[][] ret =
TestUtils.convertHashMapToDoubleArray(dmlfile);
+ if (mode != ExecMode.SPARK) // TODO why only CP
correct, but R always matches? test framework?
+ for (int i = 0; i < K; i++)
+
TestUtils.compareMatrices(EXPECTED_TOPK[i], ret[i], 1e-2);
+ }
+
+ // ensure proper inlining, despite initially multiple
calls and large function
+
Assert.assertFalse(heavyHittersContainsSubString("evalSlice"));
+ } finally {
+ rtplatform = platformOld;
+ }
+ }
+
+ private void runIncSliceLineTest(int K, String err, boolean dp, boolean
selCols, int proportionOfTuplesAddedInPercent, int
proportionOfTuplesRemovedInPercent, boolean onlyNullEAdded, boolean
removeTuples, boolean encodeLat, ExecMode mode) {
+
+ runIncSliceLineTest(null, null, K, err, dp, selCols,
proportionOfTuplesAddedInPercent, proportionOfTuplesRemovedInPercent,
onlyNullEAdded, removeTuples, encodeLat, mode);
+
+ }
+
+
+ private void runIncSliceLineTest(double[][] customX, double[][]
customE,int K, String err,
+ boolean dp, boolean selCols, int
proportionOfTuplesAddedInPercent,
+ int proportionOfTuplesRemovedInPercent, boolean onlyNullEAdded,
boolean removeTuples,
+ boolean encodeLat, ExecMode mode)
+ {
+ ExecMode platformOld = setExecMode(mode);
+ loadTestConfiguration(getTestConfiguration(TEST_NAME2));
+ String HOME = SCRIPT_DIR + TEST_DIR;
+ String data = DATASET_DIR + "Salaries.csv";
+
+ try {
+ loadTestConfiguration(getTestConfiguration(TEST_NAME2));
+
+
+ double[][] newX = null;
+ double[][] e = null;
+ // read output and store for dml and R
+ if(customX != null && customE != null){
+ newX = customX;
+ e = customE;
+ } else {
+ // run data preparation
+ fullDMLScriptName = HOME + PREP_NAME + ".dml";
+ programArgs = new String[] { "-args", data,
err, output("newX"), output("e") };
+ runTest(true, false, null, -1);
+
+ newX =
TestUtils.convertHashMapToDoubleArray(readDMLMatrixFromOutputDir("newX"));
+ e =
TestUtils.convertHashMapToDoubleArray(readDMLMatrixFromOutputDir("e"));
+ }
+ int numOfAddedTuples = (int) Math.round(newX.length *
proportionOfTuplesAddedInPercent / 100.0);
+ int numOfRemovedTuples = (int) Math.round((newX.length
- numOfAddedTuples) * proportionOfTuplesRemovedInPercent / 100.0);
+ if(numOfRemovedTuples == 0){
+ numOfRemovedTuples = 1;
+ }
+
+ double[][] addedX = new
double[numOfAddedTuples][newX[0].length];
+ double[][] oldX = new double[newX.length -
numOfAddedTuples][newX[0].length];
+ double[][] indicesRemoved = new
double[numOfRemovedTuples][1];
+
+ if(removeTuples){
+ for (int i = 0; i < numOfRemovedTuples; i++) {
+ indicesRemoved[i][0] = i +1;
+ }
+ } else {
+ for (int i = 0; i < numOfRemovedTuples; i++) {
+ indicesRemoved[i][0] = 0;
+ }
+ }
+
+ for (int i = 0; i < numOfAddedTuples; i++) {
+ addedX[i] = newX[i];
+ }
+
+ for (int i = numOfAddedTuples; i < newX.length; i++) {
+ oldX[i - numOfAddedTuples] = newX[i];
+ }
+
+ double[][] addedE = new
double[numOfAddedTuples][e[0].length];
+ double[][] oldE = new double[e.length -
numOfAddedTuples][e[0].length];
+ if(onlyNullEAdded){
+ for (int i = 0; i < numOfAddedTuples; i++) {
+ addedE[i][0] = 0;
+ e[i][0] = 0;
+ }
+ } else {
+ for (int i = 0; i < numOfAddedTuples; i++) {
+ addedE[i] = e[i];
+ }
+ }
+
+ for (int i = numOfAddedTuples; i < e.length; i++) {
+ oldE[i - numOfAddedTuples] = e[i];
+ }
+
+ writeInputMatrixWithMTD("addedX", addedX, false);
+ writeInputMatrixWithMTD("oldX", oldX, false);
+ writeInputMatrixWithMTD("oldE", oldE, false);
+ writeInputMatrixWithMTD("addedE", addedE, false);
+ writeInputMatrixWithMTD("indicesRemoved",
indicesRemoved, false);
+
+ fullDMLScriptName = HOME + TEST_NAME2 + ".dml";
+ programArgs = new String[] { "-args", input("addedX"),
input("oldX"), input("oldE"), input("addedE"), String.valueOf(K),
+ String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(), String.valueOf(encodeLat).toUpperCase(),
input("indicesRemoved"),
+ String.valueOf(VERBOSE).toUpperCase(),
output("R1"), output("R2") };
+
+ runTest(true, false, null, -1);
+
+ HashMap<CellIndex, Double> dmlfile1 =
readDMLMatrixFromOutputDir("R1");
+ HashMap<CellIndex, Double> dmlfile2 =
readDMLMatrixFromOutputDir("R2");
+ double[][] ret1 =
TestUtils.convertHashMapToDoubleArray(dmlfile1);
+ double[][] ret2 =
TestUtils.convertHashMapToDoubleArray(dmlfile2);
+
+ TestUtils.compareMatrices(ret1, ret2, 1e-2);
+
+ // if removeTuples is true, then we need to remove the
tuples from the oldX and oldE
+ if(removeTuples){
+ double[][] tempOldX = new double[oldX.length -
numOfRemovedTuples][oldX[0].length];
+ double[][] tempOldE = new double[oldE.length -
numOfRemovedTuples][oldE[0].length];
+ int j = 0;
+ for (int i = 0; i < oldX.length; i++) {
+ if(j < indicesRemoved.length){
+ if(i == (int)
indicesRemoved[j][0] - 1){
+ j++;
+ } else {
+ tempOldX[i-j] = oldX[i];
+ tempOldE[i-j] = oldE[i];
+ }
+ } else {
+ tempOldX[i-j] = oldX[i];
+ tempOldE[i-j] = oldE[i];
+ }
+ }
+ oldX = tempOldX;
+ oldE = tempOldE;
+
+ }
+
+ // combine oldX and addedX and write it into newX
+ newX = new double[oldX.length +
addedX.length][oldX[0].length];
+ for (int i = 0; i < oldX.length; i++) {
+ newX[i] = oldX[i];
+ }
+ for (int i = 0; i < addedX.length; i++) {
+ newX[oldX.length + i] = addedX[i];
+ }
+
+ // combine oldE and addedE and write it into e
+ e = new double[oldE.length +
addedE.length][oldE[0].length];
+ for (int i = 0; i < oldE.length; i++) {
+ e[i] = oldE[i];
+ }
+ for (int i = 0; i < addedE.length; i++) {
+ e[oldE.length + i] = addedE[i];
+ }
+
+
+
+
+ if(customX != null && customE != null){
+ newX = customX;
+ e = customE;
+ }
+ // execute main test
+ writeInputMatrixWithMTD("newX", newX, false);
+ writeInputMatrixWithMTD("e", e, false);
+ fullDMLScriptName = HOME + "slicefinder" + ".dml";
+ programArgs = new String[] { "-args", input("newX"),
input("e"), String.valueOf(K),
+ String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(),
+ String.valueOf(VERBOSE).toUpperCase(),
output("R") };
+
+ runTest(true, false, null, -1);
+
+ HashMap<CellIndex, Double> dmlfile3 =
readDMLMatrixFromOutputDir("R");
+
+
+ TestUtils.compareMatrices(dmlfile1, dmlfile3, 1e-2,
"R1", "R");
+
+
+ // compare expected results
+ if (err.equals("e") && customX == null && customE ==
null && !onlyNullEAdded && !removeTuples) {
+ double[][] ret =
TestUtils.convertHashMapToDoubleArray(dmlfile1);
+ if (mode != ExecMode.SPARK) // TODO why only CP
correct, but R always matches? test framework?
+ for (int i = 0; i < K; i++)
+
TestUtils.compareMatrices(EXPECTED_TOPK[i], ret[i], 1e-2);
+ }
+
+ // ensure proper inlining, despite initially multiple
calls and large function
+
Assert.assertFalse(heavyHittersContainsSubString("evalSlice"));
+ } finally {
+ rtplatform = platformOld;
+ }
+ }
+
+ public void testIncSliceLineCustomInputs(double[][] newX, double[][] e,
int K, double[][] correctRes) {
+ boolean dp = true, selCols = false;
+ ExecMode mode = ExecMode.SINGLE_NODE;
+ ExecMode platformOld = setExecMode(mode);
+ loadTestConfiguration(getTestConfiguration(TEST_NAME));
+ String HOME = SCRIPT_DIR + TEST_DIR;
+
+ try {
+ loadTestConfiguration(getTestConfiguration(TEST_NAME));
+
+ writeInputMatrixWithMTD("newX", newX, false);
+ writeInputMatrixWithMTD("e", e, false);
+
+ fullDMLScriptName = HOME + TEST_NAME + ".dml";
+ programArgs = new String[] { "-args", input("newX"),
input("e"), String.valueOf(K),
+ String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(),
+ String.valueOf(VERBOSE).toUpperCase(),
output("R") };
+
+ runTest(true, false, null, -1);
+
+ HashMap<CellIndex, Double> dmlfile =
readDMLMatrixFromOutputDir("R");
+ double[][] ret =
TestUtils.convertHashMapToDoubleArray(dmlfile);
+ TestUtils.compareMatrices(correctRes, ret, 1e-2);
+
+
Assert.assertFalse(heavyHittersContainsSubString("evalSlice"));
+ } finally {
+ rtplatform = platformOld;
+ }
+ }
+
+ public void testIncSliceLineCustomInputsFull(double[][] addedX,
double[][] oldX,
+ double[][] oldE, double[][] addedE, int K, double[][]
correctRes)
+ {
+ boolean dp = true, selCols = false, encodeLat = true;
+ ExecMode mode = ExecMode.SINGLE_NODE;
+ ExecMode platformOld = setExecMode(mode);
+ loadTestConfiguration(getTestConfiguration(TEST_NAME2));
+ String HOME = SCRIPT_DIR + TEST_DIR;
+
+ try {
+ loadTestConfiguration(getTestConfiguration(TEST_NAME2));
+
+ double[][] indicesRemoved = new double[1][1];
+ indicesRemoved[0][0] = 0;
+
+
+ writeInputMatrixWithMTD("addedX", addedX, false);
+ writeInputMatrixWithMTD("oldX", oldX, false);
+ writeInputMatrixWithMTD("oldE", oldE, false);
+ writeInputMatrixWithMTD("addedE", addedE, false);
+ writeInputMatrixWithMTD("indicesRemoved",
indicesRemoved, false);
+
+ fullDMLScriptName = HOME + TEST_NAME2 + ".dml";
+ programArgs = new String[] { "-args", input("addedX"),
input("oldX"), input("oldE"), input("addedE"), String.valueOf(K),
+ String.valueOf(!dp).toUpperCase(),
String.valueOf(selCols).toUpperCase(), String.valueOf(encodeLat).toUpperCase(),
input("indicesRemoved"),
+ String.valueOf(VERBOSE).toUpperCase(),
output("R1"), output("R2") };
+
+ runTest(true, false, null, -1);
+
+ HashMap<CellIndex, Double> dmlfile1 =
readDMLMatrixFromOutputDir("R1");
+ HashMap<CellIndex, Double> dmlfile2 =
readDMLMatrixFromOutputDir("R2");
+ double[][] ret1 =
TestUtils.convertHashMapToDoubleArray(dmlfile1);
+ double[][] ret2 =
TestUtils.convertHashMapToDoubleArray(dmlfile2);
+ TestUtils.compareMatrices(correctRes, ret2, 1e-2);
+ TestUtils.compareMatrices(ret1, ret2, 1e-2);
+
+
Assert.assertFalse(heavyHittersContainsSubString("evalSlice"));
+ } finally {
+ rtplatform = platformOld;
+ }
+ }
}
