Changed tensor comparison return type from uint8 to bool

izdeby · izdeby · commit 9c4ba63457a7 · 2019-06-26T07:55:06.000-07:00
gh-metadata: pytorch pytorch 21113 gh/izdeby/7/head
diff --git a/aten/src/ATen/Declarations.cwrap b/aten/src/ATen/Declarations.cwrap
@@ -606,13 +606,13 @@
   options:
     - cname: ltValue
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - THTensor* self
         - real other
     - cname: ltTensor
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - arg: THTensor* self
           broadcast: other fallback
@@ -647,13 +647,13 @@
   options:
     - cname: gtValue
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - THTensor* self
         - real other
     - cname: gtTensor
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - arg: THTensor* self
           broadcast: other fallback
@@ -688,13 +688,13 @@
   options:
     - cname: leValue
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - THTensor* self
         - real other
     - cname: leTensor
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - arg: THTensor* self
           broadcast: other fallback
@@ -729,13 +729,13 @@
   options:
     - cname: geValue
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - THTensor* self
         - real other
     - cname: geTensor
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - arg: THTensor* self
           broadcast: other fallback
@@ -770,13 +770,13 @@
   options:
     - cname: eqValue
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - THTensor* self
         - real other
     - cname: eqTensor
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - arg: THTensor* self
           broadcast: other fallback
@@ -811,13 +811,13 @@
   options:
     - cname: neValue
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - THTensor* self
         - real other
     - cname: neTensor
       arguments:
-        - arg: THByteTensor* result
+        - arg: THBoolTensor* result
           output: True
         - arg: THTensor* self
           broadcast: other fallback
diff --git a/aten/src/ATen/native/Itertools.cpp b/aten/src/ATen/native/Itertools.cpp
@@ -12,7 +12,7 @@ Tensor _triu_mask(int64_t n, int64_t dims, bool diagonal, TensorOptions opt) {
   // or i <= j <= k <= ... (depending on diagonal)
   Tensor range = at::arange(n, opt.dtype(kLong));
   std::vector<Tensor> index_grids = at::meshgrid(std::vector<Tensor>(dims, range));
-  Tensor mask = at::ones(index_grids[0].sizes(), opt.dtype(kByte));
+  Tensor mask = at::ones(index_grids[0].sizes(), opt.dtype(kBool));
   if(diagonal) {
     for(int64_t i = 0; i < dims - 1; i++) {
       mask *= index_grids[i] <= index_grids[i+1];
diff --git a/aten/src/ATen/native/LinearAlgebra.cpp b/aten/src/ATen/native/LinearAlgebra.cpp
@@ -136,7 +136,7 @@ Tensor matrix_rank(const Tensor& self, bool symmetric) {
 
   Tensor S = _matrix_rank_helper(self, symmetric);
   double tol = _get_epsilon(self.scalar_type()) * std::max(self.size(0), self.size(1));
-  return (S > S.max().mul_(tol)).sum();
+  return (S > S.max().mul_(tol)).sum(ScalarType::Long);
 }
 
 static void check_1d(const Tensor& t, const char* arg, const char* fn) {
diff --git a/aten/src/ATen/native/cpu/TensorCompareKernel.cpp b/aten/src/ATen/native/cpu/TensorCompareKernel.cpp
@@ -83,7 +83,7 @@ static void max_kernel_impl(
     Tensor& max_indices,
     const Tensor& self,
     c10::optional<int64_t> dim) {
-  AT_DISPATCH_ALL_TYPES(self.scalar_type(), "max", [&] {
+  AT_DISPATCH_ALL_TYPES_AND(ScalarType::Bool, self.scalar_type(), "max", [&] {
     Reduction<scalar_t, int64_t>::apply(max, max_indices, self, dim, true);
   });
 }
@@ -93,7 +93,7 @@ static void min_kernel_impl(
     Tensor& min_indices,
     const Tensor& self,
     c10::optional<int64_t> dim) {
-  AT_DISPATCH_ALL_TYPES(self.scalar_type(), "min", [&] {
+  AT_DISPATCH_ALL_TYPES_AND(ScalarType::Bool, self.scalar_type(), "min", [&] {
     Reduction<scalar_t, int64_t>::apply(min, min_indices, self, dim, false);
   });
 }
diff --git a/aten/src/ATen/test/atest.cpp b/aten/src/ATen/test/atest.cpp
@@ -36,7 +36,7 @@ TEST(atest, atest) {
   float b = a.to<float>();
   ASSERT_EQ(b, 4);
 
-  foo = (foo * foo) == (foo.pow(3));
+  foo = ((foo * foo) == (foo.pow(3))).to(kByte);
   foo = 2 + (foo + 1);
   // foo = foo[3];
   auto foo_v = foo.accessor<uint8_t, 2>();
diff --git a/aten/src/TH/generic/THTensorMoreMath.cpp b/aten/src/TH/generic/THTensorMoreMath.cpp
@@ -6,30 +6,30 @@
 #include <ATen/CPUGenerator.h>
 #include <ATen/Utils.h>
 
-#define TENSOR_IMPLEMENT_LOGICAL(NAME,OP) \
-  void THTensor_(NAME##Value)(THByteTensor *r_, THTensor* t, scalar_t value) \
-  { \
-    THByteTensor_resizeNd(r_, t->dim(), THTensor_getSizePtr(t), NULL); \
-    TH_TENSOR_APPLY2(unsigned char, r_, scalar_t, t, \
-                     *r__data = (*t_data OP value) ? 1 : 0;); \
-  } \
-  void THTensor_(NAME##ValueT)(THTensor* r_, THTensor* t, scalar_t value) \
-  { \
-    THTensor_(resizeNd)(r_, t->dim(), THTensor_getSizePtr(t), NULL); \
-    TH_TENSOR_APPLY2(scalar_t, r_, scalar_t, t, \
-                     *r__data = (*t_data OP value) ? 1 : 0;); \
-  } \
-  void THTensor_(NAME##Tensor)(THByteTensor *r_, THTensor *ta, THTensor *tb) \
-  { \
-    THByteTensor_resizeNd(r_, ta->dim(), THTensor_getSizePtr(ta), NULL); \
-    TH_TENSOR_APPLY3(unsigned char, r_, scalar_t, ta, scalar_t, tb, \
-                     *r__data = (*ta_data OP *tb_data) ? 1 : 0;); \
-  } \
-  void THTensor_(NAME##TensorT)(THTensor *r_, THTensor *ta, THTensor *tb) \
-  { \
-    THTensor_(resizeNd)(r_, ta->dim(), THTensor_getSizePtr(ta), NULL); \
-    TH_TENSOR_APPLY3(scalar_t, r_, scalar_t, ta, scalar_t, tb, \
-                     *r__data = (*ta_data OP *tb_data) ? 1 : 0;); \
+#define TENSOR_IMPLEMENT_LOGICAL(NAME,OP)                                      \
+  void THTensor_(NAME##Value)(THBoolTensor *r_, THTensor* t, scalar_t value)   \
+  {                                                                            \
+    THBoolTensor_resizeNd(r_, t->dim(), THTensor_getSizePtr(t), NULL);         \
+    TH_TENSOR_APPLY2(bool, r_, scalar_t, t,                                    \
+                     *r__data = (*t_data OP value) ? 1 : 0;);                  \
+  }                                                                            \
+  void THTensor_(NAME##ValueT)(THTensor* r_, THTensor* t, scalar_t value)      \
+  {                                                                            \
+    THTensor_(resizeNd)(r_, t->dim(), THTensor_getSizePtr(t), NULL);           \
+    TH_TENSOR_APPLY2(scalar_t, r_, scalar_t, t,                                \
+                     *r__data = (*t_data OP value) ? 1 : 0;);                  \
+  }                                                                            \
+  void THTensor_(NAME##Tensor)(THBoolTensor *r_, THTensor *ta, THTensor *tb)   \
+  {                                                                            \
+    THBoolTensor_resizeNd(r_, ta->dim(), THTensor_getSizePtr(ta), NULL);       \
+    TH_TENSOR_APPLY3(bool, r_, scalar_t, ta, scalar_t, tb,                     \
+                     *r__data = (*ta_data OP *tb_data) ? 1 : 0;);              \
+  }                                                                            \
+  void THTensor_(NAME##TensorT)(THTensor *r_, THTensor *ta, THTensor *tb)      \
+  {                                                                            \
+    THTensor_(resizeNd)(r_, ta->dim(), THTensor_getSizePtr(ta), NULL);         \
+    TH_TENSOR_APPLY3(scalar_t, r_, scalar_t, ta, scalar_t, tb,                 \
+                     *r__data = (*ta_data OP *tb_data) ? 1 : 0;);              \
   }
 
 TENSOR_IMPLEMENT_LOGICAL(lt,<)
diff --git a/aten/src/THC/generic/THCTensorMathCompare.cu b/aten/src/THC/generic/THCTensorMathCompare.cu
@@ -5,49 +5,49 @@
 void THCTensor_(ltValue)(THCState *state, THCudaByteTensor *self_, THCTensor *src, scalar_t value)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));
-  THC_logicalValue<uint8_t, scalar_t>(state, self_, src,
+  THC_logicalValue<bool, scalar_t>(state, self_, src,
                                   TensorLTValueOp<scalar_t,
-                                  unsigned char>(value));
+                                  bool>(value));
 }
 
 void THCTensor_(gtValue)(THCState *state, THCudaByteTensor *self_, THCTensor *src, scalar_t value)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));
-  THC_logicalValue<uint8_t, scalar_t>(state, self_, src,
+  THC_logicalValue<bool, scalar_t>(state, self_, src,
                                   TensorGTValueOp<scalar_t,
-                                  unsigned char>(value));
+                                  bool>(value));
 }
 
 void THCTensor_(leValue)(THCState *state, THCudaByteTensor *self_, THCTensor *src, scalar_t value)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));
-  THC_logicalValue<uint8_t, scalar_t>(state, self_, src,
+  THC_logicalValue<bool, scalar_t>(state, self_, src,
                                   TensorLEValueOp<scalar_t,
-                                  unsigned char>(value));
+                                  bool>(value));
 }
 
 void THCTensor_(geValue)(THCState *state, THCudaByteTensor *self_, THCTensor *src, scalar_t value)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));
-  THC_logicalValue<uint8_t, scalar_t>(state, self_, src,
+  THC_logicalValue<bool, scalar_t>(state, self_, src,
                                   TensorGEValueOp<scalar_t,
-                                  unsigned char>(value));
+                                  bool>(value));
 }
 
 void THCTensor_(eqValue)(THCState *state, THCudaByteTensor *self_, THCTensor *src, scalar_t value)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));
-  THC_logicalValue<uint8_t, scalar_t>(state, self_, src,
+  THC_logicalValue<bool, scalar_t>(state, self_, src,
                                   TensorEQValueOp<scalar_t,
-                                  unsigned char>(value));
+                                  bool>(value));
 }
 
 void THCTensor_(neValue)(THCState *state, THCudaByteTensor *self_, THCTensor *src, scalar_t value)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));
-  THC_logicalValue<uint8_t, scalar_t>(state, self_, src,
+  THC_logicalValue<bool, scalar_t>(state, self_, src,
                                   TensorNEValueOp<scalar_t,
-                                  unsigned char>(value));
+                                  bool>(value));
 }
 
 void THCTensor_(ltValueT)(THCState *state, THCTensor *self_, THCTensor *src, scalar_t value)
diff --git a/aten/src/THC/generic/THCTensorMathCompareT.cu b/aten/src/THC/generic/THCTensorMathCompareT.cu
@@ -5,49 +5,49 @@
 void THCTensor_(ltTensor)(THCState *state, THCudaByteTensor *self_, THCTensor *src1, THCTensor *src2)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));
-  THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,
+  THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,
                                    TensorLTOp<scalar_t,
-                                   unsigned char>());
+                                   bool>());
 }
 
 void THCTensor_(gtTensor)(THCState *state, THCudaByteTensor *self_, THCTensor *src1, THCTensor *src2)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));
-  THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,
+  THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,
                                    TensorGTOp<scalar_t,
-                                   unsigned char>());
+                                   bool>());
 }
 
 void THCTensor_(leTensor)(THCState *state, THCudaByteTensor *self_, THCTensor *src1, THCTensor *src2)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));
-  THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,
+  THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,
                                    TensorLEOp<scalar_t,
-                                   unsigned char>());
+                                   bool>());
 }
 
 void THCTensor_(geTensor)(THCState *state, THCudaByteTensor *self_, THCTensor *src1, THCTensor *src2)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));
-  THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,
+  THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,
                                    TensorGEOp<scalar_t,
-                                   unsigned char>());
+                                   bool>());
 }
 
 void THCTensor_(eqTensor)(THCState *state, THCudaByteTensor *self_, THCTensor *src1, THCTensor *src2)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));
-  THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,
+  THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,
                                    TensorEQOp<scalar_t,
-                                   unsigned char>());
+                                   bool>());
 }
 
 void THCTensor_(neTensor)(THCState *state, THCudaByteTensor *self_, THCTensor *src1, THCTensor *src2)
 {
   THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));
-  THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,
+  THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,
                                    TensorNEOp<scalar_t,
-                                   unsigned char>());
+                                   bool>());
 }
 
 void THCTensor_(ltTensorT)(THCState *state, THCTensor *self_, THCTensor *src1, THCTensor *src2)
diff --git a/c10/core/ScalarType.h b/c10/core/ScalarType.h
@@ -109,7 +109,8 @@ namespace c10 {
   _(double, Double, d)                        \
   _(c10::qint8, QInt8, i)                     \
   _(c10::quint8, QUInt8, i)                   \
-  _(c10::qint32, QInt32, i)
+  _(c10::qint32, QInt32, i)                   \
+  _(bool, Bool, i)
 
 #define AT_FORALL_SCALAR_TYPES_EXCEPT_HALF_AND_QINT(_) \
   _(uint8_t, Byte, i)                                  \
diff --git a/test/expect/TestScript.test_listconstruct_erasure.expect b/test/expect/TestScript.test_listconstruct_erasure.expect
@@ -12,7 +12,7 @@ ModelProto {
         Node {type: "Constant", inputs: [], outputs: [1], attributes: [{ name: 'value', type: tensor, value:TensorProto shape: []}]},
         Node {type: "Less", inputs: [0,1], outputs: [2], attributes: []},
         Node {type: "Cast", inputs: [2], outputs: [3], attributes: [{ name: 'to', type: int, value: 2}]},
-        Node {type: "Cast", inputs: [3], outputs: [4], attributes: [{ name: 'to', type: int, value: 2}]},
+        Node {type: "Cast", inputs: [3], outputs: [4], attributes: [{ name: 'to', type: int, value: 9}]},
         Node {type: "ATen", inputs: [0,4], outputs: [5], attributes: [{ name: 'operator', type: string, value: 'index'}]}
       ]
     }
diff --git a/test/onnx/expect/TestOperators.test_equal.expect b/test/onnx/expect/TestOperators.test_equal.expect
@@ -61,7 +61,7 @@ graph {
     name: "3"
     type {
       tensor_type {
-        elem_type: 2
+        elem_type: 9
         shape {
           dim {
             dim_value: 1
diff --git a/test/onnx/expect/TestOperators.test_ge.expect b/test/onnx/expect/TestOperators.test_ge.expect
@@ -60,7 +60,7 @@ graph {
     name: "4"
     type {
       tensor_type {
-        elem_type: 2
+        elem_type: 9
         shape {
           dim {
             dim_value: 3
diff --git a/test/onnx/expect/TestOperators.test_gt.expect b/test/onnx/expect/TestOperators.test_gt.expect
@@ -61,7 +61,7 @@ graph {
     name: "3"
     type {
       tensor_type {
-        elem_type: 2
+        elem_type: 9
         shape {
           dim {
             dim_value: 1
diff --git a/test/onnx/expect/TestOperators.test_isnan.expect b/test/onnx/expect/TestOperators.test_isnan.expect
@@ -35,7 +35,7 @@ graph {
     name: "2"
     type {
       tensor_type {
-        elem_type: 2
+        elem_type: 9
         shape {
           dim {
             dim_value: 3
diff --git a/test/onnx/expect/TestOperators.test_le.expect b/test/onnx/expect/TestOperators.test_le.expect
@@ -60,7 +60,7 @@ graph {
     name: "4"
     type {
       tensor_type {
-        elem_type: 2
+        elem_type: 9
         shape {
           dim {
             dim_value: 3
diff --git a/test/onnx/expect/TestOperators.test_lt.expect b/test/onnx/expect/TestOperators.test_lt.expect
@@ -61,7 +61,7 @@ graph {
     name: "3"
     type {
       tensor_type {
-        elem_type: 2
+        elem_type: 9
         shape {
           dim {
             dim_value: 1
diff --git a/test/onnx/expect/TestOperators.test_ne.expect b/test/onnx/expect/TestOperators.test_ne.expect
diff --git a/test/onnx/test_pytorch_onnx_caffe2.py b/test/onnx/test_pytorch_onnx_caffe2.py
diff --git a/test/test_distributed.py b/test/test_distributed.py
diff --git a/test/test_torch.py b/test/test_torch.py
diff --git a/tools/autograd/templates/python_variable_methods.cpp b/tools/autograd/templates/python_variable_methods.cpp
diff --git a/torch/csrc/jit/passes/shape_analysis.cpp b/torch/csrc/jit/passes/shape_analysis.cpp
diff --git a/torch/csrc/jit/symbolic_script.cpp b/torch/csrc/jit/symbolic_script.cpp
diff --git a/torch/functional.py b/torch/functional.py

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ Tensor matrix_rank(const Tensor& self, bool symmetric) {`
`136`	`136`
`137`	`137`	`Tensor S = _matrix_rank_helper(self, symmetric);`
`138`	`138`	`double tol = _get_epsilon(self.scalar_type()) * std::max(self.size(0), self.size(1));`
`139`		`- return (S > S.max().mul_(tol)).sum();`
	`139`	`+ return (S > S.max().mul_(tol)).sum(ScalarType::Long);`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`static void check_1d(const Tensor& t, const char* arg, const char* fn) {`
Original file line number	Diff line number	Diff line change
`@@ -5,49 +5,49 @@`
`5`	`5`	`void THCTensor_(ltValue)(THCState state, THCudaByteTensor self_, THCTensor *src, scalar_t value)`
`6`	`6`	`{`
`7`	`7`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));`
`8`		`- THC_logicalValue<uint8_t, scalar_t>(state, self_, src,`
	`8`	`+ THC_logicalValue<bool, scalar_t>(state, self_, src,`
`9`	`9`	`TensorLTValueOp<scalar_t,`
`10`		`- unsigned char>(value));`
	`10`	`+ bool>(value));`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`void THCTensor_(gtValue)(THCState state, THCudaByteTensor self_, THCTensor *src, scalar_t value)`
`14`	`14`	`{`
`15`	`15`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));`
`16`		`- THC_logicalValue<uint8_t, scalar_t>(state, self_, src,`
	`16`	`+ THC_logicalValue<bool, scalar_t>(state, self_, src,`
`17`	`17`	`TensorGTValueOp<scalar_t,`
`18`		`- unsigned char>(value));`
	`18`	`+ bool>(value));`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`void THCTensor_(leValue)(THCState state, THCudaByteTensor self_, THCTensor *src, scalar_t value)`
`22`	`22`	`{`
`23`	`23`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));`
`24`		`- THC_logicalValue<uint8_t, scalar_t>(state, self_, src,`
	`24`	`+ THC_logicalValue<bool, scalar_t>(state, self_, src,`
`25`	`25`	`TensorLEValueOp<scalar_t,`
`26`		`- unsigned char>(value));`
	`26`	`+ bool>(value));`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`void THCTensor_(geValue)(THCState state, THCudaByteTensor self_, THCTensor *src, scalar_t value)`
`30`	`30`	`{`
`31`	`31`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));`
`32`		`- THC_logicalValue<uint8_t, scalar_t>(state, self_, src,`
	`32`	`+ THC_logicalValue<bool, scalar_t>(state, self_, src,`
`33`	`33`	`TensorGEValueOp<scalar_t,`
`34`		`- unsigned char>(value));`
	`34`	`+ bool>(value));`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`void THCTensor_(eqValue)(THCState state, THCudaByteTensor self_, THCTensor *src, scalar_t value)`
`38`	`38`	`{`
`39`	`39`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));`
`40`		`- THC_logicalValue<uint8_t, scalar_t>(state, self_, src,`
	`40`	`+ THC_logicalValue<bool, scalar_t>(state, self_, src,`
`41`	`41`	`TensorEQValueOp<scalar_t,`
`42`		`- unsigned char>(value));`
	`42`	`+ bool>(value));`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`void THCTensor_(neValue)(THCState state, THCudaByteTensor self_, THCTensor *src, scalar_t value)`
`46`	`46`	`{`
`47`	`47`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 2, self_, src));`
`48`		`- THC_logicalValue<uint8_t, scalar_t>(state, self_, src,`
	`48`	`+ THC_logicalValue<bool, scalar_t>(state, self_, src,`
`49`	`49`	`TensorNEValueOp<scalar_t,`
`50`		`- unsigned char>(value));`
	`50`	`+ bool>(value));`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`void THCTensor_(ltValueT)(THCState state, THCTensor self_, THCTensor *src, scalar_t value)`
Original file line number	Diff line number	Diff line change
`@@ -5,49 +5,49 @@`
`5`	`5`	`void THCTensor_(ltTensor)(THCState state, THCudaByteTensor self_, THCTensor src1, THCTensor src2)`
`6`	`6`	`{`
`7`	`7`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));`
`8`		`- THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,`
	`8`	`+ THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,`
`9`	`9`	`TensorLTOp<scalar_t,`
`10`		`- unsigned char>());`
	`10`	`+ bool>());`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`void THCTensor_(gtTensor)(THCState state, THCudaByteTensor self_, THCTensor src1, THCTensor src2)`
`14`	`14`	`{`
`15`	`15`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));`
`16`		`- THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,`
	`16`	`+ THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,`
`17`	`17`	`TensorGTOp<scalar_t,`
`18`		`- unsigned char>());`
	`18`	`+ bool>());`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`void THCTensor_(leTensor)(THCState state, THCudaByteTensor self_, THCTensor src1, THCTensor src2)`
`22`	`22`	`{`
`23`	`23`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));`
`24`		`- THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,`
	`24`	`+ THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,`
`25`	`25`	`TensorLEOp<scalar_t,`
`26`		`- unsigned char>());`
	`26`	`+ bool>());`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`void THCTensor_(geTensor)(THCState state, THCudaByteTensor self_, THCTensor src1, THCTensor src2)`
`30`	`30`	`{`
`31`	`31`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));`
`32`		`- THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,`
	`32`	`+ THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,`
`33`	`33`	`TensorGEOp<scalar_t,`
`34`		`- unsigned char>());`
	`34`	`+ bool>());`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`void THCTensor_(eqTensor)(THCState state, THCudaByteTensor self_, THCTensor src1, THCTensor src2)`
`38`	`38`	`{`
`39`	`39`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));`
`40`		`- THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,`
	`40`	`+ THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,`
`41`	`41`	`TensorEQOp<scalar_t,`
`42`		`- unsigned char>());`
	`42`	`+ bool>());`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`void THCTensor_(neTensor)(THCState state, THCudaByteTensor self_, THCTensor src1, THCTensor src2)`
`46`	`46`	`{`
`47`	`47`	`THCAssertSameGPU(THCTensor_(checkGPU)(state, 3, self_, src1, src2));`
`48`		`- THC_logicalTensor<uint8_t, scalar_t>(state, self_, src1, src2,`
	`48`	`+ THC_logicalTensor<bool, scalar_t>(state, self_, src1, src2,`
`49`	`49`	`TensorNEOp<scalar_t,`
`50`		`- unsigned char>());`
	`50`	`+ bool>());`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`void THCTensor_(ltTensorT)(THCState state, THCTensor self_, THCTensor src1, THCTensor src2)`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ ModelProto {`
`12`	`12`	`Node {type: "Constant", inputs: [], outputs: [1], attributes: [{ name: 'value', type: tensor, value:TensorProto shape: []}]},`
`13`	`13`	`Node {type: "Less", inputs: [0,1], outputs: [2], attributes: []},`
`14`	`14`	`Node {type: "Cast", inputs: [2], outputs: [3], attributes: [{ name: 'to', type: int, value: 2}]},`
`15`		`- Node {type: "Cast", inputs: [3], outputs: [4], attributes: [{ name: 'to', type: int, value: 2}]},`
	`15`	`+ Node {type: "Cast", inputs: [3], outputs: [4], attributes: [{ name: 'to', type: int, value: 9}]},`
`16`	`16`	`Node {type: "ATen", inputs: [0,4], outputs: [5], attributes: [{ name: 'operator', type: string, value: 'index'}]}`
`17`	`17`	`]`
`18`	`18`	`}`