class galois.GF2(galois.FieldArray)

A FieldArray subclass over \(\mathrm{GF}(2)\).

Important

This class is a pre-generated FieldArray subclass generated with galois.GF(2) and is included in the API for convenience.

Examples

This class is equivalent, and in fact identical, to the FieldArray subclass returned from the class factory GF().

In [1]: galois.GF2 is galois.GF(2)
Out[1]: True

In [2]: issubclass(galois.GF2, galois.FieldArray)
Out[2]: True

In [3]: print(galois.GF2.properties)
Galois Field:
  name: GF(2)
  characteristic: 2
  degree: 1
  order: 2
  irreducible_poly: x + 1
  is_primitive_poly: True
  primitive_element: 1

Create a FieldArray instance using GF2’s constructor.

In [4]: x = galois.GF2([1, 0, 1, 1]); x
Out[4]: GF([1, 0, 1, 1], order=2)

In [5]: isinstance(x, galois.GF2)
Out[5]: True

Constructors

GF2(x: ElementLike | ArrayLike, dtype: DTypeLike | None = None, ...)

Creates an array over \(\mathrm{GF}(p^m)\).

classmethod Identity(size: int, ...) → FieldArray

Creates an \(n \times n\) identity matrix.

classmethod Ones(shape: ShapeLike, ...) → FieldArray

Creates an array of all ones.

classmethod Random(shape: ShapeLike = (), ...) → FieldArray

Creates an array with random elements.

classmethod Range(start: ElementLike, stop, ...) → FieldArray

Creates a 1-D array with a range of elements.

classmethod Vandermonde(element: ElementLike, ...) → FieldArray

Creates an \(m \times n\) Vandermonde matrix of \(a \in \mathrm{GF}(q)\).

classmethod Vector(array: ArrayLike, ...) → FieldArray

Creates an array over \(\mathrm{GF}(p^m)\) from length-\(m\) vectors over the prime subfield \(\mathrm{GF}(p)\).

classmethod Zeros(shape: ShapeLike, ...) → FieldArray

Creates an array of all zeros.

String representation

__repr__() → str

Displays the array specifying the class and finite field order.

__str__() → str

Displays the array without specifying the class or finite field order.

class property properties : str

A formatted string of relevant properties of the Galois field.

Methods

additive_order() → integer | ndarray

Computes the additive order of each element in \(x\).

classmethod arithmetic_table(operation, ...) → str

Generates the specified arithmetic table for the finite field.

characteristic_poly() → Poly

Computes the characteristic polynomial of a finite field element \(a\) or a square matrix \(\mathbf{A}\).

column_space() → FieldArray

Computes the column space of the matrix \(\mathbf{A}\).

classmethod compile(mode)

Recompile the just-in-time compiled ufuncs for a new calculation mode.

classmethod display(...) → Generator[None, None, None]

Sets the display mode for all arrays from this FieldArray subclass.

field_norm() → FieldArray

Computes the field norm \(\mathrm{N}_{L / K}(x)\) of the elements of \(x\).

field_trace() → FieldArray

Computes the field trace \(\mathrm{Tr}_{L / K}(x)\) of the elements of \(x\).

is_quadratic_residue() → bool_ | ndarray

Determines if the elements of \(x\) are quadratic residues in the finite field.

left_null_space() → FieldArray

Computes the left null space of the matrix \(\mathbf{A}\).

lu_decompose() → Tuple[FieldArray, FieldArray]

Decomposes the input array into the product of lower and upper triangular matrices.

minimal_poly() → Poly

Computes the minimal polynomial of a finite field element \(a\).

multiplicative_order() → integer | ndarray

Computes the multiplicative order \(\textrm{ord}(x)\) of each element in \(x\).

null_space() → FieldArray

Computes the null space of the matrix \(\mathbf{A}\).

plu_decompose() → Tuple[FieldArray, FieldArray, FieldArray]

Decomposes the input array into the product of lower and upper triangular matrices using partial pivoting.

classmethod primitive_root_of_unity(n: int) → FieldArray

Finds a primitive \(n\)-th root of unity in the finite field.

classmethod primitive_roots_of_unity(n: int) → FieldArray

Finds all primitive \(n\)-th roots of unity in the finite field.

classmethod repr_table(...) → str

Generates a finite field element representation table comparing the power, polynomial, vector, and integer representations.

row_reduce(ncols: int | None = None) → FieldArray

Performs Gaussian elimination on the matrix to achieve reduced row echelon form (RREF).

row_space() → FieldArray

Computes the row space of the matrix \(\mathbf{A}\).

vector(dtype: DTypeLike | None = None) → FieldArray

Converts an array over \(\mathrm{GF}(p^m)\) to length-\(m\) vectors over the prime subfield \(\mathrm{GF}(p)\).

Properties

class property characteristic : int

The prime characteristic \(p\) of the Galois field \(\mathrm{GF}(p^m)\). Adding \(p\) copies of any element will always result in 0.

class property default_ufunc_mode : 'jit-lookup' | 'jit-calculate' | 'python-calculate'

The default ufunc compilation mode for this FieldArray subclass. The ufuncs may be recompiled with compile().

class property degree : int

The extension degree \(m\) of the Galois field \(\mathrm{GF}(p^m)\). The degree is a positive integer.

class property display_mode : 'int' | 'poly' | 'power'

The current finite field element representation. This can be changed with display().

class property dtypes : List[dtype]

List of valid integer numpy.dtype values that are compatible with this finite field. Creating an array with an unsupported dtype will raise a TypeError exception.

class property elements : FieldArray

All of the finite field’s elements \(\{0, \dots, p^m-1\}\).

class property irreducible_poly : Poly

The irreducible polynomial \(f(x)\) of the Galois field \(\mathrm{GF}(p^m)\). The irreducible polynomial is of degree \(m\) over \(\mathrm{GF}(p)\).

class property is_extension_field : bool

Indicates if the finite field is an extension field. This is true when the field’s order is a prime power.

class property is_prime_field : bool

Indicates if the finite field is a prime field, not an extension field. This is true when the field’s order is prime.

class property is_primitive_poly : bool

Indicates whether the irreducible_poly is a primitive polynomial. If so, \(x\) is a primitive element of the finite field.

class property name : str

The finite field’s name as a string GF(p) or GF(p^m).

class property order : int

The order \(p^m\) of the Galois field \(\mathrm{GF}(p^m)\). The order of the field is equal to the field’s size.

class property prime_subfield : Type[FieldArray]

The prime subfield \(\mathrm{GF}(p)\) of the extension field \(\mathrm{GF}(p^m)\).

class property primitive_element : FieldArray

A primitive element \(\alpha\) of the Galois field \(\mathrm{GF}(p^m)\). A primitive element is a multiplicative generator of the field, such that \(\mathrm{GF}(p^m) = \{0, 1, \alpha, \alpha^2, \dots, \alpha^{p^m - 2}\}\).

class property primitive_elements : FieldArray

All primitive elements \(\alpha\) of the Galois field \(\mathrm{GF}(p^m)\). A primitive element is a multiplicative generator of the field, such that \(\mathrm{GF}(p^m) = \{0, 1, \alpha, \alpha^2, \dots, \alpha^{p^m - 2}\}\).

class property quadratic_non_residues : FieldArray

All quadratic non-residues in the Galois field.

class property quadratic_residues : FieldArray

All quadratic residues in the finite field.

class property ufunc_mode : 'jit-lookup' | 'jit-calculate' | 'python-calculate'

The current ufunc compilation mode for this FieldArray subclass. The ufuncs may be recompiled with compile().

class property ufunc_modes : List[str]

All supported ufunc compilation modes for this FieldArray subclass.

class property units : FieldArray

All of the finite field’s units \(\{1, \dots, p^m-1\}\). A unit is an element with a multiplicative inverse.