Add encoding and decoding for finite fields

Author: GiacomoPope

src/sage/rings/finite_rings/element_base.pyx

@@ -142,6 +142,32 @@ cdef class FiniteRingElement(CommutativeRingElement):
         else:
             raise ValueError("unknown algorithm")
 
+    def to_bytes(self, byteorder="big"):
+        """
+        Return an array of bytes representing an integer. Internally relies
+        on the python ``int.to_bytes()`` method. Length of byte array is
+        determined from the field's order.
+
+        INPUT:
+
+        - ``byteorder`` -- str (default: ``"big"``); determines the byte order of
+          ``input_bytes``; can only be ``"big"`` or ``"little"``
+
+        OUTPUT:
+
+        - Bytes representing ``self``
+
+        EXAMPLES::
+
+            sage: F = GF(65537)
+            sage: a = F(8726)
+            sage: a.to_bytes()
+            b'\x00"\x16'
+            sage: a.to_bytes(byteorder="little")
+            b'\x16"\x00'
+        """
+        length = (self.parent().order().nbits() + 7) // 8
+        return int(self).to_bytes(length=length, byteorder=byteorder)
 
 cdef class FinitePolyExtElement(FiniteRingElement):
     """
@@ -1083,6 +1109,38 @@ cdef class FinitePolyExtElement(FiniteRingElement):
 
     integer_representation = deprecated_function_alias(33941, to_integer)
 
+    def to_bytes(self, byteorder="big"):
+        """
+        Return an array of bytes representing an integer. Internally relies
+        on the python ``int.to_bytes()`` method. Length of byte array is
+        determined from the field's order.
+
+        INPUT:
+
+        - ``byteorder`` -- str (default: ``"big"``); determines the byte order of
+          the output; can only be ``"big"`` or ``"little"``
+
+        OUTPUT:
+
+        - Bytes representing ``self``
+
+        EXAMPLES::
+
+            sage: F.<z5> = GF(3^5)
+            sage: a = z5^4 + 2*z5^3 + 1
+            sage: a.to_bytes()
+            b'\x88'
+
+        ::
+
+            sage: F.<z3> = GF(163^3)
+            sage: a = 136*z3^2 + 10*z3 + 125
+            sage: a.to_bytes()
+            b'7)\xa3'
+        """
+        length = (self.parent().order().nbits() + 7) // 8
+        return self.to_integer().to_bytes(length=length, byteorder=byteorder)
+
 cdef class Cache_base(SageObject):
     cpdef FinitePolyExtElement fetch_int(self, number) noexcept:
         r"""

src/sage/rings/finite_rings/finite_field_base.pyx

@@ -2117,6 +2117,52 @@ cdef class FiniteField(Field):
         return [sum(x * y for x, y in zip(col, basis))
                 for col in B.columns()]
 
+    def from_bytes(self, input_bytes, byteorder="big"):
+        """
+        Return the integer represented by the given array of bytes. Internally relies
+        on the python ``int.from_bytes()`` method.
+
+        INPUT:
+
+        - ``input_bytes`` -- a bytes-like object or iterable producing bytes
+
+        - ``byteorder`` -- str (default: ``"big"``); determines the byte order of
+          ``input_bytes``; can only be ``"big"`` or ``"little"``
+
+        OUTPUT:
+
+        - A field element represented by the ``input_bytes``
+
+        EXAMPLES::
+
+            sage: input_bytes = b"some_bytes"
+            sage: F = GF(2**127 - 1)
+            sage: F.from_bytes(input_bytes)
+            545127616933790290830707
+            sage: a = F.from_bytes(input_bytes, byteorder="little"); a
+            544943659528996309004147
+            sage: type(a)
+            <class 'sage.rings.finite_rings.integer_mod.IntegerMod_gmp'>
+
+        ::
+
+            sage: input_bytes = b"some_bytes"
+            sage: F_ext = GF(65537**5)
+            sage: F_ext.from_bytes(input_bytes)
+            29549*z5^4 + 40876*z5^3 + 52171*z5^2 + 13604*z5 + 20843
+            sage: F_ext.from_bytes(input_bytes, byteorder="little")
+            29539*z5^4 + 42728*z5^3 + 47440*z5^2 + 12423*z5 + 27473
+
+        TESTS::
+
+            sage: fields = [GF(2), GF(3), GF(65537), GF(2^10), GF(163^5)]
+            sage: for F in fields:
+            ....:     for _ in range(1000):
+            ....:         a = F.random_element()
+            ....:         assert F.from_bytes(a.to_bytes()) == a
+        """
+        python_int = int.from_bytes(input_bytes, byteorder=byteorder)
+        return self.from_integer(python_int)
 
 def unpickle_FiniteField_ext(_type, order, variable_name, modulus, kwargs):
     r"""

src/sage/rings/integer.pyx

@@ -7171,11 +7171,11 @@ cdef class Integer(sage.structure.element.EuclideanDomainElement):
         INPUT:
 
         - ``length`` -- positive integer (default: ``1``); integer is represented in
-        ``length`` bytes. ``OverflowError`` is raised if the integer is not representable
-        with the given length.
+          ``length`` bytes. ``OverflowError`` is raised if the integer is not representable
+          with the given length.
 
         - ``byteorder`` -- str (default: ``"big"``); determines the byte order of
-          ``input_bytes``; can only be ``"big"`` or ``"little"``
+          the output; can only be ``"big"`` or ``"little"``
 
         - ``is_signed`` -- boolean (default: ``False``); determines whether to use two's
           compliment to represent the integer