Added complements

include/ojl/bimap.hpp

@@ -133,7 +133,16 @@ namespace ojl {
 
       // Insert relations
       void
-      insert(L l, R r)
+      insert(relation rel)
+      {
+          left_elements.insert(rel.first);
+          right_elements.insert(rel.second);
+          l_relations.insert(rel);
+          r_relations.insert(rel);
+      }
+
+      void
+      insert(const L &l, const R &r)
       {
           left_elements.insert(l);
           right_elements.insert(r);
@@ -141,23 +150,23 @@ namespace ojl {
           r_relations.insert({l,r});
       }
 
+      // Erase relations
       void
-      insert(relation rel)
+      erase(const relation &rel)
       {
-          left_elements.insert(rel.first);
-          right_elements.insert(rel.second);
-          l_relations.insert(rel);
-          r_relations.insert(rel);
+          r_relations.erase(rel);
+          l_relations.erase(rel);
       }
 
-      // Erase relations
       void
-      erase(const relation &rel)
+      erase(const L &l, const R &r)
       {
+          relation rel{l,r};
           r_relations.erase(rel);
           l_relations.erase(rel);
       }
 
+
       // Erase elements
       void
       erase(left l_key)
@@ -210,6 +219,12 @@ namespace ojl {
           return l_relations.contains(rel);
       }
 
+      bool contains(L l, R r)
+      {
+          return l_relations.contains({l,r});
+      }
+
+
       bool contains(left l_key)
       {
           return l_relations.contains(l_key.val);
@@ -486,5 +501,97 @@ namespace ojl {
           return mapped_set(right{r});
       }
 
+      // A complement of this bimap (in the set of possible relations between left_elements and right_elements)
+      bimap<L,R>
+      complement()
+      {
+          bimap<L,R> ret;
+          // Insert elements
+          for (const auto &l : left_elements){
+              ret.l_insert(l);
+          }
+          for (const auto &r : right_elements){
+              ret.r_insert(r);
+          }
+
+          // Insert relations
+          for (const auto &l : left_elements){
+              for (const auto &r : right_elements){
+                  relation rel{l,r};
+                  if (!this->contains(rel)){
+                      ret.insert(rel);
+                  }
+              }
+          }
+          return ret;
+      }
+
+      bimap<L,R>
+      complement(std::set<L> left_elems, std::set<R> right_elems)
+      {
+          bimap<L,R> ret;
+          // Insert elements
+          for (const auto &l : left_elems){
+              ret.l_insert(l);
+          }
+          for (const auto &r : right_elems){
+              ret.r_insert(r);
+          }
+
+          // Insert relations
+          for (const auto &l : left_elems){
+              for (const auto &r : right_elems){
+                  relation rel{l,r};
+                  if (!this->contains(rel)){
+                      ret.insert(rel);
+                  }
+              }
+          }
+          return ret;
+      }
+
+
+
+      bimap<L,R>
+      complement(std::vector<L> left_elems, std::vector<R> right_elems)
+      {
+          bimap<L,R> ret;
+          // Insert elements
+          for (const auto &l : left_elems){
+              ret.l_insert(l);
+          }
+          for (const auto &r : right_elems){
+              ret.r_insert(r);
+          }
+
+          // Insert relations
+          for (const auto &l : left_elems){
+              for (const auto &r : right_elems){
+                  relation rel{l,r};
+                  if (!this->contains(rel)){
+                      ret.insert(rel);
+                  }
+              }
+          }
+          return ret;
+      }
+
+
   };
+
+  // Equality comparison
+  template<typename L, typename R>
+  bool
+  operator==(const bimap<L,R> &lhs, const bimap<L,R> &rhs)
+  {
+      return lhs.left_elements  == rhs.left_elements 
+          && lhs.right_elements == rhs.right_elements
+          && lhs.l_relations    == rhs.l_relations;
+     
+      if (lhs.left_elements != rhs.left_elements || lhs.right_elements != rhs.right_elements) {
+          return false;
+      }
+      return lhs.l_relations == rhs.l_relations;
+  }
+
 }

test/bimap_api/bimap_test.cpp

@@ -448,8 +448,8 @@ TEST_CASE("Bimap<EnumA, EnumB> random order mill of random vals", "[bimap, inser
 }
 
 
-
 //Strings
+//TODO: need size_t -> string converters for this
 /*
 TEST_CASE("Bimap<int, std::string> ordered mill of linear vals", "[bimap, insert, erase, count]")
 {
@@ -471,3 +471,27 @@ TEST_CASE("Bimap<int, int> random order mill of random vals", "[bimap, insert, e
     random_order_mill_random_values<int, int>(n_vals,n_vals, 313);
 }
 */
+
+// Min/max elements
+TEST_CASE("Bimap min/max elements", "[bimap, min_element, max_element, min_mapped_element, max_mapped_element]")
+{
+    CHECK(!"Not implemented");
+}
+
+// Complements
+TEST_CASE("Bimap complement API", "[bimap, complement]")
+{
+    {
+        auto bm = test_bimap_int_int_1();
+        auto complement = bm.complement();
+        auto complement_complement = complement.complement();
+        CHECK(bm == complement_complement);
+    }
+
+    {
+        auto bm = test_bimap_int_string_1();
+        auto complement = bm.complement();
+        auto complement_complement = complement.complement();
+        CHECK(bm == complement_complement);
+    }
+}