Added equality operators

tdegeus · Jun 9, 2018 · 7124e0b · 7124e0b
1 parent 320b8bb
commit 7124e0b
Show file tree

Hide file tree

Showing 18 changed files with 347 additions and 1 deletion.
diff --git a/src/cppmat/fix_diagonal_matrix.h b/src/cppmat/fix_diagonal_matrix.h
@@ -211,6 +211,18 @@ class matrix
 
 };
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t M, size_t N>
+bool operator!= (const matrix<X,M,N> &A, const matrix<X,M,N> &B);
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t M, size_t N>
+bool operator== (const matrix<X,M,N> &A, const matrix<X,M,N> &B);
+
 // =================================================================================================
 // external arithmetic operators (cppmat::tiny::diagonal)
 // =================================================================================================

diff --git a/src/cppmat/fix_diagonal_matrix.hpp b/src/cppmat/fix_diagonal_matrix.hpp
@@ -1235,6 +1235,34 @@ std::ostream& operator<<(std::ostream& out, const matrix<X,M,N>& src)
   return out;
 }
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t M, size_t N>
+inline
+bool operator!= (const matrix<X,M,N> &A, const matrix<X,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return true;
+
+  return false;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t M, size_t N>
+inline
+bool operator== (const matrix<X,M,N> &A, const matrix<X,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return false;
+
+  return true;
+}
+
 // =================================================================================================
 // arithmetic operators: external
 // =================================================================================================

diff --git a/src/cppmat/fix_regular_array.h b/src/cppmat/fix_regular_array.h
@@ -317,6 +317,18 @@ class array
 
 };
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
+bool operator!= (const array<X,RANK,I,J,K,L,M,N> &A, const array<X,RANK,I,J,K,L,M,N> &B);
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
+bool operator== (const array<X,RANK,I,J,K,L,M,N> &A, const array<X,RANK,I,J,K,L,M,N> &B);
+
 // =================================================================================================
 // external arithmetic operators
 // =================================================================================================

diff --git a/src/cppmat/fix_regular_array.hpp b/src/cppmat/fix_regular_array.hpp
@@ -2458,6 +2458,34 @@ std::ostream& operator<<(std::ostream& out, const array<X,RANK,I,J,K,L,M,N>& src
   return out;
 }
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
+inline
+bool operator!= (const array<X,RANK,I,J,K,L,M,N> &A, const array<X,RANK,I,J,K,L,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return true;
+
+  return false;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
+inline
+bool operator== (const array<X,RANK,I,J,K,L,M,N> &A, const array<X,RANK,I,J,K,L,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return false;
+
+  return true;
+}
+
 // =================================================================================================
 // arithmetic operators: external
 // =================================================================================================

diff --git a/src/cppmat/fix_symmetric_matrix.h b/src/cppmat/fix_symmetric_matrix.h
@@ -215,6 +215,18 @@ class matrix
 
 };
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t M, size_t N>
+bool operator!= (const matrix<X,M,N> &A, const matrix<X,M,N> &B);
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t M, size_t N>
+bool operator== (const matrix<X,M,N> &A, const matrix<X,M,N> &B);
+
 // =================================================================================================
 // external arithmetic operators (cppmat::tiny::symmetric)
 // =================================================================================================

diff --git a/src/cppmat/fix_symmetric_matrix.hpp b/src/cppmat/fix_symmetric_matrix.hpp
@@ -1299,6 +1299,34 @@ std::ostream& operator<<(std::ostream& out, const matrix<X,M,N>& src)
   return out;
 }
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t M, size_t N>
+inline
+bool operator!= (const matrix<X,M,N> &A, const matrix<X,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return true;
+
+  return false;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t M, size_t N>
+inline
+bool operator== (const matrix<X,M,N> &A, const matrix<X,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return false;
+
+  return true;
+}
+
 // =================================================================================================
 // arithmetic operators: external
 // =================================================================================================

diff --git a/src/cppmat/map_diagonal_matrix.h b/src/cppmat/map_diagonal_matrix.h
@@ -135,7 +135,22 @@ class matrix
 
 };
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t M, size_t N>
+bool operator!= (const matrix<X,M,N> &A, const matrix<X,M,N> &B);
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t M, size_t N>
+bool operator== (const matrix<X,M,N> &A, const matrix<X,M,N> &B);
+
+// =================================================================================================
 // print operator
+// =================================================================================================
+
 template<class X, size_t M, size_t N>
 std::ostream& operator<<(std::ostream& out, const matrix<X,M,N>& src);
 

diff --git a/src/cppmat/map_diagonal_matrix.hpp b/src/cppmat/map_diagonal_matrix.hpp
@@ -546,6 +546,34 @@ std::ostream& operator<<(std::ostream& out, const matrix<X,M,N>& src)
   return out;
 }
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t M, size_t N>
+inline
+bool operator!= (const matrix<X,M,N> &A, const matrix<X,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return true;
+
+  return false;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t M, size_t N>
+inline
+bool operator== (const matrix<X,M,N> &A, const matrix<X,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return false;
+
+  return true;
+}
+
 // =================================================================================================
 
 }}} // namespace ...

diff --git a/src/cppmat/map_regular_array.h b/src/cppmat/map_regular_array.h
@@ -198,7 +198,22 @@ class array
 
 };
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
+bool operator!= (const array<X,RANK,I,J,K,L,M,N> &A, const array<X,RANK,I,J,K,L,M,N> &B);
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
+bool operator== (const array<X,RANK,I,J,K,L,M,N> &A, const array<X,RANK,I,J,K,L,M,N> &B);
+
+// =================================================================================================
 // print operator
+// =================================================================================================
+
 template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
 std::ostream& operator<<(std::ostream& out, const array<X,RANK,I,J,K,L,M,N>& src);
 

diff --git a/src/cppmat/map_regular_array.hpp b/src/cppmat/map_regular_array.hpp
@@ -1290,6 +1290,34 @@ std::ostream& operator<<(std::ostream& out, const array<X,RANK,I,J,K,L,M,N>& src
   return out;
 }
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
+inline
+bool operator!= (const array<X,RANK,I,J,K,L,M,N> &A, const array<X,RANK,I,J,K,L,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return true;
+
+  return false;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t RANK, size_t I, size_t J, size_t K, size_t L, size_t M, size_t N>
+inline
+bool operator== (const array<X,RANK,I,J,K,L,M,N> &A, const array<X,RANK,I,J,K,L,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return false;
+
+  return true;
+}
+
 // =================================================================================================
 
 }} // namespace ...

diff --git a/src/cppmat/map_symmetric_matrix.h b/src/cppmat/map_symmetric_matrix.h
@@ -134,7 +134,22 @@ class matrix
 
 };
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t M, size_t N>
+bool operator!= (const matrix<X,M,N> &A, const matrix<X,M,N> &B);
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t M, size_t N>
+bool operator== (const matrix<X,M,N> &A, const matrix<X,M,N> &B);
+
+// =================================================================================================
 // print operator
+// =================================================================================================
+
 template<class X, size_t M, size_t N>
 std::ostream& operator<<(std::ostream& out, const matrix<X,M,N>& src);
 

diff --git a/src/cppmat/map_symmetric_matrix.hpp b/src/cppmat/map_symmetric_matrix.hpp
@@ -556,6 +556,34 @@ std::ostream& operator<<(std::ostream& out, const matrix<X,M,N>& src)
   return out;
 }
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X, size_t M, size_t N>
+inline
+bool operator!= (const matrix<X,M,N> &A, const matrix<X,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return true;
+
+  return false;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X, size_t M, size_t N>
+inline
+bool operator== (const matrix<X,M,N> &A, const matrix<X,M,N> &B)
+{
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return false;
+
+  return true;
+}
+
 // =================================================================================================
 
 }}} // namespace ...

diff --git a/src/cppmat/var_diagonal_matrix.h b/src/cppmat/var_diagonal_matrix.h
@@ -213,6 +213,10 @@ class matrix
 
 };
 
+// equality operators
+template<class X> bool operator!= (const matrix<X> &A, const matrix<X> &B);
+template<class X> bool operator== (const matrix<X> &A, const matrix<X> &B);
+
 // external arithmetic operators (cppmat::diagonal)
 template<class X> matrix<X> operator* (const matrix<X> &A, const matrix<X> &B);
 template<class X> matrix<X> operator+ (const matrix<X> &A, const matrix<X> &B);

diff --git a/src/cppmat/var_diagonal_matrix.hpp b/src/cppmat/var_diagonal_matrix.hpp
@@ -1303,6 +1303,42 @@ std::ostream& operator<<(std::ostream& out, const matrix<X>& src)
   return out;
 }
 
+// =================================================================================================
+// equality operators
+// =================================================================================================
+
+template<class X>
+inline
+bool operator!= (const matrix<X> &A, const matrix<X> &B)
+{
+  assert( A.shape() == B.shape() );
+  assert( A.rank () == B.rank () );
+  assert( A.size () == B.size () );
+
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return true;
+
+  return false;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+template<class X>
+inline
+bool operator== (const matrix<X> &A, const matrix<X> &B)
+{
+  assert( A.shape() == B.shape() );
+  assert( A.rank () == B.rank () );
+  assert( A.size () == B.size () );
+
+  for ( size_t i = 0 ; i < A.size() ; ++i )
+    if ( A[i] != B[i] )
+      return false;
+
+  return true;
+}
+
 // =================================================================================================
 // arithmetic operators: external
 // =================================================================================================

diff --git a/src/cppmat/var_regular_array.h b/src/cppmat/var_regular_array.h
@@ -349,6 +349,7 @@ class array
 
 // equality operators
 template<class X> bool operator!= (const array<X> &A, const array<X> &B);
+template<class X> bool operator== (const array<X> &A, const array<X> &B);
 
 // external arithmetic operators
 template<class X> array<X> operator* (const array<X> &A, const array<X> &B);