Galois

https://mhostetter.github.io/galois/latest
Admin
Galois is a Python library for performing arithmetic in finite fields, including polynomial...
Tokens:136,745
Snippets:964
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Galois Getting Started Guide

Source: https://mhostetter.github.io/galois/latest/getting-started

A guide to help users install the library, create example arrays, and perform basic array arithmetic. It serves as an introduction to the library's core functionalities.

```Python
# Install the package
# Create a FieldArray subclass
# Create two FieldArray instances
# Change the element representation
# Perform array arithmetic
```

--------------------------------

### Galois Library Installation and Setup

Source: https://mhostetter.github.io/galois/latest/development/formatting

Instructions for installing and setting up the Galois library, including running linters and formatters for code quality.

```Bash
$ python3
```

--------------------------------

### Galois Benchmarking Setup

Source: https://mhostetter.github.io/galois/latest/performance/benchmarks

Instructions and commands for setting up and running benchmarks for the Galois library using pytest and pytest-benchmark. Requires installation of development dependencies.

```Bash
python3 -m pip install --upgrade pip
python3 -m pip install --upgrade build
python3 -m pip install --upgrade twine
python3 -m pip install -e .[dev]
pytest
```

--------------------------------

### Galois Unit Testing Setup

Source: https://mhostetter.github.io/galois/latest/development/unit-tests

Instructions for setting up unit tests using pytest for the Galois library. Requires installing pytest and its development dependencies.

```bash
$ python3
```

--------------------------------

### Install Galois Development Dependencies

Source: https://mhostetter.github.io/galois/latest/development/installation

Installs the development dependencies required for working with the 'galois' library.

```bash
pip install -r requirements-dev.txt
```

--------------------------------

### Install Galois Library from Local Folder

Source: https://mhostetter.github.io/galois/latest/development/installation

Installs the 'galois' library in an editable mode from a local folder, typically used for development.

```bash
pip install -e .
```

--------------------------------

### Install Galois Library from GitHub

Source: https://mhostetter.github.io/galois/latest/development/installation

Installs the latest development version of the 'galois' library directly from the GitHub repository's main branch using pip.

```bash
pip install git+https://github.com/mhostetter/galois.git
```

--------------------------------

### Install Development Dependencies

Source: https://mhostetter.github.io/galois/latest/development/installation

Installs development-specific dependencies required for linting and unit testing. These are listed in the 'requirements-dev.txt' file.

```Shell
$ pip install -r requirements-dev.txt
```

--------------------------------

### Install Galois Library from PyPI

Source: https://mhostetter.github.io/galois/latest/development/installation

Installs the latest released version of the 'galois' library from the Python Package Index (PyPI) using pip.

```bash
pip install galois
```

--------------------------------

### Finite Field Division Examples

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Provides multiple examples of finite field division, showcasing different results based on the field elements and their representations. Each example illustrates the `a / b` operation.

```python
import galois

# Example 1
# _, b_inv_poly, _ = galois.egcd(b_poly, f)
# (a_poly * b_inv_poly) % f
# a * b**-1
# a / b  # Output: GF(6, order=3^2)

# Example 2
# _, b_inv_poly, _ = galois.egcd(b_poly, f)
# (a_poly * b_inv_poly) % f
# a * b**-1
# a / b  # Output: GF(2α, order=3^2)

# Example 3
# _, b_inv_poly, _ = galois.egcd(b_poly, f)
# (a_poly * b_inv_poly) % f
# a * b**-1
# a / b  # Output: GF(α^5, order=3^2)
```

--------------------------------

### Install Documentation Dependencies

Source: https://mhostetter.github.io/galois/latest/development/documentation

Installs the necessary dependencies for generating and building the Galois documentation using Sphinx. This includes Sphinx itself, the Sphinx Immaterial theme, and other related packages.

```Shell
pip install -r docs/requirements.txt
```

--------------------------------

### Install Galois Package

Source: https://mhostetter.github.io/galois/latest/getting-started

Installs the latest version of the galois package from PyPI using pip. It also shows how to import the package and check its version.

```bash
$ python3
```

```python
In [1]: import galois

In [2]: galois.__version__
Out[2]: '0.4.6'
```

--------------------------------

### Editable Install from Local Folder

Source: https://mhostetter.github.io/galois/latest/development/installation

Installs the Galois library in editable mode from a local directory. This is useful for active development, allowing changes to be reflected immediately upon importing the library.

```Shell
$ git clone <repository_url>
$ cd <repository_directory>
$ pip install -e .
```

--------------------------------

### Galois Configuration

Source: https://mhostetter.github.io/galois/latest/getting-started

Functions for configuring print options, including getting, setting, and updating print options for the Galois library.

```Python
F get_printoptions
F printoptions
F set_printoptions
```

--------------------------------

### Managing Pre-commit Hooks

Source: https://mhostetter.github.io/galois/latest/development/formatting

Commands to install, run, and uninstall pre-commit hooks. This manages the integration of pre-commit into the development workflow for automated code checks.

```bash
$ pre-commit
```

```bash
$ pre-commit
```

```bash
$ pre-commit
```

--------------------------------

### Galois Configuration Functions

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Provides functions for managing print options within the Galois library, allowing users to get and set display preferences.

```Python
F get_printoptions
F printoptions
F set_printoptions
```

--------------------------------

### Python Interpreter

Source: https://mhostetter.github.io/galois/latest/development/documentation

Starts the Python 3 interpreter, typically used for running Python scripts or interactive sessions.

```Shell
python3
```

--------------------------------

### Runtime Floor Example (Small Array Multiplication)

Source: https://mhostetter.github.io/galois/latest/performance/prime-fields

Demonstrates the runtime floor of galois ufuncs for small array sizes, showing NumPy's advantage in such cases due to overheads like dtype conversion and input verification in galois.

```Python
import galois

GF = galois.GF(2097169)

# Set to 'jit-calculate' mode
# GF.ufunc_mode

a = GF.Random(10, seed=1, dtype=int)
b = GF.Random(10, seed=2, dtype=int)

# JIT compile the ufunc
a * b

# Time the operation
# %timeit a * b
```

```Python
import numpy as np

# Assuming 'a' and 'b' are already defined galois arrays
aa, bb = a.view(np.ndarray), b.view(np.ndarray)

# Time the equivalent NumPy operation
# %timeit (aa * bb) % GF.order
```

--------------------------------

### Galois Configuration Functions

Source: https://mhostetter.github.io/galois/latest/index

Lists functions for configuring print options within the Galois library. This includes getting current print options, setting print options, and a convenience function for setting print options.

```APIDOC
Configuration Functions:
  get_printoptions()
    Returns the current print options.
  printoptions(**kwargs)
    A context manager for temporarily setting print options.
  set_printoptions(**kwargs)
    Sets the global print options.
```

--------------------------------

### Galois Configuration

Source: https://mhostetter.github.io/galois/latest/performance/prime-fields

Functions for configuring print options, including getting, setting, and updating print behavior.

```Python
F get_printoptions
F printoptions
F set_printoptions
```

--------------------------------

### Galois Configuration Functions

Source: https://mhostetter.github.io/galois/latest/development/unit-tests

Provides functions for managing print options within the Galois library, allowing users to get and set display preferences.

```python
F get_printoptions
F printoptions
F set_printoptions
```

--------------------------------

### Print Options Configuration

Source: https://mhostetter.github.io/galois/latest/basic-usage/element-representation

Functions for getting and setting print options to control the display of numbers and polynomials.

```Python
F get_printoptions
F printoptions
F set_printoptions
```

--------------------------------

### Galois Configuration Functions

Source: https://mhostetter.github.io/galois/latest/performance/benchmarks

Provides functions for managing print options within the Galois library, allowing users to get and set print formatting preferences.

```Python
F.get_printoptions
F.printoptions
F.set_printoptions
```

--------------------------------

### Build Documentation with Sphinx

Source: https://mhostetter.github.io/galois/latest/development/documentation

Builds the project documentation using the sphinx-build command. The HTML output is generated in the 'docs/build/' directory.

```bash
sphinx-build
```

--------------------------------

### Running Ruff Linter and Formatter

Source: https://mhostetter.github.io/galois/latest/development/formatting

Commands to execute the Ruff linter and formatter from the command line. These commands initiate the analysis and formatting processes based on the project's configuration.

```bash
$ python3
```

```bash
$ python3
```

--------------------------------

### Multiplicative Inverse in GF(3^2) - Example 3

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Shows the computation of the multiplicative inverse for an element 'b' in GF(3^2), represented as α^6. The example uses both the `** -1` operator and `np.reciprocal()` for clarity.

```Python
b ** -1
# Out[57]: GF(α^6, order=3^2)

np.reciprocal(b)
# Out[58]: GF(α^6, order=3^2)
```

--------------------------------

### galois.Primitive Elements

Source: https://mhostetter.github.io/galois/latest/index

Functions to get and check for primitive elements in Galois fields.

```Python
F primitive_element
F primitive_elements
F is_primitive_element
```

--------------------------------

### Run Pytest from Command Line

Source: https://mhostetter.github.io/galois/latest/development/unit-tests

Demonstrates how to execute all unit tests, specific test files, or individual unit tests using the python3 interpreter.

```bash
$ python3
```

```bash
$ python3
```

```bash
$ python3
```

--------------------------------

### galois.Primitive Elements

Source: https://mhostetter.github.io/galois/latest/development/unit-tests

Functions to get, check, and list primitive elements in Galois Fields.

```Python
F primitive_element
F primitive_elements
F is_primitive_element
```

--------------------------------

### galois Primitive Elements

Source: https://mhostetter.github.io/galois/latest/release-notes/v0

Functions to get, check, and list primitive elements within a Galois field.

```Python
F primitive_element
F primitive_elements
F is_primitive_element
```

--------------------------------

### galois C Poly API

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-prime-fields

API reference for the Poly class in galois, covering constructors, special methods, string representations, factorization, and coefficient access.

```APIDOC
C Poly
  Constructors:
    M __init__
    M Degrees
    M Identity
    M Int
    M One
    M Random
    M Roots
    M Str
    M Zero
  Special methods:
    M __call__
    M __eq__
    M __int__
    M __len__
  String representation:
    M __repr__
    M __str__
  Methods:
    M derivative
    M reverse
    M roots
  Factorization methods:
    M distinct_degree_factors
    M equal_degree_factors
    M factors
    M square_free_factors
  Coefficients:
    M coefficients
    P coeffs
    P degrees
```

--------------------------------

### Polynomial String Representation

Source: https://mhostetter.github.io/galois/latest/basic-usage/poly

Get the string representation of a polynomial object, showing its terms and coefficients.

```Python
import galois

GF = galois.GF(7)
f = galois.Poly([1, 0, 3], field=GF)

# String representation
print(str(f))
```

--------------------------------

### Serve Documentation Locally with Python HTTP Module

Source: https://mhostetter.github.io/galois/latest/development/documentation

Serves the built documentation locally using Python's built-in HTTP module on port 8080. This is necessary because the site uses directory-based URLs.

```python
python3 -m http.server 8080
```

--------------------------------

### Get FieldArray Subclass from Instance

Source: https://mhostetter.github.io/galois/latest/basic-usage/array-classes

Demonstrates how to retrieve the `FieldArray` subclass from an instance using the `type()` function.

```Python
type(x) is GF
```

--------------------------------

### Configuration

Source: https://mhostetter.github.io/galois/latest/basic-usage/poly

Functions for managing print options.

```Python
F.get_printoptions()
F.printoptions(**kwargs)
F.set_printoptions(**kwargs)
```

--------------------------------

### Galois Field Configuration

Source: https://mhostetter.github.io/galois/latest/api/galois

Provides functions for getting and setting print options for Galois Field objects.

```Python
F get_printoptions
F printoptions
F set_printoptions
```

--------------------------------

### Benchmark Comparison

Source: https://mhostetter.github.io/galois/latest/performance/benchmarks

Instructions for comparing benchmark results between Git branches. Saves and loads benchmark data using a specified format.

```bash
git$ python3=main=min,max,mean,stddev,median=name

$ git$ python3=0001_master=min,max,mean,stddev,median=name

Or, save a benchmark run from `branch` and compare it explicitly against the one from `main`. This benchmark run will save the file `.benchmarks/0001_branch.json`.
$ git$ python3=branch=min,max,mean,stddev,median=name
$ python3
```

--------------------------------

### galois.Primitive Elements

Source: https://mhostetter.github.io/galois/latest/development/formatting

Functions to get primitive elements, primitive roots of unity, and check if an element is primitive.

```python
F primitive_element
F primitive_elements
F is_primitive_element
```

--------------------------------

### Galois Field Addition Tables

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Demonstrates how to display the arithmetic addition tables for finite fields using the `galois` library. These tables are useful for verifying field arithmetic, especially for smaller fields.

```Python
print(GF9.arithmetic_table("+"))
x + y | 0  1  2  3  4  5  6  7  8 
------|---------------------------
    0 | 0  1  2  3  4  5  6  7  8 
    1 | 1  2  0  4  5  3  7  8  6 
    2 | 2  0  1  5  3  4  8  6  7 
    3 | 3  4  5  6  7  8  0  1  2 
    4 | 4  5  3  7  8  6  1  2  0 
    5 | 5  3  4  8  6  7  2  0  1 
    6 | 6  7  8  0  1  2  3  4  5 
    7 | 7  8  6  1  2  0  4  5  3 
    8 | 8  6  7  2  0  1  5  3  4 
```

```Python
print(GF9.arithmetic_table("+"))
 x + y |      0       1       2       α   α + 1   α + 2      2α  2α + 1  2α + 2 
-------|------------------------------------------------------------------------
     0 |      0       1       2       α   α + 1   α + 2      2α  2α + 1  2α + 2 
     1 |      1       2       0   α + 1   α + 2       α  2α + 1  2α + 2      2α 
     2 |      2       0       1   α + 2       α   α + 1  2α + 2      2α  2α + 1 
     α |      α   α + 1   α + 2      2α  2α + 1  2α + 2       0       1       2 
 α + 1 |  α + 1   α + 2       α  2α + 1  2α + 2      2α       1       2       0 
 α + 2 |  α + 2       α   α + 1  2α + 2      2α  2α + 1       2       0       1 
    2α |     2α  2α + 1  2α + 2       0       1       2       α   α + 1   α + 2 
2α + 1 | 2α + 1  2α + 2      2α       1       2       0   α + 1   α + 2       α 
2α + 2 | 2α + 2      2α  2α + 1       2       0       1   α + 2       α   α + 1 
```

```Python
print(GF9.arithmetic_table("+"))
x + y |   0    1    α  α^2  α^3  α^4  α^5  α^6  α^7 
------|---------------------------------------------
    0 |   0    1    α  α^2  α^3  α^4  α^5  α^6  α^7 
    1 |   1  α^4  α^2  α^7  α^6    0  α^3  α^5    α 
    α |   α  α^2  α^5  α^3    1  α^7    0  α^4  α^6 
  α^2 | α^2  α^7  α^3  α^6  α^4    α    1    0  α^5 
  α^3 | α^3  α^6    1  α^4  α^7  α^5  α^2    α    0 
  α^4 | α^4    0  α^7    α  α^5    1  α^6  α^3  α^2 
  α^5 | α^5  α^3    0    1  α^2  α^6    α  α^7  α^4 
  α^6 | α^6  α^5  α^4    0    α  α^3  α^7  α^2    1 
  α^7 | α^7    α  α^6  α^5    0  α^2  α^4    1  α^3 
```

--------------------------------

### galois C GF2 and F Field API

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-prime-fields

Documentation for GF2 and Field classes, including primitive element functions and field properties.

```APIDOC
C GF2
F Field
F GF
  Primitive elements:
    F primitive_element
    F primitive_elements
    F is_primitive_element
```

--------------------------------

### Galois Configuration Options

Source: https://mhostetter.github.io/galois/latest/basic-usage/array-creation

Utilities for managing print options, allowing users to control the display format of mathematical objects.

```Python
F get_printoptions
F printoptions
F set_printoptions
```

--------------------------------

### Get Irreducible Polynomial of GF(3^2)

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Retrieves the irreducible polynomial used to define the GF(3^2) extension field in the galois library.

```Python
f = GF9.irreducible_poly; f
```

--------------------------------

### Pre-commit Configuration for Ruff

Source: https://mhostetter.github.io/galois/latest/development/formatting

YAML configuration for pre-commit hooks, integrating Ruff for linting and formatting. This ensures code quality checks are performed before committing changes.

```yaml
repos:
-repo:https://github.com/pre-commit/pre-commit-hooks
rev:v2.3.0
hooks:
-id:check-added-large-files
-id:check-yaml
-id:check-toml
-id:end-of-file-fixer
-id:trailing-whitespace
-repo:https://github.com/astral-sh/ruff-pre-commit
rev:v0.9.2
hooks:
-id:ruff
-id:ruff-format

```

--------------------------------

### Galois Field Configuration

Source: https://mhostetter.github.io/galois/latest/basic-usage/array-classes

Functions for configuring how Galois field elements and arrays are printed and displayed, including getting and setting print options.

```python
F.get_printoptions
F.printoptions
F.set_printoptions
```

--------------------------------

### Galois Number Theory Functions

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-prime-fields

Offers a comprehensive set of number theory functions, including GCD, LCM, modular arithmetic, primality testing, and factorization.

```Python
import galois

# Example: Number theory operations

# GCD and LCM
gcd_val = galois.gcd(48, 18)
lcm_val = galois.lcm(48, 18)
print(f"GCD(48, 18) = {gcd_val}")
print(f"LCM(48, 18) = {lcm_val}")

# Primality testing
print(f"Is 17 prime? {galois.is_prime(17)}")
print(f"Is 18 prime? {galois.is_prime(18)}")

# Prime generation
print(f"10th prime: {galois.kth_prime(10)}")

# Factorization
factors = galois.factors(100)
print(f"Factors of 100: {factors}")
```

--------------------------------

### Convolution of Integer Polynomials

Source: https://mhostetter.github.io/galois/latest/basic-usage/array-arithmetic

Demonstrates the convolution of two integer polynomials represented in a Galois field. The examples show the input polynomials and the resulting convolved polynomial.

```python
In [253]: x
Out[253]: GF([ 98,  14, 157,  31], order=3^5)

In [254]: y
Out[254]: GF([179,   9, 139,  27], order=3^5)

In [255]: np.convolve(x, y)
Out[255]: GF([ 79,  80,   5,  79, 167, 166, 123], order=3^5)
```

```python
In [256]: x
Out[256]: 
GF([       α^4 + α^2 + 2α + 2,               α^2 + α + 2,
    α^4 + 2α^3 + 2α^2 + α + 1,               α^3 + α + 1], order=3^5)

In [257]: y
Out[257]: 
GF([2α^4 + α^2 + 2α + 2,                 α^2,  α^4 + 2α^3 + α + 1,
                    α^3], order=3^5)

In [258]: np.convolve(x, y)
Out[258]: 
GF([2α^3 + 2α^2 + 2α + 1, 2α^3 + 2α^2 + 2α + 2,                α + 2,
    2α^3 + 2α^2 + 2α + 1,         2α^4 + α + 2,         2α^4 + α + 1,
    α^4 + α^3 + α^2 + 2α], order=3^5)
```

```python
In [259]: x
Out[259]: GF([ α^35, α^209, α^176, α^214], order=3^5)

In [260]: y
Out[260]: GF([α^60,  α^2, α^59,  α^3], order=3^5)

In [261]: np.convolve(x, y)
Out[261]: GF([ α^95, α^236,   α^5,  α^95,   α^9,  α^45, α^217], order=3^5)
```

--------------------------------

### galois C FieldArray API

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-prime-fields

API documentation for the FieldArray class in galois, detailing constructors, conversions, element access, string representations, arithmetic compilation, and various mathematical methods.

```APIDOC
C FieldArray
  Constructors:
    M __init__
    M Identity
    M Ones
    M Random
    M Range
    M Vandermonde
    M Zeros
  Conversions:
    M Vector
    M vector
  Elements:
    P elements
    P non_squares
    P primitive_element
    P primitive_elements
    M primitive_root_of_unity
    M primitive_roots_of_unity
    P squares
    P units
  String representation:
    M __repr__
    M __str__
    M arithmetic_table
    P properties
    M repr_table
  Element representation:
    P element_repr
    M repr
  Arithmetic compilation:
    P default_ufunc_mode
    P dtypes
    P ufunc_mode
    P ufunc_modes
    M compile
  Methods:
    M additive_order
    M characteristic_poly
    M field_norm
    M field_trace
    M log
    M minimal_poly
    M multiplicative_order
  Linear algebra:
    M column_space
    M left_null_space
    M lu_decompose
    M null_space
    M plu_decompose
    M row_reduce
    M row_space
  Properties:
    P characteristic
    P degree
    P irreducible_poly
    P name
    P order
    P prime_subfield
  Attributes:
    P is_extension_field
    P is_prime_field
    P is_primitive_poly
    M is_square
```

--------------------------------

### Galois Polynomials: Methods

Source: https://mhostetter.github.io/galois/latest/development/installation

Methods for Galois Polynomial objects, including derivative, reverse, and roots.

```APIDOC
C Poly

Methods:
  M derivative(self)
    Returns the derivative of the polynomial.
  M reverse(self)
    Returns the reversed polynomial.
  M roots(self)
    Returns the roots of the polynomial.
```

--------------------------------

### Get Elements of GF(3^2) (Integer Representation)

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Retrieves all elements of the GF(3^2) field created with integer representation using the galois library.

```Python
GF9.elements
```

--------------------------------

### Create and Inspect GF(7) - Integer Representation

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-prime-fields

Demonstrates creating a prime field GF(7) using the galois library with integer representation and printing its properties, including name, characteristic, order, and primitive element.

```Python
GF7 = galois.GF(7)

print(GF7.properties)
Galois Field:
  name: GF(7)
  characteristic: 7
  degree: 1
  order: 7
  irreducible_poly: x + 4
  is_primitive_poly: True
  primitive_element: 3
```

--------------------------------

### Get Elements of GF(3^2) (Polynomial Representation)

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Retrieves all elements of the GF(3^2) field created with polynomial representation using the galois library.

```Python
GF9.elements
```

--------------------------------

### Get Elements of GF(3^2) (Power Representation)

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Retrieves all elements of the GF(3^2) field created with power representation using the galois library.

```Python
GF9.elements
```

--------------------------------

### Galois Arrays: Methods

Source: https://mhostetter.github.io/galois/latest/development/installation

Methods for Galois arrays, including compilation and representation.

```APIDOC
C Array

Methods:
  M compile(self, mode='jit')
    Compiles the array for a specific ufunc mode.
  M repr(self)
    Returns the string representation of the array.
```

--------------------------------

### Galois Polynomial Coefficients and Properties

Source: https://mhostetter.github.io/galois/latest/api

Accessors for polynomial coefficients and properties such as degree, field, and irreducibility. Includes methods to get coefficients, degrees, and non-zero coefficients.

```Python
poly.coefficients()
poly.degrees()
poly.nonzero_coeffs()
poly.nonzero_degrees()
poly.degree
poly.field
poly.is_conway
poly.is_conway_consistent
poly.is_irreducible
poly.is_monic
poly.is_primitive
poly.is_square_free
```

--------------------------------

### galois.FieldArray Methods

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Core arithmetic and algebraic methods for galois.FieldArray.

```python
M additive_order
M characteristic_poly
M field_norm
M field_trace
M log
M minimal_poly
M multiplicative_order
```

--------------------------------

### Finite Field Division with Polynomials

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-extension-fields

Demonstrates division of elements in a finite field using polynomial representation and multiplicative inversion. It shows the equivalence between `a * b**-1` and `a / b`.

```python
import galois

# Assume a, b, f, and galois.egcd are defined from context
# _, b_inv_poly, _ = galois.egcd(b_poly, f)
# (a_poly * b_inv_poly) % f
# a * b**-1
# a / b
```

--------------------------------

### Galois Poly Constructors

Source: https://mhostetter.github.io/galois/latest/genindex

Constructors for the Poly class, including identity, random, and string-based initialization.

```APIDOC
Poly:
  Constructors:
    M __init__
    M Degrees
    M Identity
    M Int
    M One
    M Random
    M Roots
    M Str
    M Zero
```

--------------------------------

### NumPy Multiplication with Galois Field Arrays

Source: https://mhostetter.github.io/galois/latest/basic-usage/array-arithmetic

Demonstrates element-wise multiplication of Galois Field arrays using both the '*' operator and the `np.multiply` universal function. The examples show the equivalence of these methods.

```Python
In [43]: x
Out[43]: GF([184,  25, 157,  31], order=3^5)

In [44]: y
Out[44]: GF([179,   9, 139,  27], order=3^5)

In [45]: x * y
Out[45]: GF([ 41, 225, 106, 123], order=3^5)

In [46]: np.multiply(x, y)
Out[46]: GF([ 41, 225, 106, 123], order=3^5)
```

```Python
In [47]: x
Out[47]: 
GF([      2α^4 + 2α^2 + α + 1,             2α^2 + 2α + 1,
    α^4 + 2α^3 + 2α^2 + α + 1,               α^3 + α + 1], order=3^5)

In [48]: y
Out[48]: 
GF([2α^4 + α^2 + 2α + 2,                 α^2,  α^4 + 2α^3 + α + 1,
                    α^3], order=3^5)

In [49]: x * y
Out[49]: 
GF([   α^3 + α^2 + α + 2,    2α^4 + 2α^3 + α^2,  α^4 + 2α^2 + 2α + 1,
    α^4 + α^3 + α^2 + 2α], order=3^5)

In [50]: np.multiply(x, y)
Out[50]: 
GF([   α^3 + α^2 + α + 2,    2α^4 + 2α^3 + α^2,  α^4 + 2α^2 + 2α + 1,
```

--------------------------------

### NumPy outer for Galois Fields (Addition)

Source: https://mhostetter.github.io/galois/latest/basic-usage/array-arithmetic

The `outer` method applies a ufunc to all pairs of inputs from two arrays. This example demonstrates the addition of elements from two Galois Field arrays.

```Python
In [229]: x
Out[229]: GF([184,  25, 157,  31], order=3**5)

In [230]: y
Out[230]: GF([179,   9, 139,  27], order=3**5)

In [231]: np.add.outer(x, y)
Out[231]: 
GF([[ 81, 166,  80, 211],
    [165,   7, 155,  52],
    [ 54, 139, 215, 103],
    [198,  40,  89,  58]], order=3**5)

In [232]: x
Out[232]: 
GF([      2α**4 + 2α**2 + α + 1,             2α**2 + 2α + 1,
    α**4 + 2α**3 + 2α**2 + α + 1,               α**3 + α + 1], order=3**5)

In [233]: y
Out[233]: 
GF([2α**4 + α**2 + 2α + 2,                 α**2,  α**4 + 2α**3 + α + 1,
                    α**3], order=3**5)

In [234]: np.add.outer(x, y)
Out[234]: 
GF([[                       α**4,               2α**4 + α + 1,
           2α**3 + 2α**2 + 2α + 2,  2α**4 + α**3 + 2α**2 + α + 1],
    [                  2α**4 + α,                     2α + 1,
          α**4 + 2α**3 + 2α**2 + 2,        α**3 + 2α**2 + 2α + 1],
    [                      2α**3,         α**4 + 2α**3 + α + 1,
     2α**4 + α**3 + 2α**2 + 2α + 2,         α**4 + 2α**2 + α + 1],
    [          2α**4 + α**3 + α**2,          α**3 + α**2 + α + 1,
                   α**4 + 2α + 2,               2α**3 + α + 1]], order=3**5)

In [235]: x
Out[235]: GF([α**156,  α**88, α**176, α**214], order=3**5)

In [236]: y
Out[236]: GF([α**60,  α**2, α**59,  α**3], order=3**5)

In [237]: np.add.outer(x, y)
Out[237]: 
GF([[  α**4,  α**45, α**236, α**178],
    [α**137, α**126,  α**43,  α**79],
    [α**124,  α**59, α**175, α**181],
    [α**103, α**115, α**166,  α**28]], order=3**5)
```

--------------------------------

### Create and Inspect GF(7) - Power Representation

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-prime-fields

Shows how to create a prime field GF(7) with a 'power' representation for elements and displays its properties, which are identical to the integer representation for prime fields.

```Python
GF7 = galois.GF(7, repr="power")

print(GF7.properties)
Galois Field:
  name: GF(7)
  characteristic: 7
  degree: 1
  order: 7
  irreducible_poly: x + 4
  is_primitive_poly: True
  primitive_element: 3
```

--------------------------------

### Galois Field Polynomial Initialization

Source: https://mhostetter.github.io/galois/latest/basic-usage/poly-arithmetic

Demonstrates how to initialize polynomials over a specific Galois Field (GF(7) in this case) using the galois.GF() and galois.Poly() classes.

```python
import galois

GF = galois.GF(7)
f = galois.Poly([1, 0, 4, 3], field=GF)
print(f)

g = galois.Poly([2, 1, 3], field=GF)
print(g)
```

--------------------------------

### NumPy at for Galois Fields (In-place Negation)

Source: https://mhostetter.github.io/galois/latest/basic-usage/array-arithmetic

The `at` method performs an operation in-place at specified indices. This example shows how to negate elements at given positions within a Galois Field array.

```Python
In [241]: x
Out[241]: GF([184,  25, 157,  31], order=3**5)

In [242]: z = x.copy()

# Negate indices 0 and 1 in-place
In [243]: np.negative.at(x, [0, 1]); x
Out[243]: GF([ 98,  14, 157,  31], order=3**5)

In [244]: z[0:1] *= -1; z
Out[244]: GF([ 98,  25, 157,  31], order=3**5)

In [245]: x
Out[245]: 
GF([       α**4 + α**2 + 2α + 2,               α**2 + α + 2,
    α**4 + 2α**3 + 2α**2 + α + 1,               α**3 + α + 1], order=3**5)

In [246]: z = x.copy()

# Negate indices 0 and 1 in-place
In [247]: np.negative.at(x, [0, 1]); x
Out[247]: 
GF([      2α**4 + 2α**2 + α + 1,             2α**2 + 2α + 1,
    α**4 + 2α**3 + 2α**2 + α + 1,               α**3 + α + 1], order=3**5)

In [248]: z[0:1] *= -1; z
Out[248]: 
GF([      2α**4 + 2α**2 + α + 1,               α**2 + α + 2,
    α**4 + 2α**3 + 2α**2 + α + 1,               α**3 + α + 1], order=3**5)

In [249]: x
Out[249]: GF([α**156,  α**88, α**176, α**214], order=3**5)

In [250]: z = x.copy()

# Negate indices 0 and 1 in-place
In [251]: np.negative.at(x, [0, 1]); x
Out[251]: GF([ α**35, α**209, α**176, α**214], order=3**5)

In [252]: z[0:1] *= -1; z
Out[252]: GF([ α**35,  α**88, α**176, α**214], order=3**5)
```

--------------------------------

### NumPy Addition with Galois Field Arrays

Source: https://mhostetter.github.io/galois/latest/basic-usage/array-arithmetic

Demonstrates addition of two Galois Field arrays using both the '+' operator and the `np.add` universal function. The examples show the equivalence of both methods.

```Python
In [4]: x
Out[4]: GF([184,  25, 157,  31], order=3^5)

In [5]: y
Out[5]: GF([179,   9, 139,  27], order=3^5)

In [6]: x + y
Out[6]: GF([ 81,   7, 215,  58], order=3^5)

In [7]: np.add(x, y)
Out[7]: GF([ 81,   7, 215,  58], order=3^5)
```

```Python
In [8]: x
Out[8]: 
GF([      2α^4 + 2α^2 + α + 1,             2α^2 + 2α + 1,
    α^4 + 2α^3 + 2α^2 + α + 1,               α^3 + α + 1], order=3^5)

In [9]: y
Out[9]: 
GF([2α^4 + α^2 + 2α + 2,                 α^2,  α^4 + 2α^3 + α + 1,
                    α^3], order=3^5)

In [10]: x + y
Out[10]: 
GF([                       α^4,                     2α + 1,
    2α^4 + α^3 + 2α^2 + 2α + 2,               2α^3 + α + 1], order=3^5)

In [11]: np.add(x, y)
Out[11]: 
GF([                       α^4,                     2α + 1,
    2α^4 + α^3 + 2α^2 + 2α + 2,               2α^3 + α + 1], order=3^5)
```

```Python
In [12]: x
Out[12]: GF([α^156,  α^88, α^176, α^214], order=3^5)

In [13]: y
Out[13]: GF([α^60,  α^2, α^59,  α^3], order=3^5)

In [14]: x + y
Out[14]: GF([  α^4, α^126, α^175,  α^28], order=3^5)

In [15]: np.add(x, y)
Out[15]: GF([  α^4, α^126, α^175,  α^28], order=3^5)
```

--------------------------------

### Get Primitive Element of a Field

Source: https://mhostetter.github.io/galois/latest/tutorials/intro-to-prime-fields

Shows how to access the primitive element of a finite field using the `primitive_element` class property in Galois. This element generates the multiplicative group of the field.

```Python
import galois

# Define GF(7)
GF7 = galois.GF(7)

# Get the primitive element
primitive_element = GF7.primitive_element
print(primitive_element)
```

--------------------------------

### BCH Code Constructors and Representation

Source: https://mhostetter.github.io/galois/latest/basic-usage/poly

Constructors and string representation methods for BCH codes.

```Python
M.__init__(n, k, t, field=None, generator=None)
M.__repr__()
M.__str__()
```

--------------------------------

### Run Pytest Benchmarks with Custom Formatting

Source: https://mhostetter.github.io/galois/latest/performance/benchmarks

This snippet demonstrates how to invoke `pytest` to run benchmarks located in the `benchmarks/` folder. It includes arguments to specify the desired performance metrics (min, max, mean, stddev, median) and to sort the benchmark results by name for better analysis.

```bash
$ python3 -m pytest benchmarks/ --benchmark-columns=min,max,mean,stddev,median --benchmark-sort=name
```
Tokens:
Raw