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

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, ...) → Self

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

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

Creates an array of all ones.

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

Creates an array with random elements.

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

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

classmethod Vandermonde(element: ElementLike, rows, ...) → Self

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

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

Creates an array of all zeros.

Conversions¶

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

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

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)\).

Elements¶

class property elements : FieldArray

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

class property non_squares : FieldArray

All non-squares in the Galois field.

class property primitive_element : FieldArray

A primitive element \(\alpha\) of the Galois field \(\mathrm{GF}(p^m)\).

class property primitive_elements : FieldArray

All primitive elements \(\alpha\) of the Galois field \(\mathrm{GF}(p^m)\).

classmethod primitive_root_of_unity(n: int) → Self

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

classmethod primitive_roots_of_unity(n: int) → Self

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

class property squares : FieldArray

All squares in the finite field.

class property units : FieldArray

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

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.

classmethod arithmetic_table(operation, ...) → str

Generates the specified arithmetic table for the finite field.

class property properties : str

A formatted string of relevant properties of the Galois field.

classmethod repr_table(...) → str

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

Element representation¶

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

The current finite field element representation.

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

Sets the element representation for all arrays from this FieldArray subclass.

Arithmetic compilation¶

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

The default ufunc compilation mode for this FieldArray subclass.

class property dtypes : list[numpy.dtype]

List of valid integer numpy.dtype values that are compatible with this finite field.

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

The current ufunc compilation mode for this FieldArray subclass.

class property ufunc_modes : list[str]

All supported ufunc compilation modes for this FieldArray subclass.

classmethod compile(mode)

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

Methods¶

additive_order() → int | numpy.ndarray

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

characteristic_poly() → Poly

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

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\).

log(base: ElementLike | ArrayLike | None = None) → int | ndarray

Computes the discrete logarithm of the array \(x\) base \(\beta\).

minimal_poly() → Poly

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

multiplicative_order() → int | numpy.ndarray

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

Linear algebra¶

column_space() → Self

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

left_null_space() → Self

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

lu_decompose() → tuple[Self, Self]

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

null_space() → Self

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

plu_decompose() → tuple[Self, Self, Self]

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

row_reduce(ncols: int | None = None, ...) → Self

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

row_space() → Self

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

Properties¶

class property characteristic : int

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

class property degree : int

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

class property irreducible_poly : Poly

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

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)\).

class property prime_subfield : type[FieldArray]

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

Attributes¶

class property is_extension_field : bool

Indicates if the finite field is an extension field, having prime power order.

class property is_prime_field : bool

Indicates if the finite field is a prime field, having prime order.

class property is_primitive_poly : bool

Indicates whether the irreducible_poly is a primitive polynomial.

is_square() → bool | numpy.ndarray

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