is_associativity issue to review

byjtew · byjtew · commit 481d8b69284a · 2023-07-17T11:18:22.000+02:00
diff --git a/include/graphblas/base/internalops.hpp b/include/graphblas/base/internalops.hpp
@@ -56,7 +56,7 @@ namespace grb {
 			 * 			- \b OperatorType: The internal::operator type to negate.
 			 */
 			template<
-				class Op,
+				typename Op,
 				enum Backend implementation = config::default_backend
 			>
 			class logical_not {
@@ -83,9 +83,7 @@ namespace grb {
 					 * 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 = is_lnegated< Op >::value 
-															? Op::OperatorType::is_associative
-															: false;
+					static constexpr bool is_associative = Op::OperatorType::is_associative;
 
 					/**
 					 * Whether this operator is \em mathematically commutative; that is,
@@ -3054,16 +3052,6 @@ namespace grb {
 
 				public:
 
-					/** @return Whether this operator is mathematically associative. */
-					static constexpr bool is_associative() {
-						return OP::is_associative;
-					}
-
-					/** @return Whether this operator is mathematically commutative. */
-					static constexpr bool is_commutative() {
-						return OP::is_commutative;
-					}
-
 					/**
 					 * Straightforward application of this operator. Computes \f$ x \odot y \f$
 					 * and stores the result in \a z.
diff --git a/include/graphblas/ops.hpp b/include/graphblas/ops.hpp
@@ -48,7 +48,10 @@ namespace grb {
 			class Op,
 			enum Backend implementation = config::default_backend
 		>
-		class logical_not : public internal::Operator< internal::logical_not< Op > > {
+		class logical_not : public internal::Operator<
+			internal::logical_not< Op >
+		> {
+
 			public:
 
 				template< class A >
@@ -1264,26 +1267,25 @@ namespace grb {
 		OP,
 		typename std::enable_if< is_operator< OP >::value, void >::type
 	> {
-		static constexpr const bool value = OP::is_associative();
+		static constexpr const bool value = is_logically_negated<OP>::value ? false : OP::OperatorType::is_associative;
 	};
 
 	template< typename OP >
 	struct is_commutative<
 		OP,
 		typename std::enable_if< is_operator< OP >::value, void >::type
 	> {
-		static constexpr const bool value = OP::is_commutative();
+		static constexpr const bool value = OP::OperatorType::is_commutative();
 	};
 
 	template< typename OP >
-	struct is_lnegated< 
+	struct is_logically_negated<
 		operators::logical_not< OP >,
 		typename std::enable_if< is_operator< OP >::value, void >::type
 	> {
-		static constexpr const bool value = true;
+		static constexpr const bool value = not is_logically_negated< OP >::value;
 	};
 
-
 	// internal type traits follow
 
 	namespace internal {
diff --git a/include/graphblas/type_traits.hpp b/include/graphblas/type_traits.hpp
@@ -237,7 +237,7 @@ namespace grb {
 	 * \ingroup typeTraits
 	 */
 	template< typename T, typename = void >
-	struct is_lnegated {
+	struct is_logically_negated {
 
 		static_assert( is_operator< T >::value,
 			"Template argument should be an ALP binary operator." );
diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt
@@ -247,7 +247,7 @@ add_grb_executables( mxv mxv.cpp
 	BACKENDS reference_omp bsp1d hybrid hyperdags nonblocking
 )
 
-add_grb_executables( operator_logical_not operator_logical_not.cpp
+add_grb_executables( logical_operators logical_operators.cpp
 	BACKENDS reference reference_omp hyperdags nonblocking bsp1d hybrid
 )
 
diff --git a/tests/unit/logical_operators.cpp b/tests/unit/logical_operators.cpp
@@ -0,0 +1,284 @@
+
+/*
+ *   Copyright 2021 Huawei Technologies Co., Ltd.
+ *
+ * Licensed 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.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+#include <graphblas.hpp>
+#include <graphblas/ops.hpp>
+
+using namespace grb;
+using namespace grb::operators;
+
+constexpr std::array< std::pair< bool, bool >, 4 > test_values = {
+	std::make_pair( false, false ),
+	std::make_pair( false, true ),
+	std::make_pair( true, false ),
+	std::make_pair( true, true )
+};
+
+template<
+	Descriptor descr = descriptors::no_operation,
+	typename OP
+>
+void test_apply(
+	RC &rc,
+	std::array< bool, 4 > &values,
+	const std::array< bool, 4 > &expected
+) {
+	rc = apply< descr, OP >( values[0], false, false );
+	rc = rc ? rc : apply< descr, OP >( values[1], false, true );
+	rc = rc ? rc : apply< descr, OP >( values[2], true, false );
+	rc = rc ? rc : apply< descr, OP >( values[3], true, true );
+	if( ! std::equal( values.cbegin(), values.cend(), expected.cbegin() ) ) {
+		rc = FAILED;
+	}
+}
+
+template<
+	Descriptor descr = descriptors::no_operation,
+	typename OP
+>
+void test_foldl(
+	RC &rc,
+	std::array< bool, 4 > &values,
+	const std::array< bool, 4 > &expected
+) {
+	values[0] = false;
+	rc = foldl< descr, OP >( values[0], false );
+	values[1] = false;
+	rc = rc ? rc : foldl< descr, OP >( values[1], true );
+	values[2] = true;
+	rc = rc ? rc : foldl< descr, OP >( values[2], false );
+	values[3] = true;
+	rc = rc ? rc : foldl< descr, OP >( values[3], true );
+	if( ! std::equal( values.cbegin(), values.cend(), expected.cbegin() ) ) {
+		rc = FAILED;
+	}
+}
+
+template<
+	Descriptor descr = descriptors::no_operation,
+	typename OP
+>
+void test_foldr(
+	RC &rc,
+	std::array< bool, 4 > &values,
+	const std::array< bool, 4 > &expected
+) {
+	values[0] = false;
+	rc = foldr< descr, OP >( false, values[0] );
+	values[1] = false;
+	rc = rc ? rc : foldr< descr, OP >( true, values[1] );
+	values[2] = true;
+	rc = rc ? rc : foldr< descr, OP >( false, values[2] );
+	values[3] = true;
+	rc = rc ? rc : foldr< descr, OP >( true, values[3] );
+	if( ! std::equal( values.cbegin(), values.cend(), expected.cbegin() ) ) {
+		rc = FAILED;
+	}
+}
+
+template<
+	Descriptor descr = descriptors::no_operation,
+	typename OP
+>
+void test_operator(
+	RC &rc,
+	const std::array< bool, 4 > &expected,
+	const bool expected_associative,
+	const typename std::enable_if<
+		grb::is_operator< OP >::value,
+		void
+	>::type* = nullptr
+) {
+
+	if( grb::is_associative< OP >::value != expected_associative ) {
+		std::cerr << "Operator associtativity property is "
+			<< grb::is_associative< OP >::value << ", should be "
+			<< expected_associative << "\n";
+		rc = FAILED;
+		return;
+	}
+
+	std::array< bool, 4 > values;
+
+	test_apply< descr, OP >( rc, values, expected );
+	if( rc != SUCCESS ) {
+		std::cerr << "Test_apply FAILED\n";
+		std::cerr << "values ?= expected\n";
+		for( size_t i = 0; i < 4; i++ ) {
+			std::cerr << "OP( " << test_values[i].first << ";"
+				<< test_values[i].second << " ): "<< values[i] << " ?= "
+				<< expected[i] << "\n";
+		}
+		return;
+	}
+	test_foldl< descr, OP >( rc, values, expected );
+	if( rc != SUCCESS ) {
+		std::cerr << "Test_foldl FAILED\n";
+		std::cerr << "values ?= expected\n";
+		for( size_t i = 0; i < 4; i++ ) {
+			std::cerr << "OP( " << test_values[i].first << ";"
+				<< test_values[i].second << " ): "<< values[i] << " ?= "
+				<< expected[i] << "\n";
+		}
+		return;
+	}
+	test_foldr< descr, OP >( rc, values, expected );
+	if( rc != SUCCESS ) {
+		std::cerr << "Test_foldr FAILED\n";
+		std::cerr << "values ?= expected\n";
+		for( size_t i = 0; i < 4; i++ ) {
+			std::cerr << "OP( " << test_values[i].first << ";"
+				<< test_values[i].second << " ): "<< values[i] << " ?= "
+				<< expected[i] << "\n";
+		}
+		return;
+	}
+}
+
+void grb_program( const size_t&, grb::RC &rc ) {
+	rc = SUCCESS;
+
+	// Logical operators
+	{ // logical_and< bool >
+		std::cout << "Testing operator: logical_and<bool>" << std::endl;
+		const std::array<bool, 4> expected = { false, false, false, true };
+		bool expected_associative = true;
+		test_operator<
+			descriptors::no_operation,
+			logical_and< bool >
+		>( rc, expected, expected_associative );
+	}
+	{ // logical_or< bool >
+		std::cout << "Testing operator: logical_or<bool>" << std::endl;
+		const std::array<bool, 4> expected = { false, true, true, true };
+		bool expected_associative = true;
+		test_operator<
+			descriptors::no_operation,
+			logical_or< bool >
+		>( rc, expected, expected_associative );
+	}
+	{ // logical_xor< bool >
+		std::cout << "Testing operator: logical_xor<bool>" << std::endl;
+		const std::array<bool, 4> expected = { false, true, true, false };
+		bool expected_associative = true;
+		test_operator<
+			descriptors::no_operation,
+			logical_xor< bool >
+		>( rc, expected, expected_associative );
+	}
+
+	// Negated operators
+	{ // logical_not< logical_and< bool > >
+		std::cout << "Testing operator: logical_not< logical_and< bool > >" << std::endl;
+		const std::array<bool, 4> expected = { true, true, true, false };
+		bool expected_associative = false;
+		test_operator<
+			descriptors::no_operation,
+			logical_not< logical_and< bool > >
+		>( rc, expected, expected_associative );
+	}
+	{ // logical_not< logical_or< bool > >
+		std::cout << "Testing operator: logical_not< logical_or< bool > >" << std::endl;
+		const std::array<bool, 4> expected = { true, false, false, false };
+		bool expected_associative = false;
+		test_operator<
+			descriptors::no_operation,
+			logical_not< logical_or< bool > >
+		>( rc, expected, expected_associative );
+	}
+	{ // logical_not< logical_xor< bool > >
+		std::cout << "Testing operator: logical_not< logical_xor< bool > >" << std::endl;
+		const std::array<bool, 4> expected = { true, false, false, true };
+		bool expected_associative = false;
+		test_operator<
+			descriptors::no_operation,
+			logical_not< logical_xor< bool > >
+		>( rc, expected, expected_associative );
+	}
+
+	// Double-negated operators
+	{ // logical_not< logical_not < logical_and< bool > > >
+		std::cout << "Testing operator: logical_not< logical_not < logical_and< bool > > >" << std::endl;
+		const std::array<bool, 4> expected = { false, false, false, true };
+		bool expected_associative = true;
+		test_operator<
+			descriptors::no_operation,
+			logical_not< logical_not< logical_and< bool > > >
+		>( rc, expected, expected_associative );
+	}
+	{ // logical_not< logical_not < logical_or< bool > > >
+		std::cout << "Testing operator: logical_not< logical_not < logical_or< bool > > >" << std::endl;
+		const std::array<bool, 4> expected = { false, true, true, true };
+		bool expected_associative = true;
+		test_operator<
+			descriptors::no_operation,
+			logical_not< logical_not< logical_or< bool > > >
+		>( rc, expected, expected_associative );
+	}
+	{ // logical_not< logical_not < logical_xor< bool > > >
+		std::cout << "Testing operator: logical_not< logical_not < logical_xor< bool > > >" << std::endl;
+		const std::array<bool, 4> expected = { false, true, true, false };
+		bool expected_associative = true;
+
+		std::cout << "Is lnegated: " << grb::is_logically_negated< logical_not< logical_not < logical_xor< bool > > > >::value << std::endl;
+		std::cout << "Is lnegated: " << grb::is_logically_negated< logical_not< logical_xor< bool > > >::value << std::endl;
+		std::cout << "Is lnegated: " << grb::is_logically_negated< logical_xor< bool > >::value << std::endl;
+
+		std::cout << "Is associative: " <<
+			is_associative< logical_not< logical_not < logical_xor< bool > > > >::value << std::endl;
+		std::cout << "Is associative: " <<
+			is_associative< logical_not< logical_xor< bool > > >::value << std::endl;
+		std::cout << "Is associative: " <<
+			is_associative< logical_xor< bool > >::value << std::endl;
+
+		test_operator<
+			descriptors::no_operation,
+			logical_not< logical_not< logical_xor< bool > > >
+		>( rc, expected, expected_associative );
+	}
+}
+
+int main( int argc, char ** argv ) {
+	// error checking
+	if( argc > 2 ) {
+		std::cerr << "Usage: " << argv[ 0 ] << "\n";
+		return 1;
+	}
+
+	std::cout << "This is functional test " << argv[ 0 ] << "\n";
+
+	grb::Launcher< AUTOMATIC > launcher;
+	RC out = SUCCESS;
+	size_t unused = 0;
+	if( launcher.exec( &grb_program, unused, out, true ) != SUCCESS ) {
+		std::cerr << "Launching test FAILED\n";
+		return 255;
+	}
+	if( out != SUCCESS ) {
+		std::cerr << std::flush;
+		std::cout << "Test FAILED (" << grb::toString( out ) << ")\n" << std::flush;
+	} else {
+		std::cout << "Test OK\n" << std::flush;
+	}
+	return 0;
+}
diff --git a/tests/unit/operator_logical_not.cpp b/tests/unit/operator_logical_not.cpp
diff --git a/tests/unit/unittests.sh b/tests/unit/unittests.sh

Original file line number	Diff line number	Diff line change
`@@ -247,7 +247,7 @@ add_grb_executables( mxv mxv.cpp`
`247`	`247`	`BACKENDS reference_omp bsp1d hybrid hyperdags nonblocking`
`248`	`248`	`)`
`249`	`249`
`250`		`-add_grb_executables( operator_logical_not operator_logical_not.cpp`
	`250`	`+add_grb_executables( logical_operators logical_operators.cpp`
`251`	`251`	`BACKENDS reference reference_omp hyperdags nonblocking bsp1d hybrid`
`252`	`252`	`)`
`253`	`253`