fixup support Vect16

Author: james-d-mitchell

src/hpcombi.cpp

@@ -16,8 +16,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-// TODO change Transf16 to pad by identity
-
 // libsemigroups headers
 #include <libsemigroups/hpcombi.hpp>
 
@@ -1265,7 +1263,7 @@ is padded with ``0`` values at the end.
 
    >>> from libsemigroups_pybind11.hpcombi import Transf16
    >>> Transf16([1, 3, 1, 10])
-   Transf16([ 1, 3, 1,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+   Transf16([ 1, 3, 1,10,10,10,10,10,10,10,10,10,10,10,10,10])
 )pbdoc");
 
       thing.def(py::init<uint64_t>(), R"pbdoc(
@@ -2369,7 +2367,7 @@ This function returns a newly constructed :any:`PPerm16` with the same image as
    True
 )pbdoc");
     }  // init_hpcombi_pperm16
-  }  // namespace
+  }    // namespace
 }  // namespace HPCombi
 
 namespace libsemigroups {

src/konieczny.cpp

@@ -740,7 +740,7 @@ not already known.
    int
 )pbdoc");
     }  // bind_konieczny
-  }  // namespace
+  }    // namespace
 
   void init_konieczny(py::module& m) {
     bind_konieczny<BMat8>(m, "BMat8");
@@ -753,10 +753,7 @@ not already known.
     bind_konieczny<PPerm<0, uint32_t>>(m, "PPerm4");
 
 #ifdef LIBSEMIGROUPS_HPCOMBI_ENABLED
-    // TODO impl in libsemigroups
-    // bind_konieczny<HPCombi::PTransf16>(m, "HPCombiPTransf16");
-    // TODO impl in libsemigroups
-    // bind_konieczny<HPCombi::Perm16>(m, "HPCombiPerm16");
+    bind_konieczny<HPCombi::PTransf16>(m, "HPCombiPTransf16");
     bind_konieczny<HPCombi::Transf16>(m, "HPCombiTransf16");
     bind_konieczny<HPCombi::PPerm16>(m, "HPCombiPPerm16");
 #endif

tests/test_hpcombi.py

@@ -27,6 +27,13 @@ def test_hpcombi_vect16_hash():
         d = {Vect16([0, 10]): 0}
         assert d[Vect16([0, 10])] == 0
 
+    def test_hpcombi_vect16_copy():
+        x = Vect16([1, 2, 0])
+        assert copy(x) is not x
+        assert x.copy() is not x
+        assert x.copy() == copy(x)
+        assert isinstance(x.copy(), Vect16)
+
     def test_hpcombi_vect16_construct_from_list():
         x = Vect16([0, 10])
         assert x[0] == 0
@@ -131,10 +138,17 @@ def test_hpcombi_vect16_is_permutation():
     # PTransf16
     ########################################################################
 
-    def test_hpcombi_ptransf_hash():
+    def test_hpcombi_ptransf16_hash():
         d = {PTransf16([0, 10]): 0}
         assert d[PTransf16([0, 10])] == 0
 
+    def test_hpcombi_ptransf16_copy():
+        x = PTransf16([1, 2, 0])
+        assert copy(x) is not x
+        assert x.copy() is not x
+        assert x.copy() == copy(x)
+        assert isinstance(x.copy(), PTransf16)
+
     def test_hpcombi_ptransf16_construct_from_list():
         x = PTransf16([0, 10])
         assert x[0] == 0
@@ -185,15 +199,17 @@ def test_hpcombi_ptransf16_one():
         assert PTransf16.one() == PTransf16(list(range(16)))
         x = PTransf16([1, 0, 1])
         assert x.one() == PTransf16.one()
+        assert isinstance(PTransf16.one(), PTransf16)
 
     def test_hpcombi_ptransf16_len():
         assert len(PTransf16()) == 16
 
     def test_hpcombi_ptransf16_validate():
         assert PTransf16.one().validate()
         assert PTransf16.one().validate(3)
-        # FIXME the following should return true, i.e. PTransf16 should
-        # always return True unless there's a value > 16 and != 255
+        # TODO update the following line if
+        # https://github.com/libsemigroups/HPCombi/issues/64
+        # is resolved.
         assert not PTransf16([0, 1, 255]).validate(3)
 
     def test_hpcombi_ptransf16_image_mask():
@@ -299,16 +315,23 @@ def test_hpcombi_ptransf_nb_fix_points():
     # Transf16
     ########################################################################
 
-    def test_hpcombi_transf_hash():
+    def test_hpcombi_transf16_hash():
         d = {Transf16([0, 10]): 0}
         assert d[Transf16([0, 10])] == 0
 
+    def test_hpcombi_transf16_copy():
+        x = Transf16([1, 2, 0])
+        assert copy(x) is not x
+        assert x.copy() is not x
+        assert x.copy() == copy(x)
+        assert isinstance(x.copy(), Transf16)
+
     def test_hpcombi_transf16_construct_from_list():
         x = Transf16([0, 10])
         assert x[0] == 0
         assert x[1] == 10
         for i in range(2, 16):
-            assert x[i] == 0
+            assert x[i] == 10
         with pytest.raises(LibsemigroupsError):
             x = Transf16([0] * 17)
         with pytest.raises(LibsemigroupsError):
@@ -319,11 +342,11 @@ def test_hpcombi_transf16_construct_from_list():
     def test_hpcombi_transf16_set_item():
         x = Transf16()
         x[1] = 10
-        assert x == Transf16([0, 10])
+        assert x == Transf16([0, 10] + [0] * 14)
 
     def test_hpcombi_transf16_to_from_ints():
         x = Transf16([0, 15])
-        assert int(x) == 3840
+        assert int(x) == 18446744073709551600
         assert Transf16(int(x)) == x
 
     def test_hpcombi_transf16_lt():
@@ -341,6 +364,7 @@ def test_hpcombi_transf16_mul():
 
     def test_hpcombi_transf16_one():
         assert Transf16.one() == Transf16(list(range(16)))
+        assert isinstance(Transf16.one(), Transf16)
 
     ########################################################################
     # Perm16
@@ -351,7 +375,6 @@ def test_hpcombi_perm_hash():
         assert d[Perm16([1, 0])] == 0
 
     def test_hpcombi_perm16_copy():
-        # TODO replicate this test for the other types
         x = Perm16([1, 2, 0])
         assert copy(x) is not x
         assert x.copy() is not x
@@ -362,7 +385,7 @@ def test_hpcombi_perm16_one():
         assert Perm16.one() == Perm16(list(range(16)))
         x = Perm16([1, 2, 0])
         assert x.one() == Perm16.one()
-        assert isinstance(x.one(), Perm16)  # TODO add this to the other test cases
+        assert isinstance(x.one(), Perm16)
 
     def test_hpcombi_perm16_inverse():
         x = Perm16([1, 2, 0])
@@ -483,12 +506,11 @@ def test_hpcombi_perm16_unrankSJT():  # pylint: disable=invalid-name
     # PPerm16
     ########################################################################
 
-    def test_hpcombi_pperm_hash():
+    def test_hpcombi_pperm16_hash():
         d = {PPerm16([1, 0]): 0}
         assert d[PPerm16([1, 0])] == 0
 
     def test_hpcombi_pperm16_copy():
-        # TODO replicate this test for the other types
         x = PPerm16([1, 2, 0])
         assert copy(x) is not x
         assert x.copy() is not x
@@ -538,10 +560,9 @@ def test_hpcombi_pperm16_left_one():
         assert x.left_one() * x == x
 
     def test_hpcombi_pperm16_inverse_ref():
-        x = Perm16([1, 2, 0])
+        x = PPerm16([1, 2, 0])
         assert x * x.inverse_ref() * x == x
         assert x.inverse_ref() * x * x.inverse_ref() == x.inverse_ref()
         assert x * x.inverse_ref() == x.left_one()
         assert x.inverse_ref() * x == x.right_one()
-        assert x.inverse_ref() * x * x.inverse_ref() == x.inverse_ref()
         assert x**-1 == x.inverse_ref()