From bdd3941d566e6002dd9a2ebcde841364b1fefc69 Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Thu, 22 Jun 2023 17:28:12 +0200
Subject: [PATCH 01/10] [SYSTEMDS-3544] added DenseBlockTrueBool for boolean
 matrix instead of bitset

---
 .../runtime/data/DenseBlockTrueBool.java      | 234 ++++++++++++++++++
 .../sysds/runtime/util/DataConverter.java     |   7 +
 .../sysds/runtime/util/UtilFunctions.java     |   7 +
 3 files changed, 248 insertions(+)
 create mode 100644 src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java

diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
new file mode 100644
index 00000000000..0bb2a68d3ce
--- /dev/null
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
@@ -0,0 +1,234 @@
+package org.apache.sysds.runtime.data;
+
+import org.apache.sysds.common.Types.ValueType;
+import org.apache.sysds.common.Warnings;
+import org.apache.sysds.runtime.util.DataConverter;
+import org.apache.sysds.runtime.util.UtilFunctions;
+
+import java.util.Arrays;
+
+public class DenseBlockTrueBool extends DenseBlockDRB{
+
+    private static final long serialVersionUID = -6741205568083878338L;
+    private boolean[] _data;
+
+    public DenseBlockTrueBool(int[] dims) {
+        super(dims);
+        reset(_rlen, _odims, 0);
+    }
+
+    @Override
+    protected void allocateBlock(int bix, int length) {
+        _data = new boolean[length];
+    }
+
+    public DenseBlockTrueBool(int[] dims, boolean[] data) {
+        super(dims);
+        _data = data;
+    }
+
+    @Override
+    public boolean isNumeric() {
+        return true;
+    }
+
+    @Override
+    public boolean isNumeric(ValueType vt) {
+        return ValueType.BOOLEAN == vt;
+    }
+
+
+    @Override
+    public void reset(int rlen, int[] odims, double v){
+        reset(rlen, odims, v!= 0);
+    }
+
+    public void reset(int rlen, int[] odims, boolean bv) {
+        int len = rlen * odims[0];
+        if( len > capacity() ) {
+            _data = new boolean[len];
+            if( bv )
+                Arrays.fill(_data, bv);
+        }
+        else {
+            Arrays.fill(_data, 0, len, bv);
+        }
+        _rlen = rlen;
+        _odims = odims;
+    }
+
+    @Override
+    public void resetNoFill(int rlen, int[] odims){
+        int len = rlen * odims[0];
+        if( len > capacity() )
+            _data = new boolean[len];
+
+        _rlen = rlen;
+        _odims = odims;
+    }
+
+    @Override
+    public long capacity() {
+        return (_data!=null) ? _data.length : -1;
+    }
+
+    @Override
+    protected long computeNnz(int bix, int start, int length) {
+        return UtilFunctions.computeNnz(_data, start, length);
+    }
+
+    @Override
+    public double[] values(int r) {
+        double[] ret = getReuseRow(false);
+        int ix = pos(r);
+        int ncol = _odims[0];
+        for(int j=0; j<ncol; j++)
+            ret[j] = _data[ix+j] ? 1 : 0;
+        return ret;
+    }
+
+    @Override
+    public double[] valuesAt(int bix) {
+        int len = _rlen*_odims[0];
+        Warnings.warnFullFP64Conversion(len);
+        return DataConverter.toDouble(_data, len);
+    }
+
+    @Override
+    public int index(int r) {
+        return 0;
+    }
+
+    @Override
+    public void incr(int r, int c) {
+        Warnings.warnInvalidBooleanIncrement(1);
+        _data[pos(r, c)] = true;
+    }
+
+    @Override
+    public void incr(int r, int c, double delta) {
+        Warnings.warnInvalidBooleanIncrement(delta);
+        incr(r,c);
+    }
+
+    protected void fillBlock(int fromIndex, int toIndex, boolean v) {
+        Arrays.fill(_data, fromIndex, toIndex, v);
+    }
+
+    protected void fillBlock(int bix, int fromIndex, int toIndex, boolean v) {
+        fillBlock(fromIndex, toIndex, v);
+    }
+    @Override
+    protected void fillBlock(int bix, int fromIndex, int toIndex, double v) {
+        fillBlock(fromIndex, toIndex, v!=0);
+    }
+
+    protected void setInternal(int ix, boolean v) {
+        _data[ix] = v;
+    }
+    protected void setInternal(int bix, int ix, boolean v) {
+        setInternal(ix, v);
+    }
+    @Override
+    protected void setInternal(int bix, int ix, double v) {
+        setInternal(ix, v != 0);
+    }
+
+    @Override
+    public DenseBlock set(String s) {
+        Arrays.fill(_data, 0, blockSize() * _odims[0], Boolean.parseBoolean(s));
+        return this;
+    }
+
+    public DenseBlock set(int r, int c, boolean v) {
+        _data[pos(r, c)] = v;
+        return this;
+    }
+    @Override
+    public DenseBlock set(int r, int c, double v) {
+        _data[pos(r, c)] = v != 0;
+        return this;
+    }
+
+    public DenseBlock set(DenseBlock db) {
+        // ToDo: Performance tests and improvements
+        double[] data = db.valuesAt(0);
+        for (int i = 0; i < _rlen*_odims[0]; i++) {
+            _data[i] = data[i] != 0;
+        }
+        return this;
+    }
+
+    @Override
+    public DenseBlock set(int rl, int ru, int cl, int cu, DenseBlock db) {
+        //TODO perf computed indexes
+        for (int r = rl; r < ru; r++) {
+            for (int c = cl; c < cu; c++) {
+                int i = r * _odims[0] + c;
+                _data[i] = db.get(r - rl, c - cl) != 0;
+            }
+        }
+        return this;
+    }
+
+
+    public DenseBlock set(int r, boolean[] v) {
+        int ri = r * _odims[0];
+        System.arraycopy(v, 0, _data, ri, v.length);
+        return this;
+    }
+
+    @Override
+    public DenseBlock set(int r, double[] v) {
+        int ri = r * _odims[0];
+        for (int i = ri; i < ri + v.length; i++) {
+            _data[i] = v[i-ri] != 0;
+        }
+        return this;
+    }
+
+    public DenseBlock set(int[] ix, boolean v) {
+        _data[pos(ix)] = v;
+        return this;
+    }
+    @Override
+    public DenseBlock set(int[] ix, double v) {
+        _data[pos(ix)] = v != 0;
+        return this;
+    }
+
+    @Override
+    public DenseBlock set(int[] ix, long v) {
+        _data[pos(ix)] = v != 0;
+        return this;
+    }
+
+    @Override
+    public DenseBlock set(int[] ix, String v) {
+        _data[pos(ix)] = Boolean.parseBoolean(v);
+        return this;
+    }
+
+    public boolean getBoolean(int r, int c){
+        return _data[pos(r,c)];
+    }
+    @Override
+    public double get(int r, int c) {
+        return _data[pos(r, c)] ? 1 : 0;
+    }
+
+    @Override
+    public double get(int[] ix) {
+        return _data[pos(ix)] ? 1 : 0;
+    }
+
+    @Override
+    public String getString(int[] ix) {
+        return String.valueOf(_data[pos(ix)]);
+    }
+
+    @Override
+    public long getLong(int[] ix) {
+        return _data[pos(ix)] ? 1 : 0;
+    }
+}
diff --git a/src/main/java/org/apache/sysds/runtime/util/DataConverter.java b/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
index 987f85a733b..899ef0ae153 100644
--- a/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
+++ b/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
@@ -1341,6 +1341,13 @@ public static double[] toDouble(BitSet data, int len) {
 		return ret;
 	}
 
+	public static double[] toDouble(boolean[] data, int len) {
+		double[] ret = new double[len];
+		for(int i=0; i<len; i++)
+			ret[i] = data[i] ? 1 : 0;
+		return ret;
+	}
+
 	public static double[] toDouble(String[] data) {
 		double[] ret = new double[data.length];
 		for(int i=0; i<data.length; i++)
diff --git a/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java b/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
index 55686031043..0da92cfa5f6 100644
--- a/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
+++ b/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
@@ -868,6 +868,13 @@ public static int computeNnz(BitSet a, int ai, int len) {
 		return lnnz;
 	}
 
+	public static int computeNnz(boolean[] a, int ai, int len) {
+		int lnnz = 0;
+		for( int i=ai; i<ai+len; i++ )
+			lnnz += a[i] ? 1 : 0;
+		return lnnz;
+	}
+
 	public static int computeNnz(String[] a, int ai, int len) {
 		int lnnz = 0;
 		for( int k=ai; k<ai+len; k++ )

From fe38cde5aa1b3020b6b5635f930f581650175818 Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Fri, 23 Jun 2023 18:20:32 +0200
Subject: [PATCH 02/10] [SYSTEMDS-3544] added tests and license for
 DenseBlockTrueBool; added support for boolean operations when using
 ValueComparisonFunctions

---
 .../java/org/apache/sysds/common/Types.java   |  2 +-
 .../sysds/runtime/data/DenseBlockFactory.java |  5 ++
 .../runtime/data/DenseBlockTrueBool.java      | 21 +++++++-
 .../runtime/matrix/data/LibMatrixBincell.java | 51 ++++++++++---------
 .../tensor/DenseBlockConstIndexingTest.java   | 20 ++++++++
 .../tensor/DenseBlockConstructionTest.java    | 39 +++++++++++---
 .../tensor/DenseBlockCountNonZeroTest.java    | 12 +++++
 .../tensor/DenseBlockGetSetIndexingTest.java  | 24 +++++----
 .../tensor/DenseBlockIncrementTest.java       | 20 ++++----
 .../tensor/DenseBlockSetDenseBlockTest.java   | 28 ++++++----
 .../tensor/DenseBlockSetRowTest.java          | 24 +++++----
 11 files changed, 171 insertions(+), 75 deletions(-)

diff --git a/src/main/java/org/apache/sysds/common/Types.java b/src/main/java/org/apache/sysds/common/Types.java
index 78ed173bc9e..46ec064c4ca 100644
--- a/src/main/java/org/apache/sysds/common/Types.java
+++ b/src/main/java/org/apache/sysds/common/Types.java
@@ -76,7 +76,7 @@ public boolean isUnknown() {
 	 */
 	public enum ValueType {
 		UINT4, UINT8, // Used for parsing in UINT values from numpy.
-		FP32, FP64, INT32, INT64, BOOLEAN, STRING, UNKNOWN,
+		FP32, FP64, INT32, INT64, BOOLEAN, TRUE_BOOLEAN, STRING, UNKNOWN,
 		CHARACTER;
 		
 		public boolean isNumeric() {
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
index c48a9d0aca3..3468863c66f 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
@@ -61,6 +61,10 @@ public static DenseBlock createDenseBlock(BitSet data, int[] dims) {
 		return new DenseBlockBool(dims, data);
 	}
 
+	public static DenseBlock createDenseBlock(boolean[] data, int[] dims) {
+		return new DenseBlockTrueBool(dims, data);
+	}
+
 	public static DenseBlock createDenseBlock(String[] data, int[] dims) {
 		return new DenseBlockString(dims, data);
 	}
@@ -115,6 +119,7 @@ public static DenseBlock createDenseBlock(ValueType vt, DenseBlock.Type type, in
 					case INT32: return new DenseBlockInt32(dims);
 					case INT64: return new DenseBlockInt64(dims);
 					case BOOLEAN: return new DenseBlockBool(dims);
+					case TRUE_BOOLEAN: return new DenseBlockTrueBool(dims);
 					case STRING: return new DenseBlockString(dims);
 					default:
 						throw new DMLRuntimeException("Unsupported dense block value type: "+vt.name());
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
index 0bb2a68d3ce..d31956ec902 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
@@ -1,3 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
 package org.apache.sysds.runtime.data;
 
 import org.apache.sysds.common.Types.ValueType;
@@ -34,7 +53,7 @@ public boolean isNumeric() {
 
     @Override
     public boolean isNumeric(ValueType vt) {
-        return ValueType.BOOLEAN == vt;
+        return ValueType.TRUE_BOOLEAN == vt;
     }
 
 
diff --git a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
index 33d7bb2da53..c6d3728f8e9 100644
--- a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
+++ b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
@@ -30,6 +30,7 @@
 import org.apache.commons.lang.NotImplementedException;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.apache.sysds.common.Types;
 import org.apache.sysds.runtime.DMLRuntimeException;
 import org.apache.sysds.runtime.data.DenseBlock;
 import org.apache.sysds.runtime.data.SparseBlock;
@@ -38,24 +39,8 @@
 import org.apache.sysds.runtime.data.SparseBlockMCSR;
 import org.apache.sysds.runtime.data.SparseRow;
 import org.apache.sysds.runtime.data.SparseRowVector;
-import org.apache.sysds.runtime.functionobjects.And;
-import org.apache.sysds.runtime.functionobjects.Builtin;
+import org.apache.sysds.runtime.functionobjects.*;
 import org.apache.sysds.runtime.functionobjects.Builtin.BuiltinCode;
-import org.apache.sysds.runtime.functionobjects.Divide;
-import org.apache.sysds.runtime.functionobjects.Equals;
-import org.apache.sysds.runtime.functionobjects.GreaterThan;
-import org.apache.sysds.runtime.functionobjects.GreaterThanEquals;
-import org.apache.sysds.runtime.functionobjects.LessThan;
-import org.apache.sysds.runtime.functionobjects.LessThanEquals;
-import org.apache.sysds.runtime.functionobjects.Minus;
-import org.apache.sysds.runtime.functionobjects.MinusMultiply;
-import org.apache.sysds.runtime.functionobjects.Multiply;
-import org.apache.sysds.runtime.functionobjects.Multiply2;
-import org.apache.sysds.runtime.functionobjects.NotEquals;
-import org.apache.sysds.runtime.functionobjects.Plus;
-import org.apache.sysds.runtime.functionobjects.PlusMultiply;
-import org.apache.sysds.runtime.functionobjects.Power2;
-import org.apache.sysds.runtime.functionobjects.ValueFunction;
 import org.apache.sysds.runtime.matrix.operators.BinaryOperator;
 import org.apache.sysds.runtime.matrix.operators.ScalarOperator;
 import org.apache.sysds.runtime.matrix.operators.UnaryOperator;
@@ -1423,14 +1408,30 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 			}
 			//general case
 			else {
-				for(int r=rl; r<ru; r++)
-					for(int c=0; c<clen; c++) {
-						double v1 = m1.quickGetValue(r, c);
-						double v2 = m2.quickGetValue(r, c);
-						double v = op.fn.execute( v1, v2 );
-						ret.appendValuePlain(r, c, v);
-						lnnz += (v!=0) ? 1 : 0;
-					}
+				// if return matrix is boolean and ValueFunction is comparison , use boolean arithmetics
+				if (ret.denseBlock.isNumeric(Types.ValueType.TRUE_BOOLEAN) && op.fn instanceof ValueComparisonFunction){
+					for(int r=rl; r<ru; r++)
+						for(int c=0; c<clen; c++) {
+							double v1 = m1.quickGetValue(r, c);
+							double v2 = m2.quickGetValue(r, c);
+
+							// make double for now, so we don't have to add boolean to abstract DenseBlock
+							// will be stored as boolean by set function of DenseBlock Boolean implementation
+							double v = ((ValueComparisonFunction) op.fn).compare( v1, v2 ) ? 1.0 : 0.0 ;
+							ret.appendValuePlain(r, c, v);
+							lnnz += (v!=0) ? 1 : 0;
+						}
+				} else {
+					for(int r=rl; r<ru; r++)
+						for(int c=0; c<clen; c++) {
+							double v1 = m1.quickGetValue(r, c);
+							double v2 = m2.quickGetValue(r, c);
+							double v = op.fn.execute( v1, v2 );
+							ret.appendValuePlain(r, c, v);
+							lnnz += (v!=0) ? 1 : 0;
+						}
+				}
+
 			}
 		}
 		
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
index 05e011233d7..0aab6901c62 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
@@ -62,6 +62,16 @@ public void testIndexDenseBlock2BoolConst() {
 			for(int j=0; j<5; j++)
 				Assert.assertEquals(1, db.get(i, j), 0);
 	}
+
+	@Test
+	public void testIndexDenseBlock2TrueBoolConst() {
+		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		db.set(7.3);
+		for(int i=0; i<db.numRows(); i++)
+			for(int j=0; j<5; j++) {
+				Assert.assertEquals(1, db.get(i, j), 0);
+			}
+	}
 	
 	@Test
 	public void testIndexDenseBlock2Int32Const() {
@@ -176,6 +186,16 @@ public void testIndexDenseBlock3BoolConst() {
 				for(int k=0; k<7; k++)
 					Assert.assertEquals(1, db.get(new int[]{i,j,k}), 0);
 	}
+
+	@Test
+	public void testIndexDenseBlock3TrueBoolConst() {
+		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		db.set(7.3);
+		for(int i=0; i<db.numRows(); i++)
+			for(int j=0; j<5; j++)
+				for(int k=0; k<7; k++)
+					Assert.assertEquals(1, db.get(new int[]{i,j,k}), 0);
+	}
 	
 	@Test
 	public void testIndexDenseBlock3Int32Const() {
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
index 2bbdd8643ee..2bd347525ae 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
@@ -20,17 +20,10 @@
 package org.apache.sysds.test.component.tensor;
 
 import org.apache.commons.lang.NotImplementedException;
+import org.apache.sysds.runtime.data.*;
 import org.junit.Assert;
 import org.junit.Test;
 import org.apache.sysds.common.Types.ValueType;
-import org.apache.sysds.runtime.data.DenseBlock;
-import org.apache.sysds.runtime.data.DenseBlockFactory;
-import org.apache.sysds.runtime.data.DenseBlockLBool;
-import org.apache.sysds.runtime.data.DenseBlockLFP32;
-import org.apache.sysds.runtime.data.DenseBlockLFP64;
-import org.apache.sysds.runtime.data.DenseBlockLString;
-import org.apache.sysds.runtime.data.DenseBlockLInt32;
-import org.apache.sysds.runtime.data.DenseBlockLInt64;
 
 
 public class DenseBlockConstructionTest 
@@ -80,6 +73,21 @@ public void testMetaDenseBlock2Bool() {
 			DenseBlockFactory.getDenseBlockType(db));
 	}
 
+	@Test
+	public void testMetaDenseBlock2TrueBool() {
+		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		Assert.assertEquals(3, db.numRows());
+		Assert.assertTrue(db.isNumeric());
+		Assert.assertTrue(db.isContiguous());
+		Assert.assertEquals(1, db.numBlocks());
+		Assert.assertEquals(3, db.blockSize());
+		Assert.assertEquals(3*5, db.size());
+		Assert.assertTrue(3*5 <= db.capacity());
+		Assert.assertEquals(0, db.countNonZeros());
+		Assert.assertEquals(DenseBlock.Type.DRB,
+				DenseBlockFactory.getDenseBlockType(db));
+	}
+
 	@Test
 	public void testMetaDenseBlock2Int32() {
 		DenseBlock db = getDenseBlock2(ValueType.INT32);
@@ -259,6 +267,21 @@ public void testMetaDenseBlock3Bool() {
 		Assert.assertEquals(DenseBlock.Type.DRB,
 			DenseBlockFactory.getDenseBlockType(db));
 	}
+
+	@Test
+	public void testMetaDenseBlock3TrueBool() {
+		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		Assert.assertEquals(3, db.numRows());
+		Assert.assertTrue(db.isNumeric());
+		Assert.assertTrue(db.isContiguous());
+		Assert.assertEquals(1, db.numBlocks());
+		Assert.assertEquals(3, db.blockSize());
+		Assert.assertEquals(3*5*7, db.size());
+		Assert.assertTrue(3*5*7 <= db.capacity());
+		Assert.assertEquals(0, db.countNonZeros());
+		Assert.assertEquals(DenseBlock.Type.DRB,
+				DenseBlockFactory.getDenseBlockType(db));
+	}
 	
 	@Test
 	public void testMetaDenseBlock3Int32() {
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
index 8f2a9a5edb8..53f8c4c9d47 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
@@ -52,6 +52,12 @@ public void testIndexDenseBlock2BoolCountNonZero() {
 		checkFullNnz2(db);
 	}
 
+	@Test
+	public void testIndexDenseBlock2TrueBoolCountNonZero() {
+		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		checkFullNnz2(db);
+	}
+
 	@Test
 	public void testIndexDenseBlock2Int32CountNonZero() {
 		DenseBlock db = getDenseBlock2(ValueType.INT32);
@@ -124,6 +130,12 @@ public void testIndexDenseBlock3BoolCountNonZero() {
 		checkFullNnz3(db);
 	}
 
+	@Test
+	public void testIndexDenseBlock3TrueBoolCountNonZero() {
+		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		checkFullNnz3(db);
+	}
+
 	@Test
 	public void testIndexDenseBlock3Int32CountNonZero() {
 		DenseBlock db = getDenseBlock3(ValueType.INT32);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
index 93edeba4748..ac245de3390 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
@@ -20,18 +20,10 @@
 package org.apache.sysds.test.component.tensor;
 
 import org.apache.commons.lang.NotImplementedException;
+import org.apache.sysds.runtime.data.*;
 import org.junit.Assert;
 import org.junit.Test;
 import org.apache.sysds.common.Types.ValueType;
-import org.apache.sysds.runtime.data.DenseBlock;
-import org.apache.sysds.runtime.data.DenseBlockBool;
-import org.apache.sysds.runtime.data.DenseBlockFactory;
-import org.apache.sysds.runtime.data.DenseBlockLBool;
-import org.apache.sysds.runtime.data.DenseBlockLFP32;
-import org.apache.sysds.runtime.data.DenseBlockLFP64;
-import org.apache.sysds.runtime.data.DenseBlockLString;
-import org.apache.sysds.runtime.data.DenseBlockLInt32;
-import org.apache.sysds.runtime.data.DenseBlockLInt64;
 
 
 public class DenseBlockGetSetIndexingTest
@@ -53,6 +45,12 @@ public void testIndexDenseBlock2BoolSetGetCell() {
 		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkSequence(setSequence(db));
 	}
+
+	@Test
+	public void testIndexDenseBlock2TrueBoolSetGetCell() {
+		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		checkSequence(setSequence(db));
+	}
 	
 	@Test
 	public void testIndexDenseBlock2Int32SetGetCell() {
@@ -125,6 +123,12 @@ public void testIndexDenseBlock3BoolSetGetCell() {
 		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		checkSequence(setSequence(db));
 	}
+
+	@Test
+	public void testIndexDenseBlock3TrueBoolSetGetCell() {
+		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		checkSequence(setSequence(db));
+	}
 	
 	@Test
 	public void testIndexDenseBlock3Int32SetGetCell() {
@@ -234,7 +238,7 @@ private static DenseBlock setSequence(DenseBlock db) {
 	}
 	
 	private static void checkSequence(DenseBlock db) {
-		boolean isBool = (db instanceof DenseBlockBool) || (db instanceof DenseBlockLBool);
+		boolean isBool = (db instanceof DenseBlockBool) || (db instanceof DenseBlockLBool) || (db instanceof DenseBlockTrueBool);
 		if( db.numDims() == 3 ) {
 			int dim12 = 5*7;
 			int dim1 = 5, dim2 = 7;
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
index e17646b36af..08606aead0d 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
@@ -20,18 +20,10 @@
 package org.apache.sysds.test.component.tensor;
 
 import org.apache.commons.lang.NotImplementedException;
+import org.apache.sysds.runtime.data.*;
 import org.junit.Assert;
 import org.junit.Test;
 import org.apache.sysds.common.Types.ValueType;
-import org.apache.sysds.runtime.data.DenseBlock;
-import org.apache.sysds.runtime.data.DenseBlockBool;
-import org.apache.sysds.runtime.data.DenseBlockFactory;
-import org.apache.sysds.runtime.data.DenseBlockLBool;
-import org.apache.sysds.runtime.data.DenseBlockLFP32;
-import org.apache.sysds.runtime.data.DenseBlockLFP64;
-import org.apache.sysds.runtime.data.DenseBlockLString;
-import org.apache.sysds.runtime.data.DenseBlockLInt32;
-import org.apache.sysds.runtime.data.DenseBlockLInt64;
 
 public class DenseBlockIncrementTest {
 	@Test
@@ -52,6 +44,12 @@ public void testIndexDenseBlock2BoolCountNonZero() {
 		checkIncrement2(db);
 	}
 
+	@Test
+	public void testIndexDenseBlock2TrueBoolCountNonZero() {
+		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		checkIncrement2(db);
+	}
+
 	@Test
 	public void testIndexDenseBlock2Int32CountNonZero() {
 		DenseBlock db = getDenseBlock2(ValueType.INT32);
@@ -153,7 +151,7 @@ private static void checkIncrement2(DenseBlock db) {
 				db.incr(i, j, -1);
 			}
 		}
-		if (db instanceof DenseBlockBool || db instanceof DenseBlockLBool) {
+		if (db instanceof DenseBlockBool || db instanceof DenseBlockLBool || db instanceof DenseBlockTrueBool) {
 			Assert.assertEquals(3 * 5, db.countNonZeros());
 		} else {
 			Assert.assertEquals(0, db.countNonZeros());
@@ -167,7 +165,7 @@ private static void checkIncrement2(DenseBlock db) {
 		Assert.assertEquals(3 * 5, db.countNonZeros());
 		for (int i = 0; i < 3; i++) {
 			for (int j = 0; j < 5; j++) {
-				if (db instanceof DenseBlockBool || db instanceof DenseBlockLBool) {
+				if (db instanceof DenseBlockBool || db instanceof DenseBlockLBool || db instanceof DenseBlockTrueBool) {
 					Assert.assertEquals(1, db.get(i, j), 0);
 				} else {
 					Assert.assertEquals(10, db.get(i, j), 0);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
index 4afd568918a..c0dd918d0ca 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
@@ -20,18 +20,10 @@
 package org.apache.sysds.test.component.tensor;
 
 import org.apache.commons.lang.NotImplementedException;
+import org.apache.sysds.runtime.data.*;
 import org.junit.Assert;
 import org.junit.Test;
 import org.apache.sysds.common.Types.ValueType;
-import org.apache.sysds.runtime.data.DenseBlock;
-import org.apache.sysds.runtime.data.DenseBlockFactory;
-import org.apache.sysds.runtime.data.DenseBlockLBool;
-import org.apache.sysds.runtime.data.DenseBlockLFP32;
-import org.apache.sysds.runtime.data.DenseBlockLFP64;
-import org.apache.sysds.runtime.data.DenseBlockLString;
-import org.apache.sysds.runtime.data.DenseBlockLInt32;
-import org.apache.sysds.runtime.data.DenseBlockLInt64;
-import org.apache.sysds.runtime.data.DenseBlockString;
 
 
 public class DenseBlockSetDenseBlockTest
@@ -63,6 +55,15 @@ public void testDenseBlock2BoolSetDenseBlock() {
 		compareDenseBlocks(db, dbSet);
 	}
 
+	@Test
+	public void testDenseBlock2TrueBoolSetDenseBlock() {
+		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		DenseBlock dbSet = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		dbSet.set(1);
+		db.set(dbSet);
+		compareDenseBlocks(db, dbSet);
+	}
+
 	@Test
 	public void testDenseBlock2Int32SetDenseBlock() {
 		DenseBlock db = getDenseBlock2(ValueType.INT32);
@@ -175,6 +176,15 @@ public void testDenseBlock3BoolSetDenseBlock() {
 		compareDenseBlocks(db, dbSet);
 	}
 
+	@Test
+	public void testDenseBlock3TrueBoolSetDenseBlock() {
+		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		DenseBlock dbSet = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		dbSet.set(1);
+		db.set(dbSet);
+		compareDenseBlocks(db, dbSet);
+	}
+
 	@Test
 	public void testDenseBlock3Int32SetDenseBlock() {
 		DenseBlock db = getDenseBlock3(ValueType.INT32);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
index 3e2d946099c..df101f8bc10 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
@@ -20,18 +20,10 @@
 package org.apache.sysds.test.component.tensor;
 
 import org.apache.commons.lang.NotImplementedException;
+import org.apache.sysds.runtime.data.*;
 import org.junit.Assert;
 import org.junit.Test;
 import org.apache.sysds.common.Types.ValueType;
-import org.apache.sysds.runtime.data.DenseBlock;
-import org.apache.sysds.runtime.data.DenseBlockBool;
-import org.apache.sysds.runtime.data.DenseBlockFactory;
-import org.apache.sysds.runtime.data.DenseBlockLBool;
-import org.apache.sysds.runtime.data.DenseBlockLFP32;
-import org.apache.sysds.runtime.data.DenseBlockLFP64;
-import org.apache.sysds.runtime.data.DenseBlockLString;
-import org.apache.sysds.runtime.data.DenseBlockLInt32;
-import org.apache.sysds.runtime.data.DenseBlockLInt64;
 
 public class DenseBlockSetRowTest {
 	@Test
@@ -52,6 +44,12 @@ public void testDenseBlock2BoolRow() {
 		checkRow(setRow(db));
 	}
 
+	@Test
+	public void testDenseBlock2TrueBoolRow() {
+		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		checkRow(setRow(db));
+	}
+
 	@Test
 	public void testDenseBlock2Int32Row() {
 		DenseBlock db = getDenseBlock2(ValueType.INT32);
@@ -124,6 +122,12 @@ public void testDenseBlock3BoolRow() {
 		checkRow(setRow(db));
 	}
 
+	@Test
+	public void testDenseBlock3TrueBoolRow() {
+		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		checkRow(setRow(db));
+	}
+
 	@Test
 	public void testDenseBlock3Int32Row() {
 		DenseBlock db = getDenseBlock3(ValueType.INT32);
@@ -246,7 +250,7 @@ private static DenseBlock setRow(DenseBlock db) {
 	}
 
 	private static void checkRow(DenseBlock db) {
-		boolean isBool = (db instanceof DenseBlockBool) || (db instanceof DenseBlockLBool);
+		boolean isBool = (db instanceof DenseBlockBool) || (db instanceof DenseBlockLBool) || (db instanceof DenseBlockTrueBool);
 		if (db.numDims() == 3) {
 			int dim1 = 5, dim2 = 7;
 			for (int i = 0; i < dim1; i++)

From 9397a7a6e5b40244c37a451b8a01bc7f49c6c733 Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Sun, 25 Jun 2023 11:21:13 +0200
Subject: [PATCH 03/10] [SYSTEMDS-3544] fixed trigger for true bool computation
 and added memory size estimates for true bool

---
 .../apache/sysds/runtime/frame/data/columns/ArrayFactory.java   | 2 ++
 .../org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java  | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
index 11defd31cd2..edfe85d7948 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
@@ -78,6 +78,8 @@ public static long getInMemorySize(ValueType type, int _numRows) {
 					return Array.baseMemoryCost() + (long) MemoryEstimates.longArrayCost(_numRows >> 6 + 1);
 				else
 					return Array.baseMemoryCost() + (long) MemoryEstimates.booleanArrayCost(_numRows);
+			case TRUE_BOOLEAN:
+				return Array.baseMemoryCost() + (long) MemoryEstimates.booleanArrayCost(_numRows);
 			case INT64:
 				return Array.baseMemoryCost() + (long) MemoryEstimates.longArrayCost(_numRows);
 			case FP64:
diff --git a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
index c6d3728f8e9..22805290300 100644
--- a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
+++ b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
@@ -1409,7 +1409,7 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 			//general case
 			else {
 				// if return matrix is boolean and ValueFunction is comparison , use boolean arithmetics
-				if (ret.denseBlock.isNumeric(Types.ValueType.TRUE_BOOLEAN) && op.fn instanceof ValueComparisonFunction){
+				if (op.fn instanceof ValueComparisonFunction && ret.denseBlock != null && ret.denseBlock.isNumeric(Types.ValueType.TRUE_BOOLEAN) ){
 					for(int r=rl; r<ru; r++)
 						for(int c=0; c<clen; c++) {
 							double v1 = m1.quickGetValue(r, c);

From 254d7568f0780aa209682bfbbb585ef427e3fcfa Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Sun, 25 Jun 2023 19:24:03 +0200
Subject: [PATCH 04/10] [SYSTEMDS-3544] use boolean arithmetics if result is
 boolean

---
 .../runtime/data/DenseBlockTrueBool.java      |  5 ++++
 .../runtime/matrix/data/LibMatrixBincell.java | 24 +++++++------------
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
index d31956ec902..56077399a7e 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
@@ -31,6 +31,11 @@ public class DenseBlockTrueBool extends DenseBlockDRB{
     private static final long serialVersionUID = -6741205568083878338L;
     private boolean[] _data;
 
+    /**
+     * Can be toggled to use boolean arithmetics when this denseblock is used as result matrix.
+     */
+    private boolean useBooleanArithmetics = true;
+
     public DenseBlockTrueBool(int[] dims) {
         super(dims);
         reset(_rlen, _odims, 0);
diff --git a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
index 22805290300..cd7545a5d97 100644
--- a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
+++ b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
@@ -32,13 +32,7 @@
 import org.apache.commons.logging.LogFactory;
 import org.apache.sysds.common.Types;
 import org.apache.sysds.runtime.DMLRuntimeException;
-import org.apache.sysds.runtime.data.DenseBlock;
-import org.apache.sysds.runtime.data.SparseBlock;
-import org.apache.sysds.runtime.data.SparseBlockCSR;
-import org.apache.sysds.runtime.data.SparseBlockFactory;
-import org.apache.sysds.runtime.data.SparseBlockMCSR;
-import org.apache.sysds.runtime.data.SparseRow;
-import org.apache.sysds.runtime.data.SparseRowVector;
+import org.apache.sysds.runtime.data.*;
 import org.apache.sysds.runtime.functionobjects.*;
 import org.apache.sysds.runtime.functionobjects.Builtin.BuiltinCode;
 import org.apache.sysds.runtime.matrix.operators.BinaryOperator;
@@ -1408,18 +1402,18 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 			}
 			//general case
 			else {
-				// if return matrix is boolean and ValueFunction is comparison , use boolean arithmetics
-				if (op.fn instanceof ValueComparisonFunction && ret.denseBlock != null && ret.denseBlock.isNumeric(Types.ValueType.TRUE_BOOLEAN) ){
+				// if ValueFunction is comparison, return matrix is true boolean and boolean arithmetics are activated, use boolean arithmetics
+				if (op.fn instanceof ValueComparisonFunction &&
+						ret.denseBlock != null &&
+						ret.getDenseBlock() instanceof DenseBlockTrueBool){
 					for(int r=rl; r<ru; r++)
 						for(int c=0; c<clen; c++) {
 							double v1 = m1.quickGetValue(r, c);
 							double v2 = m2.quickGetValue(r, c);
-
-							// make double for now, so we don't have to add boolean to abstract DenseBlock
-							// will be stored as boolean by set function of DenseBlock Boolean implementation
-							double v = ((ValueComparisonFunction) op.fn).compare( v1, v2 ) ? 1.0 : 0.0 ;
-							ret.appendValuePlain(r, c, v);
-							lnnz += (v!=0) ? 1 : 0;
+							boolean vb = ((ValueComparisonFunction) op.fn).compare( v1, v2 );
+							ret.allocateDenseBlock(false);
+							((DenseBlockTrueBool) ret.getDenseBlock()).set(r,c,vb);
+							lnnz += vb ? 1 : 0;
 						}
 				} else {
 					for(int r=rl; r<ru; r++)

From 279517779c5373797b7aceb9336c3898544bf75f Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Sun, 25 Jun 2023 19:48:07 +0200
Subject: [PATCH 05/10] [SYSTEMDS-3544] add boolean set method to Bitset
 DenseBlockBool

---
 .../sysds/runtime/data/DenseBlockBool.java    |  5 +++
 .../runtime/data/DenseBlockTrueBool.java      |  5 ---
 .../runtime/matrix/data/LibMatrixBincell.java | 40 +++++++++++++------
 3 files changed, 33 insertions(+), 17 deletions(-)

diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
index 247526701a1..f6f57170d33 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
@@ -162,6 +162,11 @@ public DenseBlock set(int r, int c, double v) {
 		_data.set(pos(r, c), v != 0);
 		return this;
 	}
+
+	public DenseBlock set(int r, int c, boolean v) {
+		_data.set(pos(r, c), v);
+		return this;
+	}
 	
 	@Override
 	public DenseBlock set(DenseBlock db) {
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
index 56077399a7e..d31956ec902 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
@@ -31,11 +31,6 @@ public class DenseBlockTrueBool extends DenseBlockDRB{
     private static final long serialVersionUID = -6741205568083878338L;
     private boolean[] _data;
 
-    /**
-     * Can be toggled to use boolean arithmetics when this denseblock is used as result matrix.
-     */
-    private boolean useBooleanArithmetics = true;
-
     public DenseBlockTrueBool(int[] dims) {
         super(dims);
         reset(_rlen, _odims, 0);
diff --git a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
index cd7545a5d97..554b9eb5e39 100644
--- a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
+++ b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
@@ -1403,18 +1403,34 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 			//general case
 			else {
 				// if ValueFunction is comparison, return matrix is true boolean and boolean arithmetics are activated, use boolean arithmetics
-				if (op.fn instanceof ValueComparisonFunction &&
-						ret.denseBlock != null &&
-						ret.getDenseBlock() instanceof DenseBlockTrueBool){
-					for(int r=rl; r<ru; r++)
-						for(int c=0; c<clen; c++) {
-							double v1 = m1.quickGetValue(r, c);
-							double v2 = m2.quickGetValue(r, c);
-							boolean vb = ((ValueComparisonFunction) op.fn).compare( v1, v2 );
-							ret.allocateDenseBlock(false);
-							((DenseBlockTrueBool) ret.getDenseBlock()).set(r,c,vb);
-							lnnz += vb ? 1 : 0;
-						}
+				if (op.fn instanceof ValueComparisonFunction &&	ret.denseBlock != null && (ret.getDenseBlock() instanceof DenseBlockTrueBool || ret.getDenseBlock() instanceof DenseBlockBool) ){
+					//TODO: Optimize casting to boolean denseblock types :/
+					if(ret.getDenseBlock() instanceof DenseBlockTrueBool){
+						for(int r=rl; r<ru; r++)
+							for(int c=0; c<clen; c++) {
+								double v1 = m1.quickGetValue(r, c);
+								double v2 = m2.quickGetValue(r, c);
+								boolean vb = ((ValueComparisonFunction) op.fn).compare( v1, v2 );
+
+								//react what is happening in appendValuePlain()
+								ret.allocateDenseBlock(false);
+								((DenseBlockTrueBool) ret.getDenseBlock()).set(r,c,vb);
+								lnnz += vb ? 1 : 0;
+							}
+					} else {
+						for(int r=rl; r<ru; r++)
+							for(int c=0; c<clen; c++) {
+								double v1 = m1.quickGetValue(r, c);
+								double v2 = m2.quickGetValue(r, c);
+								boolean vb = ((ValueComparisonFunction) op.fn).compare( v1, v2 );
+
+								//react what is happening in appendValuePlain()
+								ret.allocateDenseBlock(false);
+								((DenseBlockBool) ret.getDenseBlock()).set(r,c,vb);
+								lnnz += vb ? 1 : 0;
+							}
+					}
+
 				} else {
 					for(int r=rl; r<ru; r++)
 						for(int c=0; c<clen; c++) {

From f2f80af1597e3d83b55f550d4aa867a39ed9bca8 Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Tue, 27 Jun 2023 10:02:17 +0200
Subject: [PATCH 06/10] [SYSTEMDS-3544] renaming of BOOLEAN to BITSET and
 renaming of DenseBlockBool files

---
 .../sysds/runtime/data/DenseBlockBool.html    |  2 +-
 .../sysds/runtime/data/DenseBlockLBool.html   |  2 +-
 .../data/class-use/DenseBlockBool.html        |  6 ++--
 .../data/class-use/DenseBlockLBool.html       |  6 ++--
 docs/api/java/serialized-form.html            |  4 +--
 .../java/org/apache/sysds/common/Types.java   | 10 +++---
 .../java/org/apache/sysds/hops/DataOp.java    |  2 +-
 .../java/org/apache/sysds/hops/LiteralOp.java | 18 +++++-----
 .../sysds/hops/rewrite/HopRewriteUtils.java   | 16 ++++-----
 .../sysds/parser/BooleanIdentifier.java       |  2 +-
 .../parser/BuiltinFunctionExpression.java     | 14 ++++----
 .../apache/sysds/parser/DMLTranslator.java    | 12 +++----
 .../apache/sysds/parser/DataExpression.java   | 10 +++---
 .../sysds/parser/ForStatementBlock.java       |  2 +-
 .../org/apache/sysds/parser/Identifier.java   |  4 +--
 .../sysds/parser/IterablePredicate.java       |  2 +-
 ...arameterizedBuiltinFunctionExpression.java |  4 +--
 .../sysds/parser/RelationalExpression.java    |  2 +-
 .../parser/dml/DmlSyntacticValidator.java     |  2 +-
 .../controlprogram/IfProgramBlock.java        |  4 +--
 .../controlprogram/ParForProgramBlock.java    |  2 +-
 .../runtime/controlprogram/ProgramBlock.java  |  2 +-
 .../controlprogram/WhileProgramBlock.java     |  4 +--
 .../sysds/runtime/data/BasicTensorBlock.java  |  2 +-
 ...TrueBool.java => DenseBlockBoolArray.java} |  8 ++---
 ...ockBool.java => DenseBlockBoolBitset.java} | 10 +++---
 .../sysds/runtime/data/DenseBlockFactory.java | 10 +++---
 ...kLBool.java => DenseBlockLBoolBitset.java} |  6 ++--
 .../sysds/runtime/data/LibTensorAgg.java      |  4 +--
 .../sysds/runtime/data/LibTensorReorg.java    |  4 +--
 .../sysds/runtime/data/TensorBlock.java       |  6 ++--
 .../sysds/runtime/frame/data/FrameBlock.java  | 16 ++++-----
 .../runtime/frame/data/columns/Array.java     |  4 +--
 .../frame/data/columns/ArrayFactory.java      | 10 +++---
 .../frame/data/columns/BitSetArray.java       |  4 +--
 .../frame/data/columns/BooleanArray.java      |  4 +--
 .../frame/data/columns/DoubleArray.java       |  2 +-
 .../frame/data/columns/OptionalArray.java     |  6 ++--
 .../frame/data/columns/StringArray.java       |  2 +-
 .../frame/data/lib/FrameFromMatrixBlock.java  |  2 +-
 .../runtime/frame/data/lib/FrameUtil.java     | 14 ++++----
 .../instructions/cp/BooleanObject.java        |  2 +-
 .../instructions/cp/DataGenCPInstruction.java |  2 +-
 .../runtime/instructions/cp/ListObject.java   |  2 +-
 .../cp/ParameterizedBuiltinCPInstruction.java |  2 +-
 .../instructions/cp/ReshapeCPInstruction.java |  2 +-
 .../cp/ScalarBuiltinNaryCPInstruction.java    |  2 +-
 .../instructions/cp/ScalarObjectFactory.java  | 14 ++++----
 .../instructions/cp/SqlCPInstruction.java     |  4 +--
 .../cp/UnaryScalarCPInstruction.java          |  2 +-
 .../cp/VariableCPInstruction.java             |  4 +--
 .../ParameterizedBuiltinFEDInstruction.java   |  8 ++---
 .../instructions/fed/ReorgFEDInstruction.java |  4 +--
 .../fed/ReshapeFEDInstruction.java            |  2 +-
 .../gpu/MatrixReshapeGPUInstruction.java      |  2 +-
 .../spark/MatrixReshapeSPInstruction.java     |  2 +-
 .../instructions/spark/RandSPInstruction.java |  2 +-
 .../spark/utils/FrameRDDConverterUtils.java   |  4 +--
 .../apache/sysds/runtime/iogen/RawRow.java    |  4 +--
 .../sysds/runtime/iogen/ValueTrimFormat.java  |  8 ++---
 .../runtime/matrix/data/LibMatrixBincell.java |  9 +++--
 .../sysds/runtime/util/DataConverter.java     |  4 +--
 .../apache/sysds/runtime/util/HDFSTool.java   |  6 ++--
 .../sysds/runtime/util/ProgramConverter.java  |  2 +-
 .../sysds/runtime/util/UtilFunctions.java     | 24 ++++++-------
 .../java/org/apache/sysds/test/TestUtils.java | 10 +++---
 .../component/frame/FrameAppendTest_Old.java  |  2 +-
 .../component/frame/FrameApplySchema.java     |  6 ++--
 .../component/frame/FrameCastingTest.java     |  2 +-
 .../test/component/frame/FrameCopyTest.java   |  4 +--
 .../component/frame/FrameEvictionTest.java    |  2 +-
 .../frame/FrameFromMatrixBlockTest.java       | 28 +++++++--------
 .../test/component/frame/FrameGetSetTest.java |  4 +--
 .../component/frame/FrameIndexingTest.java    |  2 +-
 .../frame/FrameSerializationTest.java         |  2 +-
 .../sysds/test/component/frame/FrameTest.java |  4 +--
 .../test/component/frame/FrameUtilTest.java   | 20 +++++------
 .../frame/array/CustomArrayTests.java         | 36 +++++++++----------
 .../frame/array/NegativeArrayTests.java       | 12 +++----
 .../TransformCompressedTestMultiCol.java      | 14 ++++----
 .../tensor/DenseBlockConstIndexingTest.java   | 26 ++++++--------
 .../tensor/DenseBlockConstructionTest.java    | 16 ++++-----
 .../tensor/DenseBlockCountNonZeroTest.java    | 30 +++++++---------
 .../tensor/DenseBlockGetSetIndexingTest.java  | 18 +++++-----
 .../tensor/DenseBlockIncrementTest.java       | 14 ++++----
 .../tensor/DenseBlockSetDenseBlockTest.java   | 28 +++++++--------
 .../tensor/DenseBlockSetRowTest.java          | 22 ++++++------
 .../tensor/TensorConstructionTest.java        | 22 ++++++------
 .../tensor/TensorGetSetIndexingTest.java      | 10 +++---
 .../tensor/TensorSerializationTest.java       |  4 +--
 .../builtin/part1/BuiltinImputeFDTest.java    |  6 ++--
 .../tensor/TensorBinaryBlockParallelTest.java |  4 +--
 .../data/tensor/TensorBinaryBlockTest.java    |  4 +--
 .../tensor/TensorTextCellParallelTest.java    |  4 +--
 .../data/tensor/TensorTextCellTest.java       |  4 +--
 .../primitives/FederatedConstructionTest.java |  2 +-
 .../test/functions/frame/ApplySchemaTest.java |  4 +--
 .../functions/frame/DetectSchemaTest.java     |  4 +--
 .../functions/frame/FrameAppendDistTest.java  |  2 +-
 .../functions/frame/FrameConstructorTest.java |  2 +-
 .../functions/frame/FrameConverterTest.java   |  4 +--
 .../test/functions/frame/FrameEqualTest.java  |  4 +--
 .../frame/FrameIndexingDistTest.java          |  2 +-
 .../functions/frame/FrameReadWriteTest.java   |  2 +-
 .../FrameScalarCastingIntegratedTest.java     | 10 +++---
 .../frame/FrameScalarCastingTest.java         |  4 +--
 .../functions/frame/FrameSchemaReadTest.java  |  2 +-
 .../test/functions/frame/TypeOfTest.java      |  2 +-
 .../functions/iogen/GenerateRandomFrame.java  |  4 +--
 .../iogen/GenerateReaderFrameTest.java        | 10 +++---
 .../functions/misc/ScalarAssignmentTest.java  | 10 +++---
 .../misc/ValueTypeAutoCastingTest.java        | 12 +++----
 .../functions/misc/ValueTypeCastingTest.java  | 18 +++++-----
 .../test/functions/mlcontext/FrameTest.java   |  2 +-
 .../mlcontext/MLContextFrameTest.java         |  6 ++--
 .../LiteralReplaceCastScalarReadTest.java     |  4 +--
 .../ColumnEncoderSerializationTest.java       |  4 +--
 117 files changed, 412 insertions(+), 425 deletions(-)
 rename src/main/java/org/apache/sysds/runtime/data/{DenseBlockTrueBool.java => DenseBlockBoolArray.java} (96%)
 rename src/main/java/org/apache/sysds/runtime/data/{DenseBlockBool.java => DenseBlockBoolBitset.java} (95%)
 rename src/main/java/org/apache/sysds/runtime/data/{DenseBlockLBool.java => DenseBlockLBoolBitset.java} (97%)

diff --git a/docs/api/java/org/apache/sysds/runtime/data/DenseBlockBool.html b/docs/api/java/org/apache/sysds/runtime/data/DenseBlockBool.html
index 8c0fb13b465..df1293861d2 100644
--- a/docs/api/java/org/apache/sysds/runtime/data/DenseBlockBool.html
+++ b/docs/api/java/org/apache/sysds/runtime/data/DenseBlockBool.html
@@ -130,7 +130,7 @@ <h2 title="Class DenseBlockBool" class="title">Class DenseBlockBool</h2>
 <li><a href="DenseBlockDRB.html" title="class in org.apache.sysds.runtime.data">org.apache.sysds.runtime.data.DenseBlockDRB</a></li>
 <li>
 <ul class="inheritance">
-<li>org.apache.sysds.runtime.data.DenseBlockBool</li>
+<li>org.apache.sysds.runtime.data.DenseBlockBoolBitset</li>
 </ul>
 </li>
 </ul>
diff --git a/docs/api/java/org/apache/sysds/runtime/data/DenseBlockLBool.html b/docs/api/java/org/apache/sysds/runtime/data/DenseBlockLBool.html
index 298dd9ee902..1f5bde6ac4f 100644
--- a/docs/api/java/org/apache/sysds/runtime/data/DenseBlockLBool.html
+++ b/docs/api/java/org/apache/sysds/runtime/data/DenseBlockLBool.html
@@ -130,7 +130,7 @@ <h2 title="Class DenseBlockLBool" class="title">Class DenseBlockLBool</h2>
 <li><a href="DenseBlockLDRB.html" title="class in org.apache.sysds.runtime.data">org.apache.sysds.runtime.data.DenseBlockLDRB</a></li>
 <li>
 <ul class="inheritance">
-<li>org.apache.sysds.runtime.data.DenseBlockLBool</li>
+<li>org.apache.sysds.runtime.data.DenseBlockLBoolBitset</li>
 </ul>
 </li>
 </ul>
diff --git a/docs/api/java/org/apache/sysds/runtime/data/class-use/DenseBlockBool.html b/docs/api/java/org/apache/sysds/runtime/data/class-use/DenseBlockBool.html
index 12026612813..556a4be8973 100644
--- a/docs/api/java/org/apache/sysds/runtime/data/class-use/DenseBlockBool.html
+++ b/docs/api/java/org/apache/sysds/runtime/data/class-use/DenseBlockBool.html
@@ -3,7 +3,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc -->
-<title>Uses of Class org.apache.sysds.runtime.data.DenseBlockBool (Apache SystemDS 3.2.0-SNAPSHOT API)</title>
+<title>Uses of Class org.apache.sysds.runtime.data.DenseBlockBoolBitset (Apache SystemDS 3.2.0-SNAPSHOT API)</title>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 <link rel="stylesheet" type="text/css" href="../../../../../../jquery/jquery-ui.min.css" title="Style">
@@ -94,9 +94,9 @@
 </header>
 <main role="main">
 <div class="header">
-<h2 title="Uses of Class org.apache.sysds.runtime.data.DenseBlockBool" class="title">Uses of Class<br>org.apache.sysds.runtime.data.DenseBlockBool</h2>
+<h2 title="Uses of Class org.apache.sysds.runtime.data.DenseBlockBoolBitset" class="title">Uses of Class<br>org.apache.sysds.runtime.data.DenseBlockBoolBitset</h2>
 </div>
-<div class="classUseContainer">No usage of org.apache.sysds.runtime.data.DenseBlockBool</div>
+<div class="classUseContainer">No usage of org.apache.sysds.runtime.data.DenseBlockBoolBitset</div>
 </main>
 <footer role="contentinfo">
 <nav role="navigation">
diff --git a/docs/api/java/org/apache/sysds/runtime/data/class-use/DenseBlockLBool.html b/docs/api/java/org/apache/sysds/runtime/data/class-use/DenseBlockLBool.html
index 56a691ed196..26fb307efb9 100644
--- a/docs/api/java/org/apache/sysds/runtime/data/class-use/DenseBlockLBool.html
+++ b/docs/api/java/org/apache/sysds/runtime/data/class-use/DenseBlockLBool.html
@@ -3,7 +3,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc -->
-<title>Uses of Class org.apache.sysds.runtime.data.DenseBlockLBool (Apache SystemDS 3.2.0-SNAPSHOT API)</title>
+<title>Uses of Class org.apache.sysds.runtime.data.DenseBlockLBoolBitset (Apache SystemDS 3.2.0-SNAPSHOT API)</title>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 <link rel="stylesheet" type="text/css" href="../../../../../../jquery/jquery-ui.min.css" title="Style">
@@ -94,9 +94,9 @@
 </header>
 <main role="main">
 <div class="header">
-<h2 title="Uses of Class org.apache.sysds.runtime.data.DenseBlockLBool" class="title">Uses of Class<br>org.apache.sysds.runtime.data.DenseBlockLBool</h2>
+<h2 title="Uses of Class org.apache.sysds.runtime.data.DenseBlockLBoolBitset" class="title">Uses of Class<br>org.apache.sysds.runtime.data.DenseBlockLBoolBitset</h2>
 </div>
-<div class="classUseContainer">No usage of org.apache.sysds.runtime.data.DenseBlockLBool</div>
+<div class="classUseContainer">No usage of org.apache.sysds.runtime.data.DenseBlockLBoolBitset</div>
 </main>
 <footer role="contentinfo">
 <nav role="navigation">
diff --git a/docs/api/java/serialized-form.html b/docs/api/java/serialized-form.html
index e624ab9896b..8ff8bf483c9 100644
--- a/docs/api/java/serialized-form.html
+++ b/docs/api/java/serialized-form.html
@@ -3609,7 +3609,7 @@ <h4>_rlen</h4>
 <li class="blockList"><a id="org.apache.sysds.runtime.data.DenseBlockBool">
 <!--   -->
 </a>
-<h3>Class <a href="org/apache/sysds/runtime/data/DenseBlockBool.html" title="class in org.apache.sysds.runtime.data">org.apache.sysds.runtime.data.DenseBlockBool</a> extends <a href="org/apache/sysds/runtime/data/DenseBlockDRB.html" title="class in org.apache.sysds.runtime.data">DenseBlockDRB</a> implements Serializable</h3>
+<h3>Class <a href="org/apache/sysds/runtime/data/DenseBlockBool.html" title="class in org.apache.sysds.runtime.data">org.apache.sysds.runtime.data.DenseBlockBoolBitset</a> extends <a href="org/apache/sysds/runtime/data/DenseBlockDRB.html" title="class in org.apache.sysds.runtime.data">DenseBlockDRB</a> implements Serializable</h3>
 <dl class="nameValue">
 <dt>serialVersionUID:</dt>
 <dd>-2228057308997136969L</dd>
@@ -3718,7 +3718,7 @@ <h4>_data</h4>
 <li class="blockList"><a id="org.apache.sysds.runtime.data.DenseBlockLBool">
 <!--   -->
 </a>
-<h3>Class <a href="org/apache/sysds/runtime/data/DenseBlockLBool.html" title="class in org.apache.sysds.runtime.data">org.apache.sysds.runtime.data.DenseBlockLBool</a> extends <a href="org/apache/sysds/runtime/data/DenseBlockLDRB.html" title="class in org.apache.sysds.runtime.data">DenseBlockLDRB</a> implements Serializable</h3>
+<h3>Class <a href="org/apache/sysds/runtime/data/DenseBlockLBool.html" title="class in org.apache.sysds.runtime.data">org.apache.sysds.runtime.data.DenseBlockLBoolBitset</a> extends <a href="org/apache/sysds/runtime/data/DenseBlockLDRB.html" title="class in org.apache.sysds.runtime.data">DenseBlockLDRB</a> implements Serializable</h3>
 <dl class="nameValue">
 <dt>serialVersionUID:</dt>
 <dd>2604223782138590322L</dd>
diff --git a/src/main/java/org/apache/sysds/common/Types.java b/src/main/java/org/apache/sysds/common/Types.java
index 46ec064c4ca..57270e1eae2 100644
--- a/src/main/java/org/apache/sysds/common/Types.java
+++ b/src/main/java/org/apache/sysds/common/Types.java
@@ -76,7 +76,7 @@ public boolean isUnknown() {
 	 */
 	public enum ValueType {
 		UINT4, UINT8, // Used for parsing in UINT values from numpy.
-		FP32, FP64, INT32, INT64, BOOLEAN, TRUE_BOOLEAN, STRING, UNKNOWN,
+		FP32, FP64, INT32, INT64, BITSET, BOOLEAN, STRING, UNKNOWN,
 		CHARACTER;
 		
 		public boolean isNumeric() {
@@ -86,7 +86,7 @@ public boolean isUnknown() {
 			return this == UNKNOWN;
 		}
 		public boolean isPseudoNumeric() {
-			return isNumeric() || this == BOOLEAN || this == CHARACTER;
+			return isNumeric() || this == BITSET || this == CHARACTER;
 		}
 		public String toExternalString() {
 			switch(this) {
@@ -96,7 +96,7 @@ public String toExternalString() {
 				case UINT8:
 				case INT32:
 				case INT64:   return "INT";
-				case BOOLEAN: return "BOOLEAN";
+				case BITSET: return "BOOLEAN";
 				default:      return toString();
 			}
 		}
@@ -113,7 +113,7 @@ public static ValueType fromExternalString(String value) {
 				case "INT32":    return INT32;
 				case "INT64":
 				case "INT":      return INT64;
-				case "BOOLEAN":  return BOOLEAN;
+				case "BOOLEAN":  return BITSET;
 				case "STRING":   return STRING;
 				case "CHARACTER": return CHARACTER;
 				case "UNKNOWN":  return UNKNOWN;
@@ -195,7 +195,7 @@ else if(b == UNKNOWN)
 					default:
 						return a;
 				}
-				case BOOLEAN:
+				case BITSET:
 					return b; // always higher type in b;
 				case UNKNOWN:
 				default:
diff --git a/src/main/java/org/apache/sysds/hops/DataOp.java b/src/main/java/org/apache/sysds/hops/DataOp.java
index 42c51e452b7..63c9e6368cb 100644
--- a/src/main/java/org/apache/sysds/hops/DataOp.java
+++ b/src/main/java/org/apache/sysds/hops/DataOp.java
@@ -396,7 +396,7 @@ protected double computeOutputMemEstimate( long dim1, long dim2, long nnz )
 					ret = OptimizerUtils.INT_SIZE; break;
 				case FP64:
 					ret = OptimizerUtils.DOUBLE_SIZE; break;
-				case BOOLEAN:
+				case BITSET:
 					ret = OptimizerUtils.BOOLEAN_SIZE; break;
 				case STRING: 
 					// by default, it estimates the size of string[100]
diff --git a/src/main/java/org/apache/sysds/hops/LiteralOp.java b/src/main/java/org/apache/sysds/hops/LiteralOp.java
index 5d3f06bd663..213cb8aabe5 100644
--- a/src/main/java/org/apache/sysds/hops/LiteralOp.java
+++ b/src/main/java/org/apache/sysds/hops/LiteralOp.java
@@ -58,7 +58,7 @@ public LiteralOp(String value) {
 	}
 
 	public LiteralOp(boolean value) {
-		super(String.valueOf(value), DataType.SCALAR, ValueType.BOOLEAN);
+		super(String.valueOf(value), DataType.SCALAR, ValueType.BITSET);
 		value_boolean = value;
 	}
 	
@@ -96,8 +96,8 @@ public Lop constructLops()
 			case FP64:
 				l = Data.createLiteralLop(ValueType.FP64, Double.toString(value_double));
 				break;
-			case BOOLEAN:
-				l = Data.createLiteralLop(ValueType.BOOLEAN, Boolean.toString(value_boolean));
+			case BITSET:
+				l = Data.createLiteralLop(ValueType.BITSET, Boolean.toString(value_boolean));
 				break;
 			case STRING:
 				l = Data.createLiteralLop(ValueType.STRING, value_string);
@@ -131,7 +131,7 @@ public String getOpString() {
 			case FP64:
 				val = Double.toString(value_double);
 				break;
-			case BOOLEAN:
+			case BITSET:
 				val = Boolean.toString(value_boolean);
 				break;
 			case STRING:
@@ -156,7 +156,7 @@ protected double computeOutputMemEstimate( long dim1, long dim2, long nnz )
 				ret = OptimizerUtils.INT_SIZE; break;
 			case FP64:
 				ret = OptimizerUtils.DOUBLE_SIZE; break;
-			case BOOLEAN:
+			case BITSET:
 				ret = OptimizerUtils.BOOLEAN_SIZE; break;
 			case STRING: 
 				ret = this.value_string.length() * OptimizerUtils.CHAR_SIZE; break;
@@ -205,7 +205,7 @@ public long getLongValue() {
 				return UtilFunctions.toLong(value_double);
 			case STRING:
 				return Long.parseLong(value_string);
-			case BOOLEAN:
+			case BITSET:
 				return value_boolean ? 1 : 0;
 			default:
 				return -1;
@@ -220,7 +220,7 @@ public double getDoubleValue() {
 				return value_double;
 			case STRING:
 				return Double.parseDouble(value_string);
-			case BOOLEAN:
+			case BITSET:
 				return value_boolean ? 1 : 0;
 			default:
 				throw new HopsException("Can not coerce an object of type " + getValueType() + " into Double.");
@@ -235,7 +235,7 @@ public boolean getBooleanValue() {
 				return (value_double != 0);
 			case STRING:
 				return Boolean.parseBoolean(value_string);
-			case BOOLEAN:
+			case BITSET:
 				return value_boolean;
 			default:
 				throw new HopsException("Can not coerce an object of type " + getValueType() + " into Boolean.");
@@ -244,7 +244,7 @@ public boolean getBooleanValue() {
 	
 	public String getStringValue() {
 		switch( getValueType() ) {
-			case BOOLEAN:
+			case BITSET:
 				return String.valueOf(value_boolean);
 			case UINT4:
 			case UINT8:
diff --git a/src/main/java/org/apache/sysds/hops/rewrite/HopRewriteUtils.java b/src/main/java/org/apache/sysds/hops/rewrite/HopRewriteUtils.java
index 338393eda5b..c74b3f42bdd 100644
--- a/src/main/java/org/apache/sysds/hops/rewrite/HopRewriteUtils.java
+++ b/src/main/java/org/apache/sysds/hops/rewrite/HopRewriteUtils.java
@@ -105,7 +105,7 @@ public static boolean getBooleanValue( LiteralOp op ) {
 		switch( op.getValueType() ) {
 			case FP64:    return op.getDoubleValue() != 0; 
 			case INT64:   return op.getLongValue()   != 0;
-			case BOOLEAN: return op.getBooleanValue();
+			case BITSET: return op.getBooleanValue();
 			default: throw new HopsException("Invalid boolean value: "+op.getValueType());
 		}
 	}
@@ -115,7 +115,7 @@ public static boolean getBooleanValueSafe( LiteralOp op ) {
 			switch( op.getValueType() ) {
 				case FP64:    return op.getDoubleValue() != 0; 
 				case INT64:   return op.getLongValue()   != 0;
-				case BOOLEAN: return op.getBooleanValue();
+				case BITSET: return op.getBooleanValue();
 				default: throw new HopsException("Invalid boolean value: "+op.getValueType());
 			}
 		}
@@ -131,7 +131,7 @@ public static double getDoubleValue( LiteralOp op ) {
 			case STRING:
 			case FP64:    return op.getDoubleValue(); 
 			case INT64:   return op.getLongValue();
-			case BOOLEAN: return op.getBooleanValue() ? 1 : 0;
+			case BITSET: return op.getBooleanValue() ? 1 : 0;
 			default: throw new HopsException("Invalid double value: "+op.getValueType());
 		}
 	}
@@ -140,7 +140,7 @@ public static double getDoubleValueSafe( LiteralOp op ) {
 		switch( op.getValueType() ) {
 			case FP64:  return op.getDoubleValue(); 
 			case INT64:     return op.getLongValue();
-			case BOOLEAN: return op.getBooleanValue() ? 1 : 0;
+			case BITSET: return op.getBooleanValue() ? 1 : 0;
 			default: return Double.MAX_VALUE;
 		}
 	}
@@ -160,7 +160,7 @@ public static long getIntValue( LiteralOp op ) {
 			case FP64:  return UtilFunctions.toLong(op.getDoubleValue());
 			case STRING:
 			case INT64:     return op.getLongValue();
-			case BOOLEAN: return op.getBooleanValue() ? 1 : 0;
+			case BITSET: return op.getBooleanValue() ? 1 : 0;
 			default: throw new HopsException("Invalid int value: "+op.getValueType());
 		}
 	}
@@ -173,7 +173,7 @@ public static long getIntValueSafe( LiteralOp op ) {
 		switch( op.getValueType() ) {
 			case FP64:    return UtilFunctions.toLong(op.getDoubleValue());
 			case INT64:   return op.getLongValue();
-			case BOOLEAN: return op.getBooleanValue() ? 1 : 0;
+			case BITSET: return op.getBooleanValue() ? 1 : 0;
 			default: return Long.MAX_VALUE;
 		}
 	}
@@ -196,7 +196,7 @@ public static boolean isLiteralOfValue(Hop hop, String val) {
 	public static boolean isLiteralOfValue( Hop hop, boolean val ) {
 		try {
 			return (hop instanceof LiteralOp 
-				&& (hop.getValueType()==ValueType.BOOLEAN)
+				&& (hop.getValueType()==ValueType.BITSET)
 				&& ((LiteralOp)hop).getBooleanValue()==val);
 		}
 		catch(HopsException ex) {
@@ -655,7 +655,7 @@ public static BinaryOp createBinary(Hop input1, Hop input2, OpOp2 op, boolean ou
 			mainInput.getValueType(), op, input1, input2);
 		//cleanup value type for relational operations
 		if( bop.isPPredOperation() && bop.getDataType().isScalar() )
-			bop.setValueType(ValueType.BOOLEAN);
+			bop.setValueType(ValueType.BITSET);
 		bop.setOuterVectorOperation(outer);
 		bop.setBlocksize(mainInput.getBlocksize());
 		copyLineNumbers(mainInput, bop);
diff --git a/src/main/java/org/apache/sysds/parser/BooleanIdentifier.java b/src/main/java/org/apache/sysds/parser/BooleanIdentifier.java
index dc4e164451a..98206ed2f76 100644
--- a/src/main/java/org/apache/sysds/parser/BooleanIdentifier.java
+++ b/src/main/java/org/apache/sysds/parser/BooleanIdentifier.java
@@ -50,7 +50,7 @@ private void setInfo(boolean val) {
 		_val = val;
 		setDimensions(0, 0);
 		computeDataType();
-		setValueType(ValueType.BOOLEAN);
+		setValueType(ValueType.BITSET);
 	}
 
 	@Override
diff --git a/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java b/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
index 80e9f75b80e..a72606546be 100644
--- a/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
+++ b/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
@@ -616,7 +616,7 @@ public void validateExpression(HashMap<String, DataIdentifier> ids, HashMap<Stri
 				case INT32:
 				case UINT8:
 				case UINT4:
-				case BOOLEAN:
+				case BITSET:
 					output.setValueType(ValueType.INT64);
 					break;
 				case UNKNOWN:
@@ -779,7 +779,7 @@ else if( getAllExpr().length == 2 ) { //binary
 			//output.setDataType(id.getDataType()); //TODO whenever we support multiple matrix value types, currently noop.
 			output.setDimensions(0, 0);
 			output.setBlocksize(0);
-			output.setValueType(ValueType.BOOLEAN);
+			output.setValueType(ValueType.BITSET);
 			break;
 			
 		case IFELSE:
@@ -966,7 +966,7 @@ else if( getOpCode() == Builtins.RBIND ) {
 			output.setDataType(DataType.SCALAR);
 			output.setDimensions(0, 0);
 			output.setBlocksize(0);
-			output.setValueType(ValueType.BOOLEAN);
+			output.setValueType(ValueType.BITSET);
 			break;
 		
 		// Contingency tables
@@ -1270,20 +1270,20 @@ else if( getOpCode() == Builtins.RBIND ) {
 				checkNumParameters(4);
 				if (in[3].getOutput().getValueType() != ValueType.INT64) 
 					throw new LanguageException("Fourth argument, seed, to sample() must be an integer value.");
-				if (in[2].getOutput().getValueType() != ValueType.BOOLEAN ) 
+				if (in[2].getOutput().getValueType() != ValueType.BITSET)
 					throw new LanguageException("Third argument to sample() must either denote replacement policy (boolean) or seed (integer).");
 			}
 			else if(in.length == 3) 
 			{
 				checkNumParameters(3);
-				if (in[2].getOutput().getValueType() != ValueType.BOOLEAN 
+				if (in[2].getOutput().getValueType() != ValueType.BITSET
 						&& in[2].getOutput().getValueType() != ValueType.INT64 ) 
 					throw new LanguageException("Third argument to sample() must either denote replacement policy (boolean) or seed (integer).");
 			}
 			
 			if ( check && in.length >= 3 
 					&& isConstant(in[2]) 
-					&& in[2].getOutput().getValueType() == ValueType.BOOLEAN  
+					&& in[2].getOutput().getValueType() == ValueType.BITSET
 					&& !((BooleanIdentifier)in[2]).getValue() )
 				throw new LanguageException("Sample (size=" + ((ConstIdentifier)in[0]).getLongValue() 
 						+ ") larger than population (size=" + ((ConstIdentifier)in[1]).getLongValue() 
@@ -2030,7 +2030,7 @@ public static Builtins getValueTypeCastOperator( ValueType vt ) {
 				return Builtins.CAST_AS_DOUBLE;
 			case INT64:
 				return Builtins.CAST_AS_INT;
-			case BOOLEAN:
+			case BITSET:
 				return Builtins.CAST_AS_BOOLEAN;
 			default:
 				throw new LanguageException("No cast for value type "+vt);
diff --git a/src/main/java/org/apache/sysds/parser/DMLTranslator.java b/src/main/java/org/apache/sysds/parser/DMLTranslator.java
index ba5877d81b9..8cd860ec943 100644
--- a/src/main/java/org/apache/sysds/parser/DMLTranslator.java
+++ b/src/main/java/org/apache/sysds/parser/DMLTranslator.java
@@ -1439,7 +1439,7 @@ else if (passedSB instanceof IfStatementBlock) {
 		
 		DataIdentifier target = new DataIdentifier(Expression.getTempName());
 		target.setDataType(DataType.SCALAR);
-		target.setValueType(ValueType.BOOLEAN);
+		target.setValueType(ValueType.BITSET);
 		target.setParseInfo(passedSB);
 		Hop predicateHops = null;
 		Expression predicate = cp.getPredicate();
@@ -1806,12 +1806,12 @@ private Hop processRelationalExpression(RelationalExpression source, DataIdentif
 			}
 			else if(left.getDataType() == DataType.FRAME || right.getDataType() == DataType.FRAME) {
 				target.setDataType(DataType.FRAME);
-				target.setValueType(ValueType.BOOLEAN);
+				target.setValueType(ValueType.BITSET);
 			}
 			else {
 				// Added to support scalar relational comparison
 				target.setDataType(DataType.SCALAR);
-				target.setValueType(ValueType.BOOLEAN);
+				target.setValueType(ValueType.BITSET);
 			}
 		}
 		
@@ -1859,7 +1859,7 @@ private Hop processBooleanExpression(BooleanExpression source, DataIdentifier ta
 		if (target == null)
 			target = createTarget(source);
 		if( target.getDataType().isScalar() )
-			target.setValueType(ValueType.BOOLEAN);
+			target.setValueType(ValueType.BITSET);
 		
 		if (source.getRight() == null) {
 			Hop currUop = new UnaryOp(target.getName(), target.getDataType(), target.getValueType(), OpOp1.NOT, left);
@@ -2561,7 +2561,7 @@ else if ( sop.equalsIgnoreCase("!=") )
 			currBuiltinOp = new UnaryOp(target.getName(), target.getDataType(), ValueType.INT64, OpOp1.CAST_AS_INT, expr);
 			break;
 		case CAST_AS_BOOLEAN:
-			currBuiltinOp = new UnaryOp(target.getName(), target.getDataType(), ValueType.BOOLEAN, OpOp1.CAST_AS_BOOLEAN, expr);
+			currBuiltinOp = new UnaryOp(target.getName(), target.getDataType(), ValueType.BITSET, OpOp1.CAST_AS_BOOLEAN, expr);
 			break;
 		case LOCAL:
 			currBuiltinOp = new UnaryOp(target.getName(), target.getDataType(), ValueType.FP64, OpOp1.LOCAL, expr);
@@ -2708,7 +2708,7 @@ else if ( sop.equalsIgnoreCase("!=") )
 			else if ( in.length == 3 )
 			{
 				// check if the third argument is "replace" or "seed"
-				if ( expr3.getValueType() == ValueType.BOOLEAN ) 
+				if ( expr3.getValueType() == ValueType.BITSET)
 				{
 					tmpparams.put(DataExpression.RAND_PDF, expr3);
 					tmpparams.put(DataExpression.RAND_SEED, new LiteralOp(DataGenOp.UNSPECIFIED_SEED) );
diff --git a/src/main/java/org/apache/sysds/parser/DataExpression.java b/src/main/java/org/apache/sysds/parser/DataExpression.java
index c100c4de502..4213b4b176c 100644
--- a/src/main/java/org/apache/sysds/parser/DataExpression.java
+++ b/src/main/java/org/apache/sysds/parser/DataExpression.java
@@ -1129,8 +1129,8 @@ else if( getVarParam(READNNZPARAM) != null ) {
 				//handle all csv default parameters
 				handleCSVDefaultParam(DELIM_DELIMITER, ValueType.STRING, conditional);
 				handleCSVDefaultParam(DELIM_FILL_VALUE, ValueType.FP64, conditional);
-				handleCSVDefaultParam(DELIM_HAS_HEADER_ROW, ValueType.BOOLEAN, conditional);
-				handleCSVDefaultParam(DELIM_FILL, ValueType.BOOLEAN, conditional);
+				handleCSVDefaultParam(DELIM_HAS_HEADER_ROW, ValueType.BITSET, conditional);
+				handleCSVDefaultParam(DELIM_FILL, ValueType.BITSET, conditional);
 				handleCSVDefaultParam(DELIM_NA_STRINGS, ValueType.STRING, conditional);
 			}
 
@@ -1283,7 +1283,7 @@ else if (valueTypeString.equalsIgnoreCase(Statement.STRING_VALUE_TYPE))
 				else if (valueTypeString.equalsIgnoreCase(Statement.INT_VALUE_TYPE))
 					getOutput().setValueType(ValueType.INT64);
 				else if (valueTypeString.equalsIgnoreCase(Statement.BOOLEAN_VALUE_TYPE))
-					getOutput().setValueType(ValueType.BOOLEAN);
+					getOutput().setValueType(ValueType.BITSET);
 				else if (valueTypeString.equalsIgnoreCase(ValueType.UNKNOWN.name()))
 					getOutput().setValueType(ValueType.UNKNOWN);
 				else {
@@ -2168,7 +2168,7 @@ private void handleCSVDefaultParam(String param, ValueType vt, boolean condition
 		if (getVarParam(param) == null) {
 			Expression defExpr = null;
 			switch(vt) {
-				case BOOLEAN:
+				case BITSET:
 					defExpr = new BooleanIdentifier((boolean)csvDefaults.get(param), this);
 					break;
 				case FP64:
@@ -2198,7 +2198,7 @@ private boolean checkFormatType(FileFormat... fmts) {
 	private boolean checkValueType(Expression expr, ValueType vt) {
 		return (vt == ValueType.STRING && expr instanceof StringIdentifier)
 			|| (vt == ValueType.FP64 && (expr instanceof DoubleIdentifier || expr instanceof IntIdentifier))
-			|| (vt == ValueType.BOOLEAN && expr instanceof BooleanIdentifier);
+			|| (vt == ValueType.BITSET && expr instanceof BooleanIdentifier);
 	}
 
 	private void validateParams(boolean conditional, Set<String> validParamNames, String legalMessage) {
diff --git a/src/main/java/org/apache/sysds/parser/ForStatementBlock.java b/src/main/java/org/apache/sysds/parser/ForStatementBlock.java
index ce31ae9bcf5..36515381db9 100644
--- a/src/main/java/org/apache/sysds/parser/ForStatementBlock.java
+++ b/src/main/java/org/apache/sysds/parser/ForStatementBlock.java
@@ -386,7 +386,7 @@ private static Expression replaceConstantVar(Expression expr, HashMap<String, Co
 				case INT64:
 					ret = new IntIdentifier((IntIdentifier) constValue, expr);
 					break;
-				case BOOLEAN:
+				case BITSET:
 					ret = new IntIdentifier(
 							new BooleanObject(((BooleanIdentifier) constValue).getValue()).getLongValue(), expr);
 					break;
diff --git a/src/main/java/org/apache/sysds/parser/Identifier.java b/src/main/java/org/apache/sysds/parser/Identifier.java
index 3ea3252a852..ba6acffdf5d 100644
--- a/src/main/java/org/apache/sysds/parser/Identifier.java
+++ b/src/main/java/org/apache/sysds/parser/Identifier.java
@@ -202,7 +202,7 @@ public void computeDataType() {
 	
 	public void setBooleanProperties(){
 		_dataType = DataType.SCALAR;
-		_valueType = ValueType.BOOLEAN;
+		_valueType = ValueType.BITSET;
 		_dim1 = 0;
 		_dim2 = 0;
 		_blocksize = 0;
@@ -222,7 +222,7 @@ public void setIntProperties(){
 	
 	
 	public boolean isScalarBoolean(){
-		return (_valueType == ValueType.BOOLEAN) && (_dataType == DataType.SCALAR);
+		return (_valueType == ValueType.BITSET) && (_dataType == DataType.SCALAR);
 	}
 	
 	public boolean dimsKnown(){
diff --git a/src/main/java/org/apache/sysds/parser/IterablePredicate.java b/src/main/java/org/apache/sysds/parser/IterablePredicate.java
index 9f5d9184240..5ef51b4ecfa 100644
--- a/src/main/java/org/apache/sysds/parser/IterablePredicate.java
+++ b/src/main/java/org/apache/sysds/parser/IterablePredicate.java
@@ -191,7 +191,7 @@ private void checkNumericScalarOutput( Expression expr ) {
 		
 		Identifier ident = expr.getOutput();
 		if( ident.getDataType() == DataType.MATRIX ||
-			(ident.getDataType() == DataType.SCALAR && (ident.getValueType() == ValueType.BOOLEAN || 
+			(ident.getDataType() == DataType.SCALAR && (ident.getValueType() == ValueType.BITSET ||
 			ident.getValueType() == ValueType.STRING)) )
 		{
 			throw new LanguageException(this.printErrorLocation() + "expression in iterable predicate in for loop '" + expr.toString() + "' must return a numeric scalar");
diff --git a/src/main/java/org/apache/sysds/parser/ParameterizedBuiltinFunctionExpression.java b/src/main/java/org/apache/sysds/parser/ParameterizedBuiltinFunctionExpression.java
index 1906ee818e8..eed0cc55a0f 100644
--- a/src/main/java/org/apache/sysds/parser/ParameterizedBuiltinFunctionExpression.java
+++ b/src/main/java/org/apache/sysds/parser/ParameterizedBuiltinFunctionExpression.java
@@ -848,7 +848,7 @@ else if( !(margin instanceof DataIdentifier) && !margin.toString().equals("rows"
 		}
 		
 		Expression empty = getVarParam("empty.return");
-		if( empty!=null && (!empty.getOutput().getDataType().isScalar() || empty.getOutput().getValueType() != ValueType.BOOLEAN) ){
+		if( empty!=null && (!empty.getOutput().getDataType().isScalar() || empty.getOutput().getValueType() != ValueType.BITSET) ){
 			raiseValidateError("Boolean parameter 'empty.return' is of type "+empty.getOutput().getDataType()
 				+"["+empty.getOutput().getValueType()+"].", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
 		}
@@ -987,7 +987,7 @@ private void checkEmptyTargetParam(Expression target, boolean conditional) {
 	}
 	
 	private void checkOptionalBooleanParam(Expression param, String name, boolean conditional) {
-		if( param!=null && (!param.getOutput().getDataType().isScalar() || param.getOutput().getValueType() != ValueType.BOOLEAN) ){
+		if( param!=null && (!param.getOutput().getDataType().isScalar() || param.getOutput().getValueType() != ValueType.BITSET) ){
 			raiseValidateError("Boolean parameter '"+name+"' is of type "+param.getOutput().getDataType()
 				+"["+param.getOutput().getValueType()+"].", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
 		}
diff --git a/src/main/java/org/apache/sysds/parser/RelationalExpression.java b/src/main/java/org/apache/sysds/parser/RelationalExpression.java
index f0b4695439a..254d230cf14 100644
--- a/src/main/java/org/apache/sysds/parser/RelationalExpression.java
+++ b/src/main/java/org/apache/sysds/parser/RelationalExpression.java
@@ -160,7 +160,7 @@ public void validateExpression(HashMap<String,DataIdentifier> ids, HashMap<Strin
 		else if(isLeftFrame && isRightFrame) {
 			output.setDataType(DataType.FRAME);
 			output.setDimensions(_left.getOutput().getDim1(), _left.getOutput().getDim2());
-			output.setValueType(ValueType.BOOLEAN);
+			output.setValueType(ValueType.BITSET);
 		}
 		else if( isLeftFrame || isRightFrame ) {
 			raiseValidateError("Unsupported relational expression for mixed types "
diff --git a/src/main/java/org/apache/sysds/parser/dml/DmlSyntacticValidator.java b/src/main/java/org/apache/sysds/parser/dml/DmlSyntacticValidator.java
index 6387cfcaf4d..bc387a0e32a 100644
--- a/src/main/java/org/apache/sysds/parser/dml/DmlSyntacticValidator.java
+++ b/src/main/java/org/apache/sysds/parser/dml/DmlSyntacticValidator.java
@@ -1725,7 +1725,7 @@ else if( (shortVt && valueType.equals("str"))
 		}
 		else if( (shortVt && valueType.equals("bool"))
 			|| valueType.equals("boolean") || valueType.equals("Boolean")) {
-			dataId.setValueType(ValueType.BOOLEAN);
+			dataId.setValueType(ValueType.BITSET);
 		}
 		else if( (shortVt && valueType.equals("float") )
 			|| valueType.equals("double") || valueType.equals("Double")) {
diff --git a/src/main/java/org/apache/sysds/runtime/controlprogram/IfProgramBlock.java b/src/main/java/org/apache/sysds/runtime/controlprogram/IfProgramBlock.java
index f88dff517eb..cb8008c38fb 100644
--- a/src/main/java/org/apache/sysds/runtime/controlprogram/IfProgramBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/controlprogram/IfProgramBlock.java
@@ -138,10 +138,10 @@ private BooleanObject executePredicate(ExecutionContext ec)
 			if( _sb != null ) {
 				IfStatementBlock isb = (IfStatementBlock)_sb;
 				result = (BooleanObject) executePredicate(_predicate, isb.getPredicateHops(), 
-					isb.requiresPredicateRecompilation(), ValueType.BOOLEAN, ec);
+					isb.requiresPredicateRecompilation(), ValueType.BITSET, ec);
 			}
 			else
-				result = (BooleanObject) executePredicate(_predicate, null, false, ValueType.BOOLEAN, ec);
+				result = (BooleanObject) executePredicate(_predicate, null, false, ValueType.BITSET, ec);
 		}
 		catch(Exception ex) {
 			throw new DMLRuntimeException(this.printBlockErrorLocation() + "Failed to evaluate the IF predicate.", ex);
diff --git a/src/main/java/org/apache/sysds/runtime/controlprogram/ParForProgramBlock.java b/src/main/java/org/apache/sysds/runtime/controlprogram/ParForProgramBlock.java
index 2fc12c4c267..47ab3824ac4 100644
--- a/src/main/java/org/apache/sysds/runtime/controlprogram/ParForProgramBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/controlprogram/ParForProgramBlock.java
@@ -1124,7 +1124,7 @@ private static void createEmptyUnscopedVariables( LocalVariableMap out, Statemen
 				{
 					case SCALAR:
 						switch( valuetype ) {
-							case BOOLEAN: dataObj = new BooleanObject(false); break;
+							case BITSET: dataObj = new BooleanObject(false); break;
 							case INT64:     dataObj = new IntObject(-1);        break;
 							case FP64:  dataObj = new DoubleObject(-1d);    break;
 							case STRING:  dataObj = new StringObject("-1");   break;
diff --git a/src/main/java/org/apache/sysds/runtime/controlprogram/ProgramBlock.java b/src/main/java/org/apache/sysds/runtime/controlprogram/ProgramBlock.java
index 75fe42de89d..d9fd3da3c48 100644
--- a/src/main/java/org/apache/sysds/runtime/controlprogram/ProgramBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/controlprogram/ProgramBlock.java
@@ -218,7 +218,7 @@ protected ScalarObject executePredicateInstructions(ArrayList<Instruction> inst,
 		// check and correct scalar ret type (incl save double to int)
 		if(retType != null && retType != ret.getValueType())
 			switch(retType) {
-				case BOOLEAN:
+				case BITSET:
 					ret = new BooleanObject(ret.getBooleanValue());
 					break;
 				case INT64:
diff --git a/src/main/java/org/apache/sysds/runtime/controlprogram/WhileProgramBlock.java b/src/main/java/org/apache/sysds/runtime/controlprogram/WhileProgramBlock.java
index 7dea91b7aba..c62f6b9d36c 100644
--- a/src/main/java/org/apache/sysds/runtime/controlprogram/WhileProgramBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/controlprogram/WhileProgramBlock.java
@@ -77,10 +77,10 @@ private BooleanObject executePredicate(ExecutionContext ec)
 				WhileStatementBlock wsb = (WhileStatementBlock)_sb;
 				Hop predicateOp = wsb.getPredicateHops();
 				boolean recompile = wsb.requiresPredicateRecompilation();
-				result = (BooleanObject) executePredicate(_predicate, predicateOp, recompile, ValueType.BOOLEAN, ec);
+				result = (BooleanObject) executePredicate(_predicate, predicateOp, recompile, ValueType.BITSET, ec);
 			}
 			else
-				result = (BooleanObject) executePredicate(_predicate, null, false, ValueType.BOOLEAN, ec);
+				result = (BooleanObject) executePredicate(_predicate, null, false, ValueType.BITSET, ec);
 		}
 		catch(Exception ex) {
 			throw new DMLRuntimeException(this.printBlockErrorLocation() + "Failed to evaluate the while predicate.", ex);
diff --git a/src/main/java/org/apache/sysds/runtime/data/BasicTensorBlock.java b/src/main/java/org/apache/sysds/runtime/data/BasicTensorBlock.java
index 3710f723318..8cf4563888d 100644
--- a/src/main/java/org/apache/sysds/runtime/data/BasicTensorBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/data/BasicTensorBlock.java
@@ -312,7 +312,7 @@ public Object get(int[] ix) {
 					return _denseBlock.getLong(ix);
 				case INT32:
 					return (int) _denseBlock.getLong(ix);
-				case BOOLEAN:
+				case BITSET:
 					return _denseBlock.get(ix) != 0;
 				case STRING:
 					return _denseBlock.getString(ix);
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolArray.java
similarity index 96%
rename from src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
rename to src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolArray.java
index d31956ec902..e0882e366c0 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockTrueBool.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolArray.java
@@ -26,12 +26,12 @@
 
 import java.util.Arrays;
 
-public class DenseBlockTrueBool extends DenseBlockDRB{
+public class DenseBlockBoolArray extends DenseBlockDRB{
 
     private static final long serialVersionUID = -6741205568083878338L;
     private boolean[] _data;
 
-    public DenseBlockTrueBool(int[] dims) {
+    public DenseBlockBoolArray(int[] dims) {
         super(dims);
         reset(_rlen, _odims, 0);
     }
@@ -41,7 +41,7 @@ protected void allocateBlock(int bix, int length) {
         _data = new boolean[length];
     }
 
-    public DenseBlockTrueBool(int[] dims, boolean[] data) {
+    public DenseBlockBoolArray(int[] dims, boolean[] data) {
         super(dims);
         _data = data;
     }
@@ -53,7 +53,7 @@ public boolean isNumeric() {
 
     @Override
     public boolean isNumeric(ValueType vt) {
-        return ValueType.TRUE_BOOLEAN == vt;
+        return ValueType.BOOLEAN == vt;
     }
 
 
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
similarity index 95%
rename from src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
rename to src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
index f6f57170d33..68cbc535d4d 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
@@ -27,13 +27,13 @@
 import org.apache.sysds.runtime.util.DataConverter;
 import org.apache.sysds.runtime.util.UtilFunctions;
 
-public class DenseBlockBool extends DenseBlockDRB
+public class DenseBlockBoolBitset extends DenseBlockDRB
 {
 	private static final long serialVersionUID = -2228057308997136969L;
 	
 	private BitSet _data;
 
-	public DenseBlockBool(int[] dims) {
+	public DenseBlockBoolBitset(int[] dims) {
 		super(dims);
 		reset(_rlen, _odims, 0);
 	}
@@ -43,12 +43,12 @@ protected void allocateBlock(int bix, int length) {
 		_data = new BitSet(length);
 	}
 
-	public DenseBlockBool(int[] dims, BitSet data) {
+	public DenseBlockBoolBitset(int[] dims, BitSet data) {
 		super(dims);
 		_data = data;
 	}
 
-	public DenseBlockBool(int[] dims, boolean[] data) {
+	public DenseBlockBoolBitset(int[] dims, boolean[] data) {
 		super(dims);
 		_data = new BitSet(data.length);
 		for(int i=0; i<data.length; i++)
@@ -67,7 +67,7 @@ public boolean isNumeric() {
 	
 	@Override
 	public boolean isNumeric(ValueType vt) {
-		return ValueType.BOOLEAN == vt;
+		return ValueType.BITSET == vt;
 	}
 	
 	@Override
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
index 3468863c66f..1facadab740 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
@@ -58,11 +58,11 @@ public static DenseBlock createDenseBlock(ValueType vt, int[] dims, boolean dedu
 	}
 
 	public static DenseBlock createDenseBlock(BitSet data, int[] dims) {
-		return new DenseBlockBool(dims, data);
+		return new DenseBlockBoolBitset(dims, data);
 	}
 
 	public static DenseBlock createDenseBlock(boolean[] data, int[] dims) {
-		return new DenseBlockTrueBool(dims, data);
+		return new DenseBlockBoolArray(dims, data);
 	}
 
 	public static DenseBlock createDenseBlock(String[] data, int[] dims) {
@@ -118,8 +118,8 @@ public static DenseBlock createDenseBlock(ValueType vt, DenseBlock.Type type, in
 					case FP64: return new DenseBlockFP64(dims);
 					case INT32: return new DenseBlockInt32(dims);
 					case INT64: return new DenseBlockInt64(dims);
-					case BOOLEAN: return new DenseBlockBool(dims);
-					case TRUE_BOOLEAN: return new DenseBlockTrueBool(dims);
+					case BITSET: return new DenseBlockBoolBitset(dims);
+					case BOOLEAN: return new DenseBlockBoolArray(dims);
 					case STRING: return new DenseBlockString(dims);
 					default:
 						throw new DMLRuntimeException("Unsupported dense block value type: "+vt.name());
@@ -128,7 +128,7 @@ public static DenseBlock createDenseBlock(ValueType vt, DenseBlock.Type type, in
 				switch(vt) {
 					case FP32: return new DenseBlockLFP32(dims);
 					case FP64: return new DenseBlockLFP64(dims);
-					case BOOLEAN: return new DenseBlockLBool(dims);
+					case BITSET: return new DenseBlockLBoolBitset(dims);
 					case INT32: return new DenseBlockLInt32(dims);
 					case INT64: return new DenseBlockLInt64(dims);
 					case STRING: return new DenseBlockLString(dims);
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockLBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockLBoolBitset.java
similarity index 97%
rename from src/main/java/org/apache/sysds/runtime/data/DenseBlockLBool.java
rename to src/main/java/org/apache/sysds/runtime/data/DenseBlockLBoolBitset.java
index e49b3a9b7c6..0ad5b2aa490 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockLBool.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockLBoolBitset.java
@@ -28,13 +28,13 @@
 import org.apache.sysds.runtime.util.DataConverter;
 import org.apache.sysds.runtime.util.UtilFunctions;
 
-public class DenseBlockLBool extends DenseBlockLDRB
+public class DenseBlockLBoolBitset extends DenseBlockLDRB
 {
 	private static final long serialVersionUID = 2604223782138590322L;
 
 	private BitSet[] _blocks;
 
-	public DenseBlockLBool(int[] dims) {
+	public DenseBlockLBoolBitset(int[] dims) {
 		super(dims);
 		reset(_rlen, _odims, 0);
 	}
@@ -61,7 +61,7 @@ public boolean isNumeric() {
 	
 	@Override
 	public boolean isNumeric(ValueType vt) {
-		return ValueType.BOOLEAN == vt;
+		return ValueType.BITSET == vt;
 	}
 
 
diff --git a/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java b/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
index 6ea603edace..c43b2b932d8 100644
--- a/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
+++ b/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
@@ -49,7 +49,7 @@ private enum AggType {
 	 */
 	public static boolean satisfiesMultiThreadingConstraints(BasicTensorBlock in, int k) {
 		// TODO more conditions depending on operation
-		return k > 1 && in._vt != Types.ValueType.BOOLEAN;
+		return k > 1 && in._vt != Types.ValueType.BITSET;
 	}
 
 	/**
@@ -224,7 +224,7 @@ private static void sum(BasicTensorBlock in, BasicTensorBlock out, Plus plus, in
 			throw new DMLRuntimeException("Sparse aggregation not implemented for Tensor");
 		}
 		switch (in.getValueType()) {
-			case BOOLEAN: {
+			case BITSET: {
 				//TODO switch to no-op nnz meta data once available
 				out.set(0, 0, in.getDenseBlock().countNonZeros());
 				break;
diff --git a/src/main/java/org/apache/sysds/runtime/data/LibTensorReorg.java b/src/main/java/org/apache/sysds/runtime/data/LibTensorReorg.java
index e7dc8af6685..f0377310cd1 100644
--- a/src/main/java/org/apache/sysds/runtime/data/LibTensorReorg.java
+++ b/src/main/java/org/apache/sysds/runtime/data/LibTensorReorg.java
@@ -96,8 +96,8 @@ private static void reshapeDense(BasicTensorBlock in, BasicTensorBlock out, int[
 			//we don't need to create a copy, given our copy on write semantics.
 			//however, note that with update in-place this would be an invalid optimization
 			DenseBlock denseBlock = in._denseBlock;
-			if (denseBlock instanceof DenseBlockBool) {
-				DenseBlockBool specificBlock = (DenseBlockBool) denseBlock;
+			if (denseBlock instanceof DenseBlockBoolBitset) {
+				DenseBlockBoolBitset specificBlock = (DenseBlockBoolBitset) denseBlock;
 				out._denseBlock = DenseBlockFactory.createDenseBlock(specificBlock.getData(), dims);
 			} else if (denseBlock instanceof DenseBlockString) {
 				DenseBlockString specificBlock = (DenseBlockString) denseBlock;
diff --git a/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java b/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
index 5047ee25248..6150152fa1d 100644
--- a/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
@@ -658,7 +658,7 @@ public long getExactBlockDataSerializedSize(BasicTensorBlock bt) {
 				case INT64:
 				case FP64:
 					size += 8 * getLength(); break;
-				case BOOLEAN:
+				case BITSET:
 					//TODO perf bits instead of bytes
 					size += getLength(); break;
 					//size += Math.ceil((double)getLength() / 64); break;
@@ -737,7 +737,7 @@ else if (!bt.isSparse()) {
 						case FP64: out.writeDouble(a.get(i, j)); break;
 						case INT32: out.writeInt((int) a.getLong(ix)); break;
 						case INT64: out.writeLong(a.getLong(ix)); break;
-						case BOOLEAN: out.writeBoolean(a.get(i, j) != 0); break;
+						case BITSET: out.writeBoolean(a.get(i, j) != 0); break;
 						case STRING:
 							String s = a.getString(ix);
 							out.writeUTF(s == null ? "" : s);
@@ -811,7 +811,7 @@ protected void readBlockData(DataInput in, BasicTensorBlock bt) throws IOExcepti
 							case FP64: a.set(i, j, in.readDouble()); break;
 							case INT32: a.set(ix, in.readInt()); break;
 							case INT64: a.set(ix, in.readLong()); break;
-							case BOOLEAN: a.set(i, j, in.readByte()); break;
+							case BITSET: a.set(i, j, in.readByte()); break;
 							case STRING:
 								// FIXME readUTF is not supported for CacheDataInput
 								a.set(ix, in.readUTF());
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/FrameBlock.java b/src/main/java/org/apache/sysds/runtime/frame/data/FrameBlock.java
index 5faacaf8d1d..0876e870285 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/FrameBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/FrameBlock.java
@@ -575,7 +575,7 @@ public void appendColumn(String[] col) {
 	 */
 	public void appendColumn(boolean[] col) {
 		ensureColumnCompatibility(col.length);
-		appendColumnMetaData(ValueType.BOOLEAN);
+		appendColumnMetaData(ValueType.BITSET);
 		_coldata = FrameUtil.add(_coldata, ArrayFactory.create(col));
 	}
 
@@ -949,7 +949,7 @@ else if(getSchema()[i] == ValueType.INT64 || that.getSchema()[i] == ValueType.IN
 				}
 			}
 		}
-		return new FrameBlock(UtilFunctions.nCopies(frameBlock.getNumColumns(), ValueType.BOOLEAN), outputData);
+		return new FrameBlock(UtilFunctions.nCopies(frameBlock.getNumColumns(), ValueType.BITSET), outputData);
 	}
 
 	private static boolean checkAndSetEmpty(FrameBlock fb1, FrameBlock fb2, String[][] out, int r, int c) {
@@ -1324,8 +1324,8 @@ else if(schemaCol.contains("STRING"))
 
 				ValueType dataType = FrameUtil.isType(dataValue);
 
-				if(!dataType.toString().contains(type) && !(dataType == ValueType.BOOLEAN && type.equals("INT")) &&
-					!(dataType == ValueType.BOOLEAN && type.equals("FP"))) {
+				if(!dataType.toString().contains(type) && !(dataType == ValueType.BITSET && type.equals("INT")) &&
+					!(dataType == ValueType.BITSET && type.equals("FP"))) {
 					LOG.warn("Datatype detected: " + dataType + " where expected: " + schemaString[i] + " col: " + (i + 1)
 						+ ", row:" + (j + 1));
 
@@ -1435,8 +1435,8 @@ public FrameBlock valueSwap(FrameBlock schema) {
 				String type = dataType.toString().replaceAll("\\d", "");
 				// get the avergae column length
 				if(!dataType.toString().contains(schemaString[i]) &&
-					!(dataType == ValueType.BOOLEAN && schemaString[i].equals("INT")) &&
-					!(dataType == ValueType.BOOLEAN && schemaString[i].equals("FP")) &&
+					!(dataType == ValueType.BITSET && schemaString[i].equals("INT")) &&
+					!(dataType == ValueType.BITSET && schemaString[i].equals("FP")) &&
 					!(dataType.toString().contains("INT") && schemaString[i].equals("FP"))) {
 					LOG.warn("conflict " + dataType + " " + schemaString[i] + " " + dataValue);
 					// check the other column with satisfy the data type of this value
@@ -1601,10 +1601,10 @@ public <T> FrameBlock replaceOperations(String pattern, String replacement) {
 
 		boolean NaNp = "NaN".equals(pattern);
 		boolean NaNr = "NaN".equals(replacement);
-		ValueType patternType = UtilFunctions.isBoolean(pattern) ? ValueType.BOOLEAN : (NumberUtils.isCreatable(pattern) |
+		ValueType patternType = UtilFunctions.isBoolean(pattern) ? ValueType.BITSET : (NumberUtils.isCreatable(pattern) |
 			NaNp ? (UtilFunctions.isIntegerNumber(pattern) ? ValueType.INT64 : ValueType.FP64) : ValueType.STRING);
 		ValueType replacementType = UtilFunctions
-			.isBoolean(replacement) ? ValueType.BOOLEAN : (NumberUtils.isCreatable(replacement) |
+			.isBoolean(replacement) ? ValueType.BITSET : (NumberUtils.isCreatable(replacement) |
 				NaNr ? (UtilFunctions.isIntegerNumber(replacement) ? ValueType.INT64 : ValueType.FP64) : ValueType.STRING);
 
 		if(patternType != replacementType || !ValueType.isSameTypeString(patternType, replacementType))
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/Array.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/Array.java
index 3fbf3ed2d0c..1c4c4b033a4 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/Array.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/Array.java
@@ -381,7 +381,7 @@ public Array<?> changeTypeWithNulls(ValueType t) {
 			return changeType(t);
 
 		switch(t) {
-			case BOOLEAN:
+			case BITSET:
 				if(size() > ArrayFactory.bitSetSwitchPoint)
 					return new OptionalArray<Boolean>(changeTypeBitSet(), nulls);
 				else
@@ -415,7 +415,7 @@ public Array<?> changeTypeWithNulls(ValueType t) {
 	 */
 	public final Array<?> changeType(ValueType t) {
 		switch(t) {
-			case BOOLEAN:
+			case BITSET:
 				if(size() > ArrayFactory.bitSetSwitchPoint)
 					return changeTypeBitSet();
 				else
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
index edfe85d7948..45cd31270a2 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
@@ -73,12 +73,12 @@ public static <T> OptionalArray<T> create(T[] col) {
 
 	public static long getInMemorySize(ValueType type, int _numRows) {
 		switch(type) {
-			case BOOLEAN:
+			case BITSET:
 				if(_numRows > bitSetSwitchPoint)
 					return Array.baseMemoryCost() + (long) MemoryEstimates.longArrayCost(_numRows >> 6 + 1);
 				else
 					return Array.baseMemoryCost() + (long) MemoryEstimates.booleanArrayCost(_numRows);
-			case TRUE_BOOLEAN:
+			case BOOLEAN:
 				return Array.baseMemoryCost() + (long) MemoryEstimates.booleanArrayCost(_numRows);
 			case INT64:
 				return Array.baseMemoryCost() + (long) MemoryEstimates.longArrayCost(_numRows);
@@ -109,7 +109,7 @@ public static Array<?> allocate(ValueType v, int nRow, String val) {
 
 	public static Array<?> allocateOptional(ValueType v, int nRow) {
 		switch(v) {
-			case BOOLEAN:
+			case BITSET:
 				if(nRow > bitSetSwitchPoint)
 					return new OptionalArray<>(new BitSetArray(nRow), true);
 				else
@@ -142,7 +142,7 @@ public static ABooleanArray allocateBoolean(int nRow) {
 
 	public static Array<?> allocate(ValueType v, int nRow) {
 		switch(v) {
-			case BOOLEAN:
+			case BITSET:
 				return allocateBoolean(nRow);
 			case UINT4:
 			case UINT8:
@@ -260,7 +260,7 @@ else if(target.getFrameArrayType() != FrameArrayType.OPTIONAL //
 
 	public static Object parseString(String s, ValueType v) {
 		switch(v) {
-			case BOOLEAN:
+			case BITSET:
 				return BooleanArray.parseBoolean(s);
 			case CHARACTER:
 				return CharArray.parseChar(s);
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/BitSetArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/BitSetArray.java
index d6c2489ec2c..6155e6aa953 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/BitSetArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/BitSetArray.java
@@ -365,12 +365,12 @@ public byte[] getAsByteArray() {
 
 	@Override
 	public ValueType getValueType() {
-		return ValueType.BOOLEAN;
+		return ValueType.BITSET;
 	}
 
 	@Override
 	public Pair<ValueType, Boolean> analyzeValueType() {
-		return new Pair<ValueType, Boolean>(ValueType.BOOLEAN, false);
+		return new Pair<ValueType, Boolean>(ValueType.BITSET, false);
 	}
 
 	@Override
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/BooleanArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/BooleanArray.java
index e74f8bcd653..33171e7c859 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/BooleanArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/BooleanArray.java
@@ -185,12 +185,12 @@ public byte[] getAsByteArray() {
 
 	@Override
 	public ValueType getValueType() {
-		return ValueType.BOOLEAN;
+		return ValueType.BITSET;
 	}
 
 	@Override
 	public Pair<ValueType, Boolean> analyzeValueType() {
-		return new Pair<ValueType, Boolean>(ValueType.BOOLEAN, false);
+		return new Pair<ValueType, Boolean>(ValueType.BITSET, false);
 	}
 
 	@Override
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/DoubleArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/DoubleArray.java
index de8def92de8..5c266bdc029 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/DoubleArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/DoubleArray.java
@@ -208,7 +208,7 @@ public Pair<ValueType, Boolean> analyzeValueType() {
 					}
 					break;
 				default:
-				case BOOLEAN:
+				case BITSET:
 					switch(c) {
 						case FP64:
 						case FP32:
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/OptionalArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/OptionalArray.java
index 6898e9472c4..e52611bfdd9 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/OptionalArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/OptionalArray.java
@@ -42,7 +42,7 @@ public OptionalArray(T[] a) {
 		super(a.length);
 
 		if(a instanceof Boolean[])
-			_a = (Array<T>) ArrayFactory.allocate(ValueType.BOOLEAN, a.length);
+			_a = (Array<T>) ArrayFactory.allocate(ValueType.BITSET, a.length);
 		else if(a instanceof Integer[])
 			_a = (Array<T>) ArrayFactory.allocate(ValueType.INT32, a.length);
 		else if(a instanceof Double[])
@@ -109,7 +109,7 @@ protected static OptionalArray<?> readOpt(DataInput in, int nRow) throws IOExcep
 		final Array<?> a = ArrayFactory.read(in, nRow);
 		final ABooleanArray n = (ABooleanArray) ArrayFactory.read(in, nRow);
 		switch(a.getValueType()) {
-			case BOOLEAN:
+			case BITSET:
 				return new OptionalArray<Boolean>((Array<Boolean>) a, n);
 			case FP32:
 				return new OptionalArray<Float>((Array<Float>) a, n);
@@ -400,7 +400,7 @@ public final boolean isNotEmpty(int i) {
 	public Array<?> changeTypeWithNulls(ValueType t) {
 
 		switch(t) {
-			case BOOLEAN:
+			case BITSET:
 				if(size() > ArrayFactory.bitSetSwitchPoint)
 					return changeTypeBitSet();
 				else
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/StringArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/StringArray.java
index e99903d4b39..e839d583755 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/StringArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/StringArray.java
@@ -222,7 +222,7 @@ private static final ValueType getHighest(ValueType state, ValueType c) {
 					default:
 				}
 				break;
-			case BOOLEAN:
+			case BITSET:
 				switch(c) {
 					case FP64:
 					case FP32:
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameFromMatrixBlock.java b/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameFromMatrixBlock.java
index 3164724f4f6..6d06f7ee5f6 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameFromMatrixBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameFromMatrixBlock.java
@@ -85,7 +85,7 @@ public static FrameBlock convertToFrameBlock(MatrixBlock mb, ValueType[] schema,
 	private ValueType[] getSchema(MatrixBlock mb) {
 		final int nCol = mb.getNumColumns();
 		final int nRow = mb.getNumRows();
-		ValueType[] schema = UtilFunctions.nCopies(nCol, ValueType.BOOLEAN);
+		ValueType[] schema = UtilFunctions.nCopies(nCol, ValueType.BITSET);
 		for(int r = 0; r < nRow; r++)
 			for(int c = 0; c < nCol; c++)
 				schema[c] = FrameUtil.isType(mb.quickGetValue(r, c), schema[c]);
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameUtil.java b/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameUtil.java
index 7f66ecfe6d3..985ceedf2e8 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameUtil.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameUtil.java
@@ -61,7 +61,7 @@ public static Array<?>[] add(Array<?>[] ar, Array<?> e) {
 
 	private static ValueType isBooleanType(final String val, int len) {
 		if(val.length() <= 16 && booleanPattern.matcher(val).matches())
-			return ValueType.BOOLEAN;
+			return ValueType.BITSET;
 		return null;
 	}
 
@@ -138,10 +138,10 @@ public static ValueType isType(String val, ValueType minType) {
 		ValueType r = null;
 		switch(minType) {
 			case UNKNOWN:
-			case BOOLEAN:
+			case BITSET:
 			case CHARACTER:
 				if(isBooleanType(val, len) != null)
-					return ValueType.BOOLEAN;
+					return ValueType.BITSET;
 			case UINT8:
 			case INT32:
 			case INT64:
@@ -162,12 +162,12 @@ public static ValueType isType(String val, ValueType minType) {
 	}
 
 	public static ValueType isType(String val) {
-		return isType(val, ValueType.BOOLEAN);
+		return isType(val, ValueType.BITSET);
 	}
 
 	public static ValueType isType(double val) {
 		if(val == 1.0d || val == 0.0d)
-			return ValueType.BOOLEAN;
+			return ValueType.BITSET;
 		else if((long) (val) == val) {
 			if((int) val == val)
 				return ValueType.INT32;
@@ -183,7 +183,7 @@ else if(same(val, (float) val))
 
 	public static ValueType isType(double val, ValueType min) {
 		switch(min) {
-			case BOOLEAN:
+			case BITSET:
 				return isType(val);
 			case INT32:
 			case UINT8:
@@ -239,7 +239,7 @@ public static boolean isDefault(String v, ValueType t) {
 		if(v == null)
 			return true;
 		switch(t) {
-			case BOOLEAN:
+			case BITSET:
 				return !BooleanArray.parseBoolean(v);
 			case CHARACTER:
 				return 0 == CharArray.parseChar(v);
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/BooleanObject.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/BooleanObject.java
index c285761a54b..522f927a917 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/BooleanObject.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/BooleanObject.java
@@ -29,7 +29,7 @@ public class BooleanObject extends ScalarObject
 	private final boolean _value;
 	
 	public BooleanObject(boolean val){
-		super(ValueType.BOOLEAN);
+		super(ValueType.BITSET);
 		_value = val;
 	}
 
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/DataGenCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/DataGenCPInstruction.java
index ad218bbbed1..f18d14f3a64 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/DataGenCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/DataGenCPInstruction.java
@@ -430,7 +430,7 @@ private CacheBlock<?> processRandInstructionTensor(ExecutionContext ec, long lSe
 		if(minValueStr.equals(maxValueStr)) {
 			if(minMaxAreDoubles)
 				outT.set(minValue);
-			else if(output.getValueType() == ValueType.STRING || output.getValueType() == ValueType.BOOLEAN)
+			else if(output.getValueType() == ValueType.STRING || output.getValueType() == ValueType.BITSET)
 				outT.set(minValueStr);
 			else
 				throw new DMLRuntimeException("Rand instruction cannot fill numeric tensor with non numeric elements.");
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ListObject.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ListObject.java
index 5c302fe80a9..92936cc3672 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ListObject.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ListObject.java
@@ -468,7 +468,7 @@ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundExcept
 					switch (valueType) {
 						case INT64:     so = new IntObject(Long.parseLong(value)); break;
 						case FP64:  	so = new DoubleObject(Double.parseDouble(value)); break;
-						case BOOLEAN: 	so = new BooleanObject(Boolean.parseBoolean(value)); break;
+						case BITSET: 	so = new BooleanObject(Boolean.parseBoolean(value)); break;
 						case STRING:  	so = new StringObject(value); break;
 						default:
 							throw new DMLRuntimeException("Unable to parse valuetype " + valueType);
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ParameterizedBuiltinCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ParameterizedBuiltinCPInstruction.java
index 18a199e9308..d3b84411cd2 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ParameterizedBuiltinCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ParameterizedBuiltinCPInstruction.java
@@ -574,7 +574,7 @@ private CPOperand getStringLiteral(String name) {
 	}
 
 	private CPOperand getBoolLiteral(String name) {
-		return getLiteral(name, ValueType.BOOLEAN);
+		return getLiteral(name, ValueType.BITSET);
 	}
 
 	private CPOperand getLiteral(String name, ValueType vt) {
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ReshapeCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ReshapeCPInstruction.java
index 9cf30acb374..63da1d1f25d 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ReshapeCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ReshapeCPInstruction.java
@@ -96,7 +96,7 @@ else if (input1.getDataType() == Types.DataType.MATRIX) {
 			MatrixBlock in = ec.getMatrixInput(input1.getName());
 			int rows = (int) ec.getScalarInput(_opRows).getLongValue(); //save cast
 			int cols = (int) ec.getScalarInput(_opCols).getLongValue(); //save cast
-			BooleanObject byRow = (BooleanObject) ec.getScalarInput(_opByRow.getName(), ValueType.BOOLEAN, _opByRow.isLiteral());
+			BooleanObject byRow = (BooleanObject) ec.getScalarInput(_opByRow.getName(), ValueType.BITSET, _opByRow.isLiteral());
 
 			//execute operations
 			MatrixBlock out = new MatrixBlock();
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarBuiltinNaryCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarBuiltinNaryCPInstruction.java
index 096072895fd..cb67d0781b6 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarBuiltinNaryCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarBuiltinNaryCPInstruction.java
@@ -75,7 +75,7 @@ public void processInstruction(ExecutionContext ec) {
 					case FP64:
 						objects[i - 1] = scalarObject.getDoubleValue();
 						break;
-					case BOOLEAN:
+					case BITSET:
 						objects[i - 1] = scalarObject.getBooleanValue();
 						break;
 					case STRING:
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarObjectFactory.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarObjectFactory.java
index 6e74620394d..12d77da3bcb 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarObjectFactory.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarObjectFactory.java
@@ -40,7 +40,7 @@ public static ScalarObject createScalarObject(ValueType vt, String value) {
 		switch( vt ) {
 			case INT64:   return new IntObject(UtilFunctions.parseToLong(value));
 			case FP64:    return new DoubleObject(Double.parseDouble(value));
-			case BOOLEAN: return new BooleanObject(Boolean.parseBoolean(value));
+			case BITSET: return new BooleanObject(Boolean.parseBoolean(value));
 			case STRING:  return new StringObject(value);
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
@@ -49,7 +49,7 @@ public static ScalarObject createScalarObject(ValueType vt, String value) {
 	public static ScalarObject createScalarObject(ValueType vt, Object obj) {
 		//TODO add new scalar object for extended type system
 		switch( vt ) {
-			case BOOLEAN: return new BooleanObject((Boolean)obj);
+			case BITSET: return new BooleanObject((Boolean)obj);
 			case INT64:   return new IntObject((Long)obj);
 			case INT32:   return new IntObject((Integer)obj);
 			case FP64:    return new DoubleObject((Double)obj);
@@ -63,7 +63,7 @@ public static ScalarObject createScalarObject(ValueType vt, double value) {
 		switch( vt ) {
 			case INT64:     return new IntObject(UtilFunctions.toLong(value));
 			case FP64:  return new DoubleObject(value);
-			case BOOLEAN: return new BooleanObject(value != 0);
+			case BITSET: return new BooleanObject(value != 0);
 			case STRING:  return new StringObject(String.valueOf(value));
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
@@ -73,7 +73,7 @@ public static ScalarObject createScalarObject(ValueType vt, ScalarObject so) {
 		switch( vt ) {
 			case FP64:    return castToDouble(so);
 			case INT64:   return castToLong(so);
-			case BOOLEAN: return new BooleanObject(so.getBooleanValue());
+			case BITSET: return new BooleanObject(so.getBooleanValue());
 			case STRING:  return new StringObject(so.getStringValue());
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
@@ -87,7 +87,7 @@ public static ScalarObject createScalarObject(ValueType vt, LiteralOp lit) {
 		switch( vt ) {
 			case FP64:    return new DoubleObject(lit.getDoubleValue());
 			case INT64:   return new IntObject(lit.getLongValue());
-			case BOOLEAN: return new BooleanObject(lit.getBooleanValue());
+			case BITSET: return new BooleanObject(lit.getBooleanValue());
 			case STRING:  return new StringObject(lit.getStringValue());
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
@@ -97,7 +97,7 @@ public static LiteralOp createLiteralOp(ScalarObject so) {
 		switch( so.getValueType() ){
 			case FP64:    return new LiteralOp(so.getDoubleValue());
 			case INT64:   return new LiteralOp(so.getLongValue());
-			case BOOLEAN: return new LiteralOp(so.getBooleanValue());
+			case BITSET: return new LiteralOp(so.getBooleanValue());
 			case STRING:  return new LiteralOp(so.getStringValue());
 			default:
 				throw new HopsException("Unsupported literal value type: "+so.getValueType());
@@ -117,7 +117,7 @@ public static LiteralOp createLiteralOp(ValueType vt, String value) {
 		switch( vt ) {
 			case FP64:    return new LiteralOp(Double.parseDouble(value));
 			case INT64:   return new LiteralOp(Long.parseLong(value));
-			case BOOLEAN: return new LiteralOp(Boolean.parseBoolean(value));
+			case BITSET: return new LiteralOp(Boolean.parseBoolean(value));
 			case STRING:  return new LiteralOp(value);
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/SqlCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/SqlCPInstruction.java
index e4453bce8ba..99dc737b829 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/SqlCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/SqlCPInstruction.java
@@ -101,7 +101,7 @@ private static void setCell(TensorBlock outBlock, ResultSet resultSet, ValueType
 			case FP32: outBlock.set(ix, resultSet.getFloat(sqlCol)); break;
 			case INT64: outBlock.set(ix, resultSet.getLong(sqlCol)); break;
 			case INT32: outBlock.set(ix, resultSet.getInt(sqlCol)); break;
-			case BOOLEAN: outBlock.set(ix, resultSet.getBoolean(sqlCol)); break;
+			case BITSET: outBlock.set(ix, resultSet.getBoolean(sqlCol)); break;
 			case STRING: outBlock.set(ix, resultSet.getString(sqlCol)); break;
 			default: throw new DMLRuntimeException("Cell can not be set to valuetype " + valueType.name());
 		}
@@ -122,7 +122,7 @@ private static ValueType[] getSchemaFromMetaData(ResultSetMetaData meta) throws
 				case Types.SMALLINT:
 				case Types.TINYINT:
 				case Types.INTEGER: schema[i] = ValueType.INT32; break;
-				case Types.BIT:     schema[i] = ValueType.BOOLEAN; break;
+				case Types.BIT:     schema[i] = ValueType.BITSET; break;
 				default:            schema[i] = ValueType.STRING; break;
 			}
 		}
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/UnaryScalarCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/UnaryScalarCPInstruction.java
index ecced1f13d0..fbdd58000a0 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/UnaryScalarCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/UnaryScalarCPInstruction.java
@@ -72,7 +72,7 @@ else if ( opcode.equalsIgnoreCase("assert") ) {
 			UnaryOperator dop = (UnaryOperator) _optr;
 			if ( so instanceof IntObject && output.getValueType() == ValueType.INT64 )
 				sores = new IntObject((long)dop.fn.execute(so.getLongValue()));
-			else if( so instanceof BooleanObject && output.getValueType() == ValueType.BOOLEAN )
+			else if( so instanceof BooleanObject && output.getValueType() == ValueType.BITSET)
 				sores = new BooleanObject(dop.fn.execute(so.getBooleanValue()));
 			else
 				sores = new DoubleObject(dop.fn.execute(so.getDoubleValue()));
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/VariableCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/VariableCPInstruction.java
index 8bec222b0d3..e2794892fcf 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/VariableCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/VariableCPInstruction.java
@@ -386,7 +386,7 @@ else if ( voc == VariableOperationCode.Write ) {
 			// file name
 			in2 = new CPOperand(parts[2], ValueType.STRING, DataType.SCALAR);
 			// file name override flag (always literal)
-			in3 = new CPOperand(parts[3], ValueType.BOOLEAN, DataType.SCALAR);
+			in3 = new CPOperand(parts[3], ValueType.BITSET, DataType.SCALAR);
 
 			// format
 			String fmt = parts[5];
@@ -544,7 +544,7 @@ else if(fmt.equalsIgnoreCase("hdf5")) {
 			in1 = new CPOperand(parts[1]);
 			in2 = new CPOperand(parts[2]);
 			// second argument must be a boolean
-			if ( in2.getValueType() != ValueType.BOOLEAN)
+			if ( in2.getValueType() != ValueType.BITSET)
 				throw new DMLRuntimeException("Unexpected value type for second argument in: " + str);
 			break;
 
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/fed/ParameterizedBuiltinFEDInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/fed/ParameterizedBuiltinFEDInstruction.java
index 7654b92eccb..62f7e5f3d83 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/fed/ParameterizedBuiltinFEDInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/fed/ParameterizedBuiltinFEDInstruction.java
@@ -370,10 +370,10 @@ public Pair<String, LineageItem> getLineageItem(ExecutionContext ec) {
 			LineageItem[] liUdfInputs = Arrays.stream(getInputIDs())
 				.mapToObj(id -> ec.getLineage().get(String.valueOf(id))).toArray(LineageItem[]::new);
 			CPOperand slice = new CPOperand(Arrays.toString(_slice), ValueType.STRING, DataType.SCALAR, true);
-			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BOOLEAN, DataType.SCALAR, true);
-			CPOperand lower = new CPOperand(String.valueOf(_lower), ValueType.BOOLEAN, DataType.SCALAR, true);
-			CPOperand diag = new CPOperand(String.valueOf(_diag), ValueType.BOOLEAN, DataType.SCALAR, true);
-			CPOperand values = new CPOperand(String.valueOf(_values), ValueType.BOOLEAN, DataType.SCALAR, true);
+			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BITSET, DataType.SCALAR, true);
+			CPOperand lower = new CPOperand(String.valueOf(_lower), ValueType.BITSET, DataType.SCALAR, true);
+			CPOperand diag = new CPOperand(String.valueOf(_diag), ValueType.BITSET, DataType.SCALAR, true);
+			CPOperand values = new CPOperand(String.valueOf(_values), ValueType.BITSET, DataType.SCALAR, true);
 			LineageItem[] otherInputs = LineageItemUtils.getLineage(ec, slice, rowFed, lower, diag, values);
 			LineageItem[] liInputs = Stream.concat(Arrays.stream(liUdfInputs), Arrays.stream(otherInputs))
 				.toArray(LineageItem[]::new);
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/fed/ReorgFEDInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/fed/ReorgFEDInstruction.java
index 0b173d7fe8c..eea8f398bb8 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/fed/ReorgFEDInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/fed/ReorgFEDInstruction.java
@@ -349,7 +349,7 @@ public Pair<String, LineageItem> getLineageItem(ExecutionContext ec) {
 					.mapToObj(id -> ec.getLineage().get(String.valueOf(id))).toArray(LineageItem[]::new);
 			CPOperand r_op = new CPOperand(_r_op.fn.getClass().getSimpleName(), ValueType.STRING, DataType.SCALAR, true);
 			CPOperand slice = new CPOperand(Arrays.toString(_slice), ValueType.STRING, DataType.SCALAR, true);
-			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BOOLEAN, DataType.SCALAR, true);
+			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BITSET, DataType.SCALAR, true);
 			LineageItem[] otherInputs = LineageItemUtils.getLineage(ec, r_op, slice, rowFed);
 			LineageItem[] liInputs = Stream.concat(Arrays.stream(liUdfInputs), Arrays.stream(otherInputs))
 					.toArray(LineageItem[]::new);
@@ -408,7 +408,7 @@ public Pair<String, LineageItem> getLineageItem(ExecutionContext ec) {
 			CPOperand r_op = new CPOperand(_r_op.fn.getClass().getSimpleName(), ValueType.STRING, DataType.SCALAR, true);
 			CPOperand len = new CPOperand(String.valueOf(_len), ValueType.INT32, DataType.SCALAR, true);
 			CPOperand slice = new CPOperand(Arrays.toString(_slice), ValueType.STRING, DataType.SCALAR, true);
-			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BOOLEAN, DataType.SCALAR, true);
+			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BITSET, DataType.SCALAR, true);
 			LineageItem[] otherInputs = LineageItemUtils.getLineage(ec, r_op, len, slice, rowFed);
 			LineageItem[] liInputs = Stream.concat(Arrays.stream(liUdfInputs), Arrays.stream(otherInputs))
 					.toArray(LineageItem[]::new);
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/fed/ReshapeFEDInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/fed/ReshapeFEDInstruction.java
index 3d355cd1dd5..ded0d3a6b72 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/fed/ReshapeFEDInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/fed/ReshapeFEDInstruction.java
@@ -88,7 +88,7 @@ public void processInstruction(ExecutionContext ec) {
 		if(output.getDataType() == Types.DataType.MATRIX) {
 			MatrixObject mo1 = ec.getMatrixObject(input1);
 			BooleanObject byRow = (BooleanObject) ec
-				.getScalarInput(_opByRow.getName(), Types.ValueType.BOOLEAN, _opByRow.isLiteral());
+				.getScalarInput(_opByRow.getName(), Types.ValueType.BITSET, _opByRow.isLiteral());
 			int rows = (int) ec.getScalarInput(_opRows).getLongValue();
 			int cols = (int) ec.getScalarInput(_opCols).getLongValue();
 
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/gpu/MatrixReshapeGPUInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/gpu/MatrixReshapeGPUInstruction.java
index f82d712b45f..fa53be321ad 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/gpu/MatrixReshapeGPUInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/gpu/MatrixReshapeGPUInstruction.java
@@ -74,7 +74,7 @@ public static MatrixReshapeGPUInstruction parseInstruction ( String str ) {
 	public void processInstruction(ExecutionContext ec) {
 		int rows = (int)ec.getScalarInput(_opRows).getLongValue(); //save cast
 		int cols = (int)ec.getScalarInput(_opCols).getLongValue(); //save cast
-		BooleanObject byRow = (BooleanObject) ec.getScalarInput(_opByRow.getName(), ValueType.BOOLEAN, _opByRow.isLiteral());
+		BooleanObject byRow = (BooleanObject) ec.getScalarInput(_opByRow.getName(), ValueType.BITSET, _opByRow.isLiteral());
 		
 		GPUStatistics.incrementNoOfExecutedGPUInst();
 		String instName = getExtendedOpcode();
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/spark/MatrixReshapeSPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/spark/MatrixReshapeSPInstruction.java
index d8b8e4e3842..9aa06431163 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/spark/MatrixReshapeSPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/spark/MatrixReshapeSPInstruction.java
@@ -87,7 +87,7 @@ public void processInstruction(ExecutionContext ec) {
 		//get parameters
 		long rows = ec.getScalarInput(_opRows).getLongValue(); //save cast
 		long cols = ec.getScalarInput(_opCols).getLongValue(); //save cast
-		boolean byRow = ec.getScalarInput(_opByRow.getName(), ValueType.BOOLEAN, _opByRow.isLiteral()).getBooleanValue();
+		boolean byRow = ec.getScalarInput(_opByRow.getName(), ValueType.BITSET, _opByRow.isLiteral()).getBooleanValue();
 
 		DataCharacteristics mcIn = sec.getDataCharacteristics(input1.getName());
 		DataCharacteristics mcOut = sec.getDataCharacteristics(output.getName());
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/spark/RandSPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/spark/RandSPInstruction.java
index 05b16d4f76e..7dc4b8e3f2c 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/spark/RandSPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/spark/RandSPInstruction.java
@@ -1127,7 +1127,7 @@ public Tuple2<TensorIndexes, TensorBlock> call(Tuple2<TensorIndexes, Long> kv)
 			else {
 				switch (_vt) {
 					case STRING:
-					case BOOLEAN:
+					case BITSET:
 						tb.set(_min);
 						break;
 					case INT64:
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/spark/utils/FrameRDDConverterUtils.java b/src/main/java/org/apache/sysds/runtime/instructions/spark/utils/FrameRDDConverterUtils.java
index 9371d43094c..22d805826f3 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/spark/utils/FrameRDDConverterUtils.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/spark/utils/FrameRDDConverterUtils.java
@@ -307,7 +307,7 @@ public static StructType convertFrameSchemaToDFSchema(ValueType[] fschema, boole
 				case STRING:  dt = DataTypes.StringType; break;
 				case FP64:  dt = DataTypes.DoubleType; break;
 				case INT64:     dt = DataTypes.LongType; break;
-				case BOOLEAN: dt = DataTypes.BooleanType; break;
+				case BITSET: dt = DataTypes.BooleanType; break;
 				default:      dt = DataTypes.StringType;
 					LOG.warn("Using default type String for " + schema.toString());
 			}
@@ -348,7 +348,7 @@ else if(structType.dataType() == DataTypes.LongType
 				|| structType.dataType() == DataTypes.IntegerType)
 				fschema[pos++] = ValueType.INT64;
 			else if(structType.dataType() == DataTypes.BooleanType)
-				fschema[pos++] = ValueType.BOOLEAN;
+				fschema[pos++] = ValueType.BITSET;
 			else if(structType.dataType() instanceof VectorUDT) {
 				if( containsVect )
 					throw new RuntimeException("Found invalid second vector column.");
diff --git a/src/main/java/org/apache/sysds/runtime/iogen/RawRow.java b/src/main/java/org/apache/sysds/runtime/iogen/RawRow.java
index 6ef8222e3f0..f3b5f8d1888 100644
--- a/src/main/java/org/apache/sysds/runtime/iogen/RawRow.java
+++ b/src/main/java/org/apache/sysds/runtime/iogen/RawRow.java
@@ -71,7 +71,7 @@ public Pair<Integer, Integer> findValue(ValueTrimFormat vtf, boolean forward, bo
 
 		else if(vt == Types.ValueType.STRING)
 			return findStringValue(vtf, forward, update);
-		else if(vt == Types.ValueType.BOOLEAN) {
+		else if(vt == Types.ValueType.BITSET) {
 			ValueTrimFormat vtfb = new ValueTrimFormat(vtf.getStringOfActualValue());
 			return findStringValue(vtfb, forward, update);
 		}
@@ -129,7 +129,7 @@ public Pair<Integer, Integer> findAtValue(ValueTrimFormat vtf, int rawIndex, int
 			return findAtStringValue(vtf, rawIndex, update);
 		else if(vtf.getValueType().isNumeric())
 			return findAtNumericValue(vtf, rawIndex, numericIndex, update);
-		else if(vtf.getValueType() == Types.ValueType.BOOLEAN) {
+		else if(vtf.getValueType() == Types.ValueType.BITSET) {
 			ValueTrimFormat vtfb = new ValueTrimFormat(vtf.getStringOfActualValue());
 			return findAtStringValue(vtfb, rawIndex, update);
 		}
diff --git a/src/main/java/org/apache/sysds/runtime/iogen/ValueTrimFormat.java b/src/main/java/org/apache/sysds/runtime/iogen/ValueTrimFormat.java
index 5f5f20a6823..10640505261 100644
--- a/src/main/java/org/apache/sysds/runtime/iogen/ValueTrimFormat.java
+++ b/src/main/java/org/apache/sysds/runtime/iogen/ValueTrimFormat.java
@@ -73,7 +73,7 @@ public ValueTrimFormat(int colIndex, Types.ValueType vt, Object o) {
 				s.append(c);
 			NString = s.toString();
 		}
-		else if(vt != Types.ValueType.STRING && vt != Types.ValueType.BOOLEAN) {
+		else if(vt != Types.ValueType.STRING && vt != Types.ValueType.BITSET) {
 			throw new RuntimeException("Don't support  value type format!");
 		}
 	}
@@ -132,7 +132,7 @@ public boolean isNotSet() {
 			return actualValue == null || ((String) actualValue).length() == 0;
 		else if(this.valueType.isNumeric())
 			return getDoubleActualValue() == 0;
-		else if(this.valueType == Types.ValueType.BOOLEAN)
+		else if(this.valueType == Types.ValueType.BITSET)
 			return actualValue == null || !((Boolean) actualValue);
 		return true;
 	}
@@ -147,7 +147,7 @@ else if(this.valueType.isNumeric()) {
 			N = new char[] {'0'};
 			NString = null;
 		}
-		else if(this.valueType == Types.ValueType.BOOLEAN)
+		else if(this.valueType == Types.ValueType.BITSET)
 			actualValue = null;
 	}
 
@@ -173,7 +173,7 @@ private static int getLength(ValueTrimFormat vtf) {
 		int len = -1;
 		if(vt == Types.ValueType.STRING )
 			len = vtf.getStringOfActualValue().length();
-		else if(vt == Types.ValueType.BOOLEAN)
+		else if(vt == Types.ValueType.BITSET)
 			len = 1;
 		return len;
 	}
diff --git a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
index 554b9eb5e39..5392564423d 100644
--- a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
+++ b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
@@ -30,7 +30,6 @@
 import org.apache.commons.lang.NotImplementedException;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.apache.sysds.common.Types;
 import org.apache.sysds.runtime.DMLRuntimeException;
 import org.apache.sysds.runtime.data.*;
 import org.apache.sysds.runtime.functionobjects.*;
@@ -1403,9 +1402,9 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 			//general case
 			else {
 				// if ValueFunction is comparison, return matrix is true boolean and boolean arithmetics are activated, use boolean arithmetics
-				if (op.fn instanceof ValueComparisonFunction &&	ret.denseBlock != null && (ret.getDenseBlock() instanceof DenseBlockTrueBool || ret.getDenseBlock() instanceof DenseBlockBool) ){
+				if (op.fn instanceof ValueComparisonFunction &&	ret.denseBlock != null && (ret.getDenseBlock() instanceof DenseBlockBoolArray || ret.getDenseBlock() instanceof DenseBlockBoolBitset) ){
 					//TODO: Optimize casting to boolean denseblock types :/
-					if(ret.getDenseBlock() instanceof DenseBlockTrueBool){
+					if(ret.getDenseBlock() instanceof DenseBlockBoolArray){
 						for(int r=rl; r<ru; r++)
 							for(int c=0; c<clen; c++) {
 								double v1 = m1.quickGetValue(r, c);
@@ -1414,7 +1413,7 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 
 								//react what is happening in appendValuePlain()
 								ret.allocateDenseBlock(false);
-								((DenseBlockTrueBool) ret.getDenseBlock()).set(r,c,vb);
+								((DenseBlockBoolArray) ret.getDenseBlock()).set(r,c,vb);
 								lnnz += vb ? 1 : 0;
 							}
 					} else {
@@ -1426,7 +1425,7 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 
 								//react what is happening in appendValuePlain()
 								ret.allocateDenseBlock(false);
-								((DenseBlockBool) ret.getDenseBlock()).set(r,c,vb);
+								((DenseBlockBoolBitset) ret.getDenseBlock()).set(r,c,vb);
 								lnnz += vb ? 1 : 0;
 							}
 					}
diff --git a/src/main/java/org/apache/sysds/runtime/util/DataConverter.java b/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
index 899ef0ae153..364d3cef1c9 100644
--- a/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
+++ b/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
@@ -1124,7 +1124,7 @@ private static void concatenateTensorValue(TensorBlock tb, StringBuilder sb, Dec
 			case INT64:
 				sb.append(tb.get(ix));
 				break;
-			case BOOLEAN:
+			case BITSET:
 				sb.append(((Boolean) tb.get(ix)).toString().toUpperCase());
 				break;
 			case STRING:
@@ -1190,7 +1190,7 @@ public static String toString(FrameBlock fb, boolean sparse, String separator, S
 					sb.append(String.valueOf(row[j]));
 				else if( fb.getSchema()[j] == ValueType.FP64 )
 					sb.append(dfFormat(df, (Double)row[j]));
-				else if( fb.getSchema()[j] == ValueType.BOOLEAN )
+				else if( fb.getSchema()[j] == ValueType.BITSET)
 					sb.append(new BooleanObject((Boolean)row[j])
 						.getLanguageSpecificStringValue());
 				else
diff --git a/src/main/java/org/apache/sysds/runtime/util/HDFSTool.java b/src/main/java/org/apache/sysds/runtime/util/HDFSTool.java
index 58452b9c9a3..7b8373ec09f 100644
--- a/src/main/java/org/apache/sysds/runtime/util/HDFSTool.java
+++ b/src/main/java/org/apache/sysds/runtime/util/HDFSTool.java
@@ -280,7 +280,7 @@ public static long readIntegerFromHDFSFile(String filename) throws IOException {
 	}
 	
 	public static boolean readBooleanFromHDFSFile(String filename) throws IOException {
-		return (Boolean)readObjectFromHDFSFile(filename, ValueType.BOOLEAN);
+		return (Boolean)readObjectFromHDFSFile(filename, ValueType.BITSET);
 	}
 	
 	public static String readStringFromHDFSFile(String filename) 
@@ -309,7 +309,7 @@ public static Object readObjectFromHDFSFile(String filename, ValueType vt) throw
 			throw new IOException("Empty file on hdfs: "+filename);
 		
 		switch( vt ) {
-			case BOOLEAN: return Boolean.parseBoolean(line);
+			case BITSET: return Boolean.parseBoolean(line);
 			case FP64: return Double.parseDouble(line);
 			case INT64: return Long.parseLong(line);
 			default: return line;
@@ -322,7 +322,7 @@ public static ScalarObject readScalarObjectFromHDFSFile(String fname, ValueType
 			switch( vt ) {
 				case INT64:   obj = readIntegerFromHDFSFile(fname); break;
 				case FP64:    obj = readDoubleFromHDFSFile(fname); break;
-				case BOOLEAN: obj = readBooleanFromHDFSFile(fname); break;
+				case BITSET: obj = readBooleanFromHDFSFile(fname); break;
 				case STRING:
 				default:      obj = readStringFromHDFSFile(fname);
 			}
diff --git a/src/main/java/org/apache/sysds/runtime/util/ProgramConverter.java b/src/main/java/org/apache/sysds/runtime/util/ProgramConverter.java
index 8fbfe311259..05412a9edd9 100644
--- a/src/main/java/org/apache/sysds/runtime/util/ProgramConverter.java
+++ b/src/main/java/org/apache/sysds/runtime/util/ProgramConverter.java
@@ -1653,7 +1653,7 @@ public static Object[] parseDataObject(String in) {
 				switch ( valuetype ) {
 					case INT64:     dat = new IntObject(Long.parseLong(valString)); break;
 					case FP64:  dat = new DoubleObject(Double.parseDouble(valString)); break;
-					case BOOLEAN: dat = new BooleanObject(Boolean.parseBoolean(valString)); break;
+					case BITSET: dat = new BooleanObject(Boolean.parseBoolean(valString)); break;
 					case STRING:  dat = new StringObject(valString); break;
 					default:
 						throw new DMLRuntimeException("Unable to parse valuetype "+valuetype);
diff --git a/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java b/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
index 0da92cfa5f6..6578ec39e40 100644
--- a/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
+++ b/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
@@ -471,7 +471,7 @@ public static Object doubleToObject(ValueType vt, double in, boolean sparse) {
 		if( Double.isNaN(in) && sparse) return null;
 		switch( vt ) {
 			case STRING:  return String.valueOf(in);
-			case BOOLEAN: return (in!=0);
+			case BITSET: return (in!=0);
 			case INT32:   return UtilFunctions.toInt(in);
 			case INT64:   return UtilFunctions.toLong(in);
 			case FP32:    return ((float)in);
@@ -484,7 +484,7 @@ public static Object stringToObject(ValueType vt, String in) {
 		if( in == null || in.isEmpty() )  return null;
 		switch( vt ) {
 			case STRING:  return in;
-			case BOOLEAN: return Boolean.parseBoolean(in);
+			case BITSET: return Boolean.parseBoolean(in);
 			case UINT4:
 			case UINT8:
 			case INT32:   return Integer.parseInt(in);
@@ -511,7 +511,7 @@ public static double objectToDouble(ValueType vt, Object in) {
 			case FP32:    return (Float)in;
 			case INT64:   return (Long)in;
 			case INT32:   return (Integer)in;
-			case BOOLEAN: return ((Boolean)in) ? 1 : 0;
+			case BITSET: return ((Boolean)in) ? 1 : 0;
 			case STRING:
 				try {
 					return !((String) in).isEmpty() ? Double.parseDouble((String) in) : 0;
@@ -541,7 +541,7 @@ public static float objectToFloat(ValueType vt, Object in) {
 				return (Long) in;
 			case INT32:
 				return (Integer) in;
-			case BOOLEAN:
+			case BITSET:
 				return ((Boolean) in) ? 1 : 0;
 			case STRING:
 				return !((String) in).isEmpty() ? Float.parseFloat((String) in) : 0;
@@ -559,7 +559,7 @@ public static char objectToCharacter(ValueType vt, Object in){
 			case INT64:
 			case INT32:
 				return in.toString().charAt(0);
-			case BOOLEAN:
+			case BITSET:
 				return ((Boolean) in) ? '1' : '0';
 			case STRING:
 				return !((String) in).isEmpty() ? ((String)in).charAt(0) : 0;
@@ -580,7 +580,7 @@ public static int objectToInteger(ValueType vt, Object in) {
 				return ((Long) in).intValue();
 			case INT32:
 				return (Integer) in;
-			case BOOLEAN:
+			case BITSET:
 				return ((Boolean) in) ? 1 : 0;
 			case STRING:
 				return !((String) in).isEmpty() ? Integer.parseInt((String) in) : 0;
@@ -601,7 +601,7 @@ public static long objectToLong(ValueType vt, Object in) {
 				return (Long) in;
 			case INT32:
 				return (Integer) in;
-			case BOOLEAN:
+			case BITSET:
 				return ((Boolean) in) ? 1 : 0;
 			case STRING:
 				return !((String) in).isEmpty() ? Long.parseLong((String) in) : 0;
@@ -622,7 +622,7 @@ public static boolean objectToBoolean(ValueType vt, Object in) {
 				return (Long) in == 1;
 			case INT32:
 				return (Integer) in == 1;
-			case BOOLEAN:
+			case BITSET:
 				return ((Boolean) in);
 			case STRING:
 				return Boolean.parseBoolean((String) in);
@@ -669,7 +669,7 @@ public static Object objectToObject(ValueType vt, Object in) {
 			|| in instanceof Float && vt == ValueType.FP32
 			|| in instanceof Long && vt == ValueType.INT64
 			|| in instanceof Integer && vt == ValueType.INT32
-			|| in instanceof Boolean && vt == ValueType.BOOLEAN
+			|| in instanceof Boolean && vt == ValueType.BITSET
 			|| in instanceof String && vt == ValueType.STRING )
 			return in; //quick path to avoid double parsing
 		else
@@ -691,7 +691,7 @@ public static int compareTo(ValueType vt, Object in1, Object in2) {
  
 		switch( vt ) {
 			case STRING:  return ((String)in1).compareTo((String)in2);
-			case BOOLEAN: return ((Boolean)in1).compareTo((Boolean)in2);
+			case BITSET: return ((Boolean)in1).compareTo((Boolean)in2);
 			case INT64:   return ((Long)in1).compareTo((Long)in2);
 			case INT32:   return ((Integer)in1).compareTo((Integer)in2);
 			case FP64:    return ((Double)in1).compareTo((Double)in2);
@@ -1264,7 +1264,7 @@ public static Object generateRandomValueFromValueType(ValueType valueType, Rando
 			case FP64:    return random.nextDouble();
 			case INT32:   return random.nextInt();
 			case INT64:   return random.nextLong();
-			case BOOLEAN: return random.nextBoolean();
+			case BITSET: return random.nextBoolean();
 			case STRING:
 				return random.ints('a', 'z' + 1).limit(10)
 					.collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
@@ -1294,7 +1294,7 @@ else if (schemaValues[i].equalsIgnoreCase("INT64"))
 			else if (schemaValues[i].equalsIgnoreCase("INT32"))
 				vt[i] = ValueType.INT32;
 			else if (schemaValues[i].equalsIgnoreCase("BOOLEAN"))
-				vt[i] = ValueType.BOOLEAN;
+				vt[i] = ValueType.BITSET;
 			else
 				throw new DMLRuntimeException("Invalid column schema. Allowed values are STRING, FP64, FP32, INT64, INT32 and Boolean");
 		}
diff --git a/src/test/java/org/apache/sysds/test/TestUtils.java b/src/test/java/org/apache/sysds/test/TestUtils.java
index ae68201b508..586ab4f2bc0 100644
--- a/src/test/java/org/apache/sysds/test/TestUtils.java
+++ b/src/test/java/org/apache/sysds/test/TestUtils.java
@@ -1607,7 +1607,7 @@ public static int compareTo(ValueType vt, Object in1, Object in2, double toleran
 
 		switch( vt ) {
 			case STRING:  return ((String)in1).compareTo((String)in2);
-			case BOOLEAN: return ((Boolean)in1).compareTo((Boolean)in2);
+			case BITSET: return ((Boolean)in1).compareTo((Boolean)in2);
 			case INT64:     return ((Long)in1).compareTo((Long)in2);
 			case FP64:
 				return (Math.abs((Double)in1-(Double)in2) < tolerance)?0:
@@ -1625,7 +1625,7 @@ public static int compareToR(ValueType vt, Object in1, Object inR, double tolera
 				if (in1 == null)
 					throw new DMLRuntimeException("Fail");
 			 	return ((String)in1).compareTo((String)inR);
-			case BOOLEAN:
+			case BITSET:
 				if(in1 == null)
 					return Boolean.FALSE.compareTo(((Boolean)inR).booleanValue());
 				else
@@ -2256,7 +2256,7 @@ public static FrameBlock generateRandomFrameBlock(int rows, ValueType[] schema,
 	private static Array<?> generateColumn(int rows, ValueType type, Random rand, double nullChance) {
 		if(nullChance == 0) {
 			switch(type) {
-				case BOOLEAN:
+				case BITSET:
 					Array<Boolean> a = (Array<Boolean>) ArrayFactory.allocate(type, rows);
 					for(int r = 0; r < rows; r++)
 						a.set(r, rand.nextBoolean());
@@ -2305,7 +2305,7 @@ private static Array<?> generateColumn(int rows, ValueType type, Random rand, do
 		}
 		else {
 			switch(type) {
-				case BOOLEAN:
+				case BITSET:
 					OptionalArray<Boolean> a = (OptionalArray<Boolean>) ArrayFactory.allocateOptional(type, rows);
 					for(int r = 0; r < rows; r++) {
 						if(rand.nextDouble() < nullChance)
@@ -2541,7 +2541,7 @@ public static Object generateRandomValueFromValueType(ValueType valueType, Rando
 			case FP64:    return random.nextDouble();
 			case INT32:   return random.nextInt();
 			case INT64:   return random.nextLong();
-			case BOOLEAN: return random.nextBoolean();
+			case BITSET: return random.nextBoolean();
 			case STRING:
 				return random.ints('a', 'z' + 1)
 						.limit(10)
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameAppendTest_Old.java b/src/test/java/org/apache/sysds/test/component/frame/FrameAppendTest_Old.java
index 9d0339d2b30..d3bbd3cf155 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameAppendTest_Old.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameAppendTest_Old.java
@@ -35,7 +35,7 @@ public class FrameAppendTest_Old extends AutomatedTestBase {
 	private final static ValueType[] schemaStrings = new ValueType[] {ValueType.STRING, ValueType.STRING,
 		ValueType.STRING};
 	private final static ValueType[] schemaMixed = new ValueType[] {ValueType.STRING, ValueType.FP64, ValueType.INT64,
-		ValueType.BOOLEAN};
+		ValueType.BITSET};
 
 	@Override
 	public void setUp() {
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameApplySchema.java b/src/test/java/org/apache/sysds/test/component/frame/FrameApplySchema.java
index 388c41a820f..d725ab868b9 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameApplySchema.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameApplySchema.java
@@ -38,10 +38,10 @@ public void testApplySchemaStringToBoolean() {
 		try {
 
 			FrameBlock fb = genStringContainingBoolean(10, 2);
-			ValueType[] schema = new ValueType[] {ValueType.BOOLEAN, ValueType.BOOLEAN};
+			ValueType[] schema = new ValueType[] {ValueType.BITSET, ValueType.BITSET};
 			FrameBlock ret = FrameLibApplySchema.applySchema(fb, schema);
-			assertTrue(ret.getColumn(0).getValueType() == ValueType.BOOLEAN);
-			assertTrue(ret.getColumn(1).getValueType() == ValueType.BOOLEAN);
+			assertTrue(ret.getColumn(0).getValueType() == ValueType.BITSET);
+			assertTrue(ret.getColumn(1).getValueType() == ValueType.BITSET);
 		}
 		catch(Exception e) {
 			e.printStackTrace();
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameCastingTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameCastingTest.java
index c26ab71e2ec..2670ddaf3ad 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameCastingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameCastingTest.java
@@ -33,7 +33,7 @@ public class FrameCastingTest extends AutomatedTestBase
 {
 	private final static int rows = 312;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};	
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 	
 	private enum CastType {
 		M2F_S,
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameCopyTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameCopyTest.java
index 5d22dab36e5..27da3944fe9 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameCopyTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameCopyTest.java
@@ -32,7 +32,7 @@ public class FrameCopyTest extends AutomatedTestBase
 {
 	private final static int rows = 342;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};	
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 	
 	@Override
 	public void setUp() {
@@ -137,7 +137,7 @@ void updateFrameWithDummyData(FrameBlock frame, int updateRow)
 		for( int j=0; j<lschema.length; j++ )	{
 			switch( lschema[j] ) {
 				case STRING:  frame.set(updateRow,  j,  "String:"+ frame.get(updateRow, j)); break;
-				case BOOLEAN: frame.set(updateRow,  j, ((Boolean)frame.get(updateRow, j))?Boolean.FALSE:Boolean.TRUE); break;
+				case BITSET: frame.set(updateRow,  j, ((Boolean)frame.get(updateRow, j))?Boolean.FALSE:Boolean.TRUE); break;
 				case INT64:     frame.set(updateRow,  j, (Long)frame.get(updateRow, j) * 2 + 5); break;
 				case FP64:  frame.set(updateRow,  j, (Double)frame.get(updateRow, j) * 2 + 7); break;
 				default: throw new RuntimeException("Unsupported value type: "+lschema[j]);
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameEvictionTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameEvictionTest.java
index d158d7f9c1f..d75b583c851 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameEvictionTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameEvictionTest.java
@@ -46,7 +46,7 @@ public class FrameEvictionTest extends AutomatedTestBase
 	
 	private final static ValueType[] schemaDoubles = new ValueType[]{ValueType.FP64, ValueType.FP64, ValueType.FP64};	
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};	
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 	
 	@Override
 	public void setUp() {
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameFromMatrixBlockTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameFromMatrixBlockTest.java
index 76c71973222..5a8eca4c262 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameFromMatrixBlockTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameFromMatrixBlockTest.java
@@ -40,8 +40,8 @@ public class FrameFromMatrixBlockTest {
 	public void toBoolean() {
 		try {
 			MatrixBlock mb = new MatrixBlock(10, 3, 1.0);
-			FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
-			verifyEquivalence(mb, fb, ValueType.BOOLEAN);
+			FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
+			verifyEquivalence(mb, fb, ValueType.BITSET);
 		}
 		catch(Exception e) {
 			e.printStackTrace();
@@ -52,22 +52,22 @@ public void toBoolean() {
 	@Test
 	public void toBooleanEmpty() {
 		MatrixBlock mb = new MatrixBlock(10, 3, 0.0);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
-		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
+		verifyEquivalence(mb, fb, ValueType.BITSET);
 	}
 
 	@Test
 	public void toBooleanSparse() {
 		MatrixBlock mb = TestUtils.generateTestMatrixBlock(100, 100, 1, 1, 0.2, 213);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
-		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
+		verifyEquivalence(mb, fb, ValueType.BITSET);
 	}
 
 	@Test
 	public void toBooleanVerySparse() {
 		MatrixBlock mb = TestUtils.generateTestMatrixBlock(100, 100, 1, 1, 0.001, 213);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
-		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
+		verifyEquivalence(mb, fb, ValueType.BITSET);
 	}
 
 	@Test
@@ -80,8 +80,8 @@ public void singleColShortcut() {
 	@Test
 	public void singleColShortcutToBoolean() {
 		MatrixBlock mb = TestUtils.generateTestMatrixBlock(100, 1, 1, 1, 0.2, 213);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
-		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
+		verifyEquivalence(mb, fb, ValueType.BITSET);
 	}
 
 	@Test
@@ -101,8 +101,8 @@ public void toFloatDenseParallel() {
 	@Test
 	public void toBooleanDenseParallel() {
 		MatrixBlock mb = TestUtils.generateTestMatrixBlock(1000, 100, 1, 1, 0.5, 213);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 4);
-		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 4);
+		verifyEquivalence(mb, fb, ValueType.BITSET);
 	}
 
 	@Test
@@ -122,8 +122,8 @@ public void toFloatDenseMultiBlockParallel() {
 	@Test
 	public void toBooleanDenseMultiBlock() {
 		MatrixBlock mb = mock(TestUtils.generateTestMatrixBlock(100, 10, 1, 1, 0.7, 213));
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
-		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
+		verifyEquivalence(mb, fb, ValueType.BITSET);
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameGetSetTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameGetSetTest.java
index 63f617711a2..f42f23da98c 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameGetSetTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameGetSetTest.java
@@ -31,7 +31,7 @@ public class FrameGetSetTest extends AutomatedTestBase
 {
 	private final static int rows = 131;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};	
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 	
 	private enum InitType {
 		COLUMN,
@@ -103,7 +103,7 @@ private void runFrameGetSetTest( ValueType[] schema, InitType itype)
 								tmp1[i] = (String)UtilFunctions.doubleToObject(vt, A[i][j]);
 							frame.appendColumn(tmp1);
 							break;
-						case BOOLEAN:
+						case BITSET:
 							boolean[] tmp2 = new boolean[rows];
 							for( int i=0; i<rows; i++ )
 								A[i][j] = (tmp2[i] = (Boolean)UtilFunctions.doubleToObject(vt, A[i][j], false))?1:0;
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameIndexingTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameIndexingTest.java
index a2bd67c8033..8d21b162eac 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameIndexingTest.java
@@ -39,7 +39,7 @@ public class FrameIndexingTest extends AutomatedTestBase
 	private final static int cu = 2;
 	
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};	
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 	
 	private enum IXType {
 		RIX,
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameSerializationTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameSerializationTest.java
index acb6b8cf3ea..809ce0074ef 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameSerializationTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameSerializationTest.java
@@ -56,7 +56,7 @@ public static Collection<Object[]> data() {
 		ArrayList<Object[]> tests = new ArrayList<>();
 
 		ValueType[] schemaStrings = new ValueType[] {ValueType.STRING, ValueType.STRING, ValueType.STRING};
-		ValueType[] schemaMixed = new ValueType[] {ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
+		ValueType[] schemaMixed = new ValueType[] {ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 		ValueType[] rand = TestUtils.generateRandomSchema(10, 3);
 		ValueType[] rand2 = TestUtils.generateRandomSchema(10, 4);
 		try {
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameTest.java
index ce76f6a13a8..73e86b58d1c 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameTest.java
@@ -210,7 +210,7 @@ public void cBindStringCol() {
 
 	@Test
 	public void rBindZeros() {
-		ValueType[] bools = UtilFunctions.nCopies(f.getNumColumns(), ValueType.BOOLEAN);
+		ValueType[] bools = UtilFunctions.nCopies(f.getNumColumns(), ValueType.BITSET);
 		FrameBlock b = new FrameBlock(bools, "0", 10);
 
 		FrameBlock ff = append(b, f, false);
@@ -232,7 +232,7 @@ public void rBindZeros() {
 
 	@Test
 	public void rBindZerosMany() {
-		ValueType[] bools = UtilFunctions.nCopies(f.getNumColumns(), ValueType.BOOLEAN);
+		ValueType[] bools = UtilFunctions.nCopies(f.getNumColumns(), ValueType.BITSET);
 		FrameBlock b = new FrameBlock(bools, "0", 240);
 		FrameBlock ff = append(b, f, false);
 		for(int r = 0; r < 240; r++)
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameUtilTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameUtilTest.java
index 8f4fb790aa8..8582558d96d 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameUtilTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameUtilTest.java
@@ -59,42 +59,42 @@ public void testIsTypeMinimumFloat_6() {
 
 	@Test
 	public void testIsTypeMinimumBoolean_1() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("TRUE", ValueType.UNKNOWN));
+		assertEquals(ValueType.BITSET, FrameUtil.isType("TRUE", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_2() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("True", ValueType.UNKNOWN));
+		assertEquals(ValueType.BITSET, FrameUtil.isType("True", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_3() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("true", ValueType.UNKNOWN));
+		assertEquals(ValueType.BITSET, FrameUtil.isType("true", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_4() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("t", ValueType.UNKNOWN));
+		assertEquals(ValueType.BITSET, FrameUtil.isType("t", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_5() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("f", ValueType.UNKNOWN));
+		assertEquals(ValueType.BITSET, FrameUtil.isType("f", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_6() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("false", ValueType.UNKNOWN));
+		assertEquals(ValueType.BITSET, FrameUtil.isType("false", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_7() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("False", ValueType.UNKNOWN));
+		assertEquals(ValueType.BITSET, FrameUtil.isType("False", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_8() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("FALSE", ValueType.UNKNOWN));
+		assertEquals(ValueType.BITSET, FrameUtil.isType("FALSE", ValueType.UNKNOWN));
 	}
 
 	@Test
@@ -207,12 +207,12 @@ public void testCharacter_2() {
 
 	@Test
 	public void testDoubleIsType_1() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType(0.0));
+		assertEquals(ValueType.BITSET, FrameUtil.isType(0.0));
 	}
 
 	@Test
 	public void testDoubleIsType_2() {
-		assertEquals(ValueType.BOOLEAN, FrameUtil.isType(1.0));
+		assertEquals(ValueType.BITSET, FrameUtil.isType(1.0));
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/component/frame/array/CustomArrayTests.java b/src/test/java/org/apache/sysds/test/component/frame/array/CustomArrayTests.java
index 2bbd7f8515e..770a735778c 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/array/CustomArrayTests.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/array/CustomArrayTests.java
@@ -111,7 +111,7 @@ public void changeTypeLong() {
 	@Test
 	public void changeTypeBoolean1() {
 		StringArray a = ArrayFactory.create(new String[] {"1", "0", "0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -120,7 +120,7 @@ public void changeTypeBoolean1() {
 	@Test
 	public void changeTypeBoolean2() {
 		StringArray a = ArrayFactory.create(new String[] {"1.0", "0.0", "0.0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -129,7 +129,7 @@ public void changeTypeBoolean2() {
 	@Test
 	public void changeTypeBoolean3() {
 		StringArray a = ArrayFactory.create(new String[] {"1", null, "0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -138,7 +138,7 @@ public void changeTypeBoolean3() {
 	@Test
 	public void changeTypeBoolean4() {
 		StringArray a = ArrayFactory.create(new String[] {"1.0", null, "0.0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -147,7 +147,7 @@ public void changeTypeBoolean4() {
 	@Test
 	public void changeTypeBoolean5() {
 		StringArray a = ArrayFactory.create(new String[] {"t", null, "f"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -156,7 +156,7 @@ public void changeTypeBoolean5() {
 	@Test
 	public void changeTypeBoolean6() {
 		StringArray a = ArrayFactory.create(new String[] {"true", null, "false"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -165,7 +165,7 @@ public void changeTypeBoolean6() {
 	@Test
 	public void changeTypeBoolean7() {
 		StringArray a = ArrayFactory.create(new String[] {"True", null, "False"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -174,7 +174,7 @@ public void changeTypeBoolean7() {
 	@Test
 	public void changeTypeBoolean8() {
 		StringArray a = ArrayFactory.create(new String[] {"0.0", null, "1.0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
 		assertTrue(!ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(ai.get(2));
@@ -184,28 +184,28 @@ public void changeTypeBoolean8() {
 	public void analyzeValueTypeStringBoolean() {
 		StringArray a = ArrayFactory.create(new String[] {"1", "0", "0"});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BOOLEAN, t);
+		assertEquals(ValueType.BITSET, t);
 	}
 
 	@Test
 	public void analyzeValueTypeStringBoolean_withPointZero() {
 		StringArray a = ArrayFactory.create(new String[] {"1.0", "0", "0"});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BOOLEAN, t);
+		assertEquals(ValueType.BITSET, t);
 	}
 
 	@Test
 	public void analyzeValueTypeStringBoolean_withPointZero_2() {
 		StringArray a = ArrayFactory.create(new String[] {"1.00", "0", "0"});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BOOLEAN, t);
+		assertEquals(ValueType.BITSET, t);
 	}
 
 	@Test
 	public void analyzeValueTypeStringBoolean_withPointZero_3() {
 		StringArray a = ArrayFactory.create(new String[] {"1.00000000000", "0", "0"});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BOOLEAN, t);
+		assertEquals(ValueType.BITSET, t);
 	}
 
 	@Test
@@ -360,7 +360,7 @@ public void analyzeValueTypeDouble6() {
 	public void analyzeValueTypeDouble7() {
 		DoubleArray a = ArrayFactory.create(new double[] {1.0d, 0.0d, 1.0d});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BOOLEAN, t);
+		assertEquals(ValueType.BITSET, t);
 	}
 
 	@Test
@@ -1028,14 +1028,14 @@ public void optionalSetRange() {
 
 	@Test
 	public void optionalChangeToBoolean() {
-		Array<?> a = new OptionalArray<>(new Double[3]).changeTypeWithNulls(ValueType.BOOLEAN);
+		Array<?> a = new OptionalArray<>(new Double[3]).changeTypeWithNulls(ValueType.BITSET);
 		for(int i = 0; i < a.size(); i++)
 			assertEquals(null, a.get(i));
 	}
 
 	@Test
 	public void optionalChangeToBoolean2() {
-		Array<?> a = new OptionalArray<>(new Double[] {1.0, null, null}).changeTypeWithNulls(ValueType.BOOLEAN);
+		Array<?> a = new OptionalArray<>(new Double[] {1.0, null, null}).changeTypeWithNulls(ValueType.BITSET);
 		assertEquals(true, a.get(0));
 		for(int i = 1; i < a.size(); i++)
 			assertEquals(null, a.get(i));
@@ -1043,7 +1043,7 @@ public void optionalChangeToBoolean2() {
 
 	@Test
 	public void optionalChangeToBoolean3() {
-		Array<?> a = new OptionalArray<>(new Double[67]).changeTypeWithNulls(ValueType.BOOLEAN);
+		Array<?> a = new OptionalArray<>(new Double[67]).changeTypeWithNulls(ValueType.BITSET);
 		a.set(0, "true");
 		a.set(a.size() - 1, "true");
 		assertEquals(true, a.get(0));
@@ -1072,7 +1072,7 @@ public void isEmptyBitSet() {
 
 	@Test
 	public void changeTypeBitSet() {
-		Array<?> a = new OptionalArray<>(new Character[324]).changeType(ValueType.BOOLEAN);
+		Array<?> a = new OptionalArray<>(new Character[324]).changeType(ValueType.BITSET);
 		assertTrue(a.isEmpty());
 	}
 
@@ -1147,7 +1147,7 @@ public void changeTypeNullsFromStringToCharacter() {
 	@Test
 	public void changeTypeNullsFromStringToBoolean() {
 		Array<?> a = new StringArray(new String[] {"1", null});
-		Array<?> b = a.changeTypeWithNulls(ValueType.BOOLEAN);
+		Array<?> b = a.changeTypeWithNulls(ValueType.BITSET);
 		assertEquals(true, b.get(0));
 		assertEquals(null, b.get(1));
 	}
diff --git a/src/test/java/org/apache/sysds/test/component/frame/array/NegativeArrayTests.java b/src/test/java/org/apache/sysds/test/component/frame/array/NegativeArrayTests.java
index 61442cdd0f4..b7609ad61ca 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/array/NegativeArrayTests.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/array/NegativeArrayTests.java
@@ -92,19 +92,19 @@ public void getMinMax() {
 	@Test(expected = DMLRuntimeException.class)
 	public void changeTypeBoolean_1() {
 		StringArray a = ArrayFactory.create(new String[] {"1", "10", "0"});
-		a.changeType(ValueType.BOOLEAN);
+		a.changeType(ValueType.BITSET);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
 	public void changeTypeBoolean_2() {
 		StringArray a = ArrayFactory.create(new String[] {"1", "-1", "0"});
-		a.changeType(ValueType.BOOLEAN);
+		a.changeType(ValueType.BITSET);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
 	public void changeTypeBoolean_3() {
 		StringArray a = ArrayFactory.create(new String[] {"HI", "false", "0"});
-		a.changeType(ValueType.BOOLEAN);
+		a.changeType(ValueType.BITSET);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
@@ -113,13 +113,13 @@ public void changeTypeBoolean_4() {
 		s[0] = "1";
 		s[1] = "10";
 		StringArray a = ArrayFactory.create(s);
-		a.changeType(ValueType.BOOLEAN);
+		a.changeType(ValueType.BITSET);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
 	public void changeTypeBoolean_5() {
 		StringArray a = ArrayFactory.create(new String[] {"0.0", null, "1.1"});
-		a.changeType(ValueType.BOOLEAN);
+		a.changeType(ValueType.BITSET);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
@@ -128,7 +128,7 @@ public void changeTypeBoolean_6() {
 		s[0] = "1.0";
 		s[1] = "1.2";
 		StringArray a = ArrayFactory.create(s);
-		a.changeType(ValueType.BOOLEAN);
+		a.changeType(ValueType.BITSET);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
diff --git a/src/test/java/org/apache/sysds/test/component/frame/transform/TransformCompressedTestMultiCol.java b/src/test/java/org/apache/sysds/test/component/frame/transform/TransformCompressedTestMultiCol.java
index a592fc74778..5802240c59c 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/transform/TransformCompressedTestMultiCol.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/transform/TransformCompressedTestMultiCol.java
@@ -58,22 +58,22 @@ public static Collection<Object[]> data() {
 
 			ValueType[] kPlusCols = new ValueType[1002];
 
-			Arrays.fill(kPlusCols, ValueType.BOOLEAN);
+			Arrays.fill(kPlusCols, ValueType.BITSET);
 
 			FrameBlock[] blocks = new FrameBlock[] {//
 				TestUtils.generateRandomFrameBlock(100, //
 					new ValueType[] {ValueType.UINT4, ValueType.UINT8, ValueType.UINT4}, 231), //
 				TestUtils.generateRandomFrameBlock(100, //
-					new ValueType[] {ValueType.BOOLEAN, ValueType.UINT8, ValueType.UINT4}, 231), //
-				new FrameBlock(new ValueType[] {ValueType.BOOLEAN, ValueType.INT32, ValueType.INT32}, 100), //
+					new ValueType[] {ValueType.BITSET, ValueType.UINT8, ValueType.UINT4}, 231), //
+				new FrameBlock(new ValueType[] {ValueType.BITSET, ValueType.INT32, ValueType.INT32}, 100), //
 				TestUtils.generateRandomFrameBlock(100, //
-					new ValueType[] {ValueType.UINT4, ValueType.BOOLEAN, ValueType.FP32}, 231, 0.2),
+					new ValueType[] {ValueType.UINT4, ValueType.BITSET, ValueType.FP32}, 231, 0.2),
 				TestUtils.generateRandomFrameBlock(432, //
-					new ValueType[] {ValueType.UINT4, ValueType.BOOLEAN, ValueType.FP32}, 231, 0.2),
+					new ValueType[] {ValueType.UINT4, ValueType.BITSET, ValueType.FP32}, 231, 0.2),
 				TestUtils.generateRandomFrameBlock(100, //
-					new ValueType[] {ValueType.UINT4, ValueType.BOOLEAN, ValueType.FP32}, 231, 0.9),
+					new ValueType[] {ValueType.UINT4, ValueType.BITSET, ValueType.FP32}, 231, 0.9),
 				TestUtils.generateRandomFrameBlock(100, //
-					new ValueType[] {ValueType.UINT4, ValueType.BOOLEAN, ValueType.FP32}, 231, 0.99),
+					new ValueType[] {ValueType.UINT4, ValueType.BITSET, ValueType.FP32}, 231, 0.99),
 
 				TestUtils.generateRandomFrameBlock(5, kPlusCols, 322),
 				TestUtils.generateRandomFrameBlock(1020, kPlusCols, 322),
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
index 0aab6901c62..04e949c0e79 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
@@ -23,14 +23,8 @@
 
 import org.apache.commons.lang.NotImplementedException;
 import org.apache.sysds.common.Types.ValueType;
-import org.apache.sysds.runtime.data.DenseBlock;
-import org.apache.sysds.runtime.data.DenseBlockFactory;
-import org.apache.sysds.runtime.data.DenseBlockLBool;
-import org.apache.sysds.runtime.data.DenseBlockLFP32;
-import org.apache.sysds.runtime.data.DenseBlockLFP64;
-import org.apache.sysds.runtime.data.DenseBlockLInt32;
-import org.apache.sysds.runtime.data.DenseBlockLInt64;
-import org.apache.sysds.runtime.data.DenseBlockLString;
+import org.apache.sysds.runtime.data.*;
+import org.apache.sysds.runtime.data.DenseBlockLBoolBitset;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -56,7 +50,7 @@ public void testIndexDenseBlock2FP64Const() {
 	
 	@Test
 	public void testIndexDenseBlock2BoolConst() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BITSET);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -65,7 +59,7 @@ public void testIndexDenseBlock2BoolConst() {
 
 	@Test
 	public void testIndexDenseBlock2TrueBoolConst() {
-		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++) {
@@ -125,7 +119,7 @@ public void testIndexDenseBlockLarge2FP64Const() {
 
 	@Test
 	public void testIndexDenseBlockLarge2BoolConst() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -179,7 +173,7 @@ public void testIndexDenseBlock3FP64Const() {
 	
 	@Test
 	public void testIndexDenseBlock3BoolConst() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BITSET);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -189,7 +183,7 @@ public void testIndexDenseBlock3BoolConst() {
 
 	@Test
 	public void testIndexDenseBlock3TrueBoolConst() {
-		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -246,7 +240,7 @@ public void testIndexDenseBlockLarge3FP64Const() {
 
 	@Test
 	public void testIndexDenseBlockLarge3BoolConst() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -294,7 +288,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BOOLEAN: return new DenseBlockLBool(dims);
+			case BITSET: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -307,7 +301,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BOOLEAN: return new DenseBlockLBool(dims);
+			case BITSET: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
index 2bd347525ae..585db93c26a 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
@@ -60,7 +60,7 @@ public void testMetaDenseBlock2FP64() {
 	
 	@Test
 	public void testMetaDenseBlock2Bool() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BITSET);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -75,7 +75,7 @@ public void testMetaDenseBlock2Bool() {
 
 	@Test
 	public void testMetaDenseBlock2TrueBool() {
-		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -165,7 +165,7 @@ public void testMetaDenseBlockLarge2FP64() {
 
 	@Test
 	public void testMetaDenseBlockLarge2Bool() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -255,7 +255,7 @@ public void testMetaDenseBlock3FP64() {
 	
 	@Test
 	public void testMetaDenseBlock3Bool() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BITSET);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -270,7 +270,7 @@ public void testMetaDenseBlock3Bool() {
 
 	@Test
 	public void testMetaDenseBlock3TrueBool() {
-		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -360,7 +360,7 @@ public void testMetaDenseBlockLarge3FP64() {
 
 	@Test
 	public void testMetaDenseBlockLarge3Bool() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -431,7 +431,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BOOLEAN: return new DenseBlockLBool(dims);
+			case BITSET: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -444,7 +444,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BOOLEAN: return new DenseBlockLBool(dims);
+			case BITSET: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
index 53f8c4c9d47..6ad3e280c69 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
@@ -20,17 +20,11 @@
 package org.apache.sysds.test.component.tensor;
 
 import org.apache.commons.lang.NotImplementedException;
+import org.apache.sysds.runtime.data.*;
 import org.junit.Assert;
 import org.junit.Test;
 import org.apache.sysds.common.Types.ValueType;
-import org.apache.sysds.runtime.data.DenseBlock;
-import org.apache.sysds.runtime.data.DenseBlockFactory;
-import org.apache.sysds.runtime.data.DenseBlockLBool;
-import org.apache.sysds.runtime.data.DenseBlockLFP32;
-import org.apache.sysds.runtime.data.DenseBlockLFP64;
-import org.apache.sysds.runtime.data.DenseBlockLString;
-import org.apache.sysds.runtime.data.DenseBlockLInt32;
-import org.apache.sysds.runtime.data.DenseBlockLInt64;
+import org.apache.sysds.runtime.data.DenseBlockLBoolBitset;
 
 
 public class DenseBlockCountNonZeroTest {
@@ -48,13 +42,13 @@ public void testIndexDenseBlock2FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlock2BoolCountNonZero() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BITSET);
 		checkFullNnz2(db);
 	}
 
 	@Test
 	public void testIndexDenseBlock2TrueBoolCountNonZero() {
-		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkFullNnz2(db);
 	}
 
@@ -90,7 +84,7 @@ public void testIndexDenseBlockLarge2FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlockLarge2BoolCountNonZero() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
 		checkFullNnz2(db);
 	}
 
@@ -126,13 +120,13 @@ public void testIndexDenseBlock3FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlock3BoolCountNonZero() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BITSET);
 		checkFullNnz3(db);
 	}
 
 	@Test
 	public void testIndexDenseBlock3TrueBoolCountNonZero() {
-		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		checkFullNnz3(db);
 	}
 
@@ -168,7 +162,7 @@ public void testIndexDenseBlockLarge3FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlockLarge3BoolCountNonZero() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
 		checkFullNnz3(db);
 	}
 
@@ -205,8 +199,8 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BOOLEAN:
-				return new DenseBlockLBool(dims);
+			case BITSET:
+				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
 			case INT64:
@@ -225,8 +219,8 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BOOLEAN:
-				return new DenseBlockLBool(dims);
+			case BITSET:
+				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
 			case INT64:
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
index ac245de3390..e034e0bb04e 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
@@ -42,13 +42,13 @@ public void testIndexDenseBlock2FP64SetGetCell() {
 	
 	@Test
 	public void testIndexDenseBlock2BoolSetGetCell() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BITSET);
 		checkSequence(setSequence(db));
 	}
 
 	@Test
 	public void testIndexDenseBlock2TrueBoolSetGetCell() {
-		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkSequence(setSequence(db));
 	}
 	
@@ -84,7 +84,7 @@ public void testIndexDenseBlockLarge2FP64SetGetCell() {
 
 	@Test
 	public void testIndexDenseBlockLarge2BoolSetGetCell() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
 		checkSequence(setSequence(db));
 	}
 
@@ -120,13 +120,13 @@ public void testIndexDenseBlock3FP64SetGetCell() {
 	
 	@Test
 	public void testIndexDenseBlock3BoolSetGetCell() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BITSET);
 		checkSequence(setSequence(db));
 	}
 
 	@Test
 	public void testIndexDenseBlock3TrueBoolSetGetCell() {
-		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		checkSequence(setSequence(db));
 	}
 	
@@ -162,7 +162,7 @@ public void testIndexDenseBlockLarge3FP64SetGetCell() {
 
 	@Test
 	public void testIndexDenseBlockLarge3BoolSetGetCell() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
 		checkSequence(setSequence(db));
 	}
 
@@ -197,7 +197,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BOOLEAN: return new DenseBlockLBool(dims);
+			case BITSET: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -210,7 +210,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BOOLEAN: return new DenseBlockLBool(dims);
+			case BITSET: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -238,7 +238,7 @@ private static DenseBlock setSequence(DenseBlock db) {
 	}
 	
 	private static void checkSequence(DenseBlock db) {
-		boolean isBool = (db instanceof DenseBlockBool) || (db instanceof DenseBlockLBool) || (db instanceof DenseBlockTrueBool);
+		boolean isBool = (db instanceof DenseBlockBoolBitset) || (db instanceof DenseBlockLBoolBitset) || (db instanceof DenseBlockBoolArray);
 		if( db.numDims() == 3 ) {
 			int dim12 = 5*7;
 			int dim1 = 5, dim2 = 7;
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
index 08606aead0d..fcf7cd524a1 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
@@ -40,13 +40,13 @@ public void testIndexDenseBlock2FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlock2BoolCountNonZero() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BITSET);
 		checkIncrement2(db);
 	}
 
 	@Test
 	public void testIndexDenseBlock2TrueBoolCountNonZero() {
-		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkIncrement2(db);
 	}
 
@@ -85,7 +85,7 @@ public void testIndexDenseBlockLarge2FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlockLarge2BoolCountNonZero() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
 		checkIncrement2(db);
 	}
 
@@ -121,8 +121,8 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BOOLEAN:
-				return new DenseBlockLBool(dims);
+			case BITSET:
+				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
 			case INT64:
@@ -151,7 +151,7 @@ private static void checkIncrement2(DenseBlock db) {
 				db.incr(i, j, -1);
 			}
 		}
-		if (db instanceof DenseBlockBool || db instanceof DenseBlockLBool || db instanceof DenseBlockTrueBool) {
+		if (db instanceof DenseBlockBoolBitset || db instanceof DenseBlockLBoolBitset || db instanceof DenseBlockBoolArray) {
 			Assert.assertEquals(3 * 5, db.countNonZeros());
 		} else {
 			Assert.assertEquals(0, db.countNonZeros());
@@ -165,7 +165,7 @@ private static void checkIncrement2(DenseBlock db) {
 		Assert.assertEquals(3 * 5, db.countNonZeros());
 		for (int i = 0; i < 3; i++) {
 			for (int j = 0; j < 5; j++) {
-				if (db instanceof DenseBlockBool || db instanceof DenseBlockLBool || db instanceof DenseBlockTrueBool) {
+				if (db instanceof DenseBlockBoolBitset || db instanceof DenseBlockLBoolBitset || db instanceof DenseBlockBoolArray) {
 					Assert.assertEquals(1, db.get(i, j), 0);
 				} else {
 					Assert.assertEquals(10, db.get(i, j), 0);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
index c0dd918d0ca..d1cd8b57fd9 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
@@ -48,8 +48,8 @@ public void testDenseBlock2FP64SetDenseBlock() {
 
 	@Test
 	public void testDenseBlock2BoolSetDenseBlock() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
-		DenseBlock dbSet = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BITSET);
+		DenseBlock dbSet = getDenseBlock2(ValueType.BITSET);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -57,8 +57,8 @@ public void testDenseBlock2BoolSetDenseBlock() {
 
 	@Test
 	public void testDenseBlock2TrueBoolSetDenseBlock() {
-		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
-		DenseBlock dbSet = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock dbSet = getDenseBlock2(ValueType.BOOLEAN);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -115,8 +115,8 @@ public void testDenseBlockLarge2FP64SetDenseBlock() {
 
 	@Test
 	public void testDenseBlockLarge2BoolSetDenseBlock() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
-		DenseBlock dbSet = getDenseBlockLarge2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
+		DenseBlock dbSet = getDenseBlockLarge2(ValueType.BITSET);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -169,8 +169,8 @@ public void testDenseBlock3FP64SetDenseBlock() {
 
 	@Test
 	public void testDenseBlock3BoolSetDenseBlock() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
-		DenseBlock dbSet = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BITSET);
+		DenseBlock dbSet = getDenseBlock3(ValueType.BITSET);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -178,8 +178,8 @@ public void testDenseBlock3BoolSetDenseBlock() {
 
 	@Test
 	public void testDenseBlock3TrueBoolSetDenseBlock() {
-		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
-		DenseBlock dbSet = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock dbSet = getDenseBlock3(ValueType.BOOLEAN);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -232,8 +232,8 @@ public void testDenseBlockLarge3FP64SetDenseBlock() {
 
 	@Test
 	public void testDenseBlockLarge3BoolSetDenseBlock() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
-		DenseBlock dbSet = getDenseBlockLarge3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
+		DenseBlock dbSet = getDenseBlockLarge3(ValueType.BITSET);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -279,7 +279,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BOOLEAN: return new DenseBlockLBool(dims);
+			case BITSET: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -292,7 +292,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BOOLEAN: return new DenseBlockLBool(dims);
+			case BITSET: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
index df101f8bc10..424a69ecc43 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
@@ -40,13 +40,13 @@ public void testDenseBlock2FP64Row() {
 
 	@Test
 	public void testDenseBlock2BoolRow() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BITSET);
 		checkRow(setRow(db));
 	}
 
 	@Test
 	public void testDenseBlock2TrueBoolRow() {
-		DenseBlock db = getDenseBlock2(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkRow(setRow(db));
 	}
 
@@ -82,7 +82,7 @@ public void testDenseBlockLarge2FP64Row() {
 
 	@Test
 	public void testDenseBlockLarge2BoolRow() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
 		checkRow(setRow(db));
 	}
 
@@ -118,13 +118,13 @@ public void testDenseBlock3FP64Row() {
 
 	@Test
 	public void testDenseBlock3BoolRow() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BITSET);
 		checkRow(setRow(db));
 	}
 
 	@Test
 	public void testDenseBlock3TrueBoolRow() {
-		DenseBlock db = getDenseBlock3(ValueType.TRUE_BOOLEAN);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		checkRow(setRow(db));
 	}
 
@@ -160,7 +160,7 @@ public void testDenseBlockLarge3FP64Row() {
 
 	@Test
 	public void testDenseBlockLarge3BoolRow() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
 		checkRow(setRow(db));
 	}
 
@@ -197,8 +197,8 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BOOLEAN:
-				return new DenseBlockLBool(dims);
+			case BITSET:
+				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
 			case INT64:
@@ -217,8 +217,8 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BOOLEAN:
-				return new DenseBlockLBool(dims);
+			case BITSET:
+				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
 			case INT64:
@@ -250,7 +250,7 @@ private static DenseBlock setRow(DenseBlock db) {
 	}
 
 	private static void checkRow(DenseBlock db) {
-		boolean isBool = (db instanceof DenseBlockBool) || (db instanceof DenseBlockLBool) || (db instanceof DenseBlockTrueBool);
+		boolean isBool = (db instanceof DenseBlockBoolBitset) || (db instanceof DenseBlockLBoolBitset) || (db instanceof DenseBlockBoolArray);
 		if (db.numDims() == 3) {
 			int dim1 = 5, dim2 = 7;
 			for (int i = 0; i < dim1; i++)
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/TensorConstructionTest.java b/src/test/java/org/apache/sysds/test/component/tensor/TensorConstructionTest.java
index 5efe59efa49..38b9543196a 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/TensorConstructionTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/TensorConstructionTest.java
@@ -78,8 +78,8 @@ public void testMetaTypedBasicTensor2() {
 
 	@Test
 	public void testMetaTypedBasicTensor3() {
-		BasicTensorBlock tb = new BasicTensorBlock(ValueType.BOOLEAN, new int[]{11, 12}, true);
-		Assert.assertEquals(ValueType.BOOLEAN, tb.getValueType());
+		BasicTensorBlock tb = new BasicTensorBlock(ValueType.BITSET, new int[]{11, 12}, true);
+		Assert.assertEquals(ValueType.BITSET, tb.getValueType());
 		Assert.assertEquals(2, tb.getNumDims());
 		Assert.assertEquals(11, tb.getNumRows());
 		Assert.assertEquals(12, tb.getNumColumns());
@@ -136,8 +136,8 @@ public void testMetaCopyTypedBasicTensor2() {
 
 	@Test
 	public void testMetaCopyTypedBasicTensor3() {
-		BasicTensorBlock tb = new BasicTensorBlock(new BasicTensorBlock(ValueType.BOOLEAN, new int[]{11, 12}, true));
-		Assert.assertEquals(ValueType.BOOLEAN, tb.getValueType());
+		BasicTensorBlock tb = new BasicTensorBlock(new BasicTensorBlock(ValueType.BITSET, new int[]{11, 12}, true));
+		Assert.assertEquals(ValueType.BITSET, tb.getValueType());
 		Assert.assertEquals(2, tb.getNumDims());
 		Assert.assertEquals(11, tb.getNumRows());
 		Assert.assertEquals(12, tb.getNumColumns());
@@ -178,7 +178,7 @@ public void testMetaTypedDataTensor() {
 
 	@Test
 	public void testMetaSchemaTypedDataTensor() {
-		ValueType[] schema = new ValueType[] {ValueType.BOOLEAN, ValueType.INT32, ValueType.STRING};
+		ValueType[] schema = new ValueType[] {ValueType.BITSET, ValueType.INT32, ValueType.STRING};
 		DataTensorBlock tb = new DataTensorBlock(schema);
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertEquals(2, tb.getNumDims());
@@ -188,9 +188,9 @@ public void testMetaSchemaTypedDataTensor() {
 
 	@Test
 	public void testMetaNColsTypedDataTensor() {
-		DataTensorBlock tb = new DataTensorBlock(10, ValueType.BOOLEAN);
+		DataTensorBlock tb = new DataTensorBlock(10, ValueType.BITSET);
 		ValueType[] schema = new ValueType[10];
-		Arrays.fill(schema, ValueType.BOOLEAN);
+		Arrays.fill(schema, ValueType.BITSET);
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertEquals(2, tb.getNumDims());
 		Assert.assertEquals(0, tb.getNumRows());
@@ -217,7 +217,7 @@ public void testMetaCopyValueDataTensor() {
 
 	@Test
 	public void testMetaCopyTypedDataTensor() {
-		ValueType[] schema = {ValueType.INT32, ValueType.INT64, ValueType.BOOLEAN};
+		ValueType[] schema = {ValueType.INT32, ValueType.INT64, ValueType.BITSET};
 		DataTensorBlock tb = new DataTensorBlock(new DataTensorBlock(schema, new int[]{11, 3, 13}));
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertEquals(3, tb.getNumDims());
@@ -239,7 +239,7 @@ public void testMetaCopyTypedDataTensor2() {
 
 	@Test
 	public void testMetaCopyTypedDataTensor3() {
-		ValueType[] schema = {ValueType.FP64, ValueType.FP32, ValueType.INT64, ValueType.INT32, ValueType.BOOLEAN,
+		ValueType[] schema = {ValueType.FP64, ValueType.FP32, ValueType.INT64, ValueType.INT32, ValueType.BITSET,
 				ValueType.STRING};
 		DataTensorBlock tb = new DataTensorBlock(new DataTensorBlock(schema, new int[]{2, schema.length, 2}, new String[][]{
 				new String[]{"1.4", "-5.34", "4.5", "-100000.1"},
@@ -338,7 +338,7 @@ public void testMetaTypedTensorBlock() {
 
 	@Test
 	public void testMetaSchemaTypedTensorBlock() {
-		ValueType[] schema = new ValueType[] {ValueType.BOOLEAN, ValueType.INT32, ValueType.STRING};
+		ValueType[] schema = new ValueType[] {ValueType.BITSET, ValueType.INT32, ValueType.STRING};
 		TensorBlock tb = new TensorBlock(schema, new int[]{4, 3, 2});
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertNull(tb.getValueType());
@@ -403,7 +403,7 @@ public void testMetaCopyTypedTensorBlock() {
 
 	@Test
 	public void testMetaCopySchemaTypedTensorBlock() {
-		ValueType[] schema = new ValueType[] {ValueType.BOOLEAN, ValueType.INT32, ValueType.STRING};
+		ValueType[] schema = new ValueType[] {ValueType.BITSET, ValueType.INT32, ValueType.STRING};
 		TensorBlock tb = new TensorBlock(new TensorBlock(schema, new int[]{4, 3, 2}));
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertNull(tb.getValueType());
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/TensorGetSetIndexingTest.java b/src/test/java/org/apache/sysds/test/component/tensor/TensorGetSetIndexingTest.java
index ce3e56c76ef..1b500ae098b 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/TensorGetSetIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/TensorGetSetIndexingTest.java
@@ -46,7 +46,7 @@ public void testIndexBasicTensor2FP64SetGetCell() {
 
 	@Test
 	public void testIndexBasicTensor2BoolSetGetCell() {
-		TensorBlock tb = getBasicTensor2(ValueType.BOOLEAN);
+		TensorBlock tb = getBasicTensor2(ValueType.BITSET);
 		checkSequence(setSequence(tb));
 	}
 
@@ -76,7 +76,7 @@ public void testIndexBasicTensor3FP64SetGetCell() {
 
 	@Test
 	public void testIndexBasicTensor3BoolSetGetCell() {
-		TensorBlock tb = getBasicTensor3(ValueType.BOOLEAN);
+		TensorBlock tb = getBasicTensor3(ValueType.BITSET);
 		checkSequence(setSequence(tb));
 	}
 
@@ -119,7 +119,7 @@ private static TensorBlock setSequence(TensorBlock tb) {
 	}
 
 	private static void checkSequence(TensorBlock tb) {
-		boolean isBool = (tb.isBasic() ? tb.getValueType() : tb.getSchema()[0]) == ValueType.BOOLEAN;
+		boolean isBool = (tb.isBasic() ? tb.getValueType() : tb.getSchema()[0]) == ValueType.BITSET;
 		if( tb.getNumDims() == DIM0 ) {
 			int dim12 = DIM1 * DIM2;
 			for(int i=0; i<tb.getNumRows(); i++)
@@ -160,7 +160,7 @@ public void testIndexDataTensor2FP64SetGetCell() {
 
 	@Test
 	public void testIndexDataTensor2BoolSetGetCell() {
-		TensorBlock tb = getDataTensor2(ValueType.BOOLEAN);
+		TensorBlock tb = getDataTensor2(ValueType.BITSET);
 		checkSequence(setSequence(tb));
 	}
 
@@ -190,7 +190,7 @@ public void testIndexDataTensor3FP64SetGetCell() {
 
 	@Test
 	public void testIndexDataTensor3BoolSetGetCell() {
-		TensorBlock tb = getDataTensor3(ValueType.BOOLEAN);
+		TensorBlock tb = getDataTensor3(ValueType.BITSET);
 		checkSequence(setSequence(tb));
 	}
 
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/TensorSerializationTest.java b/src/test/java/org/apache/sysds/test/component/tensor/TensorSerializationTest.java
index a04edda921e..7c3f5dee9d1 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/TensorSerializationTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/TensorSerializationTest.java
@@ -54,7 +54,7 @@ public void testSerializeBasicTensorINT64() {
 	
 	@Test
 	public void testSerializeBasicTensorBoolean() {
-		testSerializeBasicTensor(ValueType.BOOLEAN);
+		testSerializeBasicTensor(ValueType.BITSET);
 	}
 
 	@Test
@@ -79,7 +79,7 @@ public void testSerializeDataTensorINT64() {
 
 	@Test
 	public void testSerializeDataTensorBoolean() {
-		testSerializeDataTensor(ValueType.BOOLEAN);
+		testSerializeDataTensor(ValueType.BITSET);
 	}
 
 	private static void testSerializeBasicTensor(ValueType vt) {
diff --git a/src/test/java/org/apache/sysds/test/functions/builtin/part1/BuiltinImputeFDTest.java b/src/test/java/org/apache/sysds/test/functions/builtin/part1/BuiltinImputeFDTest.java
index 95ebd29638c..3be499a21d5 100644
--- a/src/test/java/org/apache/sysds/test/functions/builtin/part1/BuiltinImputeFDTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/builtin/part1/BuiltinImputeFDTest.java
@@ -43,7 +43,7 @@ public class BuiltinImputeFDTest extends AutomatedTestBase {
 	private final static int cols = 4;
 	private final static double epsilon = 0.0000000001;
 
-	private final static Types.ValueType[] schema = {Types.ValueType.BOOLEAN, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.FP64};
+	private final static Types.ValueType[] schema = {Types.ValueType.BITSET, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.FP64};
 
 	@Override
 	public void setUp() {
@@ -105,7 +105,7 @@ private static void initFrameDataString(FrameBlock frame1, double[][] data, int
 		long[] l = new long[rows];
 		String[] s1 = null, s2 = null;
 		for (int i = 0; i < rows; i++) {
-			data[i][1] = (b[i] = (Boolean) UtilFunctions.doubleToObject(Types.ValueType.BOOLEAN, data[i][1], false)) ? 1 : 0;
+			data[i][1] = (b[i] = (Boolean) UtilFunctions.doubleToObject(Types.ValueType.BITSET, data[i][1], false)) ? 1 : 0;
 			l[i] = (Long) UtilFunctions.doubleToObject(Types.ValueType.INT64, data[i][2], false);
 		}
 		switch (test)
@@ -133,7 +133,7 @@ private static FrameBlock tureOutput(double[][] data) {
 		String[] s2 = {"Austria", "Austria", "Austria", "India", "India", "India","India", "Pakistan", "Pakistan", "Pakistan", "Austria"};
 		long[] l = new long[rows];
 		for (int i = 0; i < rows; i++) {
-			data[i][1] = (b[i] = (Boolean) UtilFunctions.doubleToObject(Types.ValueType.BOOLEAN, data[i][1], false)) ? 1 : 0;
+			data[i][1] = (b[i] = (Boolean) UtilFunctions.doubleToObject(Types.ValueType.BITSET, data[i][1], false)) ? 1 : 0;
 			l[i] = (Long) UtilFunctions.doubleToObject(Types.ValueType.INT64, data[i][2], false);
 		}
 		frame1.appendColumn(b);
diff --git a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockParallelTest.java b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockParallelTest.java
index e00eb3a3879..26430b5c298 100644
--- a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockParallelTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockParallelTest.java
@@ -52,7 +52,7 @@ public void testReadWriteBinaryBlockParallelBasicTensorINT64() {
 	
 	@Test
 	public void testReadWriteBinaryBlockParallelBasicTensorBoolean() {
-		testReadWriteBinaryBlockParallelBasicTensor(ValueType.BOOLEAN);
+		testReadWriteBinaryBlockParallelBasicTensor(ValueType.BITSET);
 	}
 	
 	@Test
@@ -88,7 +88,7 @@ public void testReadWriteBinaryBlockParallelDataTensorINT64() {
 	
 	@Test
 	public void testReadWriteBinaryBlockParallelDataTensorBoolean() {
-		testReadWriteBinaryBlockParallelDataTensor(ValueType.BOOLEAN);
+		testReadWriteBinaryBlockParallelDataTensor(ValueType.BITSET);
 	}
 	
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockTest.java b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockTest.java
index 0e9671d21f3..43adf40effb 100644
--- a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockTest.java
@@ -52,7 +52,7 @@ public void testReadWriteBinaryBlockBasicTensorINT64() {
 
 	@Test
 	public void testReadWriteBinaryBlockBasicTensorBoolean() {
-		testReadWriteBinaryBlockBasicTensor(ValueType.BOOLEAN);
+		testReadWriteBinaryBlockBasicTensor(ValueType.BITSET);
 	}
 
 	@Test
@@ -88,7 +88,7 @@ public void testReadWriteBinaryBlockDataTensorINT64() {
 
 	@Test
 	public void testReadWriteBinaryBlockDataTensorBoolean() {
-		testReadWriteBinaryBlockDataTensor(ValueType.BOOLEAN);
+		testReadWriteBinaryBlockDataTensor(ValueType.BITSET);
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellParallelTest.java b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellParallelTest.java
index 622165017e0..1e8b34198b0 100644
--- a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellParallelTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellParallelTest.java
@@ -52,7 +52,7 @@ public void testReadWriteTextCellParallelBasicTensorINT64() {
 
 	@Test
 	public void testReadWriteTextCellParallelBasicTensorBoolean() {
-		testReadWriteTextCellParallelBasicTensor(ValueType.BOOLEAN);
+		testReadWriteTextCellParallelBasicTensor(ValueType.BITSET);
 	}
 
 	@Test
@@ -88,7 +88,7 @@ public void testReadWriteTextCellParallelDataTensorINT64() {
 
 	@Test
 	public void testReadWriteTextCellParallelDataTensorBoolean() {
-		testReadWriteTextCellParallelDataTensor(ValueType.BOOLEAN);
+		testReadWriteTextCellParallelDataTensor(ValueType.BITSET);
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellTest.java b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellTest.java
index 8260393ff65..038445eebdb 100644
--- a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellTest.java
@@ -52,7 +52,7 @@ public void testReadWriteTextCellBasicTensorINT64() {
 
 	@Test
 	public void testReadWriteTextCellBasicTensorBoolean() {
-		testReadWriteTextCellBasicTensor(ValueType.BOOLEAN);
+		testReadWriteTextCellBasicTensor(ValueType.BITSET);
 	}
 
 	@Test
@@ -92,7 +92,7 @@ public void testReadWriteTextCellDataTensorINT64() {
 
 	@Test
 	public void testReadWriteTextCellDataTensorBoolean() {
-		testReadWriteTextCellDataTensor(ValueType.BOOLEAN);
+		testReadWriteTextCellDataTensor(ValueType.BITSET);
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/federated/primitives/FederatedConstructionTest.java b/src/test/java/org/apache/sysds/test/functions/federated/primitives/FederatedConstructionTest.java
index d10272310cb..64c3de24962 100644
--- a/src/test/java/org/apache/sysds/test/functions/federated/primitives/FederatedConstructionTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/federated/primitives/FederatedConstructionTest.java
@@ -109,7 +109,7 @@ public void federatedFrameConstruction(Types.ExecMode execMode) throws IOExcepti
 		List<Types.ValueType> schemaList = new ArrayList<>(Collections.nCopies(cols / 4, Types.ValueType.STRING));
 		schemaList.addAll(Collections.nCopies(cols / 4, Types.ValueType.FP64));
 		schemaList.addAll(Collections.nCopies(cols / 4, Types.ValueType.INT64));
-		schemaList.addAll(Collections.nCopies(cols / 4, Types.ValueType.BOOLEAN));
+		schemaList.addAll(Collections.nCopies(cols / 4, Types.ValueType.BITSET));
 
 		Types.ValueType[] schema = new Types.ValueType[cols];
 		schemaList.toArray(schema);
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/ApplySchemaTest.java b/src/test/java/org/apache/sysds/test/functions/frame/ApplySchemaTest.java
index f90da5014d1..9b95bec7503 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/ApplySchemaTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/ApplySchemaTest.java
@@ -48,7 +48,7 @@ public class ApplySchemaTest extends AutomatedTestBase {
 
 	private final static int rows = 10;
 	// constructed schema
-	private final static Types.ValueType[] schemaStrings = {Types.ValueType.INT32, Types.ValueType.BOOLEAN,
+	private final static Types.ValueType[] schemaStrings = {Types.ValueType.INT32, Types.ValueType.BITSET,
 		Types.ValueType.FP64};
 
 	@BeforeClass
@@ -147,7 +147,7 @@ public static void initFrameDataString(FrameBlock frame1, double[][] data, Types
 						tmp1[i] = (String) UtilFunctions.doubleToObject(vt, data[i][j]);
 					frame1.appendColumn(tmp1);
 					break;
-				case BOOLEAN:
+				case BITSET:
 					boolean[] tmp2 = new boolean[rows];
 					for(int i = 0; i < rows; i++)
 						data[i][j] = (tmp2[i] = (Boolean) UtilFunctions.doubleToObject(vt, data[i][j], false)) ? 1 : 0;
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/DetectSchemaTest.java b/src/test/java/org/apache/sysds/test/functions/frame/DetectSchemaTest.java
index 3d9b9e4f55a..bb9fde0c395 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/DetectSchemaTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/DetectSchemaTest.java
@@ -50,7 +50,7 @@ public class DetectSchemaTest extends AutomatedTestBase {
 	private final static Types.ValueType[] schemaDoubles = new Types.ValueType[] {Types.ValueType.FP64,
 		Types.ValueType.FP64};
 	private final static Types.ValueType[] schemaMixed = new Types.ValueType[] {Types.ValueType.INT64,
-		Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BOOLEAN};
+		Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BITSET};
 
 	@BeforeClass
 	public static void init() {
@@ -144,7 +144,7 @@ public static void initFrameDataString(FrameBlock frame1, double[][] data, Types
 						tmp1[i] = (String) UtilFunctions.doubleToObject(vt, data[i][j]) + "AB";
 					frame1.appendColumn(tmp1);
 					break;
-				case BOOLEAN:
+				case BITSET:
 					boolean[] tmp2 = new boolean[rows];
 					for(int i = 0; i < rows; i++)
 						data[i][j] = (tmp2[i] = (Boolean) UtilFunctions.doubleToObject(vt, data[i][j], false)) ? 1 : 0;
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameAppendDistTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameAppendDistTest.java
index 604a8791c6f..443b78e1600 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameAppendDistTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameAppendDistTest.java
@@ -185,7 +185,7 @@ ValueType[] genMixSchema(int cols)
 		List<ValueType> schemaMixedLargeListStr = Collections.nCopies(cols/4, ValueType.STRING);
 		List<ValueType> schemaMixedLargeListDble  = Collections.nCopies(cols/4, ValueType.FP64);
 		List<ValueType> schemaMixedLargeListInt  = Collections.nCopies(cols/4, ValueType.INT64);
-		List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols-(cols/4)*3, ValueType.BOOLEAN);
+		List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols-(cols/4)*3, ValueType.BITSET);
 
 		final List<ValueType> schemaMixedLargeList = new ArrayList<>(schemaMixedLargeListStr);
 		schemaMixedLargeList.addAll(schemaMixedLargeListDble);
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameConstructorTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameConstructorTest.java
index 146c560ae50..e5516bd81f3 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameConstructorTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameConstructorTest.java
@@ -48,7 +48,7 @@ public class FrameConstructorTest extends AutomatedTestBase {
 	private final static int cols = 4;
 
 	private final static ValueType[] schemaStrings1 = new ValueType[]{
-		ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.BOOLEAN};
+		ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.BITSET};
 
 	private final static ValueType[] schemaStrings2 = new ValueType[]{
 		ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.STRING};
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameConverterTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameConverterTest.java
index 0743cabf275..37fcf1991a2 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameConverterTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameConverterTest.java
@@ -77,12 +77,12 @@ public class FrameConverterTest extends AutomatedTestBase
 	private final static int rows = 1593;
 	
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 
 	private final static List<ValueType> schemaMixedLargeListStr = Collections.nCopies(200, ValueType.STRING);
 	private final static List<ValueType> schemaMixedLargeListDble  = Collections.nCopies(200, ValueType.FP64);
 	private final static List<ValueType> schemaMixedLargeListInt  = Collections.nCopies(200, ValueType.INT64);
-	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(200, ValueType.BOOLEAN);
+	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(200, ValueType.BITSET);
 	
 	private static final List<ValueType> schemaMixedLargeList = CollectionUtils.asList(
 		schemaMixedLargeListStr, schemaMixedLargeListDble, schemaMixedLargeListInt, schemaMixedLargeListBool);
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameEqualTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameEqualTest.java
index fcd43213018..c84f920178e 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameEqualTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameEqualTest.java
@@ -40,8 +40,8 @@ public class FrameEqualTest extends AutomatedTestBase {
 	private static final String TEST_CLASS_DIR = TEST_DIR + FrameEqualTest.class.getSimpleName() + "/";
 
 	private final static int rows = 100;
-	private final static Types.ValueType[] schemaStrings1 = {Types.ValueType.FP64, Types.ValueType.BOOLEAN, Types.ValueType.INT64, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.FP64};
-	private final static Types.ValueType[] schemaStrings2 = {Types.ValueType.INT64, Types.ValueType.BOOLEAN, Types.ValueType.FP32, Types.ValueType.FP64, Types.ValueType.STRING, Types.ValueType.FP32};
+	private final static Types.ValueType[] schemaStrings1 = {Types.ValueType.FP64, Types.ValueType.BITSET, Types.ValueType.INT64, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.FP64};
+	private final static Types.ValueType[] schemaStrings2 = {Types.ValueType.INT64, Types.ValueType.BITSET, Types.ValueType.FP32, Types.ValueType.FP64, Types.ValueType.STRING, Types.ValueType.FP32};
 
 	public enum TestType {
 		GREATER, LESS, EQUALS, NOT_EQUALS, GREATER_EQUALS, LESS_EQUALS,
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameIndexingDistTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameIndexingDistTest.java
index d073b5d0c93..900556bd33a 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameIndexingDistTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameIndexingDistTest.java
@@ -72,7 +72,7 @@ private enum IXType {
 	private final static List<ValueType> schemaMixedLargeListStr = Collections.nCopies(cols/4, ValueType.STRING);
 	private final static List<ValueType> schemaMixedLargeListDble  = Collections.nCopies(cols/4, ValueType.FP64);
 	private final static List<ValueType> schemaMixedLargeListInt  = Collections.nCopies(cols/4, ValueType.INT64);
-	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols/4, ValueType.BOOLEAN);
+	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols/4, ValueType.BITSET);
 	private static ValueType[] schemaMixedLarge = null;
 	static {
 		final List<ValueType> schemaMixedLargeList = new ArrayList<>(schemaMixedLargeListStr);
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameReadWriteTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameReadWriteTest.java
index bec24bae724..f9b513455b7 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameReadWriteTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameReadWriteTest.java
@@ -54,7 +54,7 @@ public class FrameReadWriteTest extends AutomatedTestBase {
 
 	private final static int rows = 1593;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};	
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 	
 	private final static String DELIMITER = "::";
 	private final static boolean HEADER = true;
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingIntegratedTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingIntegratedTest.java
index 46dfc0d90fa..939a122954c 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingIntegratedTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingIntegratedTest.java
@@ -55,7 +55,7 @@ public void testFrameLongCP0() {
 	
 	@Test
 	public void testFrameBooleanCP0() { 
-		runFrameScalarCastingTest(ValueType.BOOLEAN, ExecMode.SINGLE_NODE); 
+		runFrameScalarCastingTest(ValueType.BITSET, ExecMode.SINGLE_NODE);
 	}
 	
 	@Test
@@ -75,7 +75,7 @@ public void testFrameLongCP1() {
 	
 	@Test
 	public void testFrameBooleanCP1() { 
-		runFrameScalarCastingTest(ValueType.BOOLEAN, ExecMode.HYBRID); 
+		runFrameScalarCastingTest(ValueType.BITSET, ExecMode.HYBRID);
 	}
 	
 	@Test
@@ -95,7 +95,7 @@ public void testFrameLongCP2() {
 	
 	@Test
 	public void testFrameBooleanCP2() { 
-		runFrameScalarCastingTest(ValueType.BOOLEAN, ExecMode.HYBRID); 
+		runFrameScalarCastingTest(ValueType.BITSET, ExecMode.HYBRID);
 	}
 	
 	@Test
@@ -115,7 +115,7 @@ public void testFrameLongSP() {
 	
 	@Test
 	public void testFrameBooleanSP() { 
-		runFrameScalarCastingTest(ValueType.BOOLEAN, ExecMode.SPARK); 
+		runFrameScalarCastingTest(ValueType.BITSET, ExecMode.SPARK);
 	}
 	
 	@Test
@@ -143,7 +143,7 @@ private void runFrameScalarCastingTest(ValueType vtIn, ExecMode et)
 			switch( vtIn ) {
 				case STRING: HDFSTool.writeStringToHDFS("foo", input("V")); break;
 				case INT64: HDFSTool.writeIntToHDFS(7, input("V")); break;
-				case BOOLEAN: HDFSTool.writeBooleanToHDFS(true, input("V")); break;
+				case BITSET: HDFSTool.writeBooleanToHDFS(true, input("V")); break;
 				case FP64: HDFSTool.writeDoubleToHDFS(7.3, input("V")); break;
 				default: throw new RuntimeException("Unsupported type: "+vtIn);
 			}
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingTest.java
index d183d347872..0ce2a1ee42b 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingTest.java
@@ -58,7 +58,7 @@ public void testFrame2ScalarDouble() {
 	
 	@Test
 	public void testFrame2ScalarBoolean() {
-		runFrameCastingTest(TEST_NAME1, ValueType.BOOLEAN);
+		runFrameCastingTest(TEST_NAME1, ValueType.BITSET);
 	}
 	
 	@Test
@@ -78,7 +78,7 @@ public void testScalar2FrameDouble() {
 	
 	@Test
 	public void testScalar2FrameBoolean() {
-		runFrameCastingTest(TEST_NAME2, ValueType.BOOLEAN);
+		runFrameCastingTest(TEST_NAME2, ValueType.BITSET);
 	}
 	
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameSchemaReadTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameSchemaReadTest.java
index 73515505f02..c30365fb20d 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameSchemaReadTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameSchemaReadTest.java
@@ -48,7 +48,7 @@ public class FrameSchemaReadTest extends AutomatedTestBase
 	private final static int rows = 1593;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
 	private final static ValueType[] schemaDoubles = new ValueType[]{ValueType.FP64, ValueType.FP64};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};	
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
 	
 	@Override
 	public void setUp() {
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/TypeOfTest.java b/src/test/java/org/apache/sysds/test/functions/frame/TypeOfTest.java
index c94bfdc6fb0..18cb5b4b806 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/TypeOfTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/TypeOfTest.java
@@ -42,7 +42,7 @@ public class TypeOfTest extends AutomatedTestBase {
 	private static final String TEST_CLASS_DIR = TEST_DIR + TypeOfTest.class.getSimpleName() + "/";
 
 	private final static Types.ValueType[] schemaStrings = new Types.ValueType[]{Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING};
-	private final static Types.ValueType[] schemaMixed = new Types.ValueType[]{Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BOOLEAN};
+	private final static Types.ValueType[] schemaMixed = new Types.ValueType[]{Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BITSET};
 
 	private final static int rows = 50;
 
diff --git a/src/test/java/org/apache/sysds/test/functions/iogen/GenerateRandomFrame.java b/src/test/java/org/apache/sysds/test/functions/iogen/GenerateRandomFrame.java
index 9b711057223..b5ddb2f637e 100644
--- a/src/test/java/org/apache/sysds/test/functions/iogen/GenerateRandomFrame.java
+++ b/src/test/java/org/apache/sysds/test/functions/iogen/GenerateRandomFrame.java
@@ -156,7 +156,7 @@ private static String[][] writeInLIBSVMFormat(int firstIndex,Types.ValueType[] s
 					row1.append(separator).append(c + firstIndex).append(indexSeparator).append(data[r][c]);
 				}
 				else {
-					if(schema[c].isNumeric() || schema[c] == Types.ValueType.BOOLEAN){
+					if(schema[c].isNumeric() || schema[c] == Types.ValueType.BITSET){
 						dataLibSVM[indexRow][c] = "0";
 					}
 					else if(schema[c] == Types.ValueType.STRING)
@@ -172,7 +172,7 @@ else if(schema[c] == Types.ValueType.STRING)
 					row2.append(separator).append(c + firstIndex).append(indexSeparator).append(data[r][c]);
 				}
 				else {
-					if(schema[c].isNumeric() || schema[c] == Types.ValueType.BOOLEAN){
+					if(schema[c].isNumeric() || schema[c] == Types.ValueType.BITSET){
 						dataLibSVM[indexRow][c] = "0";
 					}
 					else if(schema[c] == Types.ValueType.STRING)
diff --git a/src/test/java/org/apache/sysds/test/functions/iogen/GenerateReaderFrameTest.java b/src/test/java/org/apache/sysds/test/functions/iogen/GenerateReaderFrameTest.java
index 5816b90e907..567f7b8ad38 100644
--- a/src/test/java/org/apache/sysds/test/functions/iogen/GenerateReaderFrameTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/iogen/GenerateReaderFrameTest.java
@@ -50,9 +50,9 @@ public abstract class GenerateReaderFrameTest extends AutomatedTestBase {
 		Types.ValueType.INT64,
 		Types.ValueType.FP32,
 		Types.ValueType.FP64,
-		Types.ValueType.BOOLEAN};
+		Types.ValueType.BITSET};
 
-	protected Types.ValueType[] types1= { Types.ValueType.BOOLEAN};
+	protected Types.ValueType[] types1= { Types.ValueType.BITSET};
 
 	protected abstract String getTestName();
 
@@ -78,7 +78,7 @@ protected String getRandomString(int length) {
 	protected String defaultValue(Types.ValueType vt){
 		switch(vt){
 			case STRING: return "";
-			case BOOLEAN: return null;
+			case BITSET: return null;
 			case FP32:
 			case FP64:
 			case INT32:
@@ -117,7 +117,7 @@ protected void generateRandomNumeric(int size, Types.ValueType type, double min,
 					case INT64: o = UtilFunctions.objectToObject(type,(long)randomData[i][0]); break;
 					case FP32: o = UtilFunctions.objectToObject(type,(float)randomData[i][0]); break;
 					case FP64: o = UtilFunctions.objectToObject(type,randomData[i][0]); break;
-					case BOOLEAN: Boolean b= randomData[i][0] >0 ? true: null; o = UtilFunctions.objectToObject(type, b); break;
+					case BITSET: Boolean b= randomData[i][0] >0 ? true: null; o = UtilFunctions.objectToObject(type, b); break;
 				}
 				String s = UtilFunctions.objectToString(o);
 				data[i][colIndex] = s;
@@ -148,7 +148,7 @@ protected void generateRandomData(int nrows, int ncols, double min, double max,
 
 			if(types[rnt] == Types.ValueType.STRING)
 				generateRandomString(nrows,100,naStrings,sparsity,data,i);
-			else if(types[rnt].isNumeric() || types[rnt] == Types.ValueType.BOOLEAN)
+			else if(types[rnt].isNumeric() || types[rnt] == Types.ValueType.BITSET)
 				generateRandomNumeric(nrows, types[rnt],min,max,naStrings, sparsity,data,i);
 			}
 	}
diff --git a/src/test/java/org/apache/sysds/test/functions/misc/ScalarAssignmentTest.java b/src/test/java/org/apache/sysds/test/functions/misc/ScalarAssignmentTest.java
index 23f8a897bb4..9cfe9eb630c 100644
--- a/src/test/java/org/apache/sysds/test/functions/misc/ScalarAssignmentTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/misc/ScalarAssignmentTest.java
@@ -72,7 +72,7 @@ public void testForLoopString()
 	@Test
 	public void testForLoopBoolean() 
 	{
-		runScalarAssignmentTest(ControlFlowConstruct.FOR, ValueType.BOOLEAN);
+		runScalarAssignmentTest(ControlFlowConstruct.FOR, ValueType.BITSET);
 	}
 	
 	@Test
@@ -96,7 +96,7 @@ public void testParForLoopString()
 	@Test
 	public void testParForLoopBoolean() 
 	{
-		runScalarAssignmentTest(ControlFlowConstruct.PARFOR, ValueType.BOOLEAN);
+		runScalarAssignmentTest(ControlFlowConstruct.PARFOR, ValueType.BITSET);
 	}
 	
 	@Test
@@ -120,7 +120,7 @@ public void testWhileLoopString()
 	@Test
 	public void testWhileLoopBoolean() 
 	{
-		runScalarAssignmentTest(ControlFlowConstruct.WHILE, ValueType.BOOLEAN);
+		runScalarAssignmentTest(ControlFlowConstruct.WHILE, ValueType.BITSET);
 	}
 
 	@Test
@@ -144,7 +144,7 @@ public void testIfLoopString()
 	@Test
 	public void testIfLoopBoolean() 
 	{
-		runScalarAssignmentTest(ControlFlowConstruct.IFELSE, ValueType.BOOLEAN);
+		runScalarAssignmentTest(ControlFlowConstruct.IFELSE, ValueType.BITSET);
 	}
 
 	public void runScalarAssignmentTest( ControlFlowConstruct cfc, ValueType vt ) {
@@ -162,7 +162,7 @@ public void runScalarAssignmentTest( ControlFlowConstruct cfc, ValueType vt ) {
 			case INT64: value = Integer.valueOf(7); break;
 			case FP64: value = Double.valueOf(7.7); break;
 			case STRING: value = "This is a test!"; break;
-			case BOOLEAN: value = Boolean.valueOf(true); break;
+			case BITSET: value = Boolean.valueOf(true); break;
 			default: //do nothing
 		}
 		
diff --git a/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeAutoCastingTest.java b/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeAutoCastingTest.java
index 893b35cf422..b5ca68aa7fb 100644
--- a/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeAutoCastingTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeAutoCastingTest.java
@@ -64,7 +64,7 @@ public void testIterablePredicateInteger()
 	@Test
 	public void testIterablePredicateBoolean() 
 	{ 
-		runTest( TEST_NAME1, ValueType.BOOLEAN, true ); 
+		runTest( TEST_NAME1, ValueType.BITSET, true );
 	}
 	
 	@Test
@@ -82,7 +82,7 @@ public void testConditionalPredicateWhileInteger()
 	@Test
 	public void testConditionalPredicateWhileBoolean() 
 	{ 
-		runTest( TEST_NAME2, ValueType.BOOLEAN, false ); 
+		runTest( TEST_NAME2, ValueType.BITSET, false );
 	}
 	
 	@Test
@@ -100,7 +100,7 @@ public void testConditionalPredicateIfInteger()
 	@Test
 	public void testConditionalPredicateIfBoolean() 
 	{ 
-		runTest( TEST_NAME3, ValueType.BOOLEAN, false ); 
+		runTest( TEST_NAME3, ValueType.BITSET, false );
 	}
 	
 	@Test
@@ -118,7 +118,7 @@ public void testFunctionInliningInteger()
 	@Test
 	public void testFunctionInliningBoolean() 
 	{ 
-		runTest( TEST_NAME4, ValueType.BOOLEAN, false ); 
+		runTest( TEST_NAME4, ValueType.BITSET, false );
 	}
 	
 	@Test
@@ -136,7 +136,7 @@ public void testFunctionNoInliningInteger()
 	@Test
 	public void testFunctionNoInliningBoolean() 
 	{ 
-		runTest( TEST_NAME5, ValueType.BOOLEAN, false ); 
+		runTest( TEST_NAME5, ValueType.BITSET, false );
 	}
 
 	
@@ -163,7 +163,7 @@ private void runTest( String testName, ValueType vt, boolean exceptionExpected )
 				case INT64:
 					val1 = Integer.toString((int)V[0][0]); 
 					val2 = Integer.toString((int)V[0][1]); break;
-				case BOOLEAN:
+				case BITSET:
 					val1 = (V[0][0]!=0)?"TRUE":"FALSE"; 
 					val2 = (V[0][1]!=0)?"TRUE":"FALSE"; break;
 				default:
diff --git a/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeCastingTest.java b/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeCastingTest.java
index 7f9eac5079b..66640bb1e4d 100644
--- a/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeCastingTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeCastingTest.java
@@ -65,7 +65,7 @@ public void testScalarIntegerToDouble()
 	@Test
 	public void testScalarBooleanToDouble() 
 	{ 
-		runTest( ValueType.BOOLEAN, ValueType.FP64, false, false ); 
+		runTest( ValueType.BITSET, ValueType.FP64, false, false );
 	}
 	
 	@Test
@@ -89,7 +89,7 @@ public void testScalarIntegerToInteger()
 	@Test
 	public void testScalarBooleanToInteger() 
 	{ 
-		runTest( ValueType.BOOLEAN, ValueType.INT64, false, false ); 
+		runTest( ValueType.BITSET, ValueType.INT64, false, false );
 	}
 	
 	@Test
@@ -102,25 +102,25 @@ public void testMatrixDoubleToInteger()
 	@Test
 	public void testScalarDoubleToBoolean() 
 	{ 
-		runTest( ValueType.FP64, ValueType.BOOLEAN, false, false ); 
+		runTest( ValueType.FP64, ValueType.BITSET, false, false );
 	}
 	
 	@Test
 	public void testScalarIntegerToBoolean() 
 	{ 
-		runTest( ValueType.INT64, ValueType.BOOLEAN, false, false ); 
+		runTest( ValueType.INT64, ValueType.BITSET, false, false );
 	}
 	
 	@Test
 	public void testScalarBooleanToBoolean() 
 	{ 
-		runTest( ValueType.BOOLEAN, ValueType.BOOLEAN, false, false ); 
+		runTest( ValueType.BITSET, ValueType.BITSET, false, false );
 	}
 	
 	@Test
 	public void testMatrixDoubleToBoolean() 
 	{ 
-		runTest( ValueType.FP64, ValueType.BOOLEAN, true, true ); 
+		runTest( ValueType.FP64, ValueType.BITSET, true, true );
 	}
 	
 	private void runTest( ValueType vtIn, ValueType vtOut, boolean matrixInput, boolean exceptionExpected )
@@ -130,7 +130,7 @@ private void runTest( ValueType vtIn, ValueType vtOut, boolean matrixInput, bool
 		{
 			case FP64:  TEST_NAME = TEST_NAME1; break;
 			case INT64: 	  TEST_NAME = TEST_NAME2; break;
-			case BOOLEAN: TEST_NAME = TEST_NAME3; break;
+			case BITSET: TEST_NAME = TEST_NAME3; break;
 			default: //do nothing
 		}
 		
@@ -162,7 +162,7 @@ private void runTest( ValueType vtIn, ValueType vtOut, boolean matrixInput, bool
 					case INT64:    
 						HDFSTool.writeIntToHDFS((int)V[0][0], input("V")); 
 						inVal = ((int)V[0][0]); break;
-					case BOOLEAN: 
+					case BITSET:
 						HDFSTool.writeBooleanToHDFS(V[0][0]!=0, input("V")); 
 						inVal = (V[0][0]!=0)?1:0; break;
 					default: 
@@ -177,7 +177,7 @@ private void runTest( ValueType vtIn, ValueType vtOut, boolean matrixInput, bool
 		        switch( vtOut ) {
 					case FP64:  Assert.assertEquals(inVal, HDFSTool.readDoubleFromHDFSFile(outName), 1e-16); break;
 					case INT64:     Assert.assertEquals((int) inVal, HDFSTool.readIntegerFromHDFSFile(outName)); break;
-					case BOOLEAN: Assert.assertEquals(inVal!=0, HDFSTool.readBooleanFromHDFSFile(outName)); break;
+					case BITSET: Assert.assertEquals(inVal!=0, HDFSTool.readBooleanFromHDFSFile(outName)); break;
 					default: //do nothing
 		        }
 	        }
diff --git a/src/test/java/org/apache/sysds/test/functions/mlcontext/FrameTest.java b/src/test/java/org/apache/sysds/test/functions/mlcontext/FrameTest.java
index fe223a711ce..5feb010daf2 100644
--- a/src/test/java/org/apache/sysds/test/functions/mlcontext/FrameTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/mlcontext/FrameTest.java
@@ -86,7 +86,7 @@ public class FrameTest extends MLContextTestBase{
 	private final static List<ValueType> schemaMixedLargeListStr = Collections.nCopies(cols/4, ValueType.STRING);
 	private final static List<ValueType> schemaMixedLargeListDble  = Collections.nCopies(cols/4, ValueType.FP64);
 	private final static List<ValueType> schemaMixedLargeListInt  = Collections.nCopies(cols/4, ValueType.INT64);
-	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols/4, ValueType.BOOLEAN);
+	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols/4, ValueType.BITSET);
 	private static ValueType[] schemaMixedLarge = null;
 	static {
 		final List<ValueType> schemaMixedLargeList = new ArrayList<>(schemaMixedLargeListStr);
diff --git a/src/test/java/org/apache/sysds/test/functions/mlcontext/MLContextFrameTest.java b/src/test/java/org/apache/sysds/test/functions/mlcontext/MLContextFrameTest.java
index db4a3eac37c..42f14f880b0 100644
--- a/src/test/java/org/apache/sysds/test/functions/mlcontext/MLContextFrameTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/mlcontext/MLContextFrameTest.java
@@ -126,10 +126,10 @@ public void testFrame(FrameFormat format, SCRIPT_TYPE script_type, IO_TYPE input
 		List<String> listB = new ArrayList<>();
 		FrameMetadata fmA = null, fmB = null;
 		Script script = null;
-		ValueType[] schemaA = { ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.BOOLEAN };
+		ValueType[] schemaA = { ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.BITSET};
 		List<ValueType> lschemaA = Arrays.asList(schemaA);
 		FrameSchema fschemaA = new FrameSchema(lschemaA);
-		ValueType[] schemaB = { ValueType.STRING, ValueType.FP64, ValueType.BOOLEAN };
+		ValueType[] schemaB = { ValueType.STRING, ValueType.FP64, ValueType.BITSET};
 		List<ValueType> lschemaB = Arrays.asList(schemaB);
 		FrameSchema fschemaB = new FrameSchema(lschemaB);
 
@@ -225,7 +225,7 @@ public void testFrame(FrameFormat format, SCRIPT_TYPE script_type, IO_TYPE input
 			Assert.assertEquals(ValueType.INT64, lschemaOutA.get(0));
 			Assert.assertEquals(ValueType.STRING, lschemaOutA.get(1));
 			Assert.assertEquals(ValueType.FP64, lschemaOutA.get(2));
-			Assert.assertEquals(ValueType.BOOLEAN, lschemaOutA.get(3));
+			Assert.assertEquals(ValueType.BITSET, lschemaOutA.get(3));
 			
 			Assert.assertEquals(ValueType.STRING, lschemaOutC.get(0));
 			Assert.assertEquals(ValueType.FP64, lschemaOutC.get(1));
diff --git a/src/test/java/org/apache/sysds/test/functions/recompile/LiteralReplaceCastScalarReadTest.java b/src/test/java/org/apache/sysds/test/functions/recompile/LiteralReplaceCastScalarReadTest.java
index a9735c6dbf4..bb050f9b00e 100644
--- a/src/test/java/org/apache/sysds/test/functions/recompile/LiteralReplaceCastScalarReadTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/recompile/LiteralReplaceCastScalarReadTest.java
@@ -55,7 +55,7 @@ public void testRemoveCastsInputDouble() {
 	
 	@Test
 	public void testRemoveCastsInputBoolean() {
-		runScalarCastTest(ValueType.BOOLEAN);
+		runScalarCastTest(ValueType.BITSET);
 	}
 	
 	private void runScalarCastTest( ValueType vt ) {
@@ -71,7 +71,7 @@ private void runScalarCastTest( ValueType vt ) {
 			switch( vt ) {
 				case INT64: val = "7"; break;
 				case FP64: val = "7.3"; break;
-				case BOOLEAN: val = "TRUE"; break;
+				case BITSET: val = "TRUE"; break;
 				default: //do nothing
 			}
 			
diff --git a/src/test/java/org/apache/sysds/test/functions/transform/ColumnEncoderSerializationTest.java b/src/test/java/org/apache/sysds/test/functions/transform/ColumnEncoderSerializationTest.java
index aeec927e73b..eed755a83b0 100644
--- a/src/test/java/org/apache/sysds/test/functions/transform/ColumnEncoderSerializationTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/transform/ColumnEncoderSerializationTest.java
@@ -48,8 +48,8 @@ public class ColumnEncoderSerializationTest extends AutomatedTestBase
 		Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING,
 		Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING};
 	private final static Types.ValueType[] schemaMixed = new Types.ValueType[]{
-		Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BOOLEAN,
-		Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BOOLEAN};
+		Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BITSET,
+		Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BITSET};
 
 
 	public enum TransformType {

From 285c34bd94350c42c964484aff27629f01ffa72e Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Tue, 27 Jun 2023 10:39:47 +0200
Subject: [PATCH 07/10] [SYSTEMDS-3544] fix missing refactor in
 fromExternalString

---
 src/main/java/org/apache/sysds/common/Types.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/org/apache/sysds/common/Types.java b/src/main/java/org/apache/sysds/common/Types.java
index 57270e1eae2..3b52a2d27f4 100644
--- a/src/main/java/org/apache/sysds/common/Types.java
+++ b/src/main/java/org/apache/sysds/common/Types.java
@@ -113,7 +113,7 @@ public static ValueType fromExternalString(String value) {
 				case "INT32":    return INT32;
 				case "INT64":
 				case "INT":      return INT64;
-				case "BOOLEAN":  return BITSET;
+				case "BITSET":  return BITSET;
 				case "STRING":   return STRING;
 				case "CHARACTER": return CHARACTER;
 				case "UNKNOWN":  return UNKNOWN;

From d81df3677465aa374d1e75992e411ac0c6b30ad2 Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Tue, 27 Jun 2023 15:35:27 +0200
Subject: [PATCH 08/10] [SYSTEMDS-3544] move boolean computation to method and
 add abstract class for boolean dense blocks

---
 .../java/org/apache/sysds/common/Types.java   |  4 +-
 .../sysds/runtime/data/DenseBlockBool.java    | 11 +++
 .../runtime/data/DenseBlockBoolArray.java     |  4 +-
 .../runtime/data/DenseBlockBoolBitset.java    |  8 +-
 .../runtime/matrix/data/LibMatrixBincell.java | 74 +++++++++++--------
 5 files changed, 69 insertions(+), 32 deletions(-)
 create mode 100644 src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java

diff --git a/src/main/java/org/apache/sysds/common/Types.java b/src/main/java/org/apache/sysds/common/Types.java
index 3b52a2d27f4..18bbaa2461e 100644
--- a/src/main/java/org/apache/sysds/common/Types.java
+++ b/src/main/java/org/apache/sysds/common/Types.java
@@ -96,7 +96,8 @@ public String toExternalString() {
 				case UINT8:
 				case INT32:
 				case INT64:   return "INT";
-				case BITSET: return "BOOLEAN";
+				case BITSET:  return "BITSET";
+				case BOOLEAN: return "BOOLEAN";
 				default:      return toString();
 			}
 		}
@@ -114,6 +115,7 @@ public static ValueType fromExternalString(String value) {
 				case "INT64":
 				case "INT":      return INT64;
 				case "BITSET":  return BITSET;
+				case "BOOLEAN":  return BOOLEAN;
 				case "STRING":   return STRING;
 				case "CHARACTER": return CHARACTER;
 				case "UNKNOWN":  return UNKNOWN;
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
new file mode 100644
index 00000000000..1ae2a653fd8
--- /dev/null
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
@@ -0,0 +1,11 @@
+package org.apache.sysds.runtime.data;
+
+public abstract class DenseBlockBool extends DenseBlockDRB{
+
+    protected DenseBlockBool(int[] dims) {
+        super(dims);
+    }
+    public abstract DenseBlock set(int r, int c, boolean v);
+
+    public abstract boolean getBoolean(int r, int c);
+}
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolArray.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolArray.java
index e0882e366c0..a811d61f5d4 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolArray.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolArray.java
@@ -26,7 +26,7 @@
 
 import java.util.Arrays;
 
-public class DenseBlockBoolArray extends DenseBlockDRB{
+public class DenseBlockBoolArray extends DenseBlockBool{
 
     private static final long serialVersionUID = -6741205568083878338L;
     private boolean[] _data;
@@ -159,6 +159,7 @@ public DenseBlock set(String s) {
         return this;
     }
 
+    @Override
     public DenseBlock set(int r, int c, boolean v) {
         _data[pos(r, c)] = v;
         return this;
@@ -228,6 +229,7 @@ public DenseBlock set(int[] ix, String v) {
         return this;
     }
 
+    @Override
     public boolean getBoolean(int r, int c){
         return _data[pos(r,c)];
     }
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
index 68cbc535d4d..56ced3537e4 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
@@ -27,7 +27,7 @@
 import org.apache.sysds.runtime.util.DataConverter;
 import org.apache.sysds.runtime.util.UtilFunctions;
 
-public class DenseBlockBoolBitset extends DenseBlockDRB
+public class DenseBlockBoolBitset extends DenseBlockBool
 {
 	private static final long serialVersionUID = -2228057308997136969L;
 	
@@ -163,6 +163,7 @@ public DenseBlock set(int r, int c, double v) {
 		return this;
 	}
 
+	@Override
 	public DenseBlock set(int r, int c, boolean v) {
 		_data.set(pos(r, c), v);
 		return this;
@@ -217,6 +218,11 @@ public DenseBlock set(int[] ix, String v) {
 		return this;
 	}
 
+	@Override
+	public boolean getBoolean(int r, int c) {
+		return _data.get(pos(r,c));
+	}
+
 	@Override
 	public double get(int r, int c) {
 		return _data.get(pos(r, c)) ? 1 : 0;
diff --git a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
index 5392564423d..7ab360144f8 100644
--- a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
+++ b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
@@ -1401,35 +1401,9 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 			}
 			//general case
 			else {
-				// if ValueFunction is comparison, return matrix is true boolean and boolean arithmetics are activated, use boolean arithmetics
-				if (op.fn instanceof ValueComparisonFunction &&	ret.denseBlock != null && (ret.getDenseBlock() instanceof DenseBlockBoolArray || ret.getDenseBlock() instanceof DenseBlockBoolBitset) ){
-					//TODO: Optimize casting to boolean denseblock types :/
-					if(ret.getDenseBlock() instanceof DenseBlockBoolArray){
-						for(int r=rl; r<ru; r++)
-							for(int c=0; c<clen; c++) {
-								double v1 = m1.quickGetValue(r, c);
-								double v2 = m2.quickGetValue(r, c);
-								boolean vb = ((ValueComparisonFunction) op.fn).compare( v1, v2 );
-
-								//react what is happening in appendValuePlain()
-								ret.allocateDenseBlock(false);
-								((DenseBlockBoolArray) ret.getDenseBlock()).set(r,c,vb);
-								lnnz += vb ? 1 : 0;
-							}
-					} else {
-						for(int r=rl; r<ru; r++)
-							for(int c=0; c<clen; c++) {
-								double v1 = m1.quickGetValue(r, c);
-								double v2 = m2.quickGetValue(r, c);
-								boolean vb = ((ValueComparisonFunction) op.fn).compare( v1, v2 );
-
-								//react what is happening in appendValuePlain()
-								ret.allocateDenseBlock(false);
-								((DenseBlockBoolBitset) ret.getDenseBlock()).set(r,c,vb);
-								lnnz += vb ? 1 : 0;
-							}
-					}
-
+				// if return matrix is boolean or bitset, use boolean arithmetics
+				if (ret.denseBlock != null && ret.getDenseBlock() instanceof DenseBlockBool ){
+					lnnz = computeAsBoolean(m1, m2, ret, op, rl, ru);
 				} else {
 					for(int r=rl; r<ru; r++)
 						for(int c=0; c<clen; c++) {
@@ -1447,6 +1421,48 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 		return lnnz;
 	}
 
+	/**
+	 * EXPERIMENTAL
+	 * Runs operations that return booleans and actually uses boolean arithmetics and boolean matrices.
+	 * @param m1 input matrix 1
+	 * @param m2 input matrix 2
+	 * @param ret result matrix
+	 * @param op operator that returns boolean values
+	 * @return lnnz
+	 */
+	private static long computeAsBoolean(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op, int rl, int ru){
+		int clen = m1.clen;
+		long lnnz = 0;
+		boolean isAndOrXor = op.fn instanceof And || op.fn instanceof Or || op.fn instanceof Xor;
+		boolean isValueComparisonFunction = op.fn instanceof ValueComparisonFunction;
+
+		for(int r=rl; r<ru; r++)
+			for(int c=0; c<clen; c++) {
+
+				boolean vb;
+
+				if(isValueComparisonFunction){
+					double v1 = m1.quickGetValue(r, c);
+					double v2 = m2.quickGetValue(r, c);
+					vb = ((ValueComparisonFunction) op.fn).compare( v1, v2 );
+				} else if (isAndOrXor) {
+					boolean vb1 = ((DenseBlockBool)m1.denseBlock).getBoolean(r,c);
+					boolean vb2 = ((DenseBlockBool)m2.denseBlock).getBoolean(r,c);
+					vb = op.fn.execute(vb1, vb2);
+				} else {
+					throw new RuntimeException("Currently there is no support for boolean computation with operator of type "+op.fn.getClass().getSimpleName());
+				}
+
+				//reenact what is happening in appendValuePlain()
+				ret.allocateDenseBlock(false);
+				((DenseBlockBool) ret.getDenseBlock()).set(r,c,vb);
+
+				lnnz += vb ? 1 : 0;
+			}
+
+
+		return lnnz;
+	}
 	private static long safeBinaryScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op, int rl, int ru) {
 		//early abort possible since sparsesafe
 		if( m1.isEmptyBlock(false) ) {

From 010bdfbd3a105a470578f7c55489c542cef9d5c4 Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Fri, 30 Jun 2023 12:50:56 +0200
Subject: [PATCH 09/10] [SYSTEMDS-3544] - license - exception for double to
 bool for opearator of type and, or, xor - add constructor for operator to
 enforce desired sparse safety

---
 .../sysds/runtime/data/DenseBlockBool.java    | 19 +++++++++++++++++++
 .../runtime/matrix/data/LibMatrixBincell.java | 12 ++++++++----
 .../matrix/operators/BinaryOperator.java      |  9 +++++++++
 3 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
index 1ae2a653fd8..ed32ad68bea 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBool.java
@@ -1,3 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
 package org.apache.sysds.runtime.data;
 
 public abstract class DenseBlockBool extends DenseBlockDRB{
diff --git a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
index 7ab360144f8..f41d2ac8026 100644
--- a/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
+++ b/src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixBincell.java
@@ -1423,7 +1423,7 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 
 	/**
 	 * EXPERIMENTAL
-	 * Runs operations that return booleans and actually uses boolean arithmetics and boolean matrices.
+	 * Runs operations that return booleans and uses boolean arithmetics and boolean matrices.
 	 * @param m1 input matrix 1
 	 * @param m2 input matrix 2
 	 * @param ret result matrix
@@ -1433,7 +1433,10 @@ else if( atype == BinaryAccessType.OUTER_VECTOR_VECTOR ) { //VECTOR - VECTOR
 	private static long computeAsBoolean(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op, int rl, int ru){
 		int clen = m1.clen;
 		long lnnz = 0;
-		boolean isAndOrXor = op.fn instanceof And || op.fn instanceof Or || op.fn instanceof Xor;
+
+		//currently operators that have boolean as input and output have to use one of DenseBlockBool
+		boolean canRunAndOrXorAsFullBoolean = (op.fn instanceof And || op.fn instanceof Or || op.fn instanceof Xor) && m1.denseBlock instanceof DenseBlockBool && m2.denseBlock instanceof DenseBlockBool;
+
 		boolean isValueComparisonFunction = op.fn instanceof ValueComparisonFunction;
 
 		for(int r=rl; r<ru; r++)
@@ -1445,12 +1448,13 @@ private static long computeAsBoolean(MatrixBlock m1, MatrixBlock m2, MatrixBlock
 					double v1 = m1.quickGetValue(r, c);
 					double v2 = m2.quickGetValue(r, c);
 					vb = ((ValueComparisonFunction) op.fn).compare( v1, v2 );
-				} else if (isAndOrXor) {
+				} else if (canRunAndOrXorAsFullBoolean) {
 					boolean vb1 = ((DenseBlockBool)m1.denseBlock).getBoolean(r,c);
 					boolean vb2 = ((DenseBlockBool)m2.denseBlock).getBoolean(r,c);
 					vb = op.fn.execute(vb1, vb2);
 				} else {
-					throw new RuntimeException("Currently there is no support for boolean computation with operator of type "+op.fn.getClass().getSimpleName());
+					throw new RuntimeException("Currently there is no support for full boolean computation with operator of type "+op.fn.getClass().getSimpleName()
+							+" for input typ "+m1.denseBlock.getClass().getSimpleName()+" and output type "+ret.denseBlock.getClass().getSimpleName());
 				}
 
 				//reenact what is happening in appendValuePlain()
diff --git a/src/main/java/org/apache/sysds/runtime/matrix/operators/BinaryOperator.java b/src/main/java/org/apache/sysds/runtime/matrix/operators/BinaryOperator.java
index 992ac5bee9d..55d2f0f233d 100644
--- a/src/main/java/org/apache/sysds/runtime/matrix/operators/BinaryOperator.java
+++ b/src/main/java/org/apache/sysds/runtime/matrix/operators/BinaryOperator.java
@@ -84,6 +84,15 @@ public BinaryOperator(ValueFunction p, int k) {
 		_numThreads = k;
 	}
 
+	public BinaryOperator(ValueFunction p, boolean sparseSafe){
+		// enforce desired sparse safety
+		super(sparseSafe);
+		fn = p;
+		commutative = p instanceof Plus || p instanceof Multiply || p instanceof And || p instanceof Or ||
+				p instanceof Xor || p instanceof Minus1Multiply;
+		_numThreads = 1;
+	}
+
 	/**
 	 * Method for getting the hop binary operator type for a given function object.
 	 * This is used in order to use a common code path for consistency between 

From badf2fb649c2a19a6ea87e4fff4617aafd3894b2 Mon Sep 17 00:00:00 2001
From: louislepage <l.lepage@campus.tu-berlin.de>
Date: Tue, 4 Jul 2023 11:57:34 +0200
Subject: [PATCH 10/10] [SYSTEMDS-3544] revert renaming of valuetypes

---
 .../java/org/apache/sysds/common/Types.java   |  8 ++---
 .../java/org/apache/sysds/hops/DataOp.java    |  2 +-
 .../java/org/apache/sysds/hops/LiteralOp.java | 18 +++++-----
 .../sysds/hops/rewrite/HopRewriteUtils.java   | 16 ++++-----
 .../sysds/parser/BooleanIdentifier.java       |  2 +-
 .../parser/BuiltinFunctionExpression.java     | 14 ++++----
 .../apache/sysds/parser/DMLTranslator.java    | 12 +++----
 .../apache/sysds/parser/DataExpression.java   | 10 +++---
 .../sysds/parser/ForStatementBlock.java       |  2 +-
 .../org/apache/sysds/parser/Identifier.java   |  4 +--
 .../sysds/parser/IterablePredicate.java       |  2 +-
 ...arameterizedBuiltinFunctionExpression.java |  4 +--
 .../sysds/parser/RelationalExpression.java    |  2 +-
 .../parser/dml/DmlSyntacticValidator.java     |  2 +-
 .../controlprogram/IfProgramBlock.java        |  4 +--
 .../controlprogram/ParForProgramBlock.java    |  2 +-
 .../runtime/controlprogram/ProgramBlock.java  |  2 +-
 .../controlprogram/WhileProgramBlock.java     |  4 +--
 .../sysds/runtime/data/BasicTensorBlock.java  |  2 +-
 .../runtime/data/DenseBlockBoolBitset.java    |  2 +-
 .../sysds/runtime/data/DenseBlockFactory.java |  7 ++--
 .../runtime/data/DenseBlockLBoolBitset.java   |  2 +-
 .../sysds/runtime/data/LibTensorAgg.java      |  4 +--
 .../sysds/runtime/data/TensorBlock.java       |  6 ++--
 .../sysds/runtime/frame/data/FrameBlock.java  | 16 ++++-----
 .../runtime/frame/data/columns/Array.java     |  4 +--
 .../frame/data/columns/ArrayFactory.java      | 10 +++---
 .../frame/data/columns/BitSetArray.java       |  4 +--
 .../frame/data/columns/BooleanArray.java      |  4 +--
 .../frame/data/columns/DoubleArray.java       |  2 +-
 .../frame/data/columns/OptionalArray.java     |  6 ++--
 .../frame/data/columns/StringArray.java       |  2 +-
 .../frame/data/lib/FrameFromMatrixBlock.java  |  2 +-
 .../runtime/frame/data/lib/FrameUtil.java     | 14 ++++----
 .../instructions/cp/BooleanObject.java        |  2 +-
 .../instructions/cp/DataGenCPInstruction.java |  2 +-
 .../runtime/instructions/cp/ListObject.java   |  2 +-
 .../cp/ParameterizedBuiltinCPInstruction.java |  2 +-
 .../instructions/cp/ReshapeCPInstruction.java |  2 +-
 .../cp/ScalarBuiltinNaryCPInstruction.java    |  2 +-
 .../instructions/cp/ScalarObjectFactory.java  | 14 ++++----
 .../instructions/cp/SqlCPInstruction.java     |  4 +--
 .../cp/UnaryScalarCPInstruction.java          |  2 +-
 .../cp/VariableCPInstruction.java             |  4 +--
 .../ParameterizedBuiltinFEDInstruction.java   |  8 ++---
 .../instructions/fed/ReorgFEDInstruction.java |  4 +--
 .../fed/ReshapeFEDInstruction.java            |  2 +-
 .../gpu/MatrixReshapeGPUInstruction.java      |  2 +-
 .../spark/MatrixReshapeSPInstruction.java     |  2 +-
 .../instructions/spark/RandSPInstruction.java |  2 +-
 .../spark/utils/FrameRDDConverterUtils.java   |  4 +--
 .../apache/sysds/runtime/iogen/RawRow.java    |  4 +--
 .../sysds/runtime/iogen/ValueTrimFormat.java  |  8 ++---
 .../sysds/runtime/util/DataConverter.java     |  4 +--
 .../apache/sysds/runtime/util/HDFSTool.java   |  6 ++--
 .../sysds/runtime/util/ProgramConverter.java  |  2 +-
 .../sysds/runtime/util/UtilFunctions.java     | 24 ++++++-------
 .../java/org/apache/sysds/test/TestUtils.java | 10 +++---
 .../component/frame/FrameAppendTest_Old.java  |  2 +-
 .../component/frame/FrameApplySchema.java     |  6 ++--
 .../component/frame/FrameCastingTest.java     |  2 +-
 .../test/component/frame/FrameCopyTest.java   |  4 +--
 .../component/frame/FrameEvictionTest.java    |  2 +-
 .../frame/FrameFromMatrixBlockTest.java       | 28 +++++++--------
 .../test/component/frame/FrameGetSetTest.java |  4 +--
 .../component/frame/FrameIndexingTest.java    |  2 +-
 .../frame/FrameSerializationTest.java         |  2 +-
 .../sysds/test/component/frame/FrameTest.java |  4 +--
 .../test/component/frame/FrameUtilTest.java   | 20 +++++------
 .../frame/array/CustomArrayTests.java         | 36 +++++++++----------
 .../frame/array/NegativeArrayTests.java       | 12 +++----
 .../TransformCompressedTestMultiCol.java      | 14 ++++----
 .../tensor/DenseBlockConstIndexingTest.java   | 18 +++++-----
 .../tensor/DenseBlockConstructionTest.java    | 16 ++++-----
 .../tensor/DenseBlockCountNonZeroTest.java    | 16 ++++-----
 .../tensor/DenseBlockGetSetIndexingTest.java  | 16 ++++-----
 .../tensor/DenseBlockIncrementTest.java       |  8 ++---
 .../tensor/DenseBlockSetDenseBlockTest.java   | 28 +++++++--------
 .../tensor/DenseBlockSetRowTest.java          | 16 ++++-----
 .../tensor/TensorConstructionTest.java        | 22 ++++++------
 .../tensor/TensorGetSetIndexingTest.java      | 10 +++---
 .../tensor/TensorSerializationTest.java       |  4 +--
 .../builtin/part1/BuiltinImputeFDTest.java    |  6 ++--
 .../tensor/TensorBinaryBlockParallelTest.java |  4 +--
 .../data/tensor/TensorBinaryBlockTest.java    |  4 +--
 .../tensor/TensorTextCellParallelTest.java    |  4 +--
 .../data/tensor/TensorTextCellTest.java       |  4 +--
 .../primitives/FederatedConstructionTest.java |  2 +-
 .../test/functions/frame/ApplySchemaTest.java |  4 +--
 .../functions/frame/DetectSchemaTest.java     |  4 +--
 .../functions/frame/FrameAppendDistTest.java  |  2 +-
 .../functions/frame/FrameConstructorTest.java |  2 +-
 .../functions/frame/FrameConverterTest.java   |  4 +--
 .../test/functions/frame/FrameEqualTest.java  |  4 +--
 .../frame/FrameIndexingDistTest.java          |  2 +-
 .../functions/frame/FrameReadWriteTest.java   |  2 +-
 .../FrameScalarCastingIntegratedTest.java     | 10 +++---
 .../frame/FrameScalarCastingTest.java         |  4 +--
 .../functions/frame/FrameSchemaReadTest.java  |  2 +-
 .../test/functions/frame/TypeOfTest.java      |  2 +-
 .../functions/iogen/GenerateRandomFrame.java  |  4 +--
 .../iogen/GenerateReaderFrameTest.java        | 10 +++---
 .../functions/misc/ScalarAssignmentTest.java  | 10 +++---
 .../misc/ValueTypeAutoCastingTest.java        | 12 +++----
 .../functions/misc/ValueTypeCastingTest.java  | 18 +++++-----
 .../test/functions/mlcontext/FrameTest.java   |  2 +-
 .../mlcontext/MLContextFrameTest.java         |  6 ++--
 .../LiteralReplaceCastScalarReadTest.java     |  4 +--
 .../ColumnEncoderSerializationTest.java       |  4 +--
 109 files changed, 370 insertions(+), 373 deletions(-)

diff --git a/src/main/java/org/apache/sysds/common/Types.java b/src/main/java/org/apache/sysds/common/Types.java
index 18bbaa2461e..78ed173bc9e 100644
--- a/src/main/java/org/apache/sysds/common/Types.java
+++ b/src/main/java/org/apache/sysds/common/Types.java
@@ -76,7 +76,7 @@ public boolean isUnknown() {
 	 */
 	public enum ValueType {
 		UINT4, UINT8, // Used for parsing in UINT values from numpy.
-		FP32, FP64, INT32, INT64, BITSET, BOOLEAN, STRING, UNKNOWN,
+		FP32, FP64, INT32, INT64, BOOLEAN, STRING, UNKNOWN,
 		CHARACTER;
 		
 		public boolean isNumeric() {
@@ -86,7 +86,7 @@ public boolean isUnknown() {
 			return this == UNKNOWN;
 		}
 		public boolean isPseudoNumeric() {
-			return isNumeric() || this == BITSET || this == CHARACTER;
+			return isNumeric() || this == BOOLEAN || this == CHARACTER;
 		}
 		public String toExternalString() {
 			switch(this) {
@@ -96,7 +96,6 @@ public String toExternalString() {
 				case UINT8:
 				case INT32:
 				case INT64:   return "INT";
-				case BITSET:  return "BITSET";
 				case BOOLEAN: return "BOOLEAN";
 				default:      return toString();
 			}
@@ -114,7 +113,6 @@ public static ValueType fromExternalString(String value) {
 				case "INT32":    return INT32;
 				case "INT64":
 				case "INT":      return INT64;
-				case "BITSET":  return BITSET;
 				case "BOOLEAN":  return BOOLEAN;
 				case "STRING":   return STRING;
 				case "CHARACTER": return CHARACTER;
@@ -197,7 +195,7 @@ else if(b == UNKNOWN)
 					default:
 						return a;
 				}
-				case BITSET:
+				case BOOLEAN:
 					return b; // always higher type in b;
 				case UNKNOWN:
 				default:
diff --git a/src/main/java/org/apache/sysds/hops/DataOp.java b/src/main/java/org/apache/sysds/hops/DataOp.java
index 63c9e6368cb..42c51e452b7 100644
--- a/src/main/java/org/apache/sysds/hops/DataOp.java
+++ b/src/main/java/org/apache/sysds/hops/DataOp.java
@@ -396,7 +396,7 @@ protected double computeOutputMemEstimate( long dim1, long dim2, long nnz )
 					ret = OptimizerUtils.INT_SIZE; break;
 				case FP64:
 					ret = OptimizerUtils.DOUBLE_SIZE; break;
-				case BITSET:
+				case BOOLEAN:
 					ret = OptimizerUtils.BOOLEAN_SIZE; break;
 				case STRING: 
 					// by default, it estimates the size of string[100]
diff --git a/src/main/java/org/apache/sysds/hops/LiteralOp.java b/src/main/java/org/apache/sysds/hops/LiteralOp.java
index 213cb8aabe5..5d3f06bd663 100644
--- a/src/main/java/org/apache/sysds/hops/LiteralOp.java
+++ b/src/main/java/org/apache/sysds/hops/LiteralOp.java
@@ -58,7 +58,7 @@ public LiteralOp(String value) {
 	}
 
 	public LiteralOp(boolean value) {
-		super(String.valueOf(value), DataType.SCALAR, ValueType.BITSET);
+		super(String.valueOf(value), DataType.SCALAR, ValueType.BOOLEAN);
 		value_boolean = value;
 	}
 	
@@ -96,8 +96,8 @@ public Lop constructLops()
 			case FP64:
 				l = Data.createLiteralLop(ValueType.FP64, Double.toString(value_double));
 				break;
-			case BITSET:
-				l = Data.createLiteralLop(ValueType.BITSET, Boolean.toString(value_boolean));
+			case BOOLEAN:
+				l = Data.createLiteralLop(ValueType.BOOLEAN, Boolean.toString(value_boolean));
 				break;
 			case STRING:
 				l = Data.createLiteralLop(ValueType.STRING, value_string);
@@ -131,7 +131,7 @@ public String getOpString() {
 			case FP64:
 				val = Double.toString(value_double);
 				break;
-			case BITSET:
+			case BOOLEAN:
 				val = Boolean.toString(value_boolean);
 				break;
 			case STRING:
@@ -156,7 +156,7 @@ protected double computeOutputMemEstimate( long dim1, long dim2, long nnz )
 				ret = OptimizerUtils.INT_SIZE; break;
 			case FP64:
 				ret = OptimizerUtils.DOUBLE_SIZE; break;
-			case BITSET:
+			case BOOLEAN:
 				ret = OptimizerUtils.BOOLEAN_SIZE; break;
 			case STRING: 
 				ret = this.value_string.length() * OptimizerUtils.CHAR_SIZE; break;
@@ -205,7 +205,7 @@ public long getLongValue() {
 				return UtilFunctions.toLong(value_double);
 			case STRING:
 				return Long.parseLong(value_string);
-			case BITSET:
+			case BOOLEAN:
 				return value_boolean ? 1 : 0;
 			default:
 				return -1;
@@ -220,7 +220,7 @@ public double getDoubleValue() {
 				return value_double;
 			case STRING:
 				return Double.parseDouble(value_string);
-			case BITSET:
+			case BOOLEAN:
 				return value_boolean ? 1 : 0;
 			default:
 				throw new HopsException("Can not coerce an object of type " + getValueType() + " into Double.");
@@ -235,7 +235,7 @@ public boolean getBooleanValue() {
 				return (value_double != 0);
 			case STRING:
 				return Boolean.parseBoolean(value_string);
-			case BITSET:
+			case BOOLEAN:
 				return value_boolean;
 			default:
 				throw new HopsException("Can not coerce an object of type " + getValueType() + " into Boolean.");
@@ -244,7 +244,7 @@ public boolean getBooleanValue() {
 	
 	public String getStringValue() {
 		switch( getValueType() ) {
-			case BITSET:
+			case BOOLEAN:
 				return String.valueOf(value_boolean);
 			case UINT4:
 			case UINT8:
diff --git a/src/main/java/org/apache/sysds/hops/rewrite/HopRewriteUtils.java b/src/main/java/org/apache/sysds/hops/rewrite/HopRewriteUtils.java
index c74b3f42bdd..338393eda5b 100644
--- a/src/main/java/org/apache/sysds/hops/rewrite/HopRewriteUtils.java
+++ b/src/main/java/org/apache/sysds/hops/rewrite/HopRewriteUtils.java
@@ -105,7 +105,7 @@ public static boolean getBooleanValue( LiteralOp op ) {
 		switch( op.getValueType() ) {
 			case FP64:    return op.getDoubleValue() != 0; 
 			case INT64:   return op.getLongValue()   != 0;
-			case BITSET: return op.getBooleanValue();
+			case BOOLEAN: return op.getBooleanValue();
 			default: throw new HopsException("Invalid boolean value: "+op.getValueType());
 		}
 	}
@@ -115,7 +115,7 @@ public static boolean getBooleanValueSafe( LiteralOp op ) {
 			switch( op.getValueType() ) {
 				case FP64:    return op.getDoubleValue() != 0; 
 				case INT64:   return op.getLongValue()   != 0;
-				case BITSET: return op.getBooleanValue();
+				case BOOLEAN: return op.getBooleanValue();
 				default: throw new HopsException("Invalid boolean value: "+op.getValueType());
 			}
 		}
@@ -131,7 +131,7 @@ public static double getDoubleValue( LiteralOp op ) {
 			case STRING:
 			case FP64:    return op.getDoubleValue(); 
 			case INT64:   return op.getLongValue();
-			case BITSET: return op.getBooleanValue() ? 1 : 0;
+			case BOOLEAN: return op.getBooleanValue() ? 1 : 0;
 			default: throw new HopsException("Invalid double value: "+op.getValueType());
 		}
 	}
@@ -140,7 +140,7 @@ public static double getDoubleValueSafe( LiteralOp op ) {
 		switch( op.getValueType() ) {
 			case FP64:  return op.getDoubleValue(); 
 			case INT64:     return op.getLongValue();
-			case BITSET: return op.getBooleanValue() ? 1 : 0;
+			case BOOLEAN: return op.getBooleanValue() ? 1 : 0;
 			default: return Double.MAX_VALUE;
 		}
 	}
@@ -160,7 +160,7 @@ public static long getIntValue( LiteralOp op ) {
 			case FP64:  return UtilFunctions.toLong(op.getDoubleValue());
 			case STRING:
 			case INT64:     return op.getLongValue();
-			case BITSET: return op.getBooleanValue() ? 1 : 0;
+			case BOOLEAN: return op.getBooleanValue() ? 1 : 0;
 			default: throw new HopsException("Invalid int value: "+op.getValueType());
 		}
 	}
@@ -173,7 +173,7 @@ public static long getIntValueSafe( LiteralOp op ) {
 		switch( op.getValueType() ) {
 			case FP64:    return UtilFunctions.toLong(op.getDoubleValue());
 			case INT64:   return op.getLongValue();
-			case BITSET: return op.getBooleanValue() ? 1 : 0;
+			case BOOLEAN: return op.getBooleanValue() ? 1 : 0;
 			default: return Long.MAX_VALUE;
 		}
 	}
@@ -196,7 +196,7 @@ public static boolean isLiteralOfValue(Hop hop, String val) {
 	public static boolean isLiteralOfValue( Hop hop, boolean val ) {
 		try {
 			return (hop instanceof LiteralOp 
-				&& (hop.getValueType()==ValueType.BITSET)
+				&& (hop.getValueType()==ValueType.BOOLEAN)
 				&& ((LiteralOp)hop).getBooleanValue()==val);
 		}
 		catch(HopsException ex) {
@@ -655,7 +655,7 @@ public static BinaryOp createBinary(Hop input1, Hop input2, OpOp2 op, boolean ou
 			mainInput.getValueType(), op, input1, input2);
 		//cleanup value type for relational operations
 		if( bop.isPPredOperation() && bop.getDataType().isScalar() )
-			bop.setValueType(ValueType.BITSET);
+			bop.setValueType(ValueType.BOOLEAN);
 		bop.setOuterVectorOperation(outer);
 		bop.setBlocksize(mainInput.getBlocksize());
 		copyLineNumbers(mainInput, bop);
diff --git a/src/main/java/org/apache/sysds/parser/BooleanIdentifier.java b/src/main/java/org/apache/sysds/parser/BooleanIdentifier.java
index 98206ed2f76..dc4e164451a 100644
--- a/src/main/java/org/apache/sysds/parser/BooleanIdentifier.java
+++ b/src/main/java/org/apache/sysds/parser/BooleanIdentifier.java
@@ -50,7 +50,7 @@ private void setInfo(boolean val) {
 		_val = val;
 		setDimensions(0, 0);
 		computeDataType();
-		setValueType(ValueType.BITSET);
+		setValueType(ValueType.BOOLEAN);
 	}
 
 	@Override
diff --git a/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java b/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
index a72606546be..092969cc2bc 100644
--- a/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
+++ b/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
@@ -616,7 +616,7 @@ public void validateExpression(HashMap<String, DataIdentifier> ids, HashMap<Stri
 				case INT32:
 				case UINT8:
 				case UINT4:
-				case BITSET:
+				case BOOLEAN:
 					output.setValueType(ValueType.INT64);
 					break;
 				case UNKNOWN:
@@ -779,7 +779,7 @@ else if( getAllExpr().length == 2 ) { //binary
 			//output.setDataType(id.getDataType()); //TODO whenever we support multiple matrix value types, currently noop.
 			output.setDimensions(0, 0);
 			output.setBlocksize(0);
-			output.setValueType(ValueType.BITSET);
+			output.setValueType(ValueType.BOOLEAN);
 			break;
 			
 		case IFELSE:
@@ -966,7 +966,7 @@ else if( getOpCode() == Builtins.RBIND ) {
 			output.setDataType(DataType.SCALAR);
 			output.setDimensions(0, 0);
 			output.setBlocksize(0);
-			output.setValueType(ValueType.BITSET);
+			output.setValueType(ValueType.BOOLEAN);
 			break;
 		
 		// Contingency tables
@@ -1270,20 +1270,20 @@ else if( getOpCode() == Builtins.RBIND ) {
 				checkNumParameters(4);
 				if (in[3].getOutput().getValueType() != ValueType.INT64) 
 					throw new LanguageException("Fourth argument, seed, to sample() must be an integer value.");
-				if (in[2].getOutput().getValueType() != ValueType.BITSET)
+				if (in[2].getOutput().getValueType() != ValueType.BOOLEAN)
 					throw new LanguageException("Third argument to sample() must either denote replacement policy (boolean) or seed (integer).");
 			}
 			else if(in.length == 3) 
 			{
 				checkNumParameters(3);
-				if (in[2].getOutput().getValueType() != ValueType.BITSET
+				if (in[2].getOutput().getValueType() != ValueType.BOOLEAN
 						&& in[2].getOutput().getValueType() != ValueType.INT64 ) 
 					throw new LanguageException("Third argument to sample() must either denote replacement policy (boolean) or seed (integer).");
 			}
 			
 			if ( check && in.length >= 3 
 					&& isConstant(in[2]) 
-					&& in[2].getOutput().getValueType() == ValueType.BITSET
+					&& in[2].getOutput().getValueType() == ValueType.BOOLEAN
 					&& !((BooleanIdentifier)in[2]).getValue() )
 				throw new LanguageException("Sample (size=" + ((ConstIdentifier)in[0]).getLongValue() 
 						+ ") larger than population (size=" + ((ConstIdentifier)in[1]).getLongValue() 
@@ -2030,7 +2030,7 @@ public static Builtins getValueTypeCastOperator( ValueType vt ) {
 				return Builtins.CAST_AS_DOUBLE;
 			case INT64:
 				return Builtins.CAST_AS_INT;
-			case BITSET:
+			case BOOLEAN:
 				return Builtins.CAST_AS_BOOLEAN;
 			default:
 				throw new LanguageException("No cast for value type "+vt);
diff --git a/src/main/java/org/apache/sysds/parser/DMLTranslator.java b/src/main/java/org/apache/sysds/parser/DMLTranslator.java
index 8cd860ec943..7810eed272a 100644
--- a/src/main/java/org/apache/sysds/parser/DMLTranslator.java
+++ b/src/main/java/org/apache/sysds/parser/DMLTranslator.java
@@ -1439,7 +1439,7 @@ else if (passedSB instanceof IfStatementBlock) {
 		
 		DataIdentifier target = new DataIdentifier(Expression.getTempName());
 		target.setDataType(DataType.SCALAR);
-		target.setValueType(ValueType.BITSET);
+		target.setValueType(ValueType.BOOLEAN);
 		target.setParseInfo(passedSB);
 		Hop predicateHops = null;
 		Expression predicate = cp.getPredicate();
@@ -1806,12 +1806,12 @@ private Hop processRelationalExpression(RelationalExpression source, DataIdentif
 			}
 			else if(left.getDataType() == DataType.FRAME || right.getDataType() == DataType.FRAME) {
 				target.setDataType(DataType.FRAME);
-				target.setValueType(ValueType.BITSET);
+				target.setValueType(ValueType.BOOLEAN);
 			}
 			else {
 				// Added to support scalar relational comparison
 				target.setDataType(DataType.SCALAR);
-				target.setValueType(ValueType.BITSET);
+				target.setValueType(ValueType.BOOLEAN);
 			}
 		}
 		
@@ -1859,7 +1859,7 @@ private Hop processBooleanExpression(BooleanExpression source, DataIdentifier ta
 		if (target == null)
 			target = createTarget(source);
 		if( target.getDataType().isScalar() )
-			target.setValueType(ValueType.BITSET);
+			target.setValueType(ValueType.BOOLEAN);
 		
 		if (source.getRight() == null) {
 			Hop currUop = new UnaryOp(target.getName(), target.getDataType(), target.getValueType(), OpOp1.NOT, left);
@@ -2561,7 +2561,7 @@ else if ( sop.equalsIgnoreCase("!=") )
 			currBuiltinOp = new UnaryOp(target.getName(), target.getDataType(), ValueType.INT64, OpOp1.CAST_AS_INT, expr);
 			break;
 		case CAST_AS_BOOLEAN:
-			currBuiltinOp = new UnaryOp(target.getName(), target.getDataType(), ValueType.BITSET, OpOp1.CAST_AS_BOOLEAN, expr);
+			currBuiltinOp = new UnaryOp(target.getName(), target.getDataType(), ValueType.BOOLEAN, OpOp1.CAST_AS_BOOLEAN, expr);
 			break;
 		case LOCAL:
 			currBuiltinOp = new UnaryOp(target.getName(), target.getDataType(), ValueType.FP64, OpOp1.LOCAL, expr);
@@ -2708,7 +2708,7 @@ else if ( sop.equalsIgnoreCase("!=") )
 			else if ( in.length == 3 )
 			{
 				// check if the third argument is "replace" or "seed"
-				if ( expr3.getValueType() == ValueType.BITSET)
+				if ( expr3.getValueType() == ValueType.BOOLEAN)
 				{
 					tmpparams.put(DataExpression.RAND_PDF, expr3);
 					tmpparams.put(DataExpression.RAND_SEED, new LiteralOp(DataGenOp.UNSPECIFIED_SEED) );
diff --git a/src/main/java/org/apache/sysds/parser/DataExpression.java b/src/main/java/org/apache/sysds/parser/DataExpression.java
index 4213b4b176c..c100c4de502 100644
--- a/src/main/java/org/apache/sysds/parser/DataExpression.java
+++ b/src/main/java/org/apache/sysds/parser/DataExpression.java
@@ -1129,8 +1129,8 @@ else if( getVarParam(READNNZPARAM) != null ) {
 				//handle all csv default parameters
 				handleCSVDefaultParam(DELIM_DELIMITER, ValueType.STRING, conditional);
 				handleCSVDefaultParam(DELIM_FILL_VALUE, ValueType.FP64, conditional);
-				handleCSVDefaultParam(DELIM_HAS_HEADER_ROW, ValueType.BITSET, conditional);
-				handleCSVDefaultParam(DELIM_FILL, ValueType.BITSET, conditional);
+				handleCSVDefaultParam(DELIM_HAS_HEADER_ROW, ValueType.BOOLEAN, conditional);
+				handleCSVDefaultParam(DELIM_FILL, ValueType.BOOLEAN, conditional);
 				handleCSVDefaultParam(DELIM_NA_STRINGS, ValueType.STRING, conditional);
 			}
 
@@ -1283,7 +1283,7 @@ else if (valueTypeString.equalsIgnoreCase(Statement.STRING_VALUE_TYPE))
 				else if (valueTypeString.equalsIgnoreCase(Statement.INT_VALUE_TYPE))
 					getOutput().setValueType(ValueType.INT64);
 				else if (valueTypeString.equalsIgnoreCase(Statement.BOOLEAN_VALUE_TYPE))
-					getOutput().setValueType(ValueType.BITSET);
+					getOutput().setValueType(ValueType.BOOLEAN);
 				else if (valueTypeString.equalsIgnoreCase(ValueType.UNKNOWN.name()))
 					getOutput().setValueType(ValueType.UNKNOWN);
 				else {
@@ -2168,7 +2168,7 @@ private void handleCSVDefaultParam(String param, ValueType vt, boolean condition
 		if (getVarParam(param) == null) {
 			Expression defExpr = null;
 			switch(vt) {
-				case BITSET:
+				case BOOLEAN:
 					defExpr = new BooleanIdentifier((boolean)csvDefaults.get(param), this);
 					break;
 				case FP64:
@@ -2198,7 +2198,7 @@ private boolean checkFormatType(FileFormat... fmts) {
 	private boolean checkValueType(Expression expr, ValueType vt) {
 		return (vt == ValueType.STRING && expr instanceof StringIdentifier)
 			|| (vt == ValueType.FP64 && (expr instanceof DoubleIdentifier || expr instanceof IntIdentifier))
-			|| (vt == ValueType.BITSET && expr instanceof BooleanIdentifier);
+			|| (vt == ValueType.BOOLEAN && expr instanceof BooleanIdentifier);
 	}
 
 	private void validateParams(boolean conditional, Set<String> validParamNames, String legalMessage) {
diff --git a/src/main/java/org/apache/sysds/parser/ForStatementBlock.java b/src/main/java/org/apache/sysds/parser/ForStatementBlock.java
index 36515381db9..ce31ae9bcf5 100644
--- a/src/main/java/org/apache/sysds/parser/ForStatementBlock.java
+++ b/src/main/java/org/apache/sysds/parser/ForStatementBlock.java
@@ -386,7 +386,7 @@ private static Expression replaceConstantVar(Expression expr, HashMap<String, Co
 				case INT64:
 					ret = new IntIdentifier((IntIdentifier) constValue, expr);
 					break;
-				case BITSET:
+				case BOOLEAN:
 					ret = new IntIdentifier(
 							new BooleanObject(((BooleanIdentifier) constValue).getValue()).getLongValue(), expr);
 					break;
diff --git a/src/main/java/org/apache/sysds/parser/Identifier.java b/src/main/java/org/apache/sysds/parser/Identifier.java
index ba6acffdf5d..3ea3252a852 100644
--- a/src/main/java/org/apache/sysds/parser/Identifier.java
+++ b/src/main/java/org/apache/sysds/parser/Identifier.java
@@ -202,7 +202,7 @@ public void computeDataType() {
 	
 	public void setBooleanProperties(){
 		_dataType = DataType.SCALAR;
-		_valueType = ValueType.BITSET;
+		_valueType = ValueType.BOOLEAN;
 		_dim1 = 0;
 		_dim2 = 0;
 		_blocksize = 0;
@@ -222,7 +222,7 @@ public void setIntProperties(){
 	
 	
 	public boolean isScalarBoolean(){
-		return (_valueType == ValueType.BITSET) && (_dataType == DataType.SCALAR);
+		return (_valueType == ValueType.BOOLEAN) && (_dataType == DataType.SCALAR);
 	}
 	
 	public boolean dimsKnown(){
diff --git a/src/main/java/org/apache/sysds/parser/IterablePredicate.java b/src/main/java/org/apache/sysds/parser/IterablePredicate.java
index 5ef51b4ecfa..3e5a9d3a930 100644
--- a/src/main/java/org/apache/sysds/parser/IterablePredicate.java
+++ b/src/main/java/org/apache/sysds/parser/IterablePredicate.java
@@ -191,7 +191,7 @@ private void checkNumericScalarOutput( Expression expr ) {
 		
 		Identifier ident = expr.getOutput();
 		if( ident.getDataType() == DataType.MATRIX ||
-			(ident.getDataType() == DataType.SCALAR && (ident.getValueType() == ValueType.BITSET ||
+			(ident.getDataType() == DataType.SCALAR && (ident.getValueType() == ValueType.BOOLEAN ||
 			ident.getValueType() == ValueType.STRING)) )
 		{
 			throw new LanguageException(this.printErrorLocation() + "expression in iterable predicate in for loop '" + expr.toString() + "' must return a numeric scalar");
diff --git a/src/main/java/org/apache/sysds/parser/ParameterizedBuiltinFunctionExpression.java b/src/main/java/org/apache/sysds/parser/ParameterizedBuiltinFunctionExpression.java
index eed0cc55a0f..1906ee818e8 100644
--- a/src/main/java/org/apache/sysds/parser/ParameterizedBuiltinFunctionExpression.java
+++ b/src/main/java/org/apache/sysds/parser/ParameterizedBuiltinFunctionExpression.java
@@ -848,7 +848,7 @@ else if( !(margin instanceof DataIdentifier) && !margin.toString().equals("rows"
 		}
 		
 		Expression empty = getVarParam("empty.return");
-		if( empty!=null && (!empty.getOutput().getDataType().isScalar() || empty.getOutput().getValueType() != ValueType.BITSET) ){
+		if( empty!=null && (!empty.getOutput().getDataType().isScalar() || empty.getOutput().getValueType() != ValueType.BOOLEAN) ){
 			raiseValidateError("Boolean parameter 'empty.return' is of type "+empty.getOutput().getDataType()
 				+"["+empty.getOutput().getValueType()+"].", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
 		}
@@ -987,7 +987,7 @@ private void checkEmptyTargetParam(Expression target, boolean conditional) {
 	}
 	
 	private void checkOptionalBooleanParam(Expression param, String name, boolean conditional) {
-		if( param!=null && (!param.getOutput().getDataType().isScalar() || param.getOutput().getValueType() != ValueType.BITSET) ){
+		if( param!=null && (!param.getOutput().getDataType().isScalar() || param.getOutput().getValueType() != ValueType.BOOLEAN) ){
 			raiseValidateError("Boolean parameter '"+name+"' is of type "+param.getOutput().getDataType()
 				+"["+param.getOutput().getValueType()+"].", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
 		}
diff --git a/src/main/java/org/apache/sysds/parser/RelationalExpression.java b/src/main/java/org/apache/sysds/parser/RelationalExpression.java
index 254d230cf14..f0b4695439a 100644
--- a/src/main/java/org/apache/sysds/parser/RelationalExpression.java
+++ b/src/main/java/org/apache/sysds/parser/RelationalExpression.java
@@ -160,7 +160,7 @@ public void validateExpression(HashMap<String,DataIdentifier> ids, HashMap<Strin
 		else if(isLeftFrame && isRightFrame) {
 			output.setDataType(DataType.FRAME);
 			output.setDimensions(_left.getOutput().getDim1(), _left.getOutput().getDim2());
-			output.setValueType(ValueType.BITSET);
+			output.setValueType(ValueType.BOOLEAN);
 		}
 		else if( isLeftFrame || isRightFrame ) {
 			raiseValidateError("Unsupported relational expression for mixed types "
diff --git a/src/main/java/org/apache/sysds/parser/dml/DmlSyntacticValidator.java b/src/main/java/org/apache/sysds/parser/dml/DmlSyntacticValidator.java
index bc387a0e32a..6387cfcaf4d 100644
--- a/src/main/java/org/apache/sysds/parser/dml/DmlSyntacticValidator.java
+++ b/src/main/java/org/apache/sysds/parser/dml/DmlSyntacticValidator.java
@@ -1725,7 +1725,7 @@ else if( (shortVt && valueType.equals("str"))
 		}
 		else if( (shortVt && valueType.equals("bool"))
 			|| valueType.equals("boolean") || valueType.equals("Boolean")) {
-			dataId.setValueType(ValueType.BITSET);
+			dataId.setValueType(ValueType.BOOLEAN);
 		}
 		else if( (shortVt && valueType.equals("float") )
 			|| valueType.equals("double") || valueType.equals("Double")) {
diff --git a/src/main/java/org/apache/sysds/runtime/controlprogram/IfProgramBlock.java b/src/main/java/org/apache/sysds/runtime/controlprogram/IfProgramBlock.java
index cb8008c38fb..f88dff517eb 100644
--- a/src/main/java/org/apache/sysds/runtime/controlprogram/IfProgramBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/controlprogram/IfProgramBlock.java
@@ -138,10 +138,10 @@ private BooleanObject executePredicate(ExecutionContext ec)
 			if( _sb != null ) {
 				IfStatementBlock isb = (IfStatementBlock)_sb;
 				result = (BooleanObject) executePredicate(_predicate, isb.getPredicateHops(), 
-					isb.requiresPredicateRecompilation(), ValueType.BITSET, ec);
+					isb.requiresPredicateRecompilation(), ValueType.BOOLEAN, ec);
 			}
 			else
-				result = (BooleanObject) executePredicate(_predicate, null, false, ValueType.BITSET, ec);
+				result = (BooleanObject) executePredicate(_predicate, null, false, ValueType.BOOLEAN, ec);
 		}
 		catch(Exception ex) {
 			throw new DMLRuntimeException(this.printBlockErrorLocation() + "Failed to evaluate the IF predicate.", ex);
diff --git a/src/main/java/org/apache/sysds/runtime/controlprogram/ParForProgramBlock.java b/src/main/java/org/apache/sysds/runtime/controlprogram/ParForProgramBlock.java
index 47ab3824ac4..2fc12c4c267 100644
--- a/src/main/java/org/apache/sysds/runtime/controlprogram/ParForProgramBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/controlprogram/ParForProgramBlock.java
@@ -1124,7 +1124,7 @@ private static void createEmptyUnscopedVariables( LocalVariableMap out, Statemen
 				{
 					case SCALAR:
 						switch( valuetype ) {
-							case BITSET: dataObj = new BooleanObject(false); break;
+							case BOOLEAN: dataObj = new BooleanObject(false); break;
 							case INT64:     dataObj = new IntObject(-1);        break;
 							case FP64:  dataObj = new DoubleObject(-1d);    break;
 							case STRING:  dataObj = new StringObject("-1");   break;
diff --git a/src/main/java/org/apache/sysds/runtime/controlprogram/ProgramBlock.java b/src/main/java/org/apache/sysds/runtime/controlprogram/ProgramBlock.java
index d9fd3da3c48..75fe42de89d 100644
--- a/src/main/java/org/apache/sysds/runtime/controlprogram/ProgramBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/controlprogram/ProgramBlock.java
@@ -218,7 +218,7 @@ protected ScalarObject executePredicateInstructions(ArrayList<Instruction> inst,
 		// check and correct scalar ret type (incl save double to int)
 		if(retType != null && retType != ret.getValueType())
 			switch(retType) {
-				case BITSET:
+				case BOOLEAN:
 					ret = new BooleanObject(ret.getBooleanValue());
 					break;
 				case INT64:
diff --git a/src/main/java/org/apache/sysds/runtime/controlprogram/WhileProgramBlock.java b/src/main/java/org/apache/sysds/runtime/controlprogram/WhileProgramBlock.java
index c62f6b9d36c..7dea91b7aba 100644
--- a/src/main/java/org/apache/sysds/runtime/controlprogram/WhileProgramBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/controlprogram/WhileProgramBlock.java
@@ -77,10 +77,10 @@ private BooleanObject executePredicate(ExecutionContext ec)
 				WhileStatementBlock wsb = (WhileStatementBlock)_sb;
 				Hop predicateOp = wsb.getPredicateHops();
 				boolean recompile = wsb.requiresPredicateRecompilation();
-				result = (BooleanObject) executePredicate(_predicate, predicateOp, recompile, ValueType.BITSET, ec);
+				result = (BooleanObject) executePredicate(_predicate, predicateOp, recompile, ValueType.BOOLEAN, ec);
 			}
 			else
-				result = (BooleanObject) executePredicate(_predicate, null, false, ValueType.BITSET, ec);
+				result = (BooleanObject) executePredicate(_predicate, null, false, ValueType.BOOLEAN, ec);
 		}
 		catch(Exception ex) {
 			throw new DMLRuntimeException(this.printBlockErrorLocation() + "Failed to evaluate the while predicate.", ex);
diff --git a/src/main/java/org/apache/sysds/runtime/data/BasicTensorBlock.java b/src/main/java/org/apache/sysds/runtime/data/BasicTensorBlock.java
index 8cf4563888d..3710f723318 100644
--- a/src/main/java/org/apache/sysds/runtime/data/BasicTensorBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/data/BasicTensorBlock.java
@@ -312,7 +312,7 @@ public Object get(int[] ix) {
 					return _denseBlock.getLong(ix);
 				case INT32:
 					return (int) _denseBlock.getLong(ix);
-				case BITSET:
+				case BOOLEAN:
 					return _denseBlock.get(ix) != 0;
 				case STRING:
 					return _denseBlock.getString(ix);
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
index 56ced3537e4..ee293a38aa8 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockBoolBitset.java
@@ -67,7 +67,7 @@ public boolean isNumeric() {
 	
 	@Override
 	public boolean isNumeric(ValueType vt) {
-		return ValueType.BITSET == vt;
+		return ValueType.BOOLEAN == vt;
 	}
 	
 	@Override
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
index 1facadab740..6949ad01a84 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockFactory.java
@@ -44,7 +44,7 @@ public static DenseBlock createDenseBlock(int[] dims) {
 	public static DenseBlock createDenseBlock(int[] dims, boolean dedup) {
 		return createDenseBlock(ValueType.FP64, dims, dedup);
 	}
-	
+
 	public static DenseBlock createDenseBlock(ValueType vt, int[] dims) {
 		DenseBlock.Type type = (UtilFunctions.prod(dims) < Integer.MAX_VALUE) ?
 			DenseBlock.Type.DRB : DenseBlock.Type.LDRB;
@@ -118,8 +118,7 @@ public static DenseBlock createDenseBlock(ValueType vt, DenseBlock.Type type, in
 					case FP64: return new DenseBlockFP64(dims);
 					case INT32: return new DenseBlockInt32(dims);
 					case INT64: return new DenseBlockInt64(dims);
-					case BITSET: return new DenseBlockBoolBitset(dims);
-					case BOOLEAN: return new DenseBlockBoolArray(dims);
+					case BOOLEAN: return new DenseBlockBoolBitset(dims);
 					case STRING: return new DenseBlockString(dims);
 					default:
 						throw new DMLRuntimeException("Unsupported dense block value type: "+vt.name());
@@ -128,7 +127,7 @@ public static DenseBlock createDenseBlock(ValueType vt, DenseBlock.Type type, in
 				switch(vt) {
 					case FP32: return new DenseBlockLFP32(dims);
 					case FP64: return new DenseBlockLFP64(dims);
-					case BITSET: return new DenseBlockLBoolBitset(dims);
+					case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 					case INT32: return new DenseBlockLInt32(dims);
 					case INT64: return new DenseBlockLInt64(dims);
 					case STRING: return new DenseBlockLString(dims);
diff --git a/src/main/java/org/apache/sysds/runtime/data/DenseBlockLBoolBitset.java b/src/main/java/org/apache/sysds/runtime/data/DenseBlockLBoolBitset.java
index 0ad5b2aa490..17414c07ebc 100644
--- a/src/main/java/org/apache/sysds/runtime/data/DenseBlockLBoolBitset.java
+++ b/src/main/java/org/apache/sysds/runtime/data/DenseBlockLBoolBitset.java
@@ -61,7 +61,7 @@ public boolean isNumeric() {
 	
 	@Override
 	public boolean isNumeric(ValueType vt) {
-		return ValueType.BITSET == vt;
+		return ValueType.BOOLEAN == vt;
 	}
 
 
diff --git a/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java b/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
index c43b2b932d8..6ea603edace 100644
--- a/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
+++ b/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
@@ -49,7 +49,7 @@ private enum AggType {
 	 */
 	public static boolean satisfiesMultiThreadingConstraints(BasicTensorBlock in, int k) {
 		// TODO more conditions depending on operation
-		return k > 1 && in._vt != Types.ValueType.BITSET;
+		return k > 1 && in._vt != Types.ValueType.BOOLEAN;
 	}
 
 	/**
@@ -224,7 +224,7 @@ private static void sum(BasicTensorBlock in, BasicTensorBlock out, Plus plus, in
 			throw new DMLRuntimeException("Sparse aggregation not implemented for Tensor");
 		}
 		switch (in.getValueType()) {
-			case BITSET: {
+			case BOOLEAN: {
 				//TODO switch to no-op nnz meta data once available
 				out.set(0, 0, in.getDenseBlock().countNonZeros());
 				break;
diff --git a/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java b/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
index 6150152fa1d..5047ee25248 100644
--- a/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
@@ -658,7 +658,7 @@ public long getExactBlockDataSerializedSize(BasicTensorBlock bt) {
 				case INT64:
 				case FP64:
 					size += 8 * getLength(); break;
-				case BITSET:
+				case BOOLEAN:
 					//TODO perf bits instead of bytes
 					size += getLength(); break;
 					//size += Math.ceil((double)getLength() / 64); break;
@@ -737,7 +737,7 @@ else if (!bt.isSparse()) {
 						case FP64: out.writeDouble(a.get(i, j)); break;
 						case INT32: out.writeInt((int) a.getLong(ix)); break;
 						case INT64: out.writeLong(a.getLong(ix)); break;
-						case BITSET: out.writeBoolean(a.get(i, j) != 0); break;
+						case BOOLEAN: out.writeBoolean(a.get(i, j) != 0); break;
 						case STRING:
 							String s = a.getString(ix);
 							out.writeUTF(s == null ? "" : s);
@@ -811,7 +811,7 @@ protected void readBlockData(DataInput in, BasicTensorBlock bt) throws IOExcepti
 							case FP64: a.set(i, j, in.readDouble()); break;
 							case INT32: a.set(ix, in.readInt()); break;
 							case INT64: a.set(ix, in.readLong()); break;
-							case BITSET: a.set(i, j, in.readByte()); break;
+							case BOOLEAN: a.set(i, j, in.readByte()); break;
 							case STRING:
 								// FIXME readUTF is not supported for CacheDataInput
 								a.set(ix, in.readUTF());
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/FrameBlock.java b/src/main/java/org/apache/sysds/runtime/frame/data/FrameBlock.java
index 0876e870285..5faacaf8d1d 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/FrameBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/FrameBlock.java
@@ -575,7 +575,7 @@ public void appendColumn(String[] col) {
 	 */
 	public void appendColumn(boolean[] col) {
 		ensureColumnCompatibility(col.length);
-		appendColumnMetaData(ValueType.BITSET);
+		appendColumnMetaData(ValueType.BOOLEAN);
 		_coldata = FrameUtil.add(_coldata, ArrayFactory.create(col));
 	}
 
@@ -949,7 +949,7 @@ else if(getSchema()[i] == ValueType.INT64 || that.getSchema()[i] == ValueType.IN
 				}
 			}
 		}
-		return new FrameBlock(UtilFunctions.nCopies(frameBlock.getNumColumns(), ValueType.BITSET), outputData);
+		return new FrameBlock(UtilFunctions.nCopies(frameBlock.getNumColumns(), ValueType.BOOLEAN), outputData);
 	}
 
 	private static boolean checkAndSetEmpty(FrameBlock fb1, FrameBlock fb2, String[][] out, int r, int c) {
@@ -1324,8 +1324,8 @@ else if(schemaCol.contains("STRING"))
 
 				ValueType dataType = FrameUtil.isType(dataValue);
 
-				if(!dataType.toString().contains(type) && !(dataType == ValueType.BITSET && type.equals("INT")) &&
-					!(dataType == ValueType.BITSET && type.equals("FP"))) {
+				if(!dataType.toString().contains(type) && !(dataType == ValueType.BOOLEAN && type.equals("INT")) &&
+					!(dataType == ValueType.BOOLEAN && type.equals("FP"))) {
 					LOG.warn("Datatype detected: " + dataType + " where expected: " + schemaString[i] + " col: " + (i + 1)
 						+ ", row:" + (j + 1));
 
@@ -1435,8 +1435,8 @@ public FrameBlock valueSwap(FrameBlock schema) {
 				String type = dataType.toString().replaceAll("\\d", "");
 				// get the avergae column length
 				if(!dataType.toString().contains(schemaString[i]) &&
-					!(dataType == ValueType.BITSET && schemaString[i].equals("INT")) &&
-					!(dataType == ValueType.BITSET && schemaString[i].equals("FP")) &&
+					!(dataType == ValueType.BOOLEAN && schemaString[i].equals("INT")) &&
+					!(dataType == ValueType.BOOLEAN && schemaString[i].equals("FP")) &&
 					!(dataType.toString().contains("INT") && schemaString[i].equals("FP"))) {
 					LOG.warn("conflict " + dataType + " " + schemaString[i] + " " + dataValue);
 					// check the other column with satisfy the data type of this value
@@ -1601,10 +1601,10 @@ public <T> FrameBlock replaceOperations(String pattern, String replacement) {
 
 		boolean NaNp = "NaN".equals(pattern);
 		boolean NaNr = "NaN".equals(replacement);
-		ValueType patternType = UtilFunctions.isBoolean(pattern) ? ValueType.BITSET : (NumberUtils.isCreatable(pattern) |
+		ValueType patternType = UtilFunctions.isBoolean(pattern) ? ValueType.BOOLEAN : (NumberUtils.isCreatable(pattern) |
 			NaNp ? (UtilFunctions.isIntegerNumber(pattern) ? ValueType.INT64 : ValueType.FP64) : ValueType.STRING);
 		ValueType replacementType = UtilFunctions
-			.isBoolean(replacement) ? ValueType.BITSET : (NumberUtils.isCreatable(replacement) |
+			.isBoolean(replacement) ? ValueType.BOOLEAN : (NumberUtils.isCreatable(replacement) |
 				NaNr ? (UtilFunctions.isIntegerNumber(replacement) ? ValueType.INT64 : ValueType.FP64) : ValueType.STRING);
 
 		if(patternType != replacementType || !ValueType.isSameTypeString(patternType, replacementType))
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/Array.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/Array.java
index 1c4c4b033a4..3fbf3ed2d0c 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/Array.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/Array.java
@@ -381,7 +381,7 @@ public Array<?> changeTypeWithNulls(ValueType t) {
 			return changeType(t);
 
 		switch(t) {
-			case BITSET:
+			case BOOLEAN:
 				if(size() > ArrayFactory.bitSetSwitchPoint)
 					return new OptionalArray<Boolean>(changeTypeBitSet(), nulls);
 				else
@@ -415,7 +415,7 @@ public Array<?> changeTypeWithNulls(ValueType t) {
 	 */
 	public final Array<?> changeType(ValueType t) {
 		switch(t) {
-			case BITSET:
+			case BOOLEAN:
 				if(size() > ArrayFactory.bitSetSwitchPoint)
 					return changeTypeBitSet();
 				else
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
index 45cd31270a2..11defd31cd2 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/ArrayFactory.java
@@ -73,13 +73,11 @@ public static <T> OptionalArray<T> create(T[] col) {
 
 	public static long getInMemorySize(ValueType type, int _numRows) {
 		switch(type) {
-			case BITSET:
+			case BOOLEAN:
 				if(_numRows > bitSetSwitchPoint)
 					return Array.baseMemoryCost() + (long) MemoryEstimates.longArrayCost(_numRows >> 6 + 1);
 				else
 					return Array.baseMemoryCost() + (long) MemoryEstimates.booleanArrayCost(_numRows);
-			case BOOLEAN:
-				return Array.baseMemoryCost() + (long) MemoryEstimates.booleanArrayCost(_numRows);
 			case INT64:
 				return Array.baseMemoryCost() + (long) MemoryEstimates.longArrayCost(_numRows);
 			case FP64:
@@ -109,7 +107,7 @@ public static Array<?> allocate(ValueType v, int nRow, String val) {
 
 	public static Array<?> allocateOptional(ValueType v, int nRow) {
 		switch(v) {
-			case BITSET:
+			case BOOLEAN:
 				if(nRow > bitSetSwitchPoint)
 					return new OptionalArray<>(new BitSetArray(nRow), true);
 				else
@@ -142,7 +140,7 @@ public static ABooleanArray allocateBoolean(int nRow) {
 
 	public static Array<?> allocate(ValueType v, int nRow) {
 		switch(v) {
-			case BITSET:
+			case BOOLEAN:
 				return allocateBoolean(nRow);
 			case UINT4:
 			case UINT8:
@@ -260,7 +258,7 @@ else if(target.getFrameArrayType() != FrameArrayType.OPTIONAL //
 
 	public static Object parseString(String s, ValueType v) {
 		switch(v) {
-			case BITSET:
+			case BOOLEAN:
 				return BooleanArray.parseBoolean(s);
 			case CHARACTER:
 				return CharArray.parseChar(s);
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/BitSetArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/BitSetArray.java
index 6155e6aa953..d6c2489ec2c 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/BitSetArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/BitSetArray.java
@@ -365,12 +365,12 @@ public byte[] getAsByteArray() {
 
 	@Override
 	public ValueType getValueType() {
-		return ValueType.BITSET;
+		return ValueType.BOOLEAN;
 	}
 
 	@Override
 	public Pair<ValueType, Boolean> analyzeValueType() {
-		return new Pair<ValueType, Boolean>(ValueType.BITSET, false);
+		return new Pair<ValueType, Boolean>(ValueType.BOOLEAN, false);
 	}
 
 	@Override
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/BooleanArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/BooleanArray.java
index 33171e7c859..e74f8bcd653 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/BooleanArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/BooleanArray.java
@@ -185,12 +185,12 @@ public byte[] getAsByteArray() {
 
 	@Override
 	public ValueType getValueType() {
-		return ValueType.BITSET;
+		return ValueType.BOOLEAN;
 	}
 
 	@Override
 	public Pair<ValueType, Boolean> analyzeValueType() {
-		return new Pair<ValueType, Boolean>(ValueType.BITSET, false);
+		return new Pair<ValueType, Boolean>(ValueType.BOOLEAN, false);
 	}
 
 	@Override
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/DoubleArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/DoubleArray.java
index 5c266bdc029..de8def92de8 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/DoubleArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/DoubleArray.java
@@ -208,7 +208,7 @@ public Pair<ValueType, Boolean> analyzeValueType() {
 					}
 					break;
 				default:
-				case BITSET:
+				case BOOLEAN:
 					switch(c) {
 						case FP64:
 						case FP32:
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/OptionalArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/OptionalArray.java
index e52611bfdd9..6898e9472c4 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/OptionalArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/OptionalArray.java
@@ -42,7 +42,7 @@ public OptionalArray(T[] a) {
 		super(a.length);
 
 		if(a instanceof Boolean[])
-			_a = (Array<T>) ArrayFactory.allocate(ValueType.BITSET, a.length);
+			_a = (Array<T>) ArrayFactory.allocate(ValueType.BOOLEAN, a.length);
 		else if(a instanceof Integer[])
 			_a = (Array<T>) ArrayFactory.allocate(ValueType.INT32, a.length);
 		else if(a instanceof Double[])
@@ -109,7 +109,7 @@ protected static OptionalArray<?> readOpt(DataInput in, int nRow) throws IOExcep
 		final Array<?> a = ArrayFactory.read(in, nRow);
 		final ABooleanArray n = (ABooleanArray) ArrayFactory.read(in, nRow);
 		switch(a.getValueType()) {
-			case BITSET:
+			case BOOLEAN:
 				return new OptionalArray<Boolean>((Array<Boolean>) a, n);
 			case FP32:
 				return new OptionalArray<Float>((Array<Float>) a, n);
@@ -400,7 +400,7 @@ public final boolean isNotEmpty(int i) {
 	public Array<?> changeTypeWithNulls(ValueType t) {
 
 		switch(t) {
-			case BITSET:
+			case BOOLEAN:
 				if(size() > ArrayFactory.bitSetSwitchPoint)
 					return changeTypeBitSet();
 				else
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/columns/StringArray.java b/src/main/java/org/apache/sysds/runtime/frame/data/columns/StringArray.java
index e839d583755..e99903d4b39 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/columns/StringArray.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/columns/StringArray.java
@@ -222,7 +222,7 @@ private static final ValueType getHighest(ValueType state, ValueType c) {
 					default:
 				}
 				break;
-			case BITSET:
+			case BOOLEAN:
 				switch(c) {
 					case FP64:
 					case FP32:
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameFromMatrixBlock.java b/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameFromMatrixBlock.java
index 6d06f7ee5f6..3164724f4f6 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameFromMatrixBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameFromMatrixBlock.java
@@ -85,7 +85,7 @@ public static FrameBlock convertToFrameBlock(MatrixBlock mb, ValueType[] schema,
 	private ValueType[] getSchema(MatrixBlock mb) {
 		final int nCol = mb.getNumColumns();
 		final int nRow = mb.getNumRows();
-		ValueType[] schema = UtilFunctions.nCopies(nCol, ValueType.BITSET);
+		ValueType[] schema = UtilFunctions.nCopies(nCol, ValueType.BOOLEAN);
 		for(int r = 0; r < nRow; r++)
 			for(int c = 0; c < nCol; c++)
 				schema[c] = FrameUtil.isType(mb.quickGetValue(r, c), schema[c]);
diff --git a/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameUtil.java b/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameUtil.java
index 985ceedf2e8..7f66ecfe6d3 100644
--- a/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameUtil.java
+++ b/src/main/java/org/apache/sysds/runtime/frame/data/lib/FrameUtil.java
@@ -61,7 +61,7 @@ public static Array<?>[] add(Array<?>[] ar, Array<?> e) {
 
 	private static ValueType isBooleanType(final String val, int len) {
 		if(val.length() <= 16 && booleanPattern.matcher(val).matches())
-			return ValueType.BITSET;
+			return ValueType.BOOLEAN;
 		return null;
 	}
 
@@ -138,10 +138,10 @@ public static ValueType isType(String val, ValueType minType) {
 		ValueType r = null;
 		switch(minType) {
 			case UNKNOWN:
-			case BITSET:
+			case BOOLEAN:
 			case CHARACTER:
 				if(isBooleanType(val, len) != null)
-					return ValueType.BITSET;
+					return ValueType.BOOLEAN;
 			case UINT8:
 			case INT32:
 			case INT64:
@@ -162,12 +162,12 @@ public static ValueType isType(String val, ValueType minType) {
 	}
 
 	public static ValueType isType(String val) {
-		return isType(val, ValueType.BITSET);
+		return isType(val, ValueType.BOOLEAN);
 	}
 
 	public static ValueType isType(double val) {
 		if(val == 1.0d || val == 0.0d)
-			return ValueType.BITSET;
+			return ValueType.BOOLEAN;
 		else if((long) (val) == val) {
 			if((int) val == val)
 				return ValueType.INT32;
@@ -183,7 +183,7 @@ else if(same(val, (float) val))
 
 	public static ValueType isType(double val, ValueType min) {
 		switch(min) {
-			case BITSET:
+			case BOOLEAN:
 				return isType(val);
 			case INT32:
 			case UINT8:
@@ -239,7 +239,7 @@ public static boolean isDefault(String v, ValueType t) {
 		if(v == null)
 			return true;
 		switch(t) {
-			case BITSET:
+			case BOOLEAN:
 				return !BooleanArray.parseBoolean(v);
 			case CHARACTER:
 				return 0 == CharArray.parseChar(v);
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/BooleanObject.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/BooleanObject.java
index 522f927a917..c285761a54b 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/BooleanObject.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/BooleanObject.java
@@ -29,7 +29,7 @@ public class BooleanObject extends ScalarObject
 	private final boolean _value;
 	
 	public BooleanObject(boolean val){
-		super(ValueType.BITSET);
+		super(ValueType.BOOLEAN);
 		_value = val;
 	}
 
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/DataGenCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/DataGenCPInstruction.java
index f18d14f3a64..ad218bbbed1 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/DataGenCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/DataGenCPInstruction.java
@@ -430,7 +430,7 @@ private CacheBlock<?> processRandInstructionTensor(ExecutionContext ec, long lSe
 		if(minValueStr.equals(maxValueStr)) {
 			if(minMaxAreDoubles)
 				outT.set(minValue);
-			else if(output.getValueType() == ValueType.STRING || output.getValueType() == ValueType.BITSET)
+			else if(output.getValueType() == ValueType.STRING || output.getValueType() == ValueType.BOOLEAN)
 				outT.set(minValueStr);
 			else
 				throw new DMLRuntimeException("Rand instruction cannot fill numeric tensor with non numeric elements.");
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ListObject.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ListObject.java
index 92936cc3672..5c302fe80a9 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ListObject.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ListObject.java
@@ -468,7 +468,7 @@ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundExcept
 					switch (valueType) {
 						case INT64:     so = new IntObject(Long.parseLong(value)); break;
 						case FP64:  	so = new DoubleObject(Double.parseDouble(value)); break;
-						case BITSET: 	so = new BooleanObject(Boolean.parseBoolean(value)); break;
+						case BOOLEAN: 	so = new BooleanObject(Boolean.parseBoolean(value)); break;
 						case STRING:  	so = new StringObject(value); break;
 						default:
 							throw new DMLRuntimeException("Unable to parse valuetype " + valueType);
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ParameterizedBuiltinCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ParameterizedBuiltinCPInstruction.java
index d3b84411cd2..18a199e9308 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ParameterizedBuiltinCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ParameterizedBuiltinCPInstruction.java
@@ -574,7 +574,7 @@ private CPOperand getStringLiteral(String name) {
 	}
 
 	private CPOperand getBoolLiteral(String name) {
-		return getLiteral(name, ValueType.BITSET);
+		return getLiteral(name, ValueType.BOOLEAN);
 	}
 
 	private CPOperand getLiteral(String name, ValueType vt) {
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ReshapeCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ReshapeCPInstruction.java
index 63da1d1f25d..9cf30acb374 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ReshapeCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ReshapeCPInstruction.java
@@ -96,7 +96,7 @@ else if (input1.getDataType() == Types.DataType.MATRIX) {
 			MatrixBlock in = ec.getMatrixInput(input1.getName());
 			int rows = (int) ec.getScalarInput(_opRows).getLongValue(); //save cast
 			int cols = (int) ec.getScalarInput(_opCols).getLongValue(); //save cast
-			BooleanObject byRow = (BooleanObject) ec.getScalarInput(_opByRow.getName(), ValueType.BITSET, _opByRow.isLiteral());
+			BooleanObject byRow = (BooleanObject) ec.getScalarInput(_opByRow.getName(), ValueType.BOOLEAN, _opByRow.isLiteral());
 
 			//execute operations
 			MatrixBlock out = new MatrixBlock();
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarBuiltinNaryCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarBuiltinNaryCPInstruction.java
index cb67d0781b6..096072895fd 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarBuiltinNaryCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarBuiltinNaryCPInstruction.java
@@ -75,7 +75,7 @@ public void processInstruction(ExecutionContext ec) {
 					case FP64:
 						objects[i - 1] = scalarObject.getDoubleValue();
 						break;
-					case BITSET:
+					case BOOLEAN:
 						objects[i - 1] = scalarObject.getBooleanValue();
 						break;
 					case STRING:
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarObjectFactory.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarObjectFactory.java
index 12d77da3bcb..6e74620394d 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarObjectFactory.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/ScalarObjectFactory.java
@@ -40,7 +40,7 @@ public static ScalarObject createScalarObject(ValueType vt, String value) {
 		switch( vt ) {
 			case INT64:   return new IntObject(UtilFunctions.parseToLong(value));
 			case FP64:    return new DoubleObject(Double.parseDouble(value));
-			case BITSET: return new BooleanObject(Boolean.parseBoolean(value));
+			case BOOLEAN: return new BooleanObject(Boolean.parseBoolean(value));
 			case STRING:  return new StringObject(value);
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
@@ -49,7 +49,7 @@ public static ScalarObject createScalarObject(ValueType vt, String value) {
 	public static ScalarObject createScalarObject(ValueType vt, Object obj) {
 		//TODO add new scalar object for extended type system
 		switch( vt ) {
-			case BITSET: return new BooleanObject((Boolean)obj);
+			case BOOLEAN: return new BooleanObject((Boolean)obj);
 			case INT64:   return new IntObject((Long)obj);
 			case INT32:   return new IntObject((Integer)obj);
 			case FP64:    return new DoubleObject((Double)obj);
@@ -63,7 +63,7 @@ public static ScalarObject createScalarObject(ValueType vt, double value) {
 		switch( vt ) {
 			case INT64:     return new IntObject(UtilFunctions.toLong(value));
 			case FP64:  return new DoubleObject(value);
-			case BITSET: return new BooleanObject(value != 0);
+			case BOOLEAN: return new BooleanObject(value != 0);
 			case STRING:  return new StringObject(String.valueOf(value));
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
@@ -73,7 +73,7 @@ public static ScalarObject createScalarObject(ValueType vt, ScalarObject so) {
 		switch( vt ) {
 			case FP64:    return castToDouble(so);
 			case INT64:   return castToLong(so);
-			case BITSET: return new BooleanObject(so.getBooleanValue());
+			case BOOLEAN: return new BooleanObject(so.getBooleanValue());
 			case STRING:  return new StringObject(so.getStringValue());
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
@@ -87,7 +87,7 @@ public static ScalarObject createScalarObject(ValueType vt, LiteralOp lit) {
 		switch( vt ) {
 			case FP64:    return new DoubleObject(lit.getDoubleValue());
 			case INT64:   return new IntObject(lit.getLongValue());
-			case BITSET: return new BooleanObject(lit.getBooleanValue());
+			case BOOLEAN: return new BooleanObject(lit.getBooleanValue());
 			case STRING:  return new StringObject(lit.getStringValue());
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
@@ -97,7 +97,7 @@ public static LiteralOp createLiteralOp(ScalarObject so) {
 		switch( so.getValueType() ){
 			case FP64:    return new LiteralOp(so.getDoubleValue());
 			case INT64:   return new LiteralOp(so.getLongValue());
-			case BITSET: return new LiteralOp(so.getBooleanValue());
+			case BOOLEAN: return new LiteralOp(so.getBooleanValue());
 			case STRING:  return new LiteralOp(so.getStringValue());
 			default:
 				throw new HopsException("Unsupported literal value type: "+so.getValueType());
@@ -117,7 +117,7 @@ public static LiteralOp createLiteralOp(ValueType vt, String value) {
 		switch( vt ) {
 			case FP64:    return new LiteralOp(Double.parseDouble(value));
 			case INT64:   return new LiteralOp(Long.parseLong(value));
-			case BITSET: return new LiteralOp(Boolean.parseBoolean(value));
+			case BOOLEAN: return new LiteralOp(Boolean.parseBoolean(value));
 			case STRING:  return new LiteralOp(value);
 			default: throw new RuntimeException("Unsupported scalar value type: "+vt.name());
 		}
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/SqlCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/SqlCPInstruction.java
index 99dc737b829..e4453bce8ba 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/SqlCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/SqlCPInstruction.java
@@ -101,7 +101,7 @@ private static void setCell(TensorBlock outBlock, ResultSet resultSet, ValueType
 			case FP32: outBlock.set(ix, resultSet.getFloat(sqlCol)); break;
 			case INT64: outBlock.set(ix, resultSet.getLong(sqlCol)); break;
 			case INT32: outBlock.set(ix, resultSet.getInt(sqlCol)); break;
-			case BITSET: outBlock.set(ix, resultSet.getBoolean(sqlCol)); break;
+			case BOOLEAN: outBlock.set(ix, resultSet.getBoolean(sqlCol)); break;
 			case STRING: outBlock.set(ix, resultSet.getString(sqlCol)); break;
 			default: throw new DMLRuntimeException("Cell can not be set to valuetype " + valueType.name());
 		}
@@ -122,7 +122,7 @@ private static ValueType[] getSchemaFromMetaData(ResultSetMetaData meta) throws
 				case Types.SMALLINT:
 				case Types.TINYINT:
 				case Types.INTEGER: schema[i] = ValueType.INT32; break;
-				case Types.BIT:     schema[i] = ValueType.BITSET; break;
+				case Types.BIT:     schema[i] = ValueType.BOOLEAN; break;
 				default:            schema[i] = ValueType.STRING; break;
 			}
 		}
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/UnaryScalarCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/UnaryScalarCPInstruction.java
index fbdd58000a0..a3bc7223058 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/UnaryScalarCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/UnaryScalarCPInstruction.java
@@ -72,7 +72,7 @@ else if ( opcode.equalsIgnoreCase("assert") ) {
 			UnaryOperator dop = (UnaryOperator) _optr;
 			if ( so instanceof IntObject && output.getValueType() == ValueType.INT64 )
 				sores = new IntObject((long)dop.fn.execute(so.getLongValue()));
-			else if( so instanceof BooleanObject && output.getValueType() == ValueType.BITSET)
+			else if( so instanceof BooleanObject && output.getValueType() == ValueType.BOOLEAN)
 				sores = new BooleanObject(dop.fn.execute(so.getBooleanValue()));
 			else
 				sores = new DoubleObject(dop.fn.execute(so.getDoubleValue()));
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/cp/VariableCPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/cp/VariableCPInstruction.java
index e2794892fcf..8bec222b0d3 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/cp/VariableCPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/cp/VariableCPInstruction.java
@@ -386,7 +386,7 @@ else if ( voc == VariableOperationCode.Write ) {
 			// file name
 			in2 = new CPOperand(parts[2], ValueType.STRING, DataType.SCALAR);
 			// file name override flag (always literal)
-			in3 = new CPOperand(parts[3], ValueType.BITSET, DataType.SCALAR);
+			in3 = new CPOperand(parts[3], ValueType.BOOLEAN, DataType.SCALAR);
 
 			// format
 			String fmt = parts[5];
@@ -544,7 +544,7 @@ else if(fmt.equalsIgnoreCase("hdf5")) {
 			in1 = new CPOperand(parts[1]);
 			in2 = new CPOperand(parts[2]);
 			// second argument must be a boolean
-			if ( in2.getValueType() != ValueType.BITSET)
+			if ( in2.getValueType() != ValueType.BOOLEAN)
 				throw new DMLRuntimeException("Unexpected value type for second argument in: " + str);
 			break;
 
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/fed/ParameterizedBuiltinFEDInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/fed/ParameterizedBuiltinFEDInstruction.java
index 62f7e5f3d83..7654b92eccb 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/fed/ParameterizedBuiltinFEDInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/fed/ParameterizedBuiltinFEDInstruction.java
@@ -370,10 +370,10 @@ public Pair<String, LineageItem> getLineageItem(ExecutionContext ec) {
 			LineageItem[] liUdfInputs = Arrays.stream(getInputIDs())
 				.mapToObj(id -> ec.getLineage().get(String.valueOf(id))).toArray(LineageItem[]::new);
 			CPOperand slice = new CPOperand(Arrays.toString(_slice), ValueType.STRING, DataType.SCALAR, true);
-			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BITSET, DataType.SCALAR, true);
-			CPOperand lower = new CPOperand(String.valueOf(_lower), ValueType.BITSET, DataType.SCALAR, true);
-			CPOperand diag = new CPOperand(String.valueOf(_diag), ValueType.BITSET, DataType.SCALAR, true);
-			CPOperand values = new CPOperand(String.valueOf(_values), ValueType.BITSET, DataType.SCALAR, true);
+			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BOOLEAN, DataType.SCALAR, true);
+			CPOperand lower = new CPOperand(String.valueOf(_lower), ValueType.BOOLEAN, DataType.SCALAR, true);
+			CPOperand diag = new CPOperand(String.valueOf(_diag), ValueType.BOOLEAN, DataType.SCALAR, true);
+			CPOperand values = new CPOperand(String.valueOf(_values), ValueType.BOOLEAN, DataType.SCALAR, true);
 			LineageItem[] otherInputs = LineageItemUtils.getLineage(ec, slice, rowFed, lower, diag, values);
 			LineageItem[] liInputs = Stream.concat(Arrays.stream(liUdfInputs), Arrays.stream(otherInputs))
 				.toArray(LineageItem[]::new);
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/fed/ReorgFEDInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/fed/ReorgFEDInstruction.java
index eea8f398bb8..0b173d7fe8c 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/fed/ReorgFEDInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/fed/ReorgFEDInstruction.java
@@ -349,7 +349,7 @@ public Pair<String, LineageItem> getLineageItem(ExecutionContext ec) {
 					.mapToObj(id -> ec.getLineage().get(String.valueOf(id))).toArray(LineageItem[]::new);
 			CPOperand r_op = new CPOperand(_r_op.fn.getClass().getSimpleName(), ValueType.STRING, DataType.SCALAR, true);
 			CPOperand slice = new CPOperand(Arrays.toString(_slice), ValueType.STRING, DataType.SCALAR, true);
-			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BITSET, DataType.SCALAR, true);
+			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BOOLEAN, DataType.SCALAR, true);
 			LineageItem[] otherInputs = LineageItemUtils.getLineage(ec, r_op, slice, rowFed);
 			LineageItem[] liInputs = Stream.concat(Arrays.stream(liUdfInputs), Arrays.stream(otherInputs))
 					.toArray(LineageItem[]::new);
@@ -408,7 +408,7 @@ public Pair<String, LineageItem> getLineageItem(ExecutionContext ec) {
 			CPOperand r_op = new CPOperand(_r_op.fn.getClass().getSimpleName(), ValueType.STRING, DataType.SCALAR, true);
 			CPOperand len = new CPOperand(String.valueOf(_len), ValueType.INT32, DataType.SCALAR, true);
 			CPOperand slice = new CPOperand(Arrays.toString(_slice), ValueType.STRING, DataType.SCALAR, true);
-			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BITSET, DataType.SCALAR, true);
+			CPOperand rowFed = new CPOperand(String.valueOf(_rowFed), ValueType.BOOLEAN, DataType.SCALAR, true);
 			LineageItem[] otherInputs = LineageItemUtils.getLineage(ec, r_op, len, slice, rowFed);
 			LineageItem[] liInputs = Stream.concat(Arrays.stream(liUdfInputs), Arrays.stream(otherInputs))
 					.toArray(LineageItem[]::new);
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/fed/ReshapeFEDInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/fed/ReshapeFEDInstruction.java
index ded0d3a6b72..3d355cd1dd5 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/fed/ReshapeFEDInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/fed/ReshapeFEDInstruction.java
@@ -88,7 +88,7 @@ public void processInstruction(ExecutionContext ec) {
 		if(output.getDataType() == Types.DataType.MATRIX) {
 			MatrixObject mo1 = ec.getMatrixObject(input1);
 			BooleanObject byRow = (BooleanObject) ec
-				.getScalarInput(_opByRow.getName(), Types.ValueType.BITSET, _opByRow.isLiteral());
+				.getScalarInput(_opByRow.getName(), Types.ValueType.BOOLEAN, _opByRow.isLiteral());
 			int rows = (int) ec.getScalarInput(_opRows).getLongValue();
 			int cols = (int) ec.getScalarInput(_opCols).getLongValue();
 
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/gpu/MatrixReshapeGPUInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/gpu/MatrixReshapeGPUInstruction.java
index fa53be321ad..f82d712b45f 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/gpu/MatrixReshapeGPUInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/gpu/MatrixReshapeGPUInstruction.java
@@ -74,7 +74,7 @@ public static MatrixReshapeGPUInstruction parseInstruction ( String str ) {
 	public void processInstruction(ExecutionContext ec) {
 		int rows = (int)ec.getScalarInput(_opRows).getLongValue(); //save cast
 		int cols = (int)ec.getScalarInput(_opCols).getLongValue(); //save cast
-		BooleanObject byRow = (BooleanObject) ec.getScalarInput(_opByRow.getName(), ValueType.BITSET, _opByRow.isLiteral());
+		BooleanObject byRow = (BooleanObject) ec.getScalarInput(_opByRow.getName(), ValueType.BOOLEAN, _opByRow.isLiteral());
 		
 		GPUStatistics.incrementNoOfExecutedGPUInst();
 		String instName = getExtendedOpcode();
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/spark/MatrixReshapeSPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/spark/MatrixReshapeSPInstruction.java
index 9aa06431163..d8b8e4e3842 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/spark/MatrixReshapeSPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/spark/MatrixReshapeSPInstruction.java
@@ -87,7 +87,7 @@ public void processInstruction(ExecutionContext ec) {
 		//get parameters
 		long rows = ec.getScalarInput(_opRows).getLongValue(); //save cast
 		long cols = ec.getScalarInput(_opCols).getLongValue(); //save cast
-		boolean byRow = ec.getScalarInput(_opByRow.getName(), ValueType.BITSET, _opByRow.isLiteral()).getBooleanValue();
+		boolean byRow = ec.getScalarInput(_opByRow.getName(), ValueType.BOOLEAN, _opByRow.isLiteral()).getBooleanValue();
 
 		DataCharacteristics mcIn = sec.getDataCharacteristics(input1.getName());
 		DataCharacteristics mcOut = sec.getDataCharacteristics(output.getName());
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/spark/RandSPInstruction.java b/src/main/java/org/apache/sysds/runtime/instructions/spark/RandSPInstruction.java
index 7dc4b8e3f2c..05b16d4f76e 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/spark/RandSPInstruction.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/spark/RandSPInstruction.java
@@ -1127,7 +1127,7 @@ public Tuple2<TensorIndexes, TensorBlock> call(Tuple2<TensorIndexes, Long> kv)
 			else {
 				switch (_vt) {
 					case STRING:
-					case BITSET:
+					case BOOLEAN:
 						tb.set(_min);
 						break;
 					case INT64:
diff --git a/src/main/java/org/apache/sysds/runtime/instructions/spark/utils/FrameRDDConverterUtils.java b/src/main/java/org/apache/sysds/runtime/instructions/spark/utils/FrameRDDConverterUtils.java
index 22d805826f3..9371d43094c 100644
--- a/src/main/java/org/apache/sysds/runtime/instructions/spark/utils/FrameRDDConverterUtils.java
+++ b/src/main/java/org/apache/sysds/runtime/instructions/spark/utils/FrameRDDConverterUtils.java
@@ -307,7 +307,7 @@ public static StructType convertFrameSchemaToDFSchema(ValueType[] fschema, boole
 				case STRING:  dt = DataTypes.StringType; break;
 				case FP64:  dt = DataTypes.DoubleType; break;
 				case INT64:     dt = DataTypes.LongType; break;
-				case BITSET: dt = DataTypes.BooleanType; break;
+				case BOOLEAN: dt = DataTypes.BooleanType; break;
 				default:      dt = DataTypes.StringType;
 					LOG.warn("Using default type String for " + schema.toString());
 			}
@@ -348,7 +348,7 @@ else if(structType.dataType() == DataTypes.LongType
 				|| structType.dataType() == DataTypes.IntegerType)
 				fschema[pos++] = ValueType.INT64;
 			else if(structType.dataType() == DataTypes.BooleanType)
-				fschema[pos++] = ValueType.BITSET;
+				fschema[pos++] = ValueType.BOOLEAN;
 			else if(structType.dataType() instanceof VectorUDT) {
 				if( containsVect )
 					throw new RuntimeException("Found invalid second vector column.");
diff --git a/src/main/java/org/apache/sysds/runtime/iogen/RawRow.java b/src/main/java/org/apache/sysds/runtime/iogen/RawRow.java
index f3b5f8d1888..6ef8222e3f0 100644
--- a/src/main/java/org/apache/sysds/runtime/iogen/RawRow.java
+++ b/src/main/java/org/apache/sysds/runtime/iogen/RawRow.java
@@ -71,7 +71,7 @@ public Pair<Integer, Integer> findValue(ValueTrimFormat vtf, boolean forward, bo
 
 		else if(vt == Types.ValueType.STRING)
 			return findStringValue(vtf, forward, update);
-		else if(vt == Types.ValueType.BITSET) {
+		else if(vt == Types.ValueType.BOOLEAN) {
 			ValueTrimFormat vtfb = new ValueTrimFormat(vtf.getStringOfActualValue());
 			return findStringValue(vtfb, forward, update);
 		}
@@ -129,7 +129,7 @@ public Pair<Integer, Integer> findAtValue(ValueTrimFormat vtf, int rawIndex, int
 			return findAtStringValue(vtf, rawIndex, update);
 		else if(vtf.getValueType().isNumeric())
 			return findAtNumericValue(vtf, rawIndex, numericIndex, update);
-		else if(vtf.getValueType() == Types.ValueType.BITSET) {
+		else if(vtf.getValueType() == Types.ValueType.BOOLEAN) {
 			ValueTrimFormat vtfb = new ValueTrimFormat(vtf.getStringOfActualValue());
 			return findAtStringValue(vtfb, rawIndex, update);
 		}
diff --git a/src/main/java/org/apache/sysds/runtime/iogen/ValueTrimFormat.java b/src/main/java/org/apache/sysds/runtime/iogen/ValueTrimFormat.java
index 10640505261..5f5f20a6823 100644
--- a/src/main/java/org/apache/sysds/runtime/iogen/ValueTrimFormat.java
+++ b/src/main/java/org/apache/sysds/runtime/iogen/ValueTrimFormat.java
@@ -73,7 +73,7 @@ public ValueTrimFormat(int colIndex, Types.ValueType vt, Object o) {
 				s.append(c);
 			NString = s.toString();
 		}
-		else if(vt != Types.ValueType.STRING && vt != Types.ValueType.BITSET) {
+		else if(vt != Types.ValueType.STRING && vt != Types.ValueType.BOOLEAN) {
 			throw new RuntimeException("Don't support  value type format!");
 		}
 	}
@@ -132,7 +132,7 @@ public boolean isNotSet() {
 			return actualValue == null || ((String) actualValue).length() == 0;
 		else if(this.valueType.isNumeric())
 			return getDoubleActualValue() == 0;
-		else if(this.valueType == Types.ValueType.BITSET)
+		else if(this.valueType == Types.ValueType.BOOLEAN)
 			return actualValue == null || !((Boolean) actualValue);
 		return true;
 	}
@@ -147,7 +147,7 @@ else if(this.valueType.isNumeric()) {
 			N = new char[] {'0'};
 			NString = null;
 		}
-		else if(this.valueType == Types.ValueType.BITSET)
+		else if(this.valueType == Types.ValueType.BOOLEAN)
 			actualValue = null;
 	}
 
@@ -173,7 +173,7 @@ private static int getLength(ValueTrimFormat vtf) {
 		int len = -1;
 		if(vt == Types.ValueType.STRING )
 			len = vtf.getStringOfActualValue().length();
-		else if(vt == Types.ValueType.BITSET)
+		else if(vt == Types.ValueType.BOOLEAN)
 			len = 1;
 		return len;
 	}
diff --git a/src/main/java/org/apache/sysds/runtime/util/DataConverter.java b/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
index 364d3cef1c9..bfbb9736a4e 100644
--- a/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
+++ b/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
@@ -1124,7 +1124,7 @@ private static void concatenateTensorValue(TensorBlock tb, StringBuilder sb, Dec
 			case INT64:
 				sb.append(tb.get(ix));
 				break;
-			case BITSET:
+			case BOOLEAN:
 				sb.append(((Boolean) tb.get(ix)).toString().toUpperCase());
 				break;
 			case STRING:
@@ -1190,7 +1190,7 @@ public static String toString(FrameBlock fb, boolean sparse, String separator, S
 					sb.append(String.valueOf(row[j]));
 				else if( fb.getSchema()[j] == ValueType.FP64 )
 					sb.append(dfFormat(df, (Double)row[j]));
-				else if( fb.getSchema()[j] == ValueType.BITSET)
+				else if( fb.getSchema()[j] == ValueType.BOOLEAN)
 					sb.append(new BooleanObject((Boolean)row[j])
 						.getLanguageSpecificStringValue());
 				else
diff --git a/src/main/java/org/apache/sysds/runtime/util/HDFSTool.java b/src/main/java/org/apache/sysds/runtime/util/HDFSTool.java
index 7b8373ec09f..58452b9c9a3 100644
--- a/src/main/java/org/apache/sysds/runtime/util/HDFSTool.java
+++ b/src/main/java/org/apache/sysds/runtime/util/HDFSTool.java
@@ -280,7 +280,7 @@ public static long readIntegerFromHDFSFile(String filename) throws IOException {
 	}
 	
 	public static boolean readBooleanFromHDFSFile(String filename) throws IOException {
-		return (Boolean)readObjectFromHDFSFile(filename, ValueType.BITSET);
+		return (Boolean)readObjectFromHDFSFile(filename, ValueType.BOOLEAN);
 	}
 	
 	public static String readStringFromHDFSFile(String filename) 
@@ -309,7 +309,7 @@ public static Object readObjectFromHDFSFile(String filename, ValueType vt) throw
 			throw new IOException("Empty file on hdfs: "+filename);
 		
 		switch( vt ) {
-			case BITSET: return Boolean.parseBoolean(line);
+			case BOOLEAN: return Boolean.parseBoolean(line);
 			case FP64: return Double.parseDouble(line);
 			case INT64: return Long.parseLong(line);
 			default: return line;
@@ -322,7 +322,7 @@ public static ScalarObject readScalarObjectFromHDFSFile(String fname, ValueType
 			switch( vt ) {
 				case INT64:   obj = readIntegerFromHDFSFile(fname); break;
 				case FP64:    obj = readDoubleFromHDFSFile(fname); break;
-				case BITSET: obj = readBooleanFromHDFSFile(fname); break;
+				case BOOLEAN: obj = readBooleanFromHDFSFile(fname); break;
 				case STRING:
 				default:      obj = readStringFromHDFSFile(fname);
 			}
diff --git a/src/main/java/org/apache/sysds/runtime/util/ProgramConverter.java b/src/main/java/org/apache/sysds/runtime/util/ProgramConverter.java
index 05412a9edd9..8fbfe311259 100644
--- a/src/main/java/org/apache/sysds/runtime/util/ProgramConverter.java
+++ b/src/main/java/org/apache/sysds/runtime/util/ProgramConverter.java
@@ -1653,7 +1653,7 @@ public static Object[] parseDataObject(String in) {
 				switch ( valuetype ) {
 					case INT64:     dat = new IntObject(Long.parseLong(valString)); break;
 					case FP64:  dat = new DoubleObject(Double.parseDouble(valString)); break;
-					case BITSET: dat = new BooleanObject(Boolean.parseBoolean(valString)); break;
+					case BOOLEAN: dat = new BooleanObject(Boolean.parseBoolean(valString)); break;
 					case STRING:  dat = new StringObject(valString); break;
 					default:
 						throw new DMLRuntimeException("Unable to parse valuetype "+valuetype);
diff --git a/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java b/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
index 6578ec39e40..0da92cfa5f6 100644
--- a/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
+++ b/src/main/java/org/apache/sysds/runtime/util/UtilFunctions.java
@@ -471,7 +471,7 @@ public static Object doubleToObject(ValueType vt, double in, boolean sparse) {
 		if( Double.isNaN(in) && sparse) return null;
 		switch( vt ) {
 			case STRING:  return String.valueOf(in);
-			case BITSET: return (in!=0);
+			case BOOLEAN: return (in!=0);
 			case INT32:   return UtilFunctions.toInt(in);
 			case INT64:   return UtilFunctions.toLong(in);
 			case FP32:    return ((float)in);
@@ -484,7 +484,7 @@ public static Object stringToObject(ValueType vt, String in) {
 		if( in == null || in.isEmpty() )  return null;
 		switch( vt ) {
 			case STRING:  return in;
-			case BITSET: return Boolean.parseBoolean(in);
+			case BOOLEAN: return Boolean.parseBoolean(in);
 			case UINT4:
 			case UINT8:
 			case INT32:   return Integer.parseInt(in);
@@ -511,7 +511,7 @@ public static double objectToDouble(ValueType vt, Object in) {
 			case FP32:    return (Float)in;
 			case INT64:   return (Long)in;
 			case INT32:   return (Integer)in;
-			case BITSET: return ((Boolean)in) ? 1 : 0;
+			case BOOLEAN: return ((Boolean)in) ? 1 : 0;
 			case STRING:
 				try {
 					return !((String) in).isEmpty() ? Double.parseDouble((String) in) : 0;
@@ -541,7 +541,7 @@ public static float objectToFloat(ValueType vt, Object in) {
 				return (Long) in;
 			case INT32:
 				return (Integer) in;
-			case BITSET:
+			case BOOLEAN:
 				return ((Boolean) in) ? 1 : 0;
 			case STRING:
 				return !((String) in).isEmpty() ? Float.parseFloat((String) in) : 0;
@@ -559,7 +559,7 @@ public static char objectToCharacter(ValueType vt, Object in){
 			case INT64:
 			case INT32:
 				return in.toString().charAt(0);
-			case BITSET:
+			case BOOLEAN:
 				return ((Boolean) in) ? '1' : '0';
 			case STRING:
 				return !((String) in).isEmpty() ? ((String)in).charAt(0) : 0;
@@ -580,7 +580,7 @@ public static int objectToInteger(ValueType vt, Object in) {
 				return ((Long) in).intValue();
 			case INT32:
 				return (Integer) in;
-			case BITSET:
+			case BOOLEAN:
 				return ((Boolean) in) ? 1 : 0;
 			case STRING:
 				return !((String) in).isEmpty() ? Integer.parseInt((String) in) : 0;
@@ -601,7 +601,7 @@ public static long objectToLong(ValueType vt, Object in) {
 				return (Long) in;
 			case INT32:
 				return (Integer) in;
-			case BITSET:
+			case BOOLEAN:
 				return ((Boolean) in) ? 1 : 0;
 			case STRING:
 				return !((String) in).isEmpty() ? Long.parseLong((String) in) : 0;
@@ -622,7 +622,7 @@ public static boolean objectToBoolean(ValueType vt, Object in) {
 				return (Long) in == 1;
 			case INT32:
 				return (Integer) in == 1;
-			case BITSET:
+			case BOOLEAN:
 				return ((Boolean) in);
 			case STRING:
 				return Boolean.parseBoolean((String) in);
@@ -669,7 +669,7 @@ public static Object objectToObject(ValueType vt, Object in) {
 			|| in instanceof Float && vt == ValueType.FP32
 			|| in instanceof Long && vt == ValueType.INT64
 			|| in instanceof Integer && vt == ValueType.INT32
-			|| in instanceof Boolean && vt == ValueType.BITSET
+			|| in instanceof Boolean && vt == ValueType.BOOLEAN
 			|| in instanceof String && vt == ValueType.STRING )
 			return in; //quick path to avoid double parsing
 		else
@@ -691,7 +691,7 @@ public static int compareTo(ValueType vt, Object in1, Object in2) {
  
 		switch( vt ) {
 			case STRING:  return ((String)in1).compareTo((String)in2);
-			case BITSET: return ((Boolean)in1).compareTo((Boolean)in2);
+			case BOOLEAN: return ((Boolean)in1).compareTo((Boolean)in2);
 			case INT64:   return ((Long)in1).compareTo((Long)in2);
 			case INT32:   return ((Integer)in1).compareTo((Integer)in2);
 			case FP64:    return ((Double)in1).compareTo((Double)in2);
@@ -1264,7 +1264,7 @@ public static Object generateRandomValueFromValueType(ValueType valueType, Rando
 			case FP64:    return random.nextDouble();
 			case INT32:   return random.nextInt();
 			case INT64:   return random.nextLong();
-			case BITSET: return random.nextBoolean();
+			case BOOLEAN: return random.nextBoolean();
 			case STRING:
 				return random.ints('a', 'z' + 1).limit(10)
 					.collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
@@ -1294,7 +1294,7 @@ else if (schemaValues[i].equalsIgnoreCase("INT64"))
 			else if (schemaValues[i].equalsIgnoreCase("INT32"))
 				vt[i] = ValueType.INT32;
 			else if (schemaValues[i].equalsIgnoreCase("BOOLEAN"))
-				vt[i] = ValueType.BITSET;
+				vt[i] = ValueType.BOOLEAN;
 			else
 				throw new DMLRuntimeException("Invalid column schema. Allowed values are STRING, FP64, FP32, INT64, INT32 and Boolean");
 		}
diff --git a/src/test/java/org/apache/sysds/test/TestUtils.java b/src/test/java/org/apache/sysds/test/TestUtils.java
index 586ab4f2bc0..ae68201b508 100644
--- a/src/test/java/org/apache/sysds/test/TestUtils.java
+++ b/src/test/java/org/apache/sysds/test/TestUtils.java
@@ -1607,7 +1607,7 @@ public static int compareTo(ValueType vt, Object in1, Object in2, double toleran
 
 		switch( vt ) {
 			case STRING:  return ((String)in1).compareTo((String)in2);
-			case BITSET: return ((Boolean)in1).compareTo((Boolean)in2);
+			case BOOLEAN: return ((Boolean)in1).compareTo((Boolean)in2);
 			case INT64:     return ((Long)in1).compareTo((Long)in2);
 			case FP64:
 				return (Math.abs((Double)in1-(Double)in2) < tolerance)?0:
@@ -1625,7 +1625,7 @@ public static int compareToR(ValueType vt, Object in1, Object inR, double tolera
 				if (in1 == null)
 					throw new DMLRuntimeException("Fail");
 			 	return ((String)in1).compareTo((String)inR);
-			case BITSET:
+			case BOOLEAN:
 				if(in1 == null)
 					return Boolean.FALSE.compareTo(((Boolean)inR).booleanValue());
 				else
@@ -2256,7 +2256,7 @@ public static FrameBlock generateRandomFrameBlock(int rows, ValueType[] schema,
 	private static Array<?> generateColumn(int rows, ValueType type, Random rand, double nullChance) {
 		if(nullChance == 0) {
 			switch(type) {
-				case BITSET:
+				case BOOLEAN:
 					Array<Boolean> a = (Array<Boolean>) ArrayFactory.allocate(type, rows);
 					for(int r = 0; r < rows; r++)
 						a.set(r, rand.nextBoolean());
@@ -2305,7 +2305,7 @@ private static Array<?> generateColumn(int rows, ValueType type, Random rand, do
 		}
 		else {
 			switch(type) {
-				case BITSET:
+				case BOOLEAN:
 					OptionalArray<Boolean> a = (OptionalArray<Boolean>) ArrayFactory.allocateOptional(type, rows);
 					for(int r = 0; r < rows; r++) {
 						if(rand.nextDouble() < nullChance)
@@ -2541,7 +2541,7 @@ public static Object generateRandomValueFromValueType(ValueType valueType, Rando
 			case FP64:    return random.nextDouble();
 			case INT32:   return random.nextInt();
 			case INT64:   return random.nextLong();
-			case BITSET: return random.nextBoolean();
+			case BOOLEAN: return random.nextBoolean();
 			case STRING:
 				return random.ints('a', 'z' + 1)
 						.limit(10)
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameAppendTest_Old.java b/src/test/java/org/apache/sysds/test/component/frame/FrameAppendTest_Old.java
index d3bbd3cf155..9d0339d2b30 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameAppendTest_Old.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameAppendTest_Old.java
@@ -35,7 +35,7 @@ public class FrameAppendTest_Old extends AutomatedTestBase {
 	private final static ValueType[] schemaStrings = new ValueType[] {ValueType.STRING, ValueType.STRING,
 		ValueType.STRING};
 	private final static ValueType[] schemaMixed = new ValueType[] {ValueType.STRING, ValueType.FP64, ValueType.INT64,
-		ValueType.BITSET};
+		ValueType.BOOLEAN};
 
 	@Override
 	public void setUp() {
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameApplySchema.java b/src/test/java/org/apache/sysds/test/component/frame/FrameApplySchema.java
index d725ab868b9..388c41a820f 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameApplySchema.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameApplySchema.java
@@ -38,10 +38,10 @@ public void testApplySchemaStringToBoolean() {
 		try {
 
 			FrameBlock fb = genStringContainingBoolean(10, 2);
-			ValueType[] schema = new ValueType[] {ValueType.BITSET, ValueType.BITSET};
+			ValueType[] schema = new ValueType[] {ValueType.BOOLEAN, ValueType.BOOLEAN};
 			FrameBlock ret = FrameLibApplySchema.applySchema(fb, schema);
-			assertTrue(ret.getColumn(0).getValueType() == ValueType.BITSET);
-			assertTrue(ret.getColumn(1).getValueType() == ValueType.BITSET);
+			assertTrue(ret.getColumn(0).getValueType() == ValueType.BOOLEAN);
+			assertTrue(ret.getColumn(1).getValueType() == ValueType.BOOLEAN);
 		}
 		catch(Exception e) {
 			e.printStackTrace();
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameCastingTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameCastingTest.java
index 2670ddaf3ad..4e8f1c2b9d8 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameCastingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameCastingTest.java
@@ -33,7 +33,7 @@ public class FrameCastingTest extends AutomatedTestBase
 {
 	private final static int rows = 312;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 	
 	private enum CastType {
 		M2F_S,
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameCopyTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameCopyTest.java
index 27da3944fe9..8ee81934645 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameCopyTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameCopyTest.java
@@ -32,7 +32,7 @@ public class FrameCopyTest extends AutomatedTestBase
 {
 	private final static int rows = 342;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 	
 	@Override
 	public void setUp() {
@@ -137,7 +137,7 @@ void updateFrameWithDummyData(FrameBlock frame, int updateRow)
 		for( int j=0; j<lschema.length; j++ )	{
 			switch( lschema[j] ) {
 				case STRING:  frame.set(updateRow,  j,  "String:"+ frame.get(updateRow, j)); break;
-				case BITSET: frame.set(updateRow,  j, ((Boolean)frame.get(updateRow, j))?Boolean.FALSE:Boolean.TRUE); break;
+				case BOOLEAN: frame.set(updateRow,  j, ((Boolean)frame.get(updateRow, j))?Boolean.FALSE:Boolean.TRUE); break;
 				case INT64:     frame.set(updateRow,  j, (Long)frame.get(updateRow, j) * 2 + 5); break;
 				case FP64:  frame.set(updateRow,  j, (Double)frame.get(updateRow, j) * 2 + 7); break;
 				default: throw new RuntimeException("Unsupported value type: "+lschema[j]);
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameEvictionTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameEvictionTest.java
index d75b583c851..ef647b2e104 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameEvictionTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameEvictionTest.java
@@ -46,7 +46,7 @@ public class FrameEvictionTest extends AutomatedTestBase
 	
 	private final static ValueType[] schemaDoubles = new ValueType[]{ValueType.FP64, ValueType.FP64, ValueType.FP64};	
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 	
 	@Override
 	public void setUp() {
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameFromMatrixBlockTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameFromMatrixBlockTest.java
index 5a8eca4c262..76c71973222 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameFromMatrixBlockTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameFromMatrixBlockTest.java
@@ -40,8 +40,8 @@ public class FrameFromMatrixBlockTest {
 	public void toBoolean() {
 		try {
 			MatrixBlock mb = new MatrixBlock(10, 3, 1.0);
-			FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
-			verifyEquivalence(mb, fb, ValueType.BITSET);
+			FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
+			verifyEquivalence(mb, fb, ValueType.BOOLEAN);
 		}
 		catch(Exception e) {
 			e.printStackTrace();
@@ -52,22 +52,22 @@ public void toBoolean() {
 	@Test
 	public void toBooleanEmpty() {
 		MatrixBlock mb = new MatrixBlock(10, 3, 0.0);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
-		verifyEquivalence(mb, fb, ValueType.BITSET);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
+		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
 	}
 
 	@Test
 	public void toBooleanSparse() {
 		MatrixBlock mb = TestUtils.generateTestMatrixBlock(100, 100, 1, 1, 0.2, 213);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
-		verifyEquivalence(mb, fb, ValueType.BITSET);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
+		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
 	}
 
 	@Test
 	public void toBooleanVerySparse() {
 		MatrixBlock mb = TestUtils.generateTestMatrixBlock(100, 100, 1, 1, 0.001, 213);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
-		verifyEquivalence(mb, fb, ValueType.BITSET);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
+		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
 	}
 
 	@Test
@@ -80,8 +80,8 @@ public void singleColShortcut() {
 	@Test
 	public void singleColShortcutToBoolean() {
 		MatrixBlock mb = TestUtils.generateTestMatrixBlock(100, 1, 1, 1, 0.2, 213);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
-		verifyEquivalence(mb, fb, ValueType.BITSET);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
+		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
 	}
 
 	@Test
@@ -101,8 +101,8 @@ public void toFloatDenseParallel() {
 	@Test
 	public void toBooleanDenseParallel() {
 		MatrixBlock mb = TestUtils.generateTestMatrixBlock(1000, 100, 1, 1, 0.5, 213);
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 4);
-		verifyEquivalence(mb, fb, ValueType.BITSET);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 4);
+		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
 	}
 
 	@Test
@@ -122,8 +122,8 @@ public void toFloatDenseMultiBlockParallel() {
 	@Test
 	public void toBooleanDenseMultiBlock() {
 		MatrixBlock mb = mock(TestUtils.generateTestMatrixBlock(100, 10, 1, 1, 0.7, 213));
-		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BITSET, 1);
-		verifyEquivalence(mb, fb, ValueType.BITSET);
+		FrameBlock fb = FrameFromMatrixBlock.convertToFrameBlock(mb, ValueType.BOOLEAN, 1);
+		verifyEquivalence(mb, fb, ValueType.BOOLEAN);
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameGetSetTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameGetSetTest.java
index f42f23da98c..7eb94a90bea 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameGetSetTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameGetSetTest.java
@@ -31,7 +31,7 @@ public class FrameGetSetTest extends AutomatedTestBase
 {
 	private final static int rows = 131;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 	
 	private enum InitType {
 		COLUMN,
@@ -103,7 +103,7 @@ private void runFrameGetSetTest( ValueType[] schema, InitType itype)
 								tmp1[i] = (String)UtilFunctions.doubleToObject(vt, A[i][j]);
 							frame.appendColumn(tmp1);
 							break;
-						case BITSET:
+						case BOOLEAN:
 							boolean[] tmp2 = new boolean[rows];
 							for( int i=0; i<rows; i++ )
 								A[i][j] = (tmp2[i] = (Boolean)UtilFunctions.doubleToObject(vt, A[i][j], false))?1:0;
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameIndexingTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameIndexingTest.java
index 8d21b162eac..2ec52c80b22 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameIndexingTest.java
@@ -39,7 +39,7 @@ public class FrameIndexingTest extends AutomatedTestBase
 	private final static int cu = 2;
 	
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 	
 	private enum IXType {
 		RIX,
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameSerializationTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameSerializationTest.java
index 809ce0074ef..acb6b8cf3ea 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameSerializationTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameSerializationTest.java
@@ -56,7 +56,7 @@ public static Collection<Object[]> data() {
 		ArrayList<Object[]> tests = new ArrayList<>();
 
 		ValueType[] schemaStrings = new ValueType[] {ValueType.STRING, ValueType.STRING, ValueType.STRING};
-		ValueType[] schemaMixed = new ValueType[] {ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+		ValueType[] schemaMixed = new ValueType[] {ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 		ValueType[] rand = TestUtils.generateRandomSchema(10, 3);
 		ValueType[] rand2 = TestUtils.generateRandomSchema(10, 4);
 		try {
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameTest.java
index 73e86b58d1c..ce76f6a13a8 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameTest.java
@@ -210,7 +210,7 @@ public void cBindStringCol() {
 
 	@Test
 	public void rBindZeros() {
-		ValueType[] bools = UtilFunctions.nCopies(f.getNumColumns(), ValueType.BITSET);
+		ValueType[] bools = UtilFunctions.nCopies(f.getNumColumns(), ValueType.BOOLEAN);
 		FrameBlock b = new FrameBlock(bools, "0", 10);
 
 		FrameBlock ff = append(b, f, false);
@@ -232,7 +232,7 @@ public void rBindZeros() {
 
 	@Test
 	public void rBindZerosMany() {
-		ValueType[] bools = UtilFunctions.nCopies(f.getNumColumns(), ValueType.BITSET);
+		ValueType[] bools = UtilFunctions.nCopies(f.getNumColumns(), ValueType.BOOLEAN);
 		FrameBlock b = new FrameBlock(bools, "0", 240);
 		FrameBlock ff = append(b, f, false);
 		for(int r = 0; r < 240; r++)
diff --git a/src/test/java/org/apache/sysds/test/component/frame/FrameUtilTest.java b/src/test/java/org/apache/sysds/test/component/frame/FrameUtilTest.java
index 8582558d96d..8f4fb790aa8 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/FrameUtilTest.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/FrameUtilTest.java
@@ -59,42 +59,42 @@ public void testIsTypeMinimumFloat_6() {
 
 	@Test
 	public void testIsTypeMinimumBoolean_1() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType("TRUE", ValueType.UNKNOWN));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("TRUE", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_2() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType("True", ValueType.UNKNOWN));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("True", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_3() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType("true", ValueType.UNKNOWN));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("true", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_4() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType("t", ValueType.UNKNOWN));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("t", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_5() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType("f", ValueType.UNKNOWN));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("f", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_6() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType("false", ValueType.UNKNOWN));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("false", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_7() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType("False", ValueType.UNKNOWN));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("False", ValueType.UNKNOWN));
 	}
 
 	@Test
 	public void testIsTypeMinimumBoolean_8() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType("FALSE", ValueType.UNKNOWN));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType("FALSE", ValueType.UNKNOWN));
 	}
 
 	@Test
@@ -207,12 +207,12 @@ public void testCharacter_2() {
 
 	@Test
 	public void testDoubleIsType_1() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType(0.0));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType(0.0));
 	}
 
 	@Test
 	public void testDoubleIsType_2() {
-		assertEquals(ValueType.BITSET, FrameUtil.isType(1.0));
+		assertEquals(ValueType.BOOLEAN, FrameUtil.isType(1.0));
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/component/frame/array/CustomArrayTests.java b/src/test/java/org/apache/sysds/test/component/frame/array/CustomArrayTests.java
index 770a735778c..2bbd7f8515e 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/array/CustomArrayTests.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/array/CustomArrayTests.java
@@ -111,7 +111,7 @@ public void changeTypeLong() {
 	@Test
 	public void changeTypeBoolean1() {
 		StringArray a = ArrayFactory.create(new String[] {"1", "0", "0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -120,7 +120,7 @@ public void changeTypeBoolean1() {
 	@Test
 	public void changeTypeBoolean2() {
 		StringArray a = ArrayFactory.create(new String[] {"1.0", "0.0", "0.0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -129,7 +129,7 @@ public void changeTypeBoolean2() {
 	@Test
 	public void changeTypeBoolean3() {
 		StringArray a = ArrayFactory.create(new String[] {"1", null, "0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -138,7 +138,7 @@ public void changeTypeBoolean3() {
 	@Test
 	public void changeTypeBoolean4() {
 		StringArray a = ArrayFactory.create(new String[] {"1.0", null, "0.0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -147,7 +147,7 @@ public void changeTypeBoolean4() {
 	@Test
 	public void changeTypeBoolean5() {
 		StringArray a = ArrayFactory.create(new String[] {"t", null, "f"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -156,7 +156,7 @@ public void changeTypeBoolean5() {
 	@Test
 	public void changeTypeBoolean6() {
 		StringArray a = ArrayFactory.create(new String[] {"true", null, "false"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -165,7 +165,7 @@ public void changeTypeBoolean6() {
 	@Test
 	public void changeTypeBoolean7() {
 		StringArray a = ArrayFactory.create(new String[] {"True", null, "False"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
 		assertTrue(ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(!ai.get(2));
@@ -174,7 +174,7 @@ public void changeTypeBoolean7() {
 	@Test
 	public void changeTypeBoolean8() {
 		StringArray a = ArrayFactory.create(new String[] {"0.0", null, "1.0"});
-		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BITSET);
+		BooleanArray ai = (BooleanArray) a.changeType(ValueType.BOOLEAN);
 		assertTrue(!ai.get(0));
 		assertTrue(!ai.get(1));
 		assertTrue(ai.get(2));
@@ -184,28 +184,28 @@ public void changeTypeBoolean8() {
 	public void analyzeValueTypeStringBoolean() {
 		StringArray a = ArrayFactory.create(new String[] {"1", "0", "0"});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BITSET, t);
+		assertEquals(ValueType.BOOLEAN, t);
 	}
 
 	@Test
 	public void analyzeValueTypeStringBoolean_withPointZero() {
 		StringArray a = ArrayFactory.create(new String[] {"1.0", "0", "0"});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BITSET, t);
+		assertEquals(ValueType.BOOLEAN, t);
 	}
 
 	@Test
 	public void analyzeValueTypeStringBoolean_withPointZero_2() {
 		StringArray a = ArrayFactory.create(new String[] {"1.00", "0", "0"});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BITSET, t);
+		assertEquals(ValueType.BOOLEAN, t);
 	}
 
 	@Test
 	public void analyzeValueTypeStringBoolean_withPointZero_3() {
 		StringArray a = ArrayFactory.create(new String[] {"1.00000000000", "0", "0"});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BITSET, t);
+		assertEquals(ValueType.BOOLEAN, t);
 	}
 
 	@Test
@@ -360,7 +360,7 @@ public void analyzeValueTypeDouble6() {
 	public void analyzeValueTypeDouble7() {
 		DoubleArray a = ArrayFactory.create(new double[] {1.0d, 0.0d, 1.0d});
 		ValueType t = a.analyzeValueType().getKey();
-		assertEquals(ValueType.BITSET, t);
+		assertEquals(ValueType.BOOLEAN, t);
 	}
 
 	@Test
@@ -1028,14 +1028,14 @@ public void optionalSetRange() {
 
 	@Test
 	public void optionalChangeToBoolean() {
-		Array<?> a = new OptionalArray<>(new Double[3]).changeTypeWithNulls(ValueType.BITSET);
+		Array<?> a = new OptionalArray<>(new Double[3]).changeTypeWithNulls(ValueType.BOOLEAN);
 		for(int i = 0; i < a.size(); i++)
 			assertEquals(null, a.get(i));
 	}
 
 	@Test
 	public void optionalChangeToBoolean2() {
-		Array<?> a = new OptionalArray<>(new Double[] {1.0, null, null}).changeTypeWithNulls(ValueType.BITSET);
+		Array<?> a = new OptionalArray<>(new Double[] {1.0, null, null}).changeTypeWithNulls(ValueType.BOOLEAN);
 		assertEquals(true, a.get(0));
 		for(int i = 1; i < a.size(); i++)
 			assertEquals(null, a.get(i));
@@ -1043,7 +1043,7 @@ public void optionalChangeToBoolean2() {
 
 	@Test
 	public void optionalChangeToBoolean3() {
-		Array<?> a = new OptionalArray<>(new Double[67]).changeTypeWithNulls(ValueType.BITSET);
+		Array<?> a = new OptionalArray<>(new Double[67]).changeTypeWithNulls(ValueType.BOOLEAN);
 		a.set(0, "true");
 		a.set(a.size() - 1, "true");
 		assertEquals(true, a.get(0));
@@ -1072,7 +1072,7 @@ public void isEmptyBitSet() {
 
 	@Test
 	public void changeTypeBitSet() {
-		Array<?> a = new OptionalArray<>(new Character[324]).changeType(ValueType.BITSET);
+		Array<?> a = new OptionalArray<>(new Character[324]).changeType(ValueType.BOOLEAN);
 		assertTrue(a.isEmpty());
 	}
 
@@ -1147,7 +1147,7 @@ public void changeTypeNullsFromStringToCharacter() {
 	@Test
 	public void changeTypeNullsFromStringToBoolean() {
 		Array<?> a = new StringArray(new String[] {"1", null});
-		Array<?> b = a.changeTypeWithNulls(ValueType.BITSET);
+		Array<?> b = a.changeTypeWithNulls(ValueType.BOOLEAN);
 		assertEquals(true, b.get(0));
 		assertEquals(null, b.get(1));
 	}
diff --git a/src/test/java/org/apache/sysds/test/component/frame/array/NegativeArrayTests.java b/src/test/java/org/apache/sysds/test/component/frame/array/NegativeArrayTests.java
index b7609ad61ca..61442cdd0f4 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/array/NegativeArrayTests.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/array/NegativeArrayTests.java
@@ -92,19 +92,19 @@ public void getMinMax() {
 	@Test(expected = DMLRuntimeException.class)
 	public void changeTypeBoolean_1() {
 		StringArray a = ArrayFactory.create(new String[] {"1", "10", "0"});
-		a.changeType(ValueType.BITSET);
+		a.changeType(ValueType.BOOLEAN);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
 	public void changeTypeBoolean_2() {
 		StringArray a = ArrayFactory.create(new String[] {"1", "-1", "0"});
-		a.changeType(ValueType.BITSET);
+		a.changeType(ValueType.BOOLEAN);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
 	public void changeTypeBoolean_3() {
 		StringArray a = ArrayFactory.create(new String[] {"HI", "false", "0"});
-		a.changeType(ValueType.BITSET);
+		a.changeType(ValueType.BOOLEAN);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
@@ -113,13 +113,13 @@ public void changeTypeBoolean_4() {
 		s[0] = "1";
 		s[1] = "10";
 		StringArray a = ArrayFactory.create(s);
-		a.changeType(ValueType.BITSET);
+		a.changeType(ValueType.BOOLEAN);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
 	public void changeTypeBoolean_5() {
 		StringArray a = ArrayFactory.create(new String[] {"0.0", null, "1.1"});
-		a.changeType(ValueType.BITSET);
+		a.changeType(ValueType.BOOLEAN);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
@@ -128,7 +128,7 @@ public void changeTypeBoolean_6() {
 		s[0] = "1.0";
 		s[1] = "1.2";
 		StringArray a = ArrayFactory.create(s);
-		a.changeType(ValueType.BITSET);
+		a.changeType(ValueType.BOOLEAN);
 	}
 
 	@Test(expected = DMLRuntimeException.class)
diff --git a/src/test/java/org/apache/sysds/test/component/frame/transform/TransformCompressedTestMultiCol.java b/src/test/java/org/apache/sysds/test/component/frame/transform/TransformCompressedTestMultiCol.java
index 5802240c59c..a592fc74778 100644
--- a/src/test/java/org/apache/sysds/test/component/frame/transform/TransformCompressedTestMultiCol.java
+++ b/src/test/java/org/apache/sysds/test/component/frame/transform/TransformCompressedTestMultiCol.java
@@ -58,22 +58,22 @@ public static Collection<Object[]> data() {
 
 			ValueType[] kPlusCols = new ValueType[1002];
 
-			Arrays.fill(kPlusCols, ValueType.BITSET);
+			Arrays.fill(kPlusCols, ValueType.BOOLEAN);
 
 			FrameBlock[] blocks = new FrameBlock[] {//
 				TestUtils.generateRandomFrameBlock(100, //
 					new ValueType[] {ValueType.UINT4, ValueType.UINT8, ValueType.UINT4}, 231), //
 				TestUtils.generateRandomFrameBlock(100, //
-					new ValueType[] {ValueType.BITSET, ValueType.UINT8, ValueType.UINT4}, 231), //
-				new FrameBlock(new ValueType[] {ValueType.BITSET, ValueType.INT32, ValueType.INT32}, 100), //
+					new ValueType[] {ValueType.BOOLEAN, ValueType.UINT8, ValueType.UINT4}, 231), //
+				new FrameBlock(new ValueType[] {ValueType.BOOLEAN, ValueType.INT32, ValueType.INT32}, 100), //
 				TestUtils.generateRandomFrameBlock(100, //
-					new ValueType[] {ValueType.UINT4, ValueType.BITSET, ValueType.FP32}, 231, 0.2),
+					new ValueType[] {ValueType.UINT4, ValueType.BOOLEAN, ValueType.FP32}, 231, 0.2),
 				TestUtils.generateRandomFrameBlock(432, //
-					new ValueType[] {ValueType.UINT4, ValueType.BITSET, ValueType.FP32}, 231, 0.2),
+					new ValueType[] {ValueType.UINT4, ValueType.BOOLEAN, ValueType.FP32}, 231, 0.2),
 				TestUtils.generateRandomFrameBlock(100, //
-					new ValueType[] {ValueType.UINT4, ValueType.BITSET, ValueType.FP32}, 231, 0.9),
+					new ValueType[] {ValueType.UINT4, ValueType.BOOLEAN, ValueType.FP32}, 231, 0.9),
 				TestUtils.generateRandomFrameBlock(100, //
-					new ValueType[] {ValueType.UINT4, ValueType.BITSET, ValueType.FP32}, 231, 0.99),
+					new ValueType[] {ValueType.UINT4, ValueType.BOOLEAN, ValueType.FP32}, 231, 0.99),
 
 				TestUtils.generateRandomFrameBlock(5, kPlusCols, 322),
 				TestUtils.generateRandomFrameBlock(1020, kPlusCols, 322),
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
index 04e949c0e79..a83ca5043d6 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstIndexingTest.java
@@ -50,7 +50,7 @@ public void testIndexDenseBlock2FP64Const() {
 	
 	@Test
 	public void testIndexDenseBlock2BoolConst() {
-		DenseBlock db = getDenseBlock2(ValueType.BITSET);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -59,7 +59,7 @@ public void testIndexDenseBlock2BoolConst() {
 
 	@Test
 	public void testIndexDenseBlock2TrueBoolConst() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5});
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++) {
@@ -119,13 +119,15 @@ public void testIndexDenseBlockLarge2FP64Const() {
 
 	@Test
 	public void testIndexDenseBlockLarge2BoolConst() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
 				Assert.assertEquals(1, db.get(i, j), 0);
 	}
 
+
+
 	@Test
 	public void testIndexDenseBlockLarge2Int32Const() {
 		DenseBlock db = getDenseBlockLarge2(ValueType.INT32);
@@ -173,7 +175,7 @@ public void testIndexDenseBlock3FP64Const() {
 	
 	@Test
 	public void testIndexDenseBlock3BoolConst() {
-		DenseBlock db = getDenseBlock3(ValueType.BITSET);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -183,7 +185,7 @@ public void testIndexDenseBlock3BoolConst() {
 
 	@Test
 	public void testIndexDenseBlock3TrueBoolConst() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5,7});
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -240,7 +242,7 @@ public void testIndexDenseBlockLarge3FP64Const() {
 
 	@Test
 	public void testIndexDenseBlockLarge3BoolConst() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
 		db.set(7.3);
 		for(int i=0; i<db.numRows(); i++)
 			for(int j=0; j<5; j++)
@@ -288,7 +290,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BITSET: return new DenseBlockLBoolBitset(dims);
+			case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -301,7 +303,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BITSET: return new DenseBlockLBoolBitset(dims);
+			case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
index 585db93c26a..de42ce5e79d 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockConstructionTest.java
@@ -60,7 +60,7 @@ public void testMetaDenseBlock2FP64() {
 	
 	@Test
 	public void testMetaDenseBlock2Bool() {
-		DenseBlock db = getDenseBlock2(ValueType.BITSET);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -75,7 +75,7 @@ public void testMetaDenseBlock2Bool() {
 
 	@Test
 	public void testMetaDenseBlock2TrueBool() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5});
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -165,7 +165,7 @@ public void testMetaDenseBlockLarge2FP64() {
 
 	@Test
 	public void testMetaDenseBlockLarge2Bool() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -255,7 +255,7 @@ public void testMetaDenseBlock3FP64() {
 	
 	@Test
 	public void testMetaDenseBlock3Bool() {
-		DenseBlock db = getDenseBlock3(ValueType.BITSET);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -270,7 +270,7 @@ public void testMetaDenseBlock3Bool() {
 
 	@Test
 	public void testMetaDenseBlock3TrueBool() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5,7});
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -360,7 +360,7 @@ public void testMetaDenseBlockLarge3FP64() {
 
 	@Test
 	public void testMetaDenseBlockLarge3Bool() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
 		Assert.assertEquals(3, db.numRows());
 		Assert.assertTrue(db.isNumeric());
 		Assert.assertTrue(db.isContiguous());
@@ -431,7 +431,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BITSET: return new DenseBlockLBoolBitset(dims);
+			case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -444,7 +444,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BITSET: return new DenseBlockLBoolBitset(dims);
+			case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
index 6ad3e280c69..e227a69205f 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockCountNonZeroTest.java
@@ -42,13 +42,13 @@ public void testIndexDenseBlock2FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlock2BoolCountNonZero() {
-		DenseBlock db = getDenseBlock2(ValueType.BITSET);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkFullNnz2(db);
 	}
 
 	@Test
 	public void testIndexDenseBlock2TrueBoolCountNonZero() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5});
 		checkFullNnz2(db);
 	}
 
@@ -84,7 +84,7 @@ public void testIndexDenseBlockLarge2FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlockLarge2BoolCountNonZero() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
 		checkFullNnz2(db);
 	}
 
@@ -120,13 +120,13 @@ public void testIndexDenseBlock3FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlock3BoolCountNonZero() {
-		DenseBlock db = getDenseBlock3(ValueType.BITSET);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		checkFullNnz3(db);
 	}
 
 	@Test
 	public void testIndexDenseBlock3TrueBoolCountNonZero() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5,7});
 		checkFullNnz3(db);
 	}
 
@@ -162,7 +162,7 @@ public void testIndexDenseBlockLarge3FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlockLarge3BoolCountNonZero() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
 		checkFullNnz3(db);
 	}
 
@@ -199,7 +199,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BITSET:
+			case BOOLEAN:
 				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
@@ -219,7 +219,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BITSET:
+			case BOOLEAN:
 				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
index e034e0bb04e..8e082e1c76c 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockGetSetIndexingTest.java
@@ -42,13 +42,13 @@ public void testIndexDenseBlock2FP64SetGetCell() {
 	
 	@Test
 	public void testIndexDenseBlock2BoolSetGetCell() {
-		DenseBlock db = getDenseBlock2(ValueType.BITSET);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkSequence(setSequence(db));
 	}
 
 	@Test
 	public void testIndexDenseBlock2TrueBoolSetGetCell() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5});
 		checkSequence(setSequence(db));
 	}
 	
@@ -84,7 +84,7 @@ public void testIndexDenseBlockLarge2FP64SetGetCell() {
 
 	@Test
 	public void testIndexDenseBlockLarge2BoolSetGetCell() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
 		checkSequence(setSequence(db));
 	}
 
@@ -120,13 +120,13 @@ public void testIndexDenseBlock3FP64SetGetCell() {
 	
 	@Test
 	public void testIndexDenseBlock3BoolSetGetCell() {
-		DenseBlock db = getDenseBlock3(ValueType.BITSET);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		checkSequence(setSequence(db));
 	}
 
 	@Test
 	public void testIndexDenseBlock3TrueBoolSetGetCell() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5,7});
 		checkSequence(setSequence(db));
 	}
 	
@@ -162,7 +162,7 @@ public void testIndexDenseBlockLarge3FP64SetGetCell() {
 
 	@Test
 	public void testIndexDenseBlockLarge3BoolSetGetCell() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
 		checkSequence(setSequence(db));
 	}
 
@@ -197,7 +197,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BITSET: return new DenseBlockLBoolBitset(dims);
+			case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -210,7 +210,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BITSET: return new DenseBlockLBoolBitset(dims);
+			case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
index fcf7cd524a1..4914e3c0ba4 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockIncrementTest.java
@@ -40,13 +40,13 @@ public void testIndexDenseBlock2FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlock2BoolCountNonZero() {
-		DenseBlock db = getDenseBlock2(ValueType.BITSET);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkIncrement2(db);
 	}
 
 	@Test
 	public void testIndexDenseBlock2TrueBoolCountNonZero() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5});
 		checkIncrement2(db);
 	}
 
@@ -85,7 +85,7 @@ public void testIndexDenseBlockLarge2FP64CountNonZero() {
 
 	@Test
 	public void testIndexDenseBlockLarge2BoolCountNonZero() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
 		checkIncrement2(db);
 	}
 
@@ -121,7 +121,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BITSET:
+			case BOOLEAN:
 				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
index d1cd8b57fd9..c9b288a00a7 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetDenseBlockTest.java
@@ -48,8 +48,8 @@ public void testDenseBlock2FP64SetDenseBlock() {
 
 	@Test
 	public void testDenseBlock2BoolSetDenseBlock() {
-		DenseBlock db = getDenseBlock2(ValueType.BITSET);
-		DenseBlock dbSet = getDenseBlock2(ValueType.BITSET);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock dbSet = getDenseBlock2(ValueType.BOOLEAN);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -57,8 +57,8 @@ public void testDenseBlock2BoolSetDenseBlock() {
 
 	@Test
 	public void testDenseBlock2TrueBoolSetDenseBlock() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
-		DenseBlock dbSet = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5});
+		DenseBlock dbSet = new DenseBlockBoolArray(new int[] {3,5});
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -115,8 +115,8 @@ public void testDenseBlockLarge2FP64SetDenseBlock() {
 
 	@Test
 	public void testDenseBlockLarge2BoolSetDenseBlock() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
-		DenseBlock dbSet = getDenseBlockLarge2(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
+		DenseBlock dbSet = getDenseBlockLarge2(ValueType.BOOLEAN);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -169,8 +169,8 @@ public void testDenseBlock3FP64SetDenseBlock() {
 
 	@Test
 	public void testDenseBlock3BoolSetDenseBlock() {
-		DenseBlock db = getDenseBlock3(ValueType.BITSET);
-		DenseBlock dbSet = getDenseBlock3(ValueType.BITSET);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock dbSet = getDenseBlock3(ValueType.BOOLEAN);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -178,8 +178,8 @@ public void testDenseBlock3BoolSetDenseBlock() {
 
 	@Test
 	public void testDenseBlock3TrueBoolSetDenseBlock() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
-		DenseBlock dbSet = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5,7});
+		DenseBlock dbSet = new DenseBlockBoolArray(new int[] {3,5,7});
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -232,8 +232,8 @@ public void testDenseBlockLarge3FP64SetDenseBlock() {
 
 	@Test
 	public void testDenseBlockLarge3BoolSetDenseBlock() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
-		DenseBlock dbSet = getDenseBlockLarge3(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
+		DenseBlock dbSet = getDenseBlockLarge3(ValueType.BOOLEAN);
 		dbSet.set(1);
 		db.set(dbSet);
 		compareDenseBlocks(db, dbSet);
@@ -279,7 +279,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BITSET: return new DenseBlockLBoolBitset(dims);
+			case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
@@ -292,7 +292,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 		switch (vt) {
 			case FP32: return new DenseBlockLFP32(dims);
 			case FP64: return new DenseBlockLFP64(dims);
-			case BITSET: return new DenseBlockLBoolBitset(dims);
+			case BOOLEAN: return new DenseBlockLBoolBitset(dims);
 			case INT32: return new DenseBlockLInt32(dims);
 			case INT64: return new DenseBlockLInt64(dims);
 			case STRING: return new DenseBlockLString(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
index 424a69ecc43..ac73de98496 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/DenseBlockSetRowTest.java
@@ -40,13 +40,13 @@ public void testDenseBlock2FP64Row() {
 
 	@Test
 	public void testDenseBlock2BoolRow() {
-		DenseBlock db = getDenseBlock2(ValueType.BITSET);
+		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
 		checkRow(setRow(db));
 	}
 
 	@Test
 	public void testDenseBlock2TrueBoolRow() {
-		DenseBlock db = getDenseBlock2(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray(new int[] {3,5});
 		checkRow(setRow(db));
 	}
 
@@ -82,7 +82,7 @@ public void testDenseBlockLarge2FP64Row() {
 
 	@Test
 	public void testDenseBlockLarge2BoolRow() {
-		DenseBlock db = getDenseBlockLarge2(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge2(ValueType.BOOLEAN);
 		checkRow(setRow(db));
 	}
 
@@ -118,13 +118,13 @@ public void testDenseBlock3FP64Row() {
 
 	@Test
 	public void testDenseBlock3BoolRow() {
-		DenseBlock db = getDenseBlock3(ValueType.BITSET);
+		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
 		checkRow(setRow(db));
 	}
 
 	@Test
 	public void testDenseBlock3TrueBoolRow() {
-		DenseBlock db = getDenseBlock3(ValueType.BOOLEAN);
+		DenseBlock db = new DenseBlockBoolArray( new int[] {3,5,7});
 		checkRow(setRow(db));
 	}
 
@@ -160,7 +160,7 @@ public void testDenseBlockLarge3FP64Row() {
 
 	@Test
 	public void testDenseBlockLarge3BoolRow() {
-		DenseBlock db = getDenseBlockLarge3(ValueType.BITSET);
+		DenseBlock db = getDenseBlockLarge3(ValueType.BOOLEAN);
 		checkRow(setRow(db));
 	}
 
@@ -197,7 +197,7 @@ private static DenseBlock getDenseBlockLarge2(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BITSET:
+			case BOOLEAN:
 				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
@@ -217,7 +217,7 @@ private static DenseBlock getDenseBlockLarge3(ValueType vt) {
 				return new DenseBlockLFP32(dims);
 			case FP64:
 				return new DenseBlockLFP64(dims);
-			case BITSET:
+			case BOOLEAN:
 				return new DenseBlockLBoolBitset(dims);
 			case INT32:
 				return new DenseBlockLInt32(dims);
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/TensorConstructionTest.java b/src/test/java/org/apache/sysds/test/component/tensor/TensorConstructionTest.java
index 38b9543196a..5efe59efa49 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/TensorConstructionTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/TensorConstructionTest.java
@@ -78,8 +78,8 @@ public void testMetaTypedBasicTensor2() {
 
 	@Test
 	public void testMetaTypedBasicTensor3() {
-		BasicTensorBlock tb = new BasicTensorBlock(ValueType.BITSET, new int[]{11, 12}, true);
-		Assert.assertEquals(ValueType.BITSET, tb.getValueType());
+		BasicTensorBlock tb = new BasicTensorBlock(ValueType.BOOLEAN, new int[]{11, 12}, true);
+		Assert.assertEquals(ValueType.BOOLEAN, tb.getValueType());
 		Assert.assertEquals(2, tb.getNumDims());
 		Assert.assertEquals(11, tb.getNumRows());
 		Assert.assertEquals(12, tb.getNumColumns());
@@ -136,8 +136,8 @@ public void testMetaCopyTypedBasicTensor2() {
 
 	@Test
 	public void testMetaCopyTypedBasicTensor3() {
-		BasicTensorBlock tb = new BasicTensorBlock(new BasicTensorBlock(ValueType.BITSET, new int[]{11, 12}, true));
-		Assert.assertEquals(ValueType.BITSET, tb.getValueType());
+		BasicTensorBlock tb = new BasicTensorBlock(new BasicTensorBlock(ValueType.BOOLEAN, new int[]{11, 12}, true));
+		Assert.assertEquals(ValueType.BOOLEAN, tb.getValueType());
 		Assert.assertEquals(2, tb.getNumDims());
 		Assert.assertEquals(11, tb.getNumRows());
 		Assert.assertEquals(12, tb.getNumColumns());
@@ -178,7 +178,7 @@ public void testMetaTypedDataTensor() {
 
 	@Test
 	public void testMetaSchemaTypedDataTensor() {
-		ValueType[] schema = new ValueType[] {ValueType.BITSET, ValueType.INT32, ValueType.STRING};
+		ValueType[] schema = new ValueType[] {ValueType.BOOLEAN, ValueType.INT32, ValueType.STRING};
 		DataTensorBlock tb = new DataTensorBlock(schema);
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertEquals(2, tb.getNumDims());
@@ -188,9 +188,9 @@ public void testMetaSchemaTypedDataTensor() {
 
 	@Test
 	public void testMetaNColsTypedDataTensor() {
-		DataTensorBlock tb = new DataTensorBlock(10, ValueType.BITSET);
+		DataTensorBlock tb = new DataTensorBlock(10, ValueType.BOOLEAN);
 		ValueType[] schema = new ValueType[10];
-		Arrays.fill(schema, ValueType.BITSET);
+		Arrays.fill(schema, ValueType.BOOLEAN);
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertEquals(2, tb.getNumDims());
 		Assert.assertEquals(0, tb.getNumRows());
@@ -217,7 +217,7 @@ public void testMetaCopyValueDataTensor() {
 
 	@Test
 	public void testMetaCopyTypedDataTensor() {
-		ValueType[] schema = {ValueType.INT32, ValueType.INT64, ValueType.BITSET};
+		ValueType[] schema = {ValueType.INT32, ValueType.INT64, ValueType.BOOLEAN};
 		DataTensorBlock tb = new DataTensorBlock(new DataTensorBlock(schema, new int[]{11, 3, 13}));
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertEquals(3, tb.getNumDims());
@@ -239,7 +239,7 @@ public void testMetaCopyTypedDataTensor2() {
 
 	@Test
 	public void testMetaCopyTypedDataTensor3() {
-		ValueType[] schema = {ValueType.FP64, ValueType.FP32, ValueType.INT64, ValueType.INT32, ValueType.BITSET,
+		ValueType[] schema = {ValueType.FP64, ValueType.FP32, ValueType.INT64, ValueType.INT32, ValueType.BOOLEAN,
 				ValueType.STRING};
 		DataTensorBlock tb = new DataTensorBlock(new DataTensorBlock(schema, new int[]{2, schema.length, 2}, new String[][]{
 				new String[]{"1.4", "-5.34", "4.5", "-100000.1"},
@@ -338,7 +338,7 @@ public void testMetaTypedTensorBlock() {
 
 	@Test
 	public void testMetaSchemaTypedTensorBlock() {
-		ValueType[] schema = new ValueType[] {ValueType.BITSET, ValueType.INT32, ValueType.STRING};
+		ValueType[] schema = new ValueType[] {ValueType.BOOLEAN, ValueType.INT32, ValueType.STRING};
 		TensorBlock tb = new TensorBlock(schema, new int[]{4, 3, 2});
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertNull(tb.getValueType());
@@ -403,7 +403,7 @@ public void testMetaCopyTypedTensorBlock() {
 
 	@Test
 	public void testMetaCopySchemaTypedTensorBlock() {
-		ValueType[] schema = new ValueType[] {ValueType.BITSET, ValueType.INT32, ValueType.STRING};
+		ValueType[] schema = new ValueType[] {ValueType.BOOLEAN, ValueType.INT32, ValueType.STRING};
 		TensorBlock tb = new TensorBlock(new TensorBlock(schema, new int[]{4, 3, 2}));
 		Assert.assertArrayEquals(schema, tb.getSchema());
 		Assert.assertNull(tb.getValueType());
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/TensorGetSetIndexingTest.java b/src/test/java/org/apache/sysds/test/component/tensor/TensorGetSetIndexingTest.java
index 1b500ae098b..ce3e56c76ef 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/TensorGetSetIndexingTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/TensorGetSetIndexingTest.java
@@ -46,7 +46,7 @@ public void testIndexBasicTensor2FP64SetGetCell() {
 
 	@Test
 	public void testIndexBasicTensor2BoolSetGetCell() {
-		TensorBlock tb = getBasicTensor2(ValueType.BITSET);
+		TensorBlock tb = getBasicTensor2(ValueType.BOOLEAN);
 		checkSequence(setSequence(tb));
 	}
 
@@ -76,7 +76,7 @@ public void testIndexBasicTensor3FP64SetGetCell() {
 
 	@Test
 	public void testIndexBasicTensor3BoolSetGetCell() {
-		TensorBlock tb = getBasicTensor3(ValueType.BITSET);
+		TensorBlock tb = getBasicTensor3(ValueType.BOOLEAN);
 		checkSequence(setSequence(tb));
 	}
 
@@ -119,7 +119,7 @@ private static TensorBlock setSequence(TensorBlock tb) {
 	}
 
 	private static void checkSequence(TensorBlock tb) {
-		boolean isBool = (tb.isBasic() ? tb.getValueType() : tb.getSchema()[0]) == ValueType.BITSET;
+		boolean isBool = (tb.isBasic() ? tb.getValueType() : tb.getSchema()[0]) == ValueType.BOOLEAN;
 		if( tb.getNumDims() == DIM0 ) {
 			int dim12 = DIM1 * DIM2;
 			for(int i=0; i<tb.getNumRows(); i++)
@@ -160,7 +160,7 @@ public void testIndexDataTensor2FP64SetGetCell() {
 
 	@Test
 	public void testIndexDataTensor2BoolSetGetCell() {
-		TensorBlock tb = getDataTensor2(ValueType.BITSET);
+		TensorBlock tb = getDataTensor2(ValueType.BOOLEAN);
 		checkSequence(setSequence(tb));
 	}
 
@@ -190,7 +190,7 @@ public void testIndexDataTensor3FP64SetGetCell() {
 
 	@Test
 	public void testIndexDataTensor3BoolSetGetCell() {
-		TensorBlock tb = getDataTensor3(ValueType.BITSET);
+		TensorBlock tb = getDataTensor3(ValueType.BOOLEAN);
 		checkSequence(setSequence(tb));
 	}
 
diff --git a/src/test/java/org/apache/sysds/test/component/tensor/TensorSerializationTest.java b/src/test/java/org/apache/sysds/test/component/tensor/TensorSerializationTest.java
index 7c3f5dee9d1..a04edda921e 100644
--- a/src/test/java/org/apache/sysds/test/component/tensor/TensorSerializationTest.java
+++ b/src/test/java/org/apache/sysds/test/component/tensor/TensorSerializationTest.java
@@ -54,7 +54,7 @@ public void testSerializeBasicTensorINT64() {
 	
 	@Test
 	public void testSerializeBasicTensorBoolean() {
-		testSerializeBasicTensor(ValueType.BITSET);
+		testSerializeBasicTensor(ValueType.BOOLEAN);
 	}
 
 	@Test
@@ -79,7 +79,7 @@ public void testSerializeDataTensorINT64() {
 
 	@Test
 	public void testSerializeDataTensorBoolean() {
-		testSerializeDataTensor(ValueType.BITSET);
+		testSerializeDataTensor(ValueType.BOOLEAN);
 	}
 
 	private static void testSerializeBasicTensor(ValueType vt) {
diff --git a/src/test/java/org/apache/sysds/test/functions/builtin/part1/BuiltinImputeFDTest.java b/src/test/java/org/apache/sysds/test/functions/builtin/part1/BuiltinImputeFDTest.java
index 3be499a21d5..95ebd29638c 100644
--- a/src/test/java/org/apache/sysds/test/functions/builtin/part1/BuiltinImputeFDTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/builtin/part1/BuiltinImputeFDTest.java
@@ -43,7 +43,7 @@ public class BuiltinImputeFDTest extends AutomatedTestBase {
 	private final static int cols = 4;
 	private final static double epsilon = 0.0000000001;
 
-	private final static Types.ValueType[] schema = {Types.ValueType.BITSET, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.FP64};
+	private final static Types.ValueType[] schema = {Types.ValueType.BOOLEAN, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.FP64};
 
 	@Override
 	public void setUp() {
@@ -105,7 +105,7 @@ private static void initFrameDataString(FrameBlock frame1, double[][] data, int
 		long[] l = new long[rows];
 		String[] s1 = null, s2 = null;
 		for (int i = 0; i < rows; i++) {
-			data[i][1] = (b[i] = (Boolean) UtilFunctions.doubleToObject(Types.ValueType.BITSET, data[i][1], false)) ? 1 : 0;
+			data[i][1] = (b[i] = (Boolean) UtilFunctions.doubleToObject(Types.ValueType.BOOLEAN, data[i][1], false)) ? 1 : 0;
 			l[i] = (Long) UtilFunctions.doubleToObject(Types.ValueType.INT64, data[i][2], false);
 		}
 		switch (test)
@@ -133,7 +133,7 @@ private static FrameBlock tureOutput(double[][] data) {
 		String[] s2 = {"Austria", "Austria", "Austria", "India", "India", "India","India", "Pakistan", "Pakistan", "Pakistan", "Austria"};
 		long[] l = new long[rows];
 		for (int i = 0; i < rows; i++) {
-			data[i][1] = (b[i] = (Boolean) UtilFunctions.doubleToObject(Types.ValueType.BITSET, data[i][1], false)) ? 1 : 0;
+			data[i][1] = (b[i] = (Boolean) UtilFunctions.doubleToObject(Types.ValueType.BOOLEAN, data[i][1], false)) ? 1 : 0;
 			l[i] = (Long) UtilFunctions.doubleToObject(Types.ValueType.INT64, data[i][2], false);
 		}
 		frame1.appendColumn(b);
diff --git a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockParallelTest.java b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockParallelTest.java
index 26430b5c298..e00eb3a3879 100644
--- a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockParallelTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockParallelTest.java
@@ -52,7 +52,7 @@ public void testReadWriteBinaryBlockParallelBasicTensorINT64() {
 	
 	@Test
 	public void testReadWriteBinaryBlockParallelBasicTensorBoolean() {
-		testReadWriteBinaryBlockParallelBasicTensor(ValueType.BITSET);
+		testReadWriteBinaryBlockParallelBasicTensor(ValueType.BOOLEAN);
 	}
 	
 	@Test
@@ -88,7 +88,7 @@ public void testReadWriteBinaryBlockParallelDataTensorINT64() {
 	
 	@Test
 	public void testReadWriteBinaryBlockParallelDataTensorBoolean() {
-		testReadWriteBinaryBlockParallelDataTensor(ValueType.BITSET);
+		testReadWriteBinaryBlockParallelDataTensor(ValueType.BOOLEAN);
 	}
 	
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockTest.java b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockTest.java
index 43adf40effb..0e9671d21f3 100644
--- a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorBinaryBlockTest.java
@@ -52,7 +52,7 @@ public void testReadWriteBinaryBlockBasicTensorINT64() {
 
 	@Test
 	public void testReadWriteBinaryBlockBasicTensorBoolean() {
-		testReadWriteBinaryBlockBasicTensor(ValueType.BITSET);
+		testReadWriteBinaryBlockBasicTensor(ValueType.BOOLEAN);
 	}
 
 	@Test
@@ -88,7 +88,7 @@ public void testReadWriteBinaryBlockDataTensorINT64() {
 
 	@Test
 	public void testReadWriteBinaryBlockDataTensorBoolean() {
-		testReadWriteBinaryBlockDataTensor(ValueType.BITSET);
+		testReadWriteBinaryBlockDataTensor(ValueType.BOOLEAN);
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellParallelTest.java b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellParallelTest.java
index 1e8b34198b0..622165017e0 100644
--- a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellParallelTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellParallelTest.java
@@ -52,7 +52,7 @@ public void testReadWriteTextCellParallelBasicTensorINT64() {
 
 	@Test
 	public void testReadWriteTextCellParallelBasicTensorBoolean() {
-		testReadWriteTextCellParallelBasicTensor(ValueType.BITSET);
+		testReadWriteTextCellParallelBasicTensor(ValueType.BOOLEAN);
 	}
 
 	@Test
@@ -88,7 +88,7 @@ public void testReadWriteTextCellParallelDataTensorINT64() {
 
 	@Test
 	public void testReadWriteTextCellParallelDataTensorBoolean() {
-		testReadWriteTextCellParallelDataTensor(ValueType.BITSET);
+		testReadWriteTextCellParallelDataTensor(ValueType.BOOLEAN);
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellTest.java b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellTest.java
index 038445eebdb..8260393ff65 100644
--- a/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/data/tensor/TensorTextCellTest.java
@@ -52,7 +52,7 @@ public void testReadWriteTextCellBasicTensorINT64() {
 
 	@Test
 	public void testReadWriteTextCellBasicTensorBoolean() {
-		testReadWriteTextCellBasicTensor(ValueType.BITSET);
+		testReadWriteTextCellBasicTensor(ValueType.BOOLEAN);
 	}
 
 	@Test
@@ -92,7 +92,7 @@ public void testReadWriteTextCellDataTensorINT64() {
 
 	@Test
 	public void testReadWriteTextCellDataTensorBoolean() {
-		testReadWriteTextCellDataTensor(ValueType.BITSET);
+		testReadWriteTextCellDataTensor(ValueType.BOOLEAN);
 	}
 
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/federated/primitives/FederatedConstructionTest.java b/src/test/java/org/apache/sysds/test/functions/federated/primitives/FederatedConstructionTest.java
index 64c3de24962..d10272310cb 100644
--- a/src/test/java/org/apache/sysds/test/functions/federated/primitives/FederatedConstructionTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/federated/primitives/FederatedConstructionTest.java
@@ -109,7 +109,7 @@ public void federatedFrameConstruction(Types.ExecMode execMode) throws IOExcepti
 		List<Types.ValueType> schemaList = new ArrayList<>(Collections.nCopies(cols / 4, Types.ValueType.STRING));
 		schemaList.addAll(Collections.nCopies(cols / 4, Types.ValueType.FP64));
 		schemaList.addAll(Collections.nCopies(cols / 4, Types.ValueType.INT64));
-		schemaList.addAll(Collections.nCopies(cols / 4, Types.ValueType.BITSET));
+		schemaList.addAll(Collections.nCopies(cols / 4, Types.ValueType.BOOLEAN));
 
 		Types.ValueType[] schema = new Types.ValueType[cols];
 		schemaList.toArray(schema);
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/ApplySchemaTest.java b/src/test/java/org/apache/sysds/test/functions/frame/ApplySchemaTest.java
index 9b95bec7503..f90da5014d1 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/ApplySchemaTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/ApplySchemaTest.java
@@ -48,7 +48,7 @@ public class ApplySchemaTest extends AutomatedTestBase {
 
 	private final static int rows = 10;
 	// constructed schema
-	private final static Types.ValueType[] schemaStrings = {Types.ValueType.INT32, Types.ValueType.BITSET,
+	private final static Types.ValueType[] schemaStrings = {Types.ValueType.INT32, Types.ValueType.BOOLEAN,
 		Types.ValueType.FP64};
 
 	@BeforeClass
@@ -147,7 +147,7 @@ public static void initFrameDataString(FrameBlock frame1, double[][] data, Types
 						tmp1[i] = (String) UtilFunctions.doubleToObject(vt, data[i][j]);
 					frame1.appendColumn(tmp1);
 					break;
-				case BITSET:
+				case BOOLEAN:
 					boolean[] tmp2 = new boolean[rows];
 					for(int i = 0; i < rows; i++)
 						data[i][j] = (tmp2[i] = (Boolean) UtilFunctions.doubleToObject(vt, data[i][j], false)) ? 1 : 0;
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/DetectSchemaTest.java b/src/test/java/org/apache/sysds/test/functions/frame/DetectSchemaTest.java
index bb9fde0c395..3d9b9e4f55a 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/DetectSchemaTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/DetectSchemaTest.java
@@ -50,7 +50,7 @@ public class DetectSchemaTest extends AutomatedTestBase {
 	private final static Types.ValueType[] schemaDoubles = new Types.ValueType[] {Types.ValueType.FP64,
 		Types.ValueType.FP64};
 	private final static Types.ValueType[] schemaMixed = new Types.ValueType[] {Types.ValueType.INT64,
-		Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BITSET};
+		Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BOOLEAN};
 
 	@BeforeClass
 	public static void init() {
@@ -144,7 +144,7 @@ public static void initFrameDataString(FrameBlock frame1, double[][] data, Types
 						tmp1[i] = (String) UtilFunctions.doubleToObject(vt, data[i][j]) + "AB";
 					frame1.appendColumn(tmp1);
 					break;
-				case BITSET:
+				case BOOLEAN:
 					boolean[] tmp2 = new boolean[rows];
 					for(int i = 0; i < rows; i++)
 						data[i][j] = (tmp2[i] = (Boolean) UtilFunctions.doubleToObject(vt, data[i][j], false)) ? 1 : 0;
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameAppendDistTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameAppendDistTest.java
index 443b78e1600..604a8791c6f 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameAppendDistTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameAppendDistTest.java
@@ -185,7 +185,7 @@ ValueType[] genMixSchema(int cols)
 		List<ValueType> schemaMixedLargeListStr = Collections.nCopies(cols/4, ValueType.STRING);
 		List<ValueType> schemaMixedLargeListDble  = Collections.nCopies(cols/4, ValueType.FP64);
 		List<ValueType> schemaMixedLargeListInt  = Collections.nCopies(cols/4, ValueType.INT64);
-		List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols-(cols/4)*3, ValueType.BITSET);
+		List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols-(cols/4)*3, ValueType.BOOLEAN);
 
 		final List<ValueType> schemaMixedLargeList = new ArrayList<>(schemaMixedLargeListStr);
 		schemaMixedLargeList.addAll(schemaMixedLargeListDble);
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameConstructorTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameConstructorTest.java
index e5516bd81f3..146c560ae50 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameConstructorTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameConstructorTest.java
@@ -48,7 +48,7 @@ public class FrameConstructorTest extends AutomatedTestBase {
 	private final static int cols = 4;
 
 	private final static ValueType[] schemaStrings1 = new ValueType[]{
-		ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.BITSET};
+		ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.BOOLEAN};
 
 	private final static ValueType[] schemaStrings2 = new ValueType[]{
 		ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.STRING};
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameConverterTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameConverterTest.java
index 37fcf1991a2..0743cabf275 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameConverterTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameConverterTest.java
@@ -77,12 +77,12 @@ public class FrameConverterTest extends AutomatedTestBase
 	private final static int rows = 1593;
 	
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 
 	private final static List<ValueType> schemaMixedLargeListStr = Collections.nCopies(200, ValueType.STRING);
 	private final static List<ValueType> schemaMixedLargeListDble  = Collections.nCopies(200, ValueType.FP64);
 	private final static List<ValueType> schemaMixedLargeListInt  = Collections.nCopies(200, ValueType.INT64);
-	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(200, ValueType.BITSET);
+	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(200, ValueType.BOOLEAN);
 	
 	private static final List<ValueType> schemaMixedLargeList = CollectionUtils.asList(
 		schemaMixedLargeListStr, schemaMixedLargeListDble, schemaMixedLargeListInt, schemaMixedLargeListBool);
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameEqualTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameEqualTest.java
index c84f920178e..fcd43213018 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameEqualTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameEqualTest.java
@@ -40,8 +40,8 @@ public class FrameEqualTest extends AutomatedTestBase {
 	private static final String TEST_CLASS_DIR = TEST_DIR + FrameEqualTest.class.getSimpleName() + "/";
 
 	private final static int rows = 100;
-	private final static Types.ValueType[] schemaStrings1 = {Types.ValueType.FP64, Types.ValueType.BITSET, Types.ValueType.INT64, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.FP64};
-	private final static Types.ValueType[] schemaStrings2 = {Types.ValueType.INT64, Types.ValueType.BITSET, Types.ValueType.FP32, Types.ValueType.FP64, Types.ValueType.STRING, Types.ValueType.FP32};
+	private final static Types.ValueType[] schemaStrings1 = {Types.ValueType.FP64, Types.ValueType.BOOLEAN, Types.ValueType.INT64, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.FP64};
+	private final static Types.ValueType[] schemaStrings2 = {Types.ValueType.INT64, Types.ValueType.BOOLEAN, Types.ValueType.FP32, Types.ValueType.FP64, Types.ValueType.STRING, Types.ValueType.FP32};
 
 	public enum TestType {
 		GREATER, LESS, EQUALS, NOT_EQUALS, GREATER_EQUALS, LESS_EQUALS,
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameIndexingDistTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameIndexingDistTest.java
index 900556bd33a..d073b5d0c93 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameIndexingDistTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameIndexingDistTest.java
@@ -72,7 +72,7 @@ private enum IXType {
 	private final static List<ValueType> schemaMixedLargeListStr = Collections.nCopies(cols/4, ValueType.STRING);
 	private final static List<ValueType> schemaMixedLargeListDble  = Collections.nCopies(cols/4, ValueType.FP64);
 	private final static List<ValueType> schemaMixedLargeListInt  = Collections.nCopies(cols/4, ValueType.INT64);
-	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols/4, ValueType.BITSET);
+	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols/4, ValueType.BOOLEAN);
 	private static ValueType[] schemaMixedLarge = null;
 	static {
 		final List<ValueType> schemaMixedLargeList = new ArrayList<>(schemaMixedLargeListStr);
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameReadWriteTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameReadWriteTest.java
index f9b513455b7..96221e0ffd2 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameReadWriteTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameReadWriteTest.java
@@ -54,7 +54,7 @@ public class FrameReadWriteTest extends AutomatedTestBase {
 
 	private final static int rows = 1593;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 	
 	private final static String DELIMITER = "::";
 	private final static boolean HEADER = true;
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingIntegratedTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingIntegratedTest.java
index 939a122954c..6043204e3f4 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingIntegratedTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingIntegratedTest.java
@@ -55,7 +55,7 @@ public void testFrameLongCP0() {
 	
 	@Test
 	public void testFrameBooleanCP0() { 
-		runFrameScalarCastingTest(ValueType.BITSET, ExecMode.SINGLE_NODE);
+		runFrameScalarCastingTest(ValueType.BOOLEAN, ExecMode.SINGLE_NODE);
 	}
 	
 	@Test
@@ -75,7 +75,7 @@ public void testFrameLongCP1() {
 	
 	@Test
 	public void testFrameBooleanCP1() { 
-		runFrameScalarCastingTest(ValueType.BITSET, ExecMode.HYBRID);
+		runFrameScalarCastingTest(ValueType.BOOLEAN, ExecMode.HYBRID);
 	}
 	
 	@Test
@@ -95,7 +95,7 @@ public void testFrameLongCP2() {
 	
 	@Test
 	public void testFrameBooleanCP2() { 
-		runFrameScalarCastingTest(ValueType.BITSET, ExecMode.HYBRID);
+		runFrameScalarCastingTest(ValueType.BOOLEAN, ExecMode.HYBRID);
 	}
 	
 	@Test
@@ -115,7 +115,7 @@ public void testFrameLongSP() {
 	
 	@Test
 	public void testFrameBooleanSP() { 
-		runFrameScalarCastingTest(ValueType.BITSET, ExecMode.SPARK);
+		runFrameScalarCastingTest(ValueType.BOOLEAN, ExecMode.SPARK);
 	}
 	
 	@Test
@@ -143,7 +143,7 @@ private void runFrameScalarCastingTest(ValueType vtIn, ExecMode et)
 			switch( vtIn ) {
 				case STRING: HDFSTool.writeStringToHDFS("foo", input("V")); break;
 				case INT64: HDFSTool.writeIntToHDFS(7, input("V")); break;
-				case BITSET: HDFSTool.writeBooleanToHDFS(true, input("V")); break;
+				case BOOLEAN: HDFSTool.writeBooleanToHDFS(true, input("V")); break;
 				case FP64: HDFSTool.writeDoubleToHDFS(7.3, input("V")); break;
 				default: throw new RuntimeException("Unsupported type: "+vtIn);
 			}
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingTest.java
index 0ce2a1ee42b..d183d347872 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameScalarCastingTest.java
@@ -58,7 +58,7 @@ public void testFrame2ScalarDouble() {
 	
 	@Test
 	public void testFrame2ScalarBoolean() {
-		runFrameCastingTest(TEST_NAME1, ValueType.BITSET);
+		runFrameCastingTest(TEST_NAME1, ValueType.BOOLEAN);
 	}
 	
 	@Test
@@ -78,7 +78,7 @@ public void testScalar2FrameDouble() {
 	
 	@Test
 	public void testScalar2FrameBoolean() {
-		runFrameCastingTest(TEST_NAME2, ValueType.BITSET);
+		runFrameCastingTest(TEST_NAME2, ValueType.BOOLEAN);
 	}
 	
 	@Test
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/FrameSchemaReadTest.java b/src/test/java/org/apache/sysds/test/functions/frame/FrameSchemaReadTest.java
index c30365fb20d..33d48c486b3 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/FrameSchemaReadTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/FrameSchemaReadTest.java
@@ -48,7 +48,7 @@ public class FrameSchemaReadTest extends AutomatedTestBase
 	private final static int rows = 1593;
 	private final static ValueType[] schemaStrings = new ValueType[]{ValueType.STRING, ValueType.STRING, ValueType.STRING};	
 	private final static ValueType[] schemaDoubles = new ValueType[]{ValueType.FP64, ValueType.FP64};	
-	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BITSET};
+	private final static ValueType[] schemaMixed = new ValueType[]{ValueType.STRING, ValueType.FP64, ValueType.INT64, ValueType.BOOLEAN};
 	
 	@Override
 	public void setUp() {
diff --git a/src/test/java/org/apache/sysds/test/functions/frame/TypeOfTest.java b/src/test/java/org/apache/sysds/test/functions/frame/TypeOfTest.java
index 18cb5b4b806..c94bfdc6fb0 100644
--- a/src/test/java/org/apache/sysds/test/functions/frame/TypeOfTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/frame/TypeOfTest.java
@@ -42,7 +42,7 @@ public class TypeOfTest extends AutomatedTestBase {
 	private static final String TEST_CLASS_DIR = TEST_DIR + TypeOfTest.class.getSimpleName() + "/";
 
 	private final static Types.ValueType[] schemaStrings = new Types.ValueType[]{Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING};
-	private final static Types.ValueType[] schemaMixed = new Types.ValueType[]{Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BITSET};
+	private final static Types.ValueType[] schemaMixed = new Types.ValueType[]{Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BOOLEAN};
 
 	private final static int rows = 50;
 
diff --git a/src/test/java/org/apache/sysds/test/functions/iogen/GenerateRandomFrame.java b/src/test/java/org/apache/sysds/test/functions/iogen/GenerateRandomFrame.java
index b5ddb2f637e..9b711057223 100644
--- a/src/test/java/org/apache/sysds/test/functions/iogen/GenerateRandomFrame.java
+++ b/src/test/java/org/apache/sysds/test/functions/iogen/GenerateRandomFrame.java
@@ -156,7 +156,7 @@ private static String[][] writeInLIBSVMFormat(int firstIndex,Types.ValueType[] s
 					row1.append(separator).append(c + firstIndex).append(indexSeparator).append(data[r][c]);
 				}
 				else {
-					if(schema[c].isNumeric() || schema[c] == Types.ValueType.BITSET){
+					if(schema[c].isNumeric() || schema[c] == Types.ValueType.BOOLEAN){
 						dataLibSVM[indexRow][c] = "0";
 					}
 					else if(schema[c] == Types.ValueType.STRING)
@@ -172,7 +172,7 @@ else if(schema[c] == Types.ValueType.STRING)
 					row2.append(separator).append(c + firstIndex).append(indexSeparator).append(data[r][c]);
 				}
 				else {
-					if(schema[c].isNumeric() || schema[c] == Types.ValueType.BITSET){
+					if(schema[c].isNumeric() || schema[c] == Types.ValueType.BOOLEAN){
 						dataLibSVM[indexRow][c] = "0";
 					}
 					else if(schema[c] == Types.ValueType.STRING)
diff --git a/src/test/java/org/apache/sysds/test/functions/iogen/GenerateReaderFrameTest.java b/src/test/java/org/apache/sysds/test/functions/iogen/GenerateReaderFrameTest.java
index 567f7b8ad38..5816b90e907 100644
--- a/src/test/java/org/apache/sysds/test/functions/iogen/GenerateReaderFrameTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/iogen/GenerateReaderFrameTest.java
@@ -50,9 +50,9 @@ public abstract class GenerateReaderFrameTest extends AutomatedTestBase {
 		Types.ValueType.INT64,
 		Types.ValueType.FP32,
 		Types.ValueType.FP64,
-		Types.ValueType.BITSET};
+		Types.ValueType.BOOLEAN};
 
-	protected Types.ValueType[] types1= { Types.ValueType.BITSET};
+	protected Types.ValueType[] types1= { Types.ValueType.BOOLEAN};
 
 	protected abstract String getTestName();
 
@@ -78,7 +78,7 @@ protected String getRandomString(int length) {
 	protected String defaultValue(Types.ValueType vt){
 		switch(vt){
 			case STRING: return "";
-			case BITSET: return null;
+			case BOOLEAN: return null;
 			case FP32:
 			case FP64:
 			case INT32:
@@ -117,7 +117,7 @@ protected void generateRandomNumeric(int size, Types.ValueType type, double min,
 					case INT64: o = UtilFunctions.objectToObject(type,(long)randomData[i][0]); break;
 					case FP32: o = UtilFunctions.objectToObject(type,(float)randomData[i][0]); break;
 					case FP64: o = UtilFunctions.objectToObject(type,randomData[i][0]); break;
-					case BITSET: Boolean b= randomData[i][0] >0 ? true: null; o = UtilFunctions.objectToObject(type, b); break;
+					case BOOLEAN: Boolean b= randomData[i][0] >0 ? true: null; o = UtilFunctions.objectToObject(type, b); break;
 				}
 				String s = UtilFunctions.objectToString(o);
 				data[i][colIndex] = s;
@@ -148,7 +148,7 @@ protected void generateRandomData(int nrows, int ncols, double min, double max,
 
 			if(types[rnt] == Types.ValueType.STRING)
 				generateRandomString(nrows,100,naStrings,sparsity,data,i);
-			else if(types[rnt].isNumeric() || types[rnt] == Types.ValueType.BITSET)
+			else if(types[rnt].isNumeric() || types[rnt] == Types.ValueType.BOOLEAN)
 				generateRandomNumeric(nrows, types[rnt],min,max,naStrings, sparsity,data,i);
 			}
 	}
diff --git a/src/test/java/org/apache/sysds/test/functions/misc/ScalarAssignmentTest.java b/src/test/java/org/apache/sysds/test/functions/misc/ScalarAssignmentTest.java
index 9cfe9eb630c..23f8a897bb4 100644
--- a/src/test/java/org/apache/sysds/test/functions/misc/ScalarAssignmentTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/misc/ScalarAssignmentTest.java
@@ -72,7 +72,7 @@ public void testForLoopString()
 	@Test
 	public void testForLoopBoolean() 
 	{
-		runScalarAssignmentTest(ControlFlowConstruct.FOR, ValueType.BITSET);
+		runScalarAssignmentTest(ControlFlowConstruct.FOR, ValueType.BOOLEAN);
 	}
 	
 	@Test
@@ -96,7 +96,7 @@ public void testParForLoopString()
 	@Test
 	public void testParForLoopBoolean() 
 	{
-		runScalarAssignmentTest(ControlFlowConstruct.PARFOR, ValueType.BITSET);
+		runScalarAssignmentTest(ControlFlowConstruct.PARFOR, ValueType.BOOLEAN);
 	}
 	
 	@Test
@@ -120,7 +120,7 @@ public void testWhileLoopString()
 	@Test
 	public void testWhileLoopBoolean() 
 	{
-		runScalarAssignmentTest(ControlFlowConstruct.WHILE, ValueType.BITSET);
+		runScalarAssignmentTest(ControlFlowConstruct.WHILE, ValueType.BOOLEAN);
 	}
 
 	@Test
@@ -144,7 +144,7 @@ public void testIfLoopString()
 	@Test
 	public void testIfLoopBoolean() 
 	{
-		runScalarAssignmentTest(ControlFlowConstruct.IFELSE, ValueType.BITSET);
+		runScalarAssignmentTest(ControlFlowConstruct.IFELSE, ValueType.BOOLEAN);
 	}
 
 	public void runScalarAssignmentTest( ControlFlowConstruct cfc, ValueType vt ) {
@@ -162,7 +162,7 @@ public void runScalarAssignmentTest( ControlFlowConstruct cfc, ValueType vt ) {
 			case INT64: value = Integer.valueOf(7); break;
 			case FP64: value = Double.valueOf(7.7); break;
 			case STRING: value = "This is a test!"; break;
-			case BITSET: value = Boolean.valueOf(true); break;
+			case BOOLEAN: value = Boolean.valueOf(true); break;
 			default: //do nothing
 		}
 		
diff --git a/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeAutoCastingTest.java b/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeAutoCastingTest.java
index b5ca68aa7fb..ac8f22b7d0b 100644
--- a/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeAutoCastingTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeAutoCastingTest.java
@@ -64,7 +64,7 @@ public void testIterablePredicateInteger()
 	@Test
 	public void testIterablePredicateBoolean() 
 	{ 
-		runTest( TEST_NAME1, ValueType.BITSET, true );
+		runTest( TEST_NAME1, ValueType.BOOLEAN, true );
 	}
 	
 	@Test
@@ -82,7 +82,7 @@ public void testConditionalPredicateWhileInteger()
 	@Test
 	public void testConditionalPredicateWhileBoolean() 
 	{ 
-		runTest( TEST_NAME2, ValueType.BITSET, false );
+		runTest( TEST_NAME2, ValueType.BOOLEAN, false );
 	}
 	
 	@Test
@@ -100,7 +100,7 @@ public void testConditionalPredicateIfInteger()
 	@Test
 	public void testConditionalPredicateIfBoolean() 
 	{ 
-		runTest( TEST_NAME3, ValueType.BITSET, false );
+		runTest( TEST_NAME3, ValueType.BOOLEAN, false );
 	}
 	
 	@Test
@@ -118,7 +118,7 @@ public void testFunctionInliningInteger()
 	@Test
 	public void testFunctionInliningBoolean() 
 	{ 
-		runTest( TEST_NAME4, ValueType.BITSET, false );
+		runTest( TEST_NAME4, ValueType.BOOLEAN, false );
 	}
 	
 	@Test
@@ -136,7 +136,7 @@ public void testFunctionNoInliningInteger()
 	@Test
 	public void testFunctionNoInliningBoolean() 
 	{ 
-		runTest( TEST_NAME5, ValueType.BITSET, false );
+		runTest( TEST_NAME5, ValueType.BOOLEAN, false );
 	}
 
 	
@@ -163,7 +163,7 @@ private void runTest( String testName, ValueType vt, boolean exceptionExpected )
 				case INT64:
 					val1 = Integer.toString((int)V[0][0]); 
 					val2 = Integer.toString((int)V[0][1]); break;
-				case BITSET:
+				case BOOLEAN:
 					val1 = (V[0][0]!=0)?"TRUE":"FALSE"; 
 					val2 = (V[0][1]!=0)?"TRUE":"FALSE"; break;
 				default:
diff --git a/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeCastingTest.java b/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeCastingTest.java
index 66640bb1e4d..db93458c563 100644
--- a/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeCastingTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/misc/ValueTypeCastingTest.java
@@ -65,7 +65,7 @@ public void testScalarIntegerToDouble()
 	@Test
 	public void testScalarBooleanToDouble() 
 	{ 
-		runTest( ValueType.BITSET, ValueType.FP64, false, false );
+		runTest( ValueType.BOOLEAN, ValueType.FP64, false, false );
 	}
 	
 	@Test
@@ -89,7 +89,7 @@ public void testScalarIntegerToInteger()
 	@Test
 	public void testScalarBooleanToInteger() 
 	{ 
-		runTest( ValueType.BITSET, ValueType.INT64, false, false );
+		runTest( ValueType.BOOLEAN, ValueType.INT64, false, false );
 	}
 	
 	@Test
@@ -102,25 +102,25 @@ public void testMatrixDoubleToInteger()
 	@Test
 	public void testScalarDoubleToBoolean() 
 	{ 
-		runTest( ValueType.FP64, ValueType.BITSET, false, false );
+		runTest( ValueType.FP64, ValueType.BOOLEAN, false, false );
 	}
 	
 	@Test
 	public void testScalarIntegerToBoolean() 
 	{ 
-		runTest( ValueType.INT64, ValueType.BITSET, false, false );
+		runTest( ValueType.INT64, ValueType.BOOLEAN, false, false );
 	}
 	
 	@Test
 	public void testScalarBooleanToBoolean() 
 	{ 
-		runTest( ValueType.BITSET, ValueType.BITSET, false, false );
+		runTest( ValueType.BOOLEAN, ValueType.BOOLEAN, false, false );
 	}
 	
 	@Test
 	public void testMatrixDoubleToBoolean() 
 	{ 
-		runTest( ValueType.FP64, ValueType.BITSET, true, true );
+		runTest( ValueType.FP64, ValueType.BOOLEAN, true, true );
 	}
 	
 	private void runTest( ValueType vtIn, ValueType vtOut, boolean matrixInput, boolean exceptionExpected )
@@ -130,7 +130,7 @@ private void runTest( ValueType vtIn, ValueType vtOut, boolean matrixInput, bool
 		{
 			case FP64:  TEST_NAME = TEST_NAME1; break;
 			case INT64: 	  TEST_NAME = TEST_NAME2; break;
-			case BITSET: TEST_NAME = TEST_NAME3; break;
+			case BOOLEAN: TEST_NAME = TEST_NAME3; break;
 			default: //do nothing
 		}
 		
@@ -162,7 +162,7 @@ private void runTest( ValueType vtIn, ValueType vtOut, boolean matrixInput, bool
 					case INT64:    
 						HDFSTool.writeIntToHDFS((int)V[0][0], input("V")); 
 						inVal = ((int)V[0][0]); break;
-					case BITSET:
+					case BOOLEAN:
 						HDFSTool.writeBooleanToHDFS(V[0][0]!=0, input("V")); 
 						inVal = (V[0][0]!=0)?1:0; break;
 					default: 
@@ -177,7 +177,7 @@ private void runTest( ValueType vtIn, ValueType vtOut, boolean matrixInput, bool
 		        switch( vtOut ) {
 					case FP64:  Assert.assertEquals(inVal, HDFSTool.readDoubleFromHDFSFile(outName), 1e-16); break;
 					case INT64:     Assert.assertEquals((int) inVal, HDFSTool.readIntegerFromHDFSFile(outName)); break;
-					case BITSET: Assert.assertEquals(inVal!=0, HDFSTool.readBooleanFromHDFSFile(outName)); break;
+					case BOOLEAN: Assert.assertEquals(inVal!=0, HDFSTool.readBooleanFromHDFSFile(outName)); break;
 					default: //do nothing
 		        }
 	        }
diff --git a/src/test/java/org/apache/sysds/test/functions/mlcontext/FrameTest.java b/src/test/java/org/apache/sysds/test/functions/mlcontext/FrameTest.java
index 5feb010daf2..fe223a711ce 100644
--- a/src/test/java/org/apache/sysds/test/functions/mlcontext/FrameTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/mlcontext/FrameTest.java
@@ -86,7 +86,7 @@ public class FrameTest extends MLContextTestBase{
 	private final static List<ValueType> schemaMixedLargeListStr = Collections.nCopies(cols/4, ValueType.STRING);
 	private final static List<ValueType> schemaMixedLargeListDble  = Collections.nCopies(cols/4, ValueType.FP64);
 	private final static List<ValueType> schemaMixedLargeListInt  = Collections.nCopies(cols/4, ValueType.INT64);
-	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols/4, ValueType.BITSET);
+	private final static List<ValueType> schemaMixedLargeListBool  = Collections.nCopies(cols/4, ValueType.BOOLEAN);
 	private static ValueType[] schemaMixedLarge = null;
 	static {
 		final List<ValueType> schemaMixedLargeList = new ArrayList<>(schemaMixedLargeListStr);
diff --git a/src/test/java/org/apache/sysds/test/functions/mlcontext/MLContextFrameTest.java b/src/test/java/org/apache/sysds/test/functions/mlcontext/MLContextFrameTest.java
index 42f14f880b0..4b2c3508a84 100644
--- a/src/test/java/org/apache/sysds/test/functions/mlcontext/MLContextFrameTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/mlcontext/MLContextFrameTest.java
@@ -126,10 +126,10 @@ public void testFrame(FrameFormat format, SCRIPT_TYPE script_type, IO_TYPE input
 		List<String> listB = new ArrayList<>();
 		FrameMetadata fmA = null, fmB = null;
 		Script script = null;
-		ValueType[] schemaA = { ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.BITSET};
+		ValueType[] schemaA = { ValueType.INT64, ValueType.STRING, ValueType.FP64, ValueType.BOOLEAN};
 		List<ValueType> lschemaA = Arrays.asList(schemaA);
 		FrameSchema fschemaA = new FrameSchema(lschemaA);
-		ValueType[] schemaB = { ValueType.STRING, ValueType.FP64, ValueType.BITSET};
+		ValueType[] schemaB = { ValueType.STRING, ValueType.FP64, ValueType.BOOLEAN};
 		List<ValueType> lschemaB = Arrays.asList(schemaB);
 		FrameSchema fschemaB = new FrameSchema(lschemaB);
 
@@ -225,7 +225,7 @@ public void testFrame(FrameFormat format, SCRIPT_TYPE script_type, IO_TYPE input
 			Assert.assertEquals(ValueType.INT64, lschemaOutA.get(0));
 			Assert.assertEquals(ValueType.STRING, lschemaOutA.get(1));
 			Assert.assertEquals(ValueType.FP64, lschemaOutA.get(2));
-			Assert.assertEquals(ValueType.BITSET, lschemaOutA.get(3));
+			Assert.assertEquals(ValueType.BOOLEAN, lschemaOutA.get(3));
 			
 			Assert.assertEquals(ValueType.STRING, lschemaOutC.get(0));
 			Assert.assertEquals(ValueType.FP64, lschemaOutC.get(1));
diff --git a/src/test/java/org/apache/sysds/test/functions/recompile/LiteralReplaceCastScalarReadTest.java b/src/test/java/org/apache/sysds/test/functions/recompile/LiteralReplaceCastScalarReadTest.java
index bb050f9b00e..a9735c6dbf4 100644
--- a/src/test/java/org/apache/sysds/test/functions/recompile/LiteralReplaceCastScalarReadTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/recompile/LiteralReplaceCastScalarReadTest.java
@@ -55,7 +55,7 @@ public void testRemoveCastsInputDouble() {
 	
 	@Test
 	public void testRemoveCastsInputBoolean() {
-		runScalarCastTest(ValueType.BITSET);
+		runScalarCastTest(ValueType.BOOLEAN);
 	}
 	
 	private void runScalarCastTest( ValueType vt ) {
@@ -71,7 +71,7 @@ private void runScalarCastTest( ValueType vt ) {
 			switch( vt ) {
 				case INT64: val = "7"; break;
 				case FP64: val = "7.3"; break;
-				case BITSET: val = "TRUE"; break;
+				case BOOLEAN: val = "TRUE"; break;
 				default: //do nothing
 			}
 			
diff --git a/src/test/java/org/apache/sysds/test/functions/transform/ColumnEncoderSerializationTest.java b/src/test/java/org/apache/sysds/test/functions/transform/ColumnEncoderSerializationTest.java
index eed755a83b0..aeec927e73b 100644
--- a/src/test/java/org/apache/sysds/test/functions/transform/ColumnEncoderSerializationTest.java
+++ b/src/test/java/org/apache/sysds/test/functions/transform/ColumnEncoderSerializationTest.java
@@ -48,8 +48,8 @@ public class ColumnEncoderSerializationTest extends AutomatedTestBase
 		Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING,
 		Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING, Types.ValueType.STRING};
 	private final static Types.ValueType[] schemaMixed = new Types.ValueType[]{
-		Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BITSET,
-		Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BITSET};
+		Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BOOLEAN,
+		Types.ValueType.STRING, Types.ValueType.FP64, Types.ValueType.INT64, Types.ValueType.BOOLEAN};
 
 
 	public enum TransformType {