diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/indexaccum/IMax.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/indexaccum/IMax.java
index c01be78f9..127239bc7 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/indexaccum/IMax.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/indexaccum/IMax.java
@@ -45,15 +45,14 @@ public class IMax extends BaseIndexAccumulation {
         super(x, z, dimensions);
     }
 
-    public IMax(INDArray x, boolean keepDims, int... dimensions) {
-        super(x, keepDims, dimensions);
-
-    }
-
     public IMax(INDArray x, int... dimensions) {
         super(x, null, dimensions);
     }
 
+    public IMax(INDArray x, boolean keepDims, int... dimensions) {
+        super(x, null, dimensions);
+        this.keepDims = keepDims;
+    }
 
     @Override
     public int opNum() {
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/indexaccum/IMin.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/indexaccum/IMin.java
index e668f1ee0..a459e8c9c 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/indexaccum/IMin.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/indexaccum/IMin.java
@@ -53,6 +53,7 @@ public class IMin extends BaseIndexAccumulation {
     }
 
 
+
     @Override
     public int opNum() {
         return 1;
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/Mmul.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/Mmul.java
index 479c794c2..d4bec6ac2 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/Mmul.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/Mmul.java
@@ -141,8 +141,8 @@ public class Mmul extends DynamicCustomOp {
                 boolean transposeZ) {
         super(null,sameDiff,new SDVariable[]{x,y});
         addIArgument(ArrayUtil.fromBoolean(transposeX),
-                     ArrayUtil.fromBoolean(transposeY),
-                     ArrayUtil.fromBoolean(transposeZ));
+                ArrayUtil.fromBoolean(transposeY),
+                ArrayUtil.fromBoolean(transposeZ));
 
         addTArgument(alpha, beta);
         mt = MMulTranspose.builder().transposeA(transposeX).transposeB(transposeY).transposeResult(transposeZ).build();
@@ -306,4 +306,3 @@ public class Mmul extends DynamicCustomOp {
         return Collections.singletonList(dataTypes.get(0));
     }
 }
-
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/TensorMmul.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/TensorMmul.java
index f58347492..820df18ab 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/TensorMmul.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/TensorMmul.java
@@ -51,6 +51,35 @@ public class TensorMmul extends DynamicCustomOp {
     protected boolean addedEdges;
     protected MMulTranspose mMulTranspose;
 
+
+    public TensorMmul(INDArray x, INDArray y, int[][] axes) {
+        this(x,y,axes[0], axes[1], false, false, false);
+    }
+
+    /**
+     * Initialize with the given
+     * input, pairwise transform, result, and number
+     * of elements
+     *
+     * @param x the input
+     * @param y the pairwise transform
+     * @param z the result
+     */
+    public TensorMmul(INDArray x, INDArray y, INDArray z, int[][] axes) {
+        this(x, y, axes[0], axes[1], false, false, false);
+    }
+
+    public TensorMmul(INDArray x, INDArray y, int[] dimensionsX, int[] dimensionsY,
+                      boolean transposeX, boolean transposeY, boolean transposeZ) {
+        super(null,new INDArray[]{x, y},null);
+        this.axes = new int[][]{dimensionsX, dimensionsY};
+        addIArgument(dimensionsX.length);
+        addIArgument(dimensionsX);
+        addIArgument(dimensionsY.length);
+        addIArgument(dimensionsY);
+        addBArgument(transposeX, transposeY, transposeZ);
+    }
+
     public TensorMmul(SameDiff sameDiff,
                       SDVariable i_v1,
                       SDVariable i_v2,
@@ -229,34 +258,6 @@ public class TensorMmul extends DynamicCustomOp {
         return sameDiff.reshape(ret, aPlusB);
     }
 
-
-    public TensorMmul(INDArray x, INDArray y, int[][] axes) {
-        super(null,new INDArray[]{x, y},null);
-        this.axes = axes;
-        this.extraArgs = new Object[] {axes};
-    }
-
-    /**
-     * Initialize with the given
-     * input, pairwise transform, result, and number
-     * of elements
-     *
-     * @param x the input
-     * @param y the pairwise transform
-     * @param z the result
-     */
-    public TensorMmul(INDArray x, INDArray y, INDArray z, int[][] axes) {
-        super(null,new INDArray[]{x, y, z},null);
-        this.axes = axes;
-    }
-
-    public TensorMmul(INDArray x, INDArray y, int[] dimensionsX, int[] dimensionsY,
-                      boolean transposeX, boolean transposeY, boolean transposeZ) {
-        super(null,new INDArray[]{x, y},null);
-        this.axes = new int[][]{dimensionsX, dimensionsY};
-        addBArgument(transposeX, transposeY, transposeZ);
-    }
-
     @Override
     public String opName() {
         return "tensordot";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/floating/NormMax.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/floating/NormMax.java
index a7cf398f5..ea3fd140d 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/floating/NormMax.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/floating/NormMax.java
@@ -48,7 +48,6 @@ public class NormMax extends BaseReduceFloatOp {
         super(x, null, z, dimensions);
     }
 
-
     public NormMax(INDArray x, int... dimensions) {
         super(x, dimensions);
     }
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/floating/SquaredNorm.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/floating/SquaredNorm.java
index 2af86c181..f80a712d3 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/floating/SquaredNorm.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/floating/SquaredNorm.java
@@ -48,6 +48,10 @@ public class SquaredNorm extends BaseReduceFloatOp {
 
     public SquaredNorm(){}
 
+    public SquaredNorm(INDArray x, int... dimensions){
+        super(x,  dimensions);
+    }
+
     @Override
     public int opNum() {
         return 7;
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/longer/MatchCondition.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/longer/MatchCondition.java
index 0fb4db830..f2f097aa9 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/longer/MatchCondition.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/longer/MatchCondition.java
@@ -52,11 +52,15 @@ public class MatchCondition extends BaseReduceLongOp {
 
     public MatchCondition() {}
 
-
     public MatchCondition(INDArray x, Condition condition, int... dimensions) {
         this(x, Nd4j.EPS_THRESHOLD, condition, dimensions);
     }
 
+    public MatchCondition(INDArray x, Condition condition, boolean keepDims, int... dimensions) {
+        this(x, Nd4j.EPS_THRESHOLD, condition, dimensions);
+        this.keepDims = keepDims;
+    }
+
     public MatchCondition(INDArray x, double eps, Condition condition, int... dimensions) {
         super(x);
         this.compare = condition.getValue();
@@ -68,10 +72,6 @@ public class MatchCondition extends BaseReduceLongOp {
         defineDimensions(dimensions);
     }
 
-    public MatchCondition(INDArray in, Condition condition, boolean keepDim,  int... dimensions) {
-        this(in, condition, dimensions);
-    }
-
     @Override
     public int opNum() {
         return 2;
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/same/Sum.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/same/Sum.java
index e6fa79bb0..f2c0b1d40 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/same/Sum.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/reduce/same/Sum.java
@@ -41,7 +41,6 @@ public class Sum extends BaseReduceSameOp {
         super(sameDiff, i_v, i_v2, dimensions);
     }
 
-
     public Sum() {
     }
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarEquals.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarEquals.java
index ad2aa9b50..bafe8db88 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarEquals.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarEquals.java
@@ -40,7 +40,7 @@ public class ScalarEquals extends BaseScalarBoolOp {
     }
 
     public ScalarEquals(INDArray x, Number num) {
-        super(x, num);
+        this(x, null, num);
     }
 
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarGreaterThan.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarGreaterThan.java
index eafbcbc1a..524e66baa 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarGreaterThan.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarGreaterThan.java
@@ -19,9 +19,11 @@ package org.nd4j.linalg.api.ops.impl.scalar.comparison;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
 import org.nd4j.imports.NoOpNameFoundException;
+import org.nd4j.linalg.api.buffer.DataType;
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.api.ops.BaseScalarBoolOp;
 import org.nd4j.linalg.api.ops.BaseScalarOp;
+import org.nd4j.linalg.factory.Nd4j;
 
 import java.util.Arrays;
 import java.util.List;
@@ -56,7 +58,7 @@ public class ScalarGreaterThan extends BaseScalarBoolOp {
     }
 
     public ScalarGreaterThan(INDArray x, Number num) {
-        super(x, num);
+        this(x, null, num);
     }
 
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarGreaterThanOrEqual.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarGreaterThanOrEqual.java
index 0948c01ab..09c001dda 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarGreaterThanOrEqual.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarGreaterThanOrEqual.java
@@ -19,9 +19,11 @@ package org.nd4j.linalg.api.ops.impl.scalar.comparison;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
 import org.nd4j.imports.NoOpNameFoundException;
+import org.nd4j.linalg.api.buffer.DataType;
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.api.ops.BaseScalarBoolOp;
 import org.nd4j.linalg.api.ops.BaseScalarOp;
+import org.nd4j.linalg.factory.Nd4j;
 
 import java.util.Arrays;
 import java.util.List;
@@ -40,7 +42,7 @@ public class ScalarGreaterThanOrEqual extends BaseScalarBoolOp {
     }
 
     public ScalarGreaterThanOrEqual(INDArray x, Number num) {
-        super(x, num);
+        this(x, null, num);
     }
 
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarLessThan.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarLessThan.java
index 6f72490a1..740d05a79 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarLessThan.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarLessThan.java
@@ -18,9 +18,11 @@ package org.nd4j.linalg.api.ops.impl.scalar.comparison;
 
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
+import org.nd4j.linalg.api.buffer.DataType;
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.api.ops.BaseScalarBoolOp;
 import org.nd4j.linalg.api.ops.BaseScalarOp;
+import org.nd4j.linalg.factory.Nd4j;
 
 import java.util.Arrays;
 import java.util.List;
@@ -39,7 +41,7 @@ public class ScalarLessThan extends BaseScalarBoolOp {
     }
 
     public ScalarLessThan(INDArray x, Number num) {
-        super(x, num);
+        this(x, null, num);
     }
 
     public ScalarLessThan(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace) {
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarLessThanOrEqual.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarLessThanOrEqual.java
index 6c9a3a893..343051ec6 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarLessThanOrEqual.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarLessThanOrEqual.java
@@ -19,9 +19,11 @@ package org.nd4j.linalg.api.ops.impl.scalar.comparison;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
 import org.nd4j.imports.NoOpNameFoundException;
+import org.nd4j.linalg.api.buffer.DataType;
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.api.ops.BaseScalarBoolOp;
 import org.nd4j.linalg.api.ops.BaseScalarOp;
+import org.nd4j.linalg.factory.Nd4j;
 
 import java.util.Arrays;
 import java.util.List;
@@ -49,7 +51,7 @@ public class ScalarLessThanOrEqual extends BaseScalarBoolOp {
     }
 
     public ScalarLessThanOrEqual(INDArray x, Number num) {
-        super(x, num);
+        this(x, null, num);
     }
 
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarNotEquals.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarNotEquals.java
index f050b686e..52f4b7a99 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarNotEquals.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scalar/comparison/ScalarNotEquals.java
@@ -41,10 +41,9 @@ public class ScalarNotEquals extends BaseScalarBoolOp {
     }
 
     public ScalarNotEquals(INDArray x, Number num) {
-        super(x, num);
+        this(x, null, num);
     }
 
-
     public ScalarNotEquals(SameDiff sameDiff, SDVariable i_v, Number scalar) {
         super(sameDiff, i_v, scalar);
     }
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterAdd.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterAdd.java
index 1846ab8f8..1c524ccf1 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterAdd.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterAdd.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.scatter;
 
+import lombok.NonNull;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
 import org.nd4j.base.Preconditions;
@@ -44,12 +45,12 @@ public class ScatterAdd extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[]{ref, indices, updates}, false);
     }
 
-    public ScatterAdd(INDArray ref, INDArray indices, INDArray updates) {
-        addInputArgument(ref, indices, updates);
-    }
-
     public ScatterAdd(){}
 
+    public ScatterAdd(@NonNull INDArray ref, @NonNull INDArray indices, @NonNull INDArray update){
+        super(new INDArray[]{ref, indices, update}, null);
+    }
+
     @Override
     public String opName() {
         return "scatter_add";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterDiv.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterDiv.java
index 75badc9c2..c2993eb23 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterDiv.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterDiv.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.scatter;
 
+import lombok.NonNull;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
 import org.nd4j.base.Preconditions;
@@ -44,11 +45,12 @@ public class ScatterDiv extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[]{ref, indices, updates}, false);
     }
 
-    public ScatterDiv(INDArray ref, INDArray indices, INDArray updates) {
-        addInputArgument(ref, indices, updates);
+    public ScatterDiv() {}
+
+    public ScatterDiv(@NonNull INDArray ref, @NonNull INDArray indices, @NonNull INDArray update){
+        super(new INDArray[]{ref, indices, update}, null);
     }
 
-    public ScatterDiv() {}
 
     @Override
     public String opName() {
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMax.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMax.java
index 2dead9742..12fe3380a 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMax.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMax.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.scatter;
 
+import lombok.NonNull;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
 import org.nd4j.base.Preconditions;
@@ -42,12 +43,12 @@ public class ScatterMax extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[]{ref, indices, updates}, false);
     }
 
-    public ScatterMax(INDArray ref, INDArray indices, INDArray updates) {
-        addInputArgument(ref, indices, updates);
-    }
-
     public ScatterMax() {}
 
+    public ScatterMax(@NonNull INDArray ref, @NonNull INDArray indices, @NonNull INDArray update){
+        super(new INDArray[]{ref, indices, update}, null);
+    }
+
     @Override
     public String opName() {
         return "scatter_max";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMin.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMin.java
index 4af8a2cd2..91a49487e 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMin.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMin.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.scatter;
 
+import lombok.NonNull;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
 import org.nd4j.base.Preconditions;
@@ -42,12 +43,12 @@ public class ScatterMin extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[]{ref, indices, updates}, false);
     }
 
-    public ScatterMin(INDArray ref, INDArray indices, INDArray updates) {
-        addInputArgument(ref, indices, updates);
-    }
-
     public ScatterMin() {}
 
+    public ScatterMin(@NonNull INDArray ref, @NonNull INDArray indices, @NonNull INDArray update){
+        super(new INDArray[]{ref, indices, update}, null);
+    }
+
     @Override
     public String opName() {
         return "scatter_min";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMul.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMul.java
index 48e1a00bd..705b85d3d 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMul.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterMul.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.scatter;
 
+import lombok.NonNull;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
 import org.nd4j.base.Preconditions;
@@ -44,12 +45,12 @@ public class ScatterMul extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[]{ref, indices, updates}, false);
     }
 
-    public ScatterMul(INDArray ref, INDArray indices, INDArray updates) {
-        addInputArgument(ref, indices, updates);
-    }
-
     public ScatterMul() {}
 
+    public ScatterMul(@NonNull INDArray ref, @NonNull INDArray indices, @NonNull INDArray update){
+        super(new INDArray[]{ref, indices, update}, null);
+    }
+
     @Override
     public String opName() {
         return "scatter_mul";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterSub.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterSub.java
index f66f7d689..15e6d5ac2 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterSub.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterSub.java
@@ -44,12 +44,12 @@ public class ScatterSub extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[]{ref, indices, updates}, false);
     }
 
-    public ScatterSub(INDArray ref, INDArray indices, INDArray updates) {
-        addInputArgument(ref, indices, updates);
-    }
-
     public ScatterSub() {}
 
+    public ScatterSub(INDArray ref, INDArray indices, INDArray update){
+        super(new INDArray[]{ref, indices, update}, null);
+    }
+
     @Override
     public String opName() {
         return "scatter_sub";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterUpdate.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterUpdate.java
index c5644faa5..2e87af624 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterUpdate.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/scatter/ScatterUpdate.java
@@ -54,12 +54,12 @@ public class ScatterUpdate extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[]{ref, indices, updates}, false);
     }
 
-    public ScatterUpdate(INDArray ref, INDArray indices, INDArray updates) {
-        addInputArgument(ref, indices, updates);
-    }
-
     public ScatterUpdate(){}
 
+    public ScatterUpdate(INDArray ref, INDArray indices, INDArray update){
+        super(new INDArray[]{ref, indices, update}, null);
+    }
+
     @Override
     public String opName() {
         return "scatter_upd";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Concat.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Concat.java
index bddcef970..85cf62247 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Concat.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Concat.java
@@ -44,7 +44,7 @@ public class Concat extends DynamicCustomOp {
     }
 
     public Concat(int concatDimension, INDArray... arrays) {
-        super(null, arrays, new INDArray[0]);
+        super(null, arrays, null);
         this.concatDimension = concatDimension;
         addIArgument(concatDimension);
     }
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/ExpandDims.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/ExpandDims.java
index f0a6f436a..c51207d64 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/ExpandDims.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/ExpandDims.java
@@ -67,15 +67,16 @@ public class ExpandDims extends DynamicCustomOp {
         super(null, inputs, outputs);
     }
 
-    public ExpandDims(INDArray input, int axis) {
-        addInputArgument(input);
-        addIArgument(axis);
-    }
-
     public ExpandDims(SameDiff sameDiff, SDVariable[] args, boolean inPlace) {
         super(null, sameDiff, args, inPlace);
     }
 
+    public ExpandDims(INDArray x, int axis){
+        super(new INDArray[]{x}, null);
+        this.jaxis = axis;
+        addIArgument(axis);
+    }
+
     @Override
     public void initFromTensorFlow(NodeDef nodeDef, SameDiff initWith, Map<String, AttrValue> attributesForNode, GraphDef graph) {
         val targetNode = TFGraphMapper.getNodeWithNameFromGraph(graph, nodeDef.getInput(1));
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/GatherNd.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/GatherNd.java
index 593531098..7ac8429c8 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/GatherNd.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/GatherNd.java
@@ -42,6 +42,10 @@ public class GatherNd extends DynamicCustomOp {
         super(new INDArray[]{df, indices}, null);
     }
 
+    public GatherNd(INDArray[] inputs, INDArray[] outputs){
+        super(inputs, outputs);
+    }
+
     @Override
     public String opName() {
         return "gather_nd";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Linspace.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Linspace.java
index ede375163..f83d61c0d 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Linspace.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Linspace.java
@@ -1,5 +1,6 @@
 /*******************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
+ * Copyright (c) 2020 Konduit K.K.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Apache License, Version 2.0 which is available at
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/OneHot.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/OneHot.java
index affc603e9..c08dcb1d6 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/OneHot.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/OneHot.java
@@ -67,8 +67,7 @@ public class OneHot extends DynamicCustomOp {
     }
 
     public OneHot(INDArray indices, int depth) {
-        addInputArgument(indices);
-        addIArgument(depth);
+        this(indices, null, depth, 0, 1.0, 0.0);
     }
 
     public OneHot(INDArray indices, INDArray output, int depth, int axis, double on, double off) {
@@ -80,14 +79,16 @@ public class OneHot extends DynamicCustomOp {
         addArgs();
     }
 
-    public OneHot(INDArray indices, int depth, int axis, double on, double off, DataType dataType) {
-        addInputArgument(indices);
-        addIArgument(depth, axis);
-        addTArgument(on, off);
-        addDArgument(dataType);
+    public OneHot(INDArray indices, int depth, int axis, double on, double off) {
+        this(indices, null, depth, axis, on, off);
     }
 
-
+    public OneHot(INDArray indices, int depth, int axis, double on, double off, DataType dataType) {
+        this(indices, null, depth, axis, on, off);
+        this.outputType = dataType;
+        if (outputType != null)
+            addDArgument(outputType);
+    }
 
     protected void addArgs() {
         addIArgument(jaxis);
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/ParallelStack.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/ParallelStack.java
index 1827a6589..b4d71b40f 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/ParallelStack.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/ParallelStack.java
@@ -23,6 +23,7 @@ import org.nd4j.base.Preconditions;
 import org.nd4j.imports.descriptors.properties.PropertyMapping;
 import org.nd4j.imports.graphmapper.tf.TFGraphMapper;
 import org.nd4j.linalg.api.buffer.DataType;
+import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.api.ops.DynamicCustomOp;
 import org.tensorflow.framework.AttrValue;
 import org.tensorflow.framework.GraphDef;
@@ -44,6 +45,10 @@ public class ParallelStack extends DynamicCustomOp {
         super(null, sameDiff, values, false);
     }
 
+    public ParallelStack(INDArray[] inputs){
+        super(inputs, null);
+    }
+
     @Override
     public String opName() {
         return "parallel_stack";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Permute.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Permute.java
index 870a72a2b..85b9e2bb4 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Permute.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Permute.java
@@ -55,15 +55,16 @@ public class Permute extends Transpose {
         addIArgument(permuteDims);
     }
 
-    public Permute(INDArray input, int... permuteDims){
-        addInputArgument(input);
-        addIArgument(permuteDims);
-    }
-
     public Permute(SameDiff sd, SDVariable input, SDVariable permuteDims){
         super(sd, input, permuteDims);
     }
 
+    public Permute(INDArray input, int... permuteDims){
+        super(input, null);
+        this.permuteDims = permuteDims;
+        addIArgument(permuteDims);
+    }
+
     public Permute() {
     }
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Reshape.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Reshape.java
index 6c5c0f9d6..47960fad3 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Reshape.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Reshape.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.shape;
 
+import lombok.NoArgsConstructor;
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 import lombok.val;
@@ -41,6 +42,7 @@ import java.util.Map;
  * @author Adam Gibson
  */
 @Slf4j
+@NoArgsConstructor
 public class Reshape extends DynamicCustomOp {
 
     private long[] shape;
@@ -61,15 +63,13 @@ public class Reshape extends DynamicCustomOp {
         addIArgument(shape);
     }
 
-    public Reshape(INDArray in, INDArray shape){
-        this(in, shape, null);
-    }
 
     public Reshape(@NonNull INDArray in, @NonNull INDArray shape, INDArray out){
         super(null, new INDArray[]{in, shape}, wrapOrNull(out), null, (List<Integer>)null);
     }
 
-    public Reshape() {
+    public Reshape(INDArray in, INDArray shape){
+        this(in, shape, null);
     }
 
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Size.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Size.java
index ce3ce9cae..acec28f68 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Size.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Size.java
@@ -48,11 +48,10 @@ public class Size extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[] {input}, false);
     }
 
-    public Size(INDArray in) {
-        addInputArgument(in);
+    public Size(INDArray in){
+        super(new INDArray[] {in}, null);
     }
 
-
     @Override
     public String onnxName() {
         throw new NoOpNameFoundException("No onnx name found for shape " + opName());
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Slice.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Slice.java
index b9bcff540..effe95b2b 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Slice.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Slice.java
@@ -54,8 +54,10 @@ public class Slice extends DynamicCustomOp {
         super(null, sameDiff, new SDVariable[]{input, begin, end});
     }
 
-    public Slice(INDArray in, int[] begin, int... size) {
-        addInputArgument(in);
+    public Slice(INDArray input, int[] begin, int... size){
+        super(new INDArray[] {input}, null);
+        this.begin = begin;
+        this.size = size;
         addIArgument(begin);
         addIArgument(size);
     }
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/StridedSlice.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/StridedSlice.java
index 33c79e217..53deb43ca 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/StridedSlice.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/StridedSlice.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.shape;
 
+import lombok.NoArgsConstructor;
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 import lombok.val;
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Tile.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Tile.java
index e90e31427..687342ed8 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Tile.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Tile.java
@@ -67,13 +67,16 @@ public class Tile extends DynamicCustomOp {
         this(inputs,outputs,axis,false);
     }
 
-    public Tile(INDArray x, INDArray repeat) {
-        addInputArgument(x, repeat);
+    public Tile(INDArray x, INDArray repeat){
+        super(null, new INDArray[] {x, repeat}, null);
+        this.jaxis = null;
     }
 
-    public Tile(INDArray x, int... repeat) {
-        addInputArgument(x);
-        addIArgument(repeat);
+    public Tile(INDArray inputs, int... axis){
+        super(null, new INDArray[] {inputs}, null);
+        this.jaxis = axis;
+        this.is_static_reps = true;
+        addArguments();
     }
 
     public Tile() {}
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Transpose.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Transpose.java
index 95215b686..ea4096f63 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Transpose.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/shape/Transpose.java
@@ -60,8 +60,8 @@ public class Transpose extends DynamicCustomOp {
         super(null, new INDArray[]{input}, result == null ? null : new INDArray[]{result}, null, (List<Integer>) null);
     }
 
-    public Transpose(INDArray input) {
-        addInputArgument(input);
+    public Transpose(INDArray input){
+        this(input, null);
     }
 
     public Transpose() {
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/bool/MatchConditionTransform.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/bool/MatchConditionTransform.java
index dea1c9c3b..b3810ba15 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/bool/MatchConditionTransform.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/bool/MatchConditionTransform.java
@@ -62,12 +62,10 @@ public class MatchConditionTransform extends BaseTransformBoolOp {
         this(x, z, Nd4j.EPS_THRESHOLD, condition);
     }
 
-
     public MatchConditionTransform(INDArray x, @NonNull Condition condition) {
         this(x, null, Nd4j.EPS_THRESHOLD, condition);
     }
 
-
     public MatchConditionTransform(INDArray x, INDArray z, double eps, @NonNull Condition condition) {
         super(x, null, z);
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/comparison/CompareAndReplace.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/comparison/CompareAndReplace.java
index 80ab7fd35..9c5b54c72 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/comparison/CompareAndReplace.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/comparison/CompareAndReplace.java
@@ -69,7 +69,7 @@ public class CompareAndReplace extends BaseTransformSameOp {
      * @param condition
      */
     public CompareAndReplace(INDArray x, INDArray y, Condition condition) {
-        this(x, y, x, condition);
+        this(x, y, null, condition);
     }
 
     /**
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Assign.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Assign.java
index ca466ae34..e9ce44c57 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Assign.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Assign.java
@@ -24,6 +24,7 @@ import org.nd4j.linalg.api.buffer.DataType;
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.api.ops.DynamicCustomOp;
 import org.nd4j.linalg.api.ops.Op;
+import org.nd4j.linalg.factory.Nd4j;
 import org.tensorflow.framework.AttrValue;
 import org.tensorflow.framework.GraphDef;
 import org.tensorflow.framework.NodeDef;
@@ -46,6 +47,10 @@ public class Assign extends DynamicCustomOp {
         super(null,inputs, outputs);
     }
 
+    public Assign(INDArray x, INDArray y ) {
+        this( new INDArray[]{y ,x},new INDArray[]{y}); // TODO: Still check. y cannot be null, must be same shape as x.
+    }
+
     @Override
     public void addIArgument(int... arg) {
         super.addIArgument(arg);
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/DynamicPartition.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/DynamicPartition.java
index 718120bf7..db11a6a6c 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/DynamicPartition.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/DynamicPartition.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.transforms.custom;
 
+import lombok.NonNull;
 import lombok.val;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
@@ -67,11 +68,19 @@ public class DynamicPartition extends DynamicCustomOp {
         addArgs();
     }
 
-    public DynamicPartition(INDArray input, INDArray partitions, int numPartitions) {
-        addInputArgument(input);
-        addIArgument(numPartitions);
+    public DynamicPartition(@NonNull INDArray input, @NonNull INDArray partitions, int numPartitions) {
+        super(new INDArray[]{input, partitions}, null);
+        this.numPartitions = numPartitions;
+        addArgs();
     }
 
+    public DynamicPartition(INDArray x, INDArray [] partitions, int numPartitions){
+        //TODO; This needs fixing.
+        super(new INDArray[]{x}, null);
+        // this.partitions = partitions;
+        this.numPartitions = numPartitions;
+        addArgs();
+    }
 
     @Override
     public List<SDVariable> doDiff(List<SDVariable> i_v) {
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/DynamicStitch.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/DynamicStitch.java
index 60b2bf942..8c94c3e54 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/DynamicStitch.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/DynamicStitch.java
@@ -16,6 +16,7 @@
 
 package org.nd4j.linalg.api.ops.impl.transforms.custom;
 
+import lombok.NonNull;
 import org.apache.commons.lang3.ArrayUtils;
 import org.nd4j.autodiff.samediff.SDVariable;
 import org.nd4j.autodiff.samediff.SameDiff;
@@ -61,14 +62,8 @@ public class DynamicStitch extends DynamicCustomOp {
         this.numPartitions = inputs.length;
     }
 
-    public DynamicStitch(INDArray[] inputs, INDArray[] indices) {
-        for (INDArray input : inputs) {
-            addInputArgument(input);
-        }
-
-        for (INDArray index : indices) {
-            addInputArgument(index);
-        }
+    public DynamicStitch(@NonNull INDArray[] indices, @NonNull INDArray[] inputs) {
+        super(ArrayUtils.addAll(indices, inputs), null);
     }
 
     @Override
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/EqualTo.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/EqualTo.java
index 0d1214c9a..e58609f2a 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/EqualTo.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/EqualTo.java
@@ -48,14 +48,14 @@ public class EqualTo extends BaseDynamicTransformOp {
         super(inputs, outputs);
     }
 
-    public EqualTo( INDArray x, INDArray y) {
-        addInputArgument(x, y);
-    }
-
     public EqualTo(INDArray x, INDArray y, INDArray z){
         this(new INDArray[]{x, y}, new INDArray[]{z});
     }
 
+    public EqualTo(INDArray x, INDArray y){
+        this(new INDArray[]{x, y}, null);
+    }
+
     @Override
     public String opName() {
         return "equals";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Fill.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Fill.java
index 73f221f35..0e39eb77b 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Fill.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Fill.java
@@ -27,6 +27,7 @@ import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.api.ops.DynamicCustomOp;
 import org.nd4j.linalg.api.ops.Op;
 import org.nd4j.linalg.exception.ND4JIllegalStateException;
+import org.nd4j.linalg.factory.Nd4j;
 import org.tensorflow.framework.AttrValue;
 import org.tensorflow.framework.GraphDef;
 import org.tensorflow.framework.NodeDef;
@@ -55,19 +56,21 @@ public class Fill extends DynamicCustomOp {
         super(null,sameDiff, new SDVariable[] {shape}, false);
         this.value = value;
         this.outputDataType = outputDataType;
+        this.outputDataType = outputDataType;
         addArgs();
     }
 
+    public Fill(INDArray shape, DataType outputDataType, double value) {
+        super(new INDArray[]{shape, Nd4j.scalar(outputDataType, value)}, null);
+        this.value = value;
+        this.outputDataType = outputDataType;
+    }
+
     public Fill(INDArray shape, INDArray result, double value) {
         super(null, shape, result, Collections.singletonList(value), null);
         this.value = value;
     }
 
-    public Fill(INDArray shape, DataType dataType, double value) {
-        super(null, shape, null, Collections.singletonList(value), null);
-        this.value = value;
-    }
-
     public Fill(INDArray shape, INDArray value, INDArray result) {
         super(null, new INDArray[]{shape, value}, new INDArray[]{result});
     }
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/GreaterThan.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/GreaterThan.java
index 6a1ecc2cf..e4b28e56a 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/GreaterThan.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/GreaterThan.java
@@ -49,14 +49,14 @@ public class GreaterThan extends BaseDynamicTransformOp {
         super(inputs, outputs);
     }
 
-    public GreaterThan( INDArray x, INDArray y) {
-        addInputArgument(x,y);
-    }
-
     public GreaterThan(INDArray x, INDArray y, INDArray z){
         this(new INDArray[]{x, y}, new INDArray[]{z});
     }
 
+    public GreaterThan(INDArray x, INDArray y){
+        this(new INDArray[]{x, y}, null);
+    }
+
     @Override
     public String opName() {
         return "greater";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/GreaterThanOrEqual.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/GreaterThanOrEqual.java
index dfb7fe8dd..0ebea5e9c 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/GreaterThanOrEqual.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/GreaterThanOrEqual.java
@@ -52,9 +52,9 @@ public class GreaterThanOrEqual extends BaseDynamicTransformOp {
         this(new INDArray[]{x, y}, new INDArray[]{z});
     }
 
-    public GreaterThanOrEqual(INDArray x, INDArray y) {
 
-        this(new INDArray[]{x,y}, null);
+    public GreaterThanOrEqual(INDArray x, INDArray y){
+        this(new INDArray[]{x, y}, null);
     }
 
     @Override
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/IsNumericTensor.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/IsNumericTensor.java
index 88c0a84ba..4f1804480 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/IsNumericTensor.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/IsNumericTensor.java
@@ -45,8 +45,8 @@ public class IsNumericTensor extends DynamicCustomOp {
         super(null, inputs, outputs);
     }
 
-    public IsNumericTensor(INDArray input) {
-        addInputArgument(input);
+    public IsNumericTensor(INDArray inputs) {
+        super( new INDArray[] {inputs}, null);
     }
 
     @Override
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/LessThan.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/LessThan.java
index b1a38e0ff..0445b58c4 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/LessThan.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/LessThan.java
@@ -49,14 +49,14 @@ public class LessThan extends BaseDynamicTransformOp {
         super(inputs, outputs);
     }
 
-    public LessThan( INDArray x, INDArray y) {
-        addInputArgument(x,y);
-    }
-
     public LessThan(INDArray x, INDArray y, INDArray z){
         this(new INDArray[]{x, y}, new INDArray[]{z});
     }
 
+    public LessThan(INDArray x, INDArray y){
+        this(new INDArray[]{x, y}, null);
+    }
+
     @Override
     public String opName() {
         return "less";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/LessThanOrEqual.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/LessThanOrEqual.java
index 0ca6bf7e6..06e03335c 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/LessThanOrEqual.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/LessThanOrEqual.java
@@ -48,14 +48,14 @@ public class LessThanOrEqual extends BaseDynamicTransformOp {
         super(inputs, outputs);
     }
 
-    public LessThanOrEqual( INDArray x, INDArray y) {
-        addInputArgument(x,y);
-    }
-
     public LessThanOrEqual(INDArray x, INDArray y, INDArray z){
         this(new INDArray[]{x, y}, new INDArray[]{z});
     }
 
+    public LessThanOrEqual(INDArray x, INDArray y){
+        this(new INDArray[]{x, y}, null);
+    }
+
     @Override
     public String opName() {
         return "less_equal";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Max.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Max.java
index d2451c0f8..0197f0c79 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Max.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Max.java
@@ -48,12 +48,12 @@ public class Max extends BaseDynamicTransformOp {
         super(new INDArray[]{first, second}, out == null ? null : new INDArray[]{out});
     }
 
-    public Max( INDArray[] inputs, INDArray[] outputs) {
-        super(inputs, outputs);
+    public Max( INDArray first, INDArray second){
+        this(first, second, null);
     }
 
-    public Max( INDArray x, INDArray y) {
-        addInputArgument(x,y);
+    public Max( INDArray[] inputs, INDArray[] outputs) {
+        super(inputs, outputs);
     }
 
   @Override
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Min.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Min.java
index c195178c2..cf0cf9c58 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Min.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/Min.java
@@ -48,12 +48,12 @@ public class Min extends BaseDynamicTransformOp {
         super(new INDArray[]{first, second}, out == null ? null : new INDArray[]{out});
     }
 
-    public Min( INDArray[] inputs, INDArray[] outputs) {
-        super(inputs, outputs);
+    public Min( INDArray first, INDArray second){
+        this(first, second, null);
     }
 
-    public Min( INDArray x, INDArray y) {
-        addInputArgument(x,y);
+    public Min( INDArray[] inputs, INDArray[] outputs) {
+        super(inputs, outputs);
     }
 
     @Override
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/NotEqualTo.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/NotEqualTo.java
index 69d724a7e..ba2e36ea2 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/NotEqualTo.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/NotEqualTo.java
@@ -48,14 +48,14 @@ public class NotEqualTo extends BaseDynamicTransformOp {
         super(inputs, outputs);
     }
 
-    public NotEqualTo( INDArray x, INDArray y) {
-        addInputArgument(x,y);
-    }
-
     public NotEqualTo(INDArray x, INDArray y, INDArray z){
         this(new INDArray[]{x, y}, new INDArray[]{z});
     }
 
+    public NotEqualTo(INDArray x, INDArray y){
+        this(new INDArray[]{x, y}, null);
+    }
+
     @Override
     public String opName() {
         return "not_equals";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/ReverseSequence.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/ReverseSequence.java
index 50332daf6..f7494c618 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/ReverseSequence.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/ReverseSequence.java
@@ -59,6 +59,17 @@ public class ReverseSequence extends DynamicCustomOp {
         addArguments();
     }
 
+    public ReverseSequence(INDArray x, INDArray seq_lengths, int seqDim, int batchDim){
+        super(new INDArray[]{x, seq_lengths}, null);
+        this.seqDim = seqDim;
+        this.batchDim = batchDim;
+        addArguments();
+    }
+
+    public ReverseSequence(INDArray x, INDArray seq_lengths){
+        this(x, seq_lengths, 1, 0);
+    }
+
     private void addArguments(){
         addIArgument(seqDim);
         addIArgument(batchDim);
@@ -67,11 +78,6 @@ public class ReverseSequence extends DynamicCustomOp {
     public ReverseSequence() {
     }
 
-    public ReverseSequence(INDArray x, INDArray seq_lengths, int seqDim, int batchDim) {
-        addInputArgument(x, seq_lengths);
-        addIArgument(seqDim, batchDim);
-    }
-
     @Override
     public String opName() {
         return "reverse_sequence";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMax.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMax.java
index c98cd7d5b..217062e09 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMax.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMax.java
@@ -39,8 +39,8 @@ public class SegmentMax extends DynamicCustomOp {
         super(null, sameDiff,  new SDVariable[] {data, segmentIds}, false);
     }
 
-    public SegmentMax(INDArray data, INDArray segmentIds) {
-        addInputArgument(data, segmentIds);
+    public SegmentMax(INDArray data, INDArray segmentIds){
+        super(new INDArray[]{data, segmentIds}, null);
     }
 
     public SegmentMax(){ }
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMean.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMean.java
index eca108b2a..79e887001 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMean.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMean.java
@@ -39,12 +39,12 @@ public class SegmentMean extends DynamicCustomOp {
         super(null, sameDiff,  new SDVariable[] {data, segmentIds}, false);
     }
 
-    public SegmentMean(INDArray data, INDArray segmentIds) {
-        addInputArgument(data, segmentIds);
-    }
-
     public SegmentMean(){ }
 
+    public SegmentMean(INDArray data, INDArray segmentIds){
+        super(new INDArray[]{data, segmentIds}, null);
+    }
+
     @Override
     public String opName(){
         return "segment_mean";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMin.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMin.java
index f070dc8d1..367d6ee1a 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMin.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentMin.java
@@ -39,12 +39,12 @@ public class SegmentMin extends DynamicCustomOp {
         super(null, sameDiff,  new SDVariable[] {data, segmentIds}, false);
     }
 
-    public SegmentMin(INDArray data, INDArray segmentIds) {
-        addInputArgument(data, segmentIds);
-    }
-
     public SegmentMin(){ }
 
+    public SegmentMin(INDArray data, INDArray segmentIds){
+        super(new INDArray[]{data, segmentIds}, null);
+    }
+
     @Override
     public String opName(){
         return "segment_min";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentProd.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentProd.java
index 71d0dd2c3..ddd719045 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentProd.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentProd.java
@@ -39,12 +39,12 @@ public class SegmentProd extends DynamicCustomOp {
         super(null, sameDiff,  new SDVariable[] {data, segmentIds}, false);
     }
 
-    public SegmentProd(INDArray data, INDArray segmentIds) {
-        addInputArgument(data, segmentIds);
-    }
-
     public SegmentProd(){ }
 
+    public SegmentProd(INDArray data, INDArray segmentIds){
+        super(new INDArray[]{data, segmentIds}, null);
+    }
+
     @Override
     public String opName(){
         return "segment_prod";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentSum.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentSum.java
index a74aded65..9f6269848 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentSum.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/custom/segment/SegmentSum.java
@@ -39,12 +39,12 @@ public class SegmentSum extends DynamicCustomOp {
         super(null, sameDiff,  new SDVariable[] {data, segmentIds}, false);
     }
 
-    public SegmentSum(INDArray data, INDArray segmentIds) {
-        addInputArgument(data, segmentIds);
-    }
-
     public SegmentSum(){ }
 
+    public SegmentSum(INDArray data, INDArray segmentIds){
+        super(new INDArray[]{data, segmentIds}, null);
+    }
+
     @Override
     public String opName(){
         return "segment_sum";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/same/Identity.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/same/Identity.java
index dcee02131..6918b8d2c 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/same/Identity.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/same/Identity.java
@@ -42,7 +42,7 @@ public class Identity extends BaseDynamicTransformOp {
     }
 
     public Identity(INDArray x){
-        addInputArgument(x);
+        super(new INDArray[]{x}, null);
     }
 
     public Identity(){ }
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMax.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMax.java
index aeb543ea8..6f0432ba5 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMax.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMax.java
@@ -41,13 +41,14 @@ public class UnsortedSegmentMax extends DynamicCustomOp {
         addIArgument(numSegments);
     }
 
-    public UnsortedSegmentMax(INDArray data, INDArray segmentIds, int numSegments) {
-        addInputArgument(data, segmentIds);
+    public UnsortedSegmentMax(){ }
+
+    public UnsortedSegmentMax(INDArray data, INDArray segmentIds, int numSegments){
+        super(new INDArray[]{data, segmentIds}, null);
+        this.numSegments = numSegments;
         addIArgument(numSegments);
     }
 
-    public UnsortedSegmentMax(){ }
-
     @Override
     public String opName(){
         return "unsorted_segment_max";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMean.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMean.java
index e869a84eb..ef39f1c91 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMean.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMean.java
@@ -45,8 +45,9 @@ public class UnsortedSegmentMean extends DynamicCustomOp {
         addIArgument(numSegments);
     }
 
-    public UnsortedSegmentMean(INDArray data, INDArray segmentIds, int numSegments) {
-        addInputArgument(data, segmentIds);
+    public UnsortedSegmentMean(INDArray data, INDArray segmentIds, int numSegments){
+        super(new INDArray[]{data, segmentIds}, null);
+        this.numSegments = numSegments;
         addIArgument(numSegments);
     }
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMin.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMin.java
index fd0f5fd05..6dc6e7737 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMin.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentMin.java
@@ -45,8 +45,9 @@ public class UnsortedSegmentMin extends DynamicCustomOp {
         addIArgument(numSegments);
     }
 
-    public UnsortedSegmentMin(INDArray data, INDArray segmentIds, int numSegments) {
-        addInputArgument(data, segmentIds);
+    public UnsortedSegmentMin(INDArray data, INDArray segmentIds, int numSegments){
+        super(new INDArray[]{data, segmentIds}, null);
+        this.numSegments = numSegments;
         addIArgument(numSegments);
     }
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentProd.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentProd.java
index 12ec63222..f753fe6dc 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentProd.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentProd.java
@@ -45,8 +45,9 @@ public class UnsortedSegmentProd extends DynamicCustomOp {
         addIArgument(numSegments);
     }
 
-    public UnsortedSegmentProd(INDArray data, INDArray segmentIds, int numSegments) {
-        addInputArgument(data, segmentIds);
+    public UnsortedSegmentProd(INDArray data, INDArray segmentIds, int numSegments){
+        super(new INDArray[]{data, segmentIds}, null);
+        this.numSegments = numSegments;
         addIArgument(numSegments);
     }
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentSqrtN.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentSqrtN.java
index 9d7aceb96..ea5285f12 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentSqrtN.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentSqrtN.java
@@ -39,18 +39,18 @@ public class UnsortedSegmentSqrtN extends DynamicCustomOp {
 
     private int numSegments;
 
-    public UnsortedSegmentSqrtN(INDArray data, INDArray segmentIds, int numSegments) {
-        addInputArgument(data, segmentIds);
-        addIArgument(numSegments);
-        this.numSegments = numSegments;
-    }
-
     public UnsortedSegmentSqrtN(SameDiff sameDiff, SDVariable data, SDVariable segmentIds, int numSegments) {
         super(null, sameDiff,  new SDVariable[] {data, segmentIds}, false);
         this.numSegments = numSegments;
         addIArgument(numSegments);
     }
 
+    public UnsortedSegmentSqrtN(INDArray data, INDArray segmentIds, int numSegments){
+        super(new INDArray[]{data, segmentIds}, null);
+        this.numSegments = numSegments;
+        addIArgument(numSegments);
+    }
+
     @Override
     public String opName(){
         return "unsorted_segment_sqrt_n";
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentSum.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentSum.java
index 5e5cfd12e..d0d5b095b 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentSum.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/impl/transforms/segment/UnsortedSegmentSum.java
@@ -46,8 +46,9 @@ public class UnsortedSegmentSum extends DynamicCustomOp {
         addIArgument(numSegments);
     }
 
-    public UnsortedSegmentSum(INDArray data, INDArray segmentIds, int numSegments) {
-        addInputArgument(data, segmentIds);
+    public UnsortedSegmentSum(INDArray data, INDArray segmentIds, int numSegments){
+        super(new INDArray[]{data, segmentIds}, null);
+        this.numSegments = numSegments;
         addIArgument(numSegments);
     }
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/factory/NDValidation.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/factory/NDValidation.java
index 4986b8277..e9dd0f840 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/factory/NDValidation.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/factory/NDValidation.java
@@ -130,13 +130,20 @@ public class NDValidation {
                     " type; got array with non-integer data type " + v.dataType());
     }
 
-    public static void validateInteger(String opName, String inputName, INDArray[] vars) {
-        for (INDArray v : vars) {
-            if (v == null)
-                return;
-            if (!v.dataType().isIntType())
+    /**
+     * Validate that the operation is being applied on an integer type INDArray []
+     *
+     * @param opName    Operation name to print in the exception
+     * @param inputName Name of the input to the op to validate
+     * @param v         Variable to validate datatype for (input to operation)
+     */
+    public static void validateInteger(String opName, String inputName, INDArray [] v) {
+        if (v == null)
+            return;
+        for (int i = 0; i < v.length; i++) {
+            if (!v[i].dataType().isIntType())
                 throw new IllegalStateException("Input \"" + inputName + "\" for operation \"" + opName + "\" must be an integer" +
-                        " type; got array with non-integer data type " + v.dataType());
+                        " type; got array with non-integer data type member" + v[i].dataType());
         }
     }
 
@@ -246,11 +253,12 @@ public class NDValidation {
     }
 
     public static boolean isSameType(INDArray[] x) {
-        DataType firstDataType = x[0].dataType();
-        if (x.length > 1) {
-            for (int i = 1; i < x.length; ++i) {
-                if (firstDataType != x[i].dataType())
-                    return false;
+        if(x.length == 0)
+            return true;
+        DataType first = x[0].dataType();
+        for( int i=1; i<x.length; i++ ){
+            if(first != x[i].dataType()){
+                return false;
             }
         }
         return true;
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/factory/Nd4j.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/factory/Nd4j.java
index 43181a3b2..2b1021742 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/factory/Nd4j.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/factory/Nd4j.java
@@ -2006,10 +2006,9 @@ public class Nd4j {
      * @return the linearly spaced vector
      */
     public static INDArray linspace(@NonNull DataType dataType, double lower, double step, long num) {
-        Preconditions.checkState(dataType.isFPType());
+        Preconditions.checkState(dataType.isFPType(), "Datatype must be a floating point type for linspace, got %s", dataType);
         if (num == 1)
             return Nd4j.scalar(dataType, lower);
-
         return Nd4j.getExecutioner().exec(new Linspace(lower, num, step, dataType));
     }
 
@@ -2022,10 +2021,9 @@ public class Nd4j {
      * @return the linearly spaced vector
      */
     public static INDArray linspace( double lower, double upper, long num, @NonNull DataType dataType) {
-        Preconditions.checkState(dataType.isFPType());
+        Preconditions.checkState(dataType.isFPType(), "Datatype must be a floating point type for linspace, got %s", dataType);
         if (num == 1)
             return Nd4j.scalar(dataType, lower);
-
         return Nd4j.getExecutioner().exec(new Linspace(lower, upper, num, dataType));
     }
 
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/indexing/BooleanIndexing.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/indexing/BooleanIndexing.java
index 77f56c613..49dfd1458 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/indexing/BooleanIndexing.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/indexing/BooleanIndexing.java
@@ -159,7 +159,7 @@ public class BooleanIndexing {
         if (to.length() != from.length())
             throw new IllegalStateException("Mis matched length for to and from");
 
-        Nd4j.getExecutioner().exec(new CompareAndSet(to, from, condition));
+        Nd4j.getExecutioner().exec(new CompareAndSet(to, from, to, condition));
     }
 
 
@@ -177,7 +177,7 @@ public class BooleanIndexing {
         if (to.length() != from.length())
             throw new IllegalStateException("Mis matched length for to and from");
 
-        Nd4j.getExecutioner().exec(new CompareAndReplace(to, from, condition));
+        Nd4j.getExecutioner().exec(new CompareAndReplace(to, from, to, condition));
     }
 
     /**
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/learning/AdaGradUpdater.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/learning/AdaGradUpdater.java
index ad355d1cc..211022366 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/learning/AdaGradUpdater.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/learning/AdaGradUpdater.java
@@ -1,5 +1,6 @@
 /*******************************************************************************
  * Copyright (c) 2015-2018 Skymind, Inc.
+ * Copyright (c) 2020 Konduit K.K.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Apache License, Version 2.0 which is available at
diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/learning/NadamUpdater.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/learning/NadamUpdater.java
index 6432e288e..1cea01cb7 100644
--- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/learning/NadamUpdater.java
+++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/learning/NadamUpdater.java
@@ -19,13 +19,11 @@ package org.nd4j.linalg.learning;
 
 import lombok.Data;
 import lombok.NonNull;
-import org.apache.commons.math3.util.FastMath;
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.api.shape.Shape;
 import org.nd4j.linalg.factory.Nd4j;
 import org.nd4j.linalg.indexing.NDArrayIndex;
 import org.nd4j.linalg.learning.config.Nadam;
-import org.nd4j.linalg.ops.transforms.Transforms;
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaExecutioner.java b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaExecutioner.java
index b21123085..4b8209027 100644
--- a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaExecutioner.java
+++ b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaExecutioner.java
@@ -792,6 +792,19 @@ public class CudaExecutioner extends DefaultOpExecutioner {
             }
         }
 
+        boolean keepDims = op.isKeepDims();
+        long[] retShape = Shape.reductionShape(x, dimension, true, keepDims);
+
+        if(z == null || x == z) {
+            val ret = Nd4j.createUninitialized(DataType.LONG, retShape);
+
+            setZ(ret, op, oc);
+            z = ret;
+        } else if(!Arrays.equals(retShape, z.shape())){
+            throw new IllegalStateException("Z array shape does not match expected return type for op " + op
+                    + ": expected shape " + Arrays.toString(retShape) + ", z.shape()=" + Arrays.toString(z.shape()));
+        }
+
         long st = profilingConfigurableHookIn(op);
 
         checkForCompression(op);
@@ -2060,7 +2073,7 @@ public class CudaExecutioner extends DefaultOpExecutioner {
                     throw new ND4JIllegalStateException("Op name " + op.opName() + " failed to execute. You can't execute non-inplace CustomOp without outputs being specified");
 
                 for (val shape: list)
-                    op.addOutputArgument(Nd4j.create(shape));
+                    op.addOutputArgument(Nd4j.create(shape, false));
 
                 shapeOverride = true;
             } catch (Exception e) {
diff --git a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/NativeOpExecutioner.java b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/NativeOpExecutioner.java
index 93ff5cf52..e42495e5e 100644
--- a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/NativeOpExecutioner.java
+++ b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/NativeOpExecutioner.java
@@ -772,8 +772,10 @@ public class NativeOpExecutioner extends DefaultOpExecutioner {
 
             if (y != null) {
 
-                if (z == null)
+                if (z == null) {
                     setZ(Nd4j.create(op.resultType(), x.shape()), op, oc);
+                    z = getZ(op, oc);
+                }
 
 
                 op.validateDataTypes(oc, experimentalMode.get());
diff --git a/nd4j/nd4j-backends/nd4j-tests/src/test/java/org/nd4j/linalg/factory/ops/NDBaseTest.java b/nd4j/nd4j-backends/nd4j-tests/src/test/java/org/nd4j/linalg/factory/ops/NDBaseTest.java
new file mode 100644
index 000000000..bcf8c0ac3
--- /dev/null
+++ b/nd4j/nd4j-backends/nd4j-tests/src/test/java/org/nd4j/linalg/factory/ops/NDBaseTest.java
@@ -0,0 +1,1030 @@
+/* *****************************************************************************
+ * Copyright (c) 2015-2018 Konduit k.k.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License, Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ******************************************************************************/
+
+package org.nd4j.linalg.factory.ops;
+
+import org.junit.Test;
+import org.nd4j.linalg.BaseNd4jTest;
+import org.nd4j.linalg.api.buffer.DataType;
+import org.nd4j.linalg.api.ndarray.INDArray;
+import org.nd4j.linalg.factory.Nd4j;
+import org.nd4j.linalg.factory.Nd4jBackend;
+import org.nd4j.linalg.indexing.conditions.Conditions;
+
+import static org.junit.Assert.*;
+
+public class NDBaseTest extends BaseNd4jTest {
+    public NDBaseTest(Nd4jBackend backend) {
+        super(backend);
+    }
+
+    @Override
+    public char ordering(){
+        return 'c';
+    }
+
+    // TODO: Comment from the review. We'll remove the new NDBase() at some point.
+
+    @Test
+    public void testAll() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.BOOL, 3, 3);
+        INDArray y = base.all(x, 1);
+        INDArray y_exp = Nd4j.createFromArray(false, false, false);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testAny() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3).castTo(DataType.BOOL);
+        INDArray y = base.any(x, 1);
+        INDArray y_exp = Nd4j.createFromArray(true, true, true);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testArgmax() {
+        NDBase base = new NDBase();
+
+        INDArray x = Nd4j.createFromArray(new double[][]{{0.75, 0.5, 0.25}, {0.5, 0.75, 0.25}, {0.5, 0.25, 0.75}});
+        INDArray y = base.argmax(x, 0); //with default keepdims
+        INDArray y_exp = Nd4j.createFromArray(0L, 1L, 2L);
+        assertEquals(y_exp, y);
+
+        y = base.argmax(x, false, 0); //with explicit keepdims false
+        assertEquals(y_exp, y);
+
+        y = base.argmax(x, true, 0); //with keepdims true
+        y_exp = Nd4j.createFromArray(new long[][]{{0L, 1L, 2L}}); //expect different shape.
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testArgmin() {
+        //Copy Paste from argmax, replaced with argmin.
+        NDBase base = new NDBase();
+
+        INDArray x = Nd4j.createFromArray(new double[][]{{0.75, 0.5, 0.25}, {0.5, 0.75, 0.25}, {0.5, 0.25, 0.75}});
+        INDArray y = base.argmin(x, 0); //with default keepdims
+        INDArray y_exp = Nd4j.createFromArray(1L, 2L, 0L);
+        assertEquals(y_exp, y);
+
+        y = base.argmin(x, false, 0); //with explicit keepdims false
+        assertEquals(y_exp, y);
+
+        y = base.argmin(x, true, 0); //with keepdims true
+        y_exp = Nd4j.createFromArray(new long[][]{{1L, 2L, 0L}}); //expect different shape.
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testConcat() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = Nd4j.ones(DataType.DOUBLE, 3, 3);
+
+        INDArray z = base.concat(0, x, y);
+        assertArrayEquals(new long[]{6, 3}, z.shape());
+
+        z = base.concat(1, x, y);
+        assertArrayEquals(new long[]{3, 6}, z.shape());
+    }
+
+    @Test
+    public void testCumprod() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        INDArray y = base.cumprod(x, false, false, 0);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{1.0, 2.0, 3.0}, {4.0, 10.0, 18.0}, {28.0, 80.0, 162.0}});
+        assertEquals(y_exp, y);
+
+        y = base.cumprod(x, false, false, 1);
+        y_exp = Nd4j.createFromArray(new double[][]{{1.0, 2.0, 6.0}, {4.0, 20.0, 120.0}, {7.0, 56.0, 504.0}});
+        assertEquals(y_exp, y);
+
+    }
+
+    @Test
+    public void testCumsum() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        INDArray y = base.cumsum(x, false, false, 0);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{1.0, 2.0, 3.0}, {5.0, 7.0, 9.0}, {12.0, 15.0, 18.0}});
+        assertEquals(y_exp, y);
+
+        y = base.cumsum(x, false, false, 1);
+        y_exp = Nd4j.createFromArray(new double[][]{{1.0, 3.0, 6.0}, {4.0, 9.0, 15.0}, {7.0, 15.0, 24.0}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testDot() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 3);
+        INDArray y = base.dot(x, x, 0);
+        INDArray y_exp = Nd4j.scalar(14.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testDynamicpartition() {
+        //Try to execute the sample in the code dcumentation:
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 5);
+        int numPartitions = 2;
+        int[] partitions = new int[]{1, 0, 0, 1, 0};
+        //INDArray y = base.dynamicPartition(x, partitions, numPartitions); TODO: Fix
+        //TODO: crashes here. Op needs fixing.
+
+    }
+
+    @Test
+    public void testDynamicStitch() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        //INDArray y = base.dynamicStitch(new INDArray[]{x, x}, 0); TODO: Fix
+        //TODO: crashes here. Op needs fixing.  Bad constructor, as previously flagged. Both input and indices need to be INDArrays
+    }
+
+    @Test
+    public void testScalarEq() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.eq(x, 0.0);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testEq() {
+        //element wise  eq.
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.eq(x, x);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testExpandDims() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1,2).reshape(1,2);
+        INDArray y = base.expandDims(x, 0);
+        INDArray y_exp = x.reshape(1, 1, 2);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testFill() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(2, 2);
+        INDArray y = base.fill(x, DataType.DOUBLE, 1.1);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{1.1, 1.1}, {1.1, 1.1}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testGather() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        int[] ind = new int[]{0};
+        INDArray y = base.gather(x, ind, 0);
+        INDArray y_exp = Nd4j.createFromArray(0.0, 0.0, 0.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScalarGt() {
+        //Scalar gt.
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.gt(x, -0.1);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testGt() {
+        //element wise  gt.
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray x1 = Nd4j.ones(DataType.DOUBLE, 3, 3);
+        INDArray y = base.gt(x1, x);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+
+    @Test
+    public void testScalarGte() {
+        //Scalar gte.
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.gte(x, -0.1);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testGte() {
+        //element wise  gte.
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray x1 = Nd4j.ones(DataType.DOUBLE, 3, 3);
+        INDArray y = base.gte(x1, x);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testIdentity() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.identity(x);
+        assertEquals(x, y);
+    }
+
+    @Test
+    public void testInvertPermutation() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(2,0,1);
+        INDArray y = base.invertPermutation(x);
+        INDArray exp = Nd4j.createFromArray(1,2,0);
+        assertEquals(exp, y);
+    }
+
+    @Test
+    public void testisNumericTensor() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.isNumericTensor(x);
+        assertEquals(Nd4j.scalar(true), y);
+    }
+
+    @Test
+    public void testLinspace() {
+        NDBase base = new NDBase();
+        INDArray y = base.linspace(DataType.DOUBLE, 0.0, 9.0, 19);
+        //TODO: test crashes.
+    }
+
+    @Test
+    public void testScalarLt() {
+        //Scalar lt.
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.lt(x, 0.1);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testLt() {
+        NDBase base = new NDBase();
+        INDArray x1 = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 3, 3);
+        INDArray y = base.lt(x1, x);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScalarLte() {
+        //Scalar gt.
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.lte(x, 0.1);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testLte() {
+        NDBase base = new NDBase();
+        INDArray x1 = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 3, 3);
+        INDArray y = base.lte(x1, x);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testMatchCondition() {
+        // same test as TestMatchTransformOp,
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1.0, 1.0, 1.0, 0.0, 1.0, 1.0);
+        INDArray y = base.matchCondition(x, Conditions.epsEquals(0.0));
+        INDArray y_exp = Nd4j.createFromArray(false, false, false, true, false, false);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testMatchConditionCount() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1.0, 1.0, 1.0, 0.0, 1.0, 1.0);
+        INDArray y = base.matchConditionCount(x, Conditions.epsEquals(0.0));
+        assertEquals(Nd4j.scalar(1L), y);
+
+        x = Nd4j.eye(3);
+        y = base.matchConditionCount(x, Conditions.epsEquals(1.0), true, 1);
+        INDArray y_exp = Nd4j.createFromArray(new Long[][]{{1L}, {1L}, {1L}});
+        assertEquals(y_exp, y);
+
+        y = base.matchConditionCount(x, Conditions.epsEquals(1.0), true, 0);
+        y_exp = Nd4j.createFromArray(new Long[][]{{1L, 1L, 1L}});
+        assertEquals(y_exp, y);
+
+        y = base.matchConditionCount(x, Conditions.epsEquals(1.0), false, 1);
+        y_exp = Nd4j.createFromArray(1L, 1L, 1L);
+        assertEquals(y_exp, y);
+
+        y = base.matchConditionCount(x, Conditions.epsEquals(1.0), false, 0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testMax() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3).castTo(DataType.FLOAT);
+        INDArray y = base.max(x, 0);
+        INDArray  y_exp = Nd4j.createFromArray(1.0f, 1.0f, 1.0f);
+        assertEquals(y_exp, y);
+
+        y = base.max(x, true, 0);
+        y_exp = Nd4j.createFromArray(new float[][]{{1.0f, 1.0f, 1.0f}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testMean() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3).castTo(DataType.FLOAT);
+        INDArray y = base.mean(x, 0);
+        INDArray  y_exp = Nd4j.createFromArray(0.333333f, 0.333333f, 0.333333f);
+        assertEquals(y_exp, y);
+
+        y = base.mean(x, true, 0);
+        y_exp = Nd4j.createFromArray(new float[][]{{0.333333f, 0.333333f, 0.333333f}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testMin() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3).castTo(DataType.FLOAT);
+        INDArray y = base.min(x, 0);
+        INDArray  y_exp = Nd4j.createFromArray(0.0f, 0.0f, 0.0f);
+        assertEquals(y_exp, y);
+
+        y = base.min(x, true, 0);
+        y_exp = Nd4j.createFromArray(new float[][]{{0.0f, 0.0f, 0.0f}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testMmulTranspose() {
+        INDArray x = Nd4j.rand(DataType.FLOAT, 4, 3);
+        INDArray y = Nd4j.rand(DataType.FLOAT, 5, 4);
+        INDArray exp = x.transpose().mmul(y.transpose());
+        INDArray z = new NDBase().mmul(x, y, true, true, false);
+        assertEquals(exp, z);
+    }
+
+    @Test
+    public void testMmul() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        INDArray x1 = Nd4j.eye(3).castTo(DataType.DOUBLE);
+        INDArray y = base.mmul(x, x1);
+        assertEquals(y, x);
+    }
+
+    @Test
+    public void testScalarNeq() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray y = base.neq(x, 1.0);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testNeq() {
+        //element wise  eq.
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(DataType.DOUBLE, 3, 3);
+        INDArray x1 = Nd4j.ones(DataType.DOUBLE, 3, 3);
+        INDArray y = base.neq(x, x1);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, true, true}, {true, true, true}, {true, true, true}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testNorm1() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3).castTo(DataType.FLOAT);
+        INDArray y = base.norm1(x, 0);
+        INDArray  y_exp = Nd4j.createFromArray(1.0f, 1.0f, 1.0f);
+        assertEquals(y_exp, y);
+
+        y = base.norm1(x, true, 0);
+        y_exp = Nd4j.createFromArray(new float[][]{{1.0f, 1.0f, 1.0f}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testNorm2() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3).castTo(DataType.FLOAT);
+        INDArray y = base.norm2(x, 0);
+        INDArray  y_exp = Nd4j.createFromArray(1.0f, 1.0f, 1.0f);
+        assertEquals(y_exp, y);
+
+        y = base.norm2(x, true, 0);
+        y_exp = Nd4j.createFromArray(new float[][]{{1.0f, 1.0f, 1.0f}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testNormMax() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3).castTo(DataType.FLOAT);
+        INDArray y = base.normmax(x, 0);
+        INDArray  y_exp = Nd4j.createFromArray(1.0f, 1.0f, 1.0f);
+        assertEquals(y_exp, y);
+
+        y = base.normmax(x, true, 0);
+        y_exp = Nd4j.createFromArray(new float[][]{{1.0f, 1.0f, 1.0f}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testOneHot() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(0.0, 1.0, 2.0);
+        INDArray y = base.oneHot(x, 1, 0, 1.0, 0.0);
+        INDArray y_exp = Nd4j.createFromArray(new float[][]{{1.0f, 0.0f, 0.0f}});
+        assertEquals(y_exp, y);
+
+        y = base.oneHot(x, 1);
+        y_exp = Nd4j.createFromArray(new float[][]{{1.0f},{ 0.0f}, {0.0f}});
+        assertEquals(y_exp, y);
+
+        y = base.oneHot(x, 1, 0, 1.0, 0.0, DataType.DOUBLE);
+        y_exp = Nd4j.createFromArray(new double[][]{{1.0, 0.0, 0.0}});
+        assertEquals(y_exp, y); //TODO: Looks like we're getting back the wrong datatype.       https://github.com/eclipse/deeplearning4j/issues/8607
+    }
+
+    @Test
+    public void testOnesLike() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(3, 3);
+        INDArray y = base.onesLike(x);
+        INDArray  y_exp = Nd4j.createFromArray(1, 1);
+        assertEquals(y_exp, y);
+
+        y = base.onesLike(x, DataType.INT64);
+        y_exp = Nd4j.createFromArray(1L, 1L);
+        assertEquals(y_exp, y); //TODO: Getting back a double array, not a long.    https://github.com/eclipse/deeplearning4j/issues/8605
+    }
+
+    @Test
+    public void testPermute() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(1, 6, 6).reshape(2, 3);
+        INDArray y = base.permute(x, 1,0);
+        assertArrayEquals(new long[]{3, 2}, y.shape());
+    }
+
+    @Test
+    public void testProd() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3).castTo(DataType.FLOAT);
+        INDArray y = base.prod(x, 0);
+        INDArray y_exp = Nd4j.createFromArray(0.0f, 0.0f, 0.0f);
+        assertEquals(y_exp, y);
+
+        y = base.prod(x, true, 0);
+        y_exp = Nd4j.createFromArray(new float[][]{{0.0f, 0.0f, 0.0f}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testRange() {
+        NDBase base = new NDBase();
+        INDArray y = base.range(0.0, 3.0, 1.0, DataType.DOUBLE);
+        INDArray y_exp = Nd4j.createFromArray(0.0, 1.0, 2.0);
+        assertEquals(y_exp, y); //TODO: Asked for DOUBLE, got back a FLOAT Array.   https://github.com/eclipse/deeplearning4j/issues/8606
+    }
+
+    @Test
+    public void testRank() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3);
+        INDArray y = base.rank(x);
+        INDArray y_exp = Nd4j.scalar(2);
+        System.out.println(y);
+        assertEquals(y_exp, y);
+    }
+
+    /*
+    @Test
+    public void testRepeat() {
+        fail("AB 2020/01/09 - Not sure what this op is supposed to do...");
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.eye(3);
+        INDArray y = base.repeat(x, 0);
+        //TODO: fix, crashes the JVM.
+    }
+     */
+
+
+    @Test
+    public void testReplaceWhere() {
+        // test from BooleanIndexingTest.
+        NDBase base = new NDBase();
+        INDArray array1 = Nd4j.createFromArray( 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
+        INDArray array2 = Nd4j.createFromArray( 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
+
+        INDArray y = base.replaceWhere(array1, array2 , Conditions.greaterThan(4));
+        INDArray y_exp = Nd4j.createFromArray( 1.0, 2.0, 3.0, 4.0, 3.0, 2.0, 1.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testReshape() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        INDArray shape = Nd4j.createFromArray(new long[] {3, 3});
+        INDArray y = base.reshape(x, shape);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{1.0, 2.0, 3.0}, { 4.0, 5.0, 6.0}, { 7.0, 8.0, 9.0} } );
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testReverse() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 6).reshape(2, 3);
+        INDArray y = base.reverse(x, 0);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{ 4.0, 5.0, 6.0},{1.0, 2.0, 3.0} } );
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testReverseSequence() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3,3);
+        INDArray seq_kengths = Nd4j.createFromArray(2,3,1);
+        INDArray y = base.reverseSequence(x, seq_kengths);
+
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{ 2.0, 1.0, 3.0},{6.0, 5.0, 4.0},{7.0, 8.0, 9.0} } );
+        assertEquals(y_exp, y);
+
+        y = base.reverseSequence(x, seq_kengths, 0, 1);
+        y_exp = Nd4j.createFromArray(new double[][]{{ 4.0, 8.0, 3.0},{1.0, 5.0, 6.0},{7.0, 2.0, 9.0} } );
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScalarFloorMod() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        INDArray y = base.scalarFloorMod(x, 2.0);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{ 1.0, 0.0, 1.0},{0.0, 1.0, 0.0}, { 1.0, 0.0, 1.0} } );
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScalarMax() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        INDArray y = base.scalarMax(x, 5.0);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{ 5.0, 5.0, 5.0},{5.0, 5.0, 6.0}, { 7.0, 8.0, 9.0} } );
+        assertEquals(y_exp, y);
+        //System.out.println(y);
+    }
+
+    @Test
+    public void testScalarMin() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        INDArray y = base.scalarMin(x, 5.0);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{ 1.0, 2.0, 3.0},{4.0, 5.0, 5.0}, { 5.0, 5.0, 5.0} } );
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScalarSet() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1.0, 2.0, 0.0, 4.0, 5.0);
+        INDArray y = base.scalarSet(x, 1.0);
+        INDArray y_exp = Nd4j.ones(DataType.DOUBLE, 5);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScatterAdd() {
+        NDBase base = new NDBase();
+
+        //from testScatterOpGradients.
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 20, 10);
+        INDArray indices = Nd4j.createFromArray(3, 4, 5, 10, 18);
+        INDArray updates = Nd4j.ones(DataType.DOUBLE, 5, 10);
+        INDArray y = base.scatterAdd(x,indices, updates);
+
+        y = y.getColumn(0);
+        INDArray  y_exp = Nd4j.createFromArray(1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 1.0, 1.0, 1.0, 1.0, 2.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 1.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScatterDiv() {
+        NDBase base = new NDBase();
+
+        //from testScatterOpGradients.
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 20, 10).add(1.0);
+        INDArray indices = Nd4j.createFromArray(3, 4, 5, 10, 18);
+        INDArray updates = Nd4j.ones(DataType.DOUBLE, 5, 10).add(1.0);
+        INDArray y = base.scatterDiv(x,indices, updates);
+
+        y = y.getColumn(0);
+        INDArray  y_exp = Nd4j.createFromArray(2.0, 2.0, 2.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 1.0, 2.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScatterMax() {
+        NDBase base = new NDBase();
+
+        //from testScatterOpGradients.
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 20, 10).add(1.0);
+        INDArray indices = Nd4j.createFromArray(3, 4, 5, 10, 18);
+        INDArray updates = Nd4j.ones(DataType.DOUBLE, 5, 10).add(1.0);
+        INDArray y = base.scatterMax(x,indices, updates);
+
+        y = y.getColumn(0);
+        INDArray  y_exp = Nd4j.createFromArray(2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScatterMin() {
+        NDBase base = new NDBase();
+
+        //from testScatterOpGradients.
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 20, 10).add(1.0);
+        INDArray indices = Nd4j.createFromArray(3, 4, 5, 10, 18);
+        INDArray updates = Nd4j.ones(DataType.DOUBLE, 5, 10).add(1.0);
+        INDArray y = base.scatterMin(x,indices, updates);
+
+        y = y.getColumn(0);
+        INDArray  y_exp = Nd4j.createFromArray(2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScatterMul() {
+        NDBase base = new NDBase();
+
+        //from testScatterOpGradients.
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 20, 10).add(1.0);
+        INDArray indices = Nd4j.createFromArray(3, 4, 5, 10, 18);
+        INDArray updates = Nd4j.ones(DataType.DOUBLE, 5, 10).add(1.0);
+        INDArray y = base.scatterMul(x,indices, updates);
+
+        y = y.getColumn(0);
+        INDArray  y_exp = Nd4j.createFromArray(2.0, 2.0, 2.0, 4.0, 4.0, 4.0, 2.0, 2.0, 2.0, 2.0, 4.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 4.0, 2.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScatterSub() {
+        NDBase base = new NDBase();
+
+        //from testScatterOpGradients.
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 20, 10).add(1.0);
+        INDArray indices = Nd4j.createFromArray(3, 4, 5, 10, 18);
+        INDArray updates = Nd4j.ones(DataType.DOUBLE, 5, 10).add(1.0);
+        INDArray y = base.scatterSub(x,indices, updates);
+
+        y = y.getColumn(0);
+        INDArray  y_exp = Nd4j.createFromArray(2.0, 2.0, 2.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 0.0, 2.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testScatterUpdate() {
+        NDBase base = new NDBase();
+
+        //from testScatterOpGradients.
+        INDArray x = Nd4j.ones(DataType.DOUBLE, 10, 10);
+        INDArray indices = Nd4j.create(new double[]{3, 4, 5, 8, 9}).castTo(DataType.INT32);
+        INDArray updates = Nd4j.ones(DataType.DOUBLE, 5, 10).add(1.0);
+        INDArray y = base.scatterUpdate(x,indices, updates);
+
+        y = y.getColumn(0);
+        INDArray  y_exp = Nd4j.createFromArray(1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 1.0, 1.0, 2.0, 2.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSegmentMax() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(3, 6, 1, 4, 9,2, 2);
+        INDArray segmentIDs = Nd4j.createFromArray(0,0,1,1,1,2,2);
+        INDArray y = base.segmentMax(x, segmentIDs);
+        INDArray y_exp = Nd4j.createFromArray(6, 9, 2);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSegmentMean() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(3.0, 6.0, 1.0, 4.0, 9.0,2.0, 2.0);
+        INDArray segmentIDs = Nd4j.createFromArray(0,0,1,1,1,2,2);
+        INDArray y = base.segmentMean(x, segmentIDs);
+        INDArray y_exp = Nd4j.createFromArray(4.5, 4.6667, 2.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSegmentMin() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(3.0, 6.0, 1.0, 4.0, 9.0,2.0, 2.0);
+        INDArray segmentIDs = Nd4j.createFromArray(0,0,1,1,1,2,2);
+        INDArray y = base.segmentMin(x, segmentIDs);
+        INDArray y_exp = Nd4j.createFromArray(3.0, 1.0, 2.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSegmentProd() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(3.0, 6.0, 1.0, 4.0, 9.0,2.0, 2.0);
+        INDArray segmentIDs = Nd4j.createFromArray(0,0,1,1,1,2,2);
+        INDArray y = base.segmentProd(x, segmentIDs);
+        INDArray y_exp = Nd4j.createFromArray(18.0, 36.0, 4.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSegmentSum() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(3.0, 6.0, 1.0, 4.0, 9.0,2.0, 2.0);
+        INDArray segmentIDs = Nd4j.createFromArray(0,0,1,1,1,2,2);
+        INDArray y = base.segmentSum(x, segmentIDs);
+        INDArray y_exp = Nd4j.createFromArray(9.0, 14.0, 4.0);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSequenceMask() {
+        NDBase base = new NDBase();
+        INDArray length = Nd4j.createFromArray(1, 3, 2);
+        int maxlength = 5;
+        DataType dt = DataType.BOOL;
+        INDArray y = base.sequenceMask(length, maxlength, dt);
+        INDArray y_exp = Nd4j.createFromArray(new boolean[][]{{true, false, false, false, false}, {true, true, true, false, false}, {true, true, false, false, false}});
+        assertEquals(y_exp, y);
+
+        y = base.sequenceMask(length, maxlength, DataType.FLOAT);
+        y_exp = y_exp.castTo(DataType.FLOAT);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testShape() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(3,3);
+        INDArray y = base.shape(x);
+        INDArray y_exp = Nd4j.createFromArray(3L, 3L);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSize() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(3,3);
+        INDArray y = base.size(x);
+        assertEquals(Nd4j.scalar(9L), y);
+    }
+
+    @Test
+    public void testSizeAt() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(10,20, 30);
+        INDArray y = base.sizeAt(x, 1);
+        assertEquals(Nd4j.scalar(20L), y);
+    }
+
+    @Test
+    public void testSlice() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 6).reshape(2, 3);
+        INDArray y = base.slice(x, new int[]{0,1}, 2,1);
+        INDArray y_exp = Nd4j.create(new double[][]{{2.0}, {5.0}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSquaredNorm() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3, 3);
+        INDArray y = base.squaredNorm(x, 0);
+        INDArray y_exp = Nd4j.createFromArray(66.0, 93.0, 126.0);
+        assertEquals(y_exp, y);
+
+        y = base.squaredNorm(x, true, 0);
+        y_exp = Nd4j.createFromArray(new double[][]{{66.0, 93.0, 126.0}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSqueeze() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 10).reshape(2,1,5);
+        INDArray y = base.squeeze(x,1);
+        INDArray exp = x.reshape(2, 5);
+        assertEquals(exp, y);
+    }
+
+    @Test
+    public void testStack() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 3);
+        INDArray y = base.stack(1 , x);
+        // TODO: Op definition looks wrong. Compare stack in Nd4j.
+    }
+
+    @Test
+    public void testStandardDeviation() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 4);
+        INDArray y = base.standardDeviation(x, false, 0);
+        assertEquals(Nd4j.scalar(1.118034), y);
+
+        x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3,3);
+        y = base.standardDeviation(x, false, true, 0);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{2.4494898, 2.4494898, 2.4494898}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testStridedSlice() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3,3);
+        INDArray y = base.stridedSlice(x, new long[]{0,1}, new long[] {3,3}, 2,1);
+
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{2.0, 3.0}, {8.0, 9.0}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testSum() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3,3);
+        INDArray y = base.sum(x, 0);
+        INDArray y_exp = Nd4j.createFromArray(12.0, 15.0, 18.0);
+        assertEquals(y_exp, y);
+
+        y = base.sum(x, true, 0);
+        assertEquals(y_exp.reshape(1,3), y);
+    }
+
+    @Test
+    public void testTensorMul() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3,3);
+        INDArray y = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3,3);
+        int[] dimX = new int[] {1};
+        int[] dimY = new int[] {0};
+        boolean transposeX = false;
+        boolean transposeY = false;
+        boolean transposeResult = false;
+
+        INDArray res = base.tensorMmul(x, y, dimX, dimY, transposeX, transposeY, transposeResult);
+        // org.nd4j.linalg.exception.ND4JIllegalStateException: Op name tensordot - no output arrays were provided and calculateOutputShape failed to execute
+
+        INDArray exp = x.mmul(y);
+        assertEquals(exp, res);
+    }
+
+    @Test
+    public void testTile() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 4).reshape(2,2);
+        INDArray repeat = Nd4j.createFromArray(2, 3);
+        INDArray y = base.tile(x, repeat); // the sample from the code docs.
+
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{1.0, 2.0, 1.0, 2.0, 1.0, 2.0}, {3.0, 4.0, 3.0, 4.0, 3.0, 4.0}, {1.0, 2.0, 1.0, 2.0, 1.0, 2.0}, {3.0, 4.0, 3.0, 4.0, 3.0, 4.0}});
+        assertEquals(y_exp, y);
+
+        y = base.tile(x, 2, 3); // the sample from the code docs.
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testTranspose() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3,3);
+        INDArray y = base.transpose(x);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{1.0, 4.0, 7.0}, {2.0, 5.0, 8.0}, {3.0, 6.0, 9.0}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testUnsegmentMax() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1,3,2,6,4,9,8);
+        INDArray segmentIDs = Nd4j.createFromArray(1,0,2,0,1,1,2);
+        INDArray y = base.unsortedSegmentMax(x, segmentIDs, 3);
+        INDArray y_exp = Nd4j.createFromArray(6,9,8);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testUnsegmentMean() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1,3,2,6,4,9,8).castTo(DataType.FLOAT);
+        INDArray segmentIDs = Nd4j.createFromArray(1,0,2,0,1,1,2);
+        INDArray y = base.unsortedSegmentMean(x, segmentIDs, 3);
+        INDArray y_exp = Nd4j.createFromArray(4.5f,4.6667f, 5.0f);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testUnsegmentedMin() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1,3,2,6,4,9,8);
+        INDArray segmentIDs = Nd4j.createFromArray(1,0,2,0,1,1,2);
+        INDArray y = base.unsortedSegmentMin(x, segmentIDs, 3);
+        INDArray y_exp = Nd4j.createFromArray(3,1,2);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testUnsegmentProd() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1,3,2,6,4,9,8);
+        INDArray segmentIDs = Nd4j.createFromArray(1,0,2,0,1,1,2);
+        INDArray y = base.unsortedSegmentProd(x, segmentIDs, 3);
+        INDArray y_exp = Nd4j.createFromArray(18,36,16);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testUnsortedSegmentSqrtN() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1.0,3.0,2.0,6.0,4.0,9.0,8.0);
+        INDArray segmentIDs = Nd4j.createFromArray(1,0,2,0,1,1,2);
+        INDArray y = base.unsortedSegmentSqrtN(x, segmentIDs, 3);
+        INDArray y_exp = Nd4j.createFromArray( 6.3640,    8.0829,    7.0711);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testUnsortedSegmentSum() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.createFromArray(1,3,2,6,4,9,8);
+        INDArray segmentIDs = Nd4j.createFromArray(1,0,2,0,1,1,2);
+        INDArray y = base.unsortedSegmentSum(x, segmentIDs, 3);
+        INDArray y_exp = Nd4j.createFromArray(9,14,10);
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testVariance() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 4);
+        INDArray y = base.variance(x, false, 0);
+        assertEquals(Nd4j.scalar(1.250), y);
+
+        x = Nd4j.linspace(DataType.DOUBLE, 1.0, 1.0, 9).reshape(3,3);
+        y = base.variance(x, false, true, 0);
+        INDArray y_exp = Nd4j.createFromArray(new double[][]{{6.0, 6.0, 6.0}});
+        assertEquals(y_exp, y);
+    }
+
+    @Test
+    public void testZerosLike() {
+        NDBase base = new NDBase();
+        INDArray x = Nd4j.zeros(3,3);
+        INDArray y = base.zerosLike(x);
+        assertEquals(x, y);
+        assertNotSame(x, y);
+    }
+}
diff --git a/nd4j/nd4j-backends/nd4j-tests/src/test/java/org/nd4j/linalg/indexing/BooleanIndexingTest.java b/nd4j/nd4j-backends/nd4j-tests/src/test/java/org/nd4j/linalg/indexing/BooleanIndexingTest.java
index da155d43a..fd3626e66 100644
--- a/nd4j/nd4j-backends/nd4j-tests/src/test/java/org/nd4j/linalg/indexing/BooleanIndexingTest.java
+++ b/nd4j/nd4j-backends/nd4j-tests/src/test/java/org/nd4j/linalg/indexing/BooleanIndexingTest.java
@@ -234,9 +234,9 @@ public class BooleanIndexingTest extends BaseNd4jTest {
         INDArray array = Nd4j.create(new double[] {1, 2, 0, 4, 5});
         INDArray comp = Nd4j.create(new double[] {1, 2, 3, 4, 5});
 
-        Nd4j.getExecutioner().exec(new CompareAndReplace(array, comp, Conditions.lessThan(1)));
+        INDArray z = Nd4j.exec(new CompareAndReplace(array, comp, Conditions.lessThan(1)));
 
-        assertEquals(comp, array);
+        assertEquals(comp, z);
     }
 
     @Test
@@ -256,9 +256,9 @@ public class BooleanIndexingTest extends BaseNd4jTest {
         INDArray y = Nd4j.create(new double[] {2, 4, 3, 4, 5});
         INDArray comp = Nd4j.create(new double[] {2, 4, 0, 4, 5});
 
-        Nd4j.getExecutioner().exec(new CompareAndReplace(x, y, Conditions.epsNotEquals(0.0)));
+        INDArray z = Nd4j.exec(new CompareAndReplace(x, y, Conditions.epsNotEquals(0.0)));
 
-        assertEquals(comp, x);
+        assertEquals(comp, z);
     }
 
     @Test
@@ -267,9 +267,9 @@ public class BooleanIndexingTest extends BaseNd4jTest {
         INDArray y = Nd4j.create(new double[] {2, 4, 3, 4, 5});
         INDArray comp = Nd4j.create(new double[] {2, 4, 3, 4, 5});
 
-        Nd4j.getExecutioner().exec(new CompareAndReplace(x, y, Conditions.lessThan(4)));
+        INDArray z = Nd4j.exec(new CompareAndReplace(x, y, Conditions.lessThan(4)));
 
-        assertEquals(comp, x);
+        assertEquals(comp, z);
     }
 
     @Test
@@ -278,9 +278,9 @@ public class BooleanIndexingTest extends BaseNd4jTest {
         INDArray y = Nd4j.create(new double[] {2, 4, 3, 4, 5});
         INDArray comp = Nd4j.create(new double[] {2, 2, 3, 4, 5});
 
-        Nd4j.getExecutioner().exec(new CompareAndReplace(x, y, Conditions.lessThan(2)));
+        INDArray z = Nd4j.exec(new CompareAndReplace(x, y, Conditions.lessThan(2)));
 
-        assertEquals(comp, x);
+        assertEquals(comp, z);
     }