Implementation of xor operator

Author: byjtew

include/graphblas/base/internalops.hpp

@@ -1943,6 +1943,109 @@ namespace grb {
 
 			};
 
+			/**
+			 * The logical or operator, \f$ x \lxor y \f$.
+			 *
+			 * Assumes that the xor operator is defined on the given input types.
+			 */
+			template<
+				typename IN1, typename IN2, typename OUT,
+				enum Backend implementation = config::default_backend
+			>
+			class logical_xor {
+
+				public:
+
+					/** Alias to the left-hand input data type. */
+					typedef IN1 left_type;
+
+					/** Alias to the right-hand input data type. */
+					typedef IN2 right_type;
+
+					/** Alias to the output data type. */
+					typedef OUT result_type;
+
+					/** Whether this operator has an in-place foldl. */
+					static constexpr bool has_foldl = true;
+
+					/** Whether this operator has an in-place foldr. */
+					static constexpr bool has_foldr = true;
+
+					/**
+					 * Whether this operator is \em mathematically associative; that is,
+					 * associative when assuming equivalent data types for \a IN1, \a IN2,
+					 * and \a OUT, as well as assuming exact arithmetic, no overflows, etc.
+					 */
+					static constexpr bool is_associative = true;
+
+					/**
+					 * Whether this operator is \em mathematically commutative; that is,
+					 * commutative when assuming equivalent data types for \a IN1, \a IN2,
+					 * and \a OUT, as well as assuming exact arithmetic, no overflows, etc.
+					 */
+					static constexpr bool is_commutative = true;
+
+					/**
+					 * Out-of-place application of this operator.
+					 *
+					 * @param[in]  a The left-hand side input. Must be pre-allocated and
+					 *               initialised.
+					 * @param[in]  b The right-hand side input. Must be pre-allocated and
+					 *               initialised.
+					 * @param[out] c The output. Must be pre-allocated.
+					 *
+					 * At the end of the operation, \f$ c = \min\{a,b\} \f$.
+					 */
+					static void apply(
+						const left_type * __restrict__ const a,
+						const right_type * __restrict__ const b,
+						result_type * __restrict__ const c
+					) {
+						if( *a xor *b ) {
+							*c = static_cast< OUT >( true );
+						} else {
+							*c = static_cast< OUT >( false );
+						}
+					}
+
+					/**
+					 * In-place left-to-right folding.
+					 *
+					 * @param[in]     a Pointer to the left-hand side input data.
+					 * @param[in,out] c Pointer to the right-hand side input data. This also
+					 *                  dubs as the output memory area.
+					 */
+					static void foldr(
+						const left_type * __restrict__ const a,
+						result_type * __restrict__ const c
+					) {
+						if( *a xor *c ) {
+							*c = static_cast< result_type >( true );
+						} else {
+							*c = static_cast< result_type >( false );
+						}
+					}
+
+					/**
+					 * In-place right-to-left folding.
+					 *
+					 * @param[in,out] c Pointer to the left-hand side input data. This also
+					 *                  dubs as the output memory area.
+					 * @param[in]     b Pointer to the right-hand side input data.
+					 */
+					static void foldl(
+						result_type * __restrict__ const c,
+						const right_type * __restrict__ const b
+					) {
+						if( *b xor *c ) {
+							*c = static_cast< result_type >( true );
+						} else {
+							*c = static_cast< result_type >( false );
+						}
+					}
+
+			};
+
 			/**
 			 * The logical-and operator, \f$ x \land y \f$.
 			 *

include/graphblas/ops.hpp

@@ -490,6 +490,34 @@ namespace grb {
 				logical_or() {}
 		};
 
+		/**
+		 * The logical xor.
+		 *
+		 * It returns <tt>true</tt> whenever one and one only of its inputs 
+		 * evaluate <tt>true</tt>, and returns <tt>false</tt> otherwise.
+		 *
+		 * If the output domain is not Boolean, then the returned value is
+		 * <tt>true</tt> or <tt>false</tt> cast to the output domain.
+		 *
+		 * \warning Thus both input domains and the output domain must be 
+		 * 		\em castable to <tt>bool</tt>.
+		 */
+		template<
+			typename D1, typename D2 = D1, typename D3 = D2,
+			enum Backend implementation = config::default_backend
+		>
+		class logical_xor : public internal::Operator<
+				internal::logical_xor< D1, D2, D3, implementation >
+		> {
+
+			public:
+
+				template< typename A, typename B, typename C, enum Backend D >
+				using GenericOperator = logical_xor< A, B, C, D >;
+
+				logical_xor() {}
+		};
+
 		/**
 		 * The logical and.
 		 *
@@ -1082,6 +1110,11 @@ namespace grb {
 		static const constexpr bool value = true;
 	};
 
+	template< typename D1, typename D2, typename D3, enum Backend implementation >
+	struct is_operator< operators::logical_xor< D1, D2, D3, implementation > > {
+		static const constexpr bool value = true;
+	};
+
 	template< typename D1, typename D2, typename D3, enum Backend implementation >
 	struct is_operator< operators::logical_and< D1, D2, D3, implementation > > {
 		static const constexpr bool value = true;
@@ -1191,6 +1224,11 @@ namespace grb {
 		static const constexpr bool value = true;
 	};
 
+	template< typename D1, typename D2, typename D3 >
+	struct is_idempotent< operators::logical_xor< D1, D2, D3 >, void > {
+		static const constexpr bool value = true;
+	};
+
 	template< typename D1, typename D2, typename D3 >
 	struct is_idempotent< operators::logical_and< D1, D2, D3 >, void > {
 		static const constexpr bool value = true;