xor fexpr

Author: samukweku

src/core/expr/fbinary/bimaker.cc

@@ -47,7 +47,7 @@ bimaker_ptr resolve_op(Op opcode, SType stype1, SType stype2) {
   switch (opcode) {
     //case Op::AND:        return resolve_op_and(stype1, stype2);
     //case Op::OR:         return resolve_op_or(stype1, stype2);
-    case Op::XOR:        return resolve_op_xor(stype1, stype2);
+    //case Op::XOR:        return resolve_op_xor(stype1, stype2);
     case Op::LSHIFT:     return resolve_op_lshift(stype1, stype2);
     case Op::RSHIFT:     return resolve_op_rshift(stype1, stype2);
 

src/core/expr/fbinary/bimaker.h

@@ -79,7 +79,7 @@ bimaker_ptr resolve_op(Op, SType, SType);
 
 //bimaker_ptr resolve_op_and(SType, SType);
 //bimaker_ptr resolve_op_or(SType, SType);
-bimaker_ptr resolve_op_xor(SType, SType);
+//bimaker_ptr resolve_op_xor(SType, SType);
 bimaker_ptr resolve_op_lshift(SType, SType);
 bimaker_ptr resolve_op_rshift(SType, SType);
 

src/core/expr/fbinary/bitwise_and.cc renamed to src/core/expr/fbinary/bitwise_and_or.cc

@@ -68,6 +68,11 @@ inline static T op_or(T x, T y) {
   return (x | y);
 }
 
+template <typename T>
+inline static T op_xor(T x, T y) {
+  return (x ^ y);
+}
+
 template<bool AND>
 class FExpr__andor__ : public FExpr_BinaryOp {
   public:
@@ -110,7 +115,8 @@ class FExpr__andor__ : public FExpr_BinaryOp {
         case SType::INT32:   return make<int32_t, AND>(std::move(lcol), std::move(rcol), stype0);
         case SType::INT64:   return make<int64_t, AND>(std::move(lcol), std::move(rcol), stype0);
         default:
-          throw TypeError() << "Operator `&` cannot be applied to columns of "
+          char op = AND?'&':'|';
+          throw TypeError() << "Operator " << op << " cannot be applied to columns of "
             "types `" << stype1 << "` and `" << stype2 << "`";
       }
     }
@@ -138,6 +144,50 @@ class FExpr__andor__ : public FExpr_BinaryOp {
 };
 
 
+class FExpr__xor__ : public FExpr_BinaryOp {
+  public:
+    using FExpr_BinaryOp::FExpr_BinaryOp;
+    using FExpr_BinaryOp::lhs_;
+    using FExpr_BinaryOp::rhs_;
+
+
+    std::string name() const override        { return "^"; }
+    int precedence() const noexcept override { return 8; }
+
+
+    Column evaluate1(Column&& lcol, Column&& rcol) const override {
+      xassert(lcol.nrows() == rcol.nrows());
+      auto stype1 = lcol.stype();
+      auto stype2 = rcol.stype();
+      auto stype0 = common_stype(stype1, stype2);
+
+      switch (stype0) {
+        case SType::BOOL:    return make<int8_t>(std::move(lcol), std::move(rcol), stype0);
+        case SType::INT8:    return make<int8_t>(std::move(lcol), std::move(rcol), stype0);
+        case SType::INT16:   return make<int16_t>(std::move(lcol), std::move(rcol), stype0);
+        case SType::INT32:   return make<int32_t>(std::move(lcol), std::move(rcol), stype0);
+        case SType::INT64:   return make<int64_t>(std::move(lcol), std::move(rcol), stype0);
+        default:
+          throw TypeError() << "Operator `^` cannot be applied to columns of "
+            "types `" << stype1 << "` and `" << stype2 << "`";
+      }
+    }
+
+  private:
+    template <typename T>
+    static Column make(Column&& a, Column&& b, SType stype) {
+      xassert(compatible_type<T>(stype));
+      size_t nrows = a.nrows();
+      a.cast_inplace(stype);
+      b.cast_inplace(stype);
+      return Column(new FuncBinary1_ColumnImpl<T, T, T>(
+        std::move(a), std::move(b),
+        op_xor<T>,
+        nrows, stype
+      ));
+    }
+};
+
 
 py::oobj PyFExpr::nb__and__(py::robj lhs, py::robj rhs) {
   return PyFExpr::make(
@@ -149,6 +199,13 @@ py::oobj PyFExpr::nb__or__(py::robj lhs, py::robj rhs) {
             new FExpr__andor__<false>(as_fexpr(lhs), as_fexpr(rhs)));
 }
 
+py::oobj PyFExpr::nb__xor__(py::robj lhs, py::robj rhs) {
+  return PyFExpr::make(
+            new FExpr__xor__(as_fexpr(lhs), as_fexpr(rhs)));
+}
+
 
 
 }}  // namespace dt::expr
+
+

src/core/expr/fexpr.cc

@@ -186,7 +186,7 @@ static oobj make_binexpr(dt::expr::Op op, robj lhs, robj rhs) {
 
 
 //oobj PyFExpr::nb__and__(robj lhs, robj rhs)      { return make_binexpr(dt::expr::Op::AND,      lhs, rhs); }
-oobj PyFExpr::nb__xor__(robj lhs, robj rhs)      { return make_binexpr(dt::expr::Op::XOR,      lhs, rhs); }
+//oobj PyFExpr::nb__xor__(robj lhs, robj rhs)      { return make_binexpr(dt::expr::Op::XOR,      lhs, rhs); }
 //oobj PyFExpr::nb__or__(robj lhs, robj rhs)       { return make_binexpr(dt::expr::Op::OR,       lhs, rhs); }
 oobj PyFExpr::nb__lshift__(robj lhs, robj rhs)   { return make_binexpr(dt::expr::Op::LSHIFT,   lhs, rhs); }
 oobj PyFExpr::nb__rshift__(robj lhs, robj rhs)   { return make_binexpr(dt::expr::Op::RSHIFT,   lhs, rhs); }