Finite field operations and erasure correction codes.

## Project description

## Introduction

The `pyfinite` package is a python package for dealing with finite
fields and related mathematical operations. Also included is a generic
matrix package for doing matrix operations over generic fields. As an
illustration a Reed-Solomon erasure correcting code implementation is
provided using these tools.

Roughly speaking a “field” is a mathematical space where consistent addition, subtraction, multiplication, and division operations are defined. A “finite field” is a field where the number of elements is finite. Perhaps the most familiar finite field is the Boolean field where the elements are 0 and 1, addition (and subtraction) correspond to XOR, and multiplication (and division) work as normal for 0 and 1.

More complicated finite fields are useful and interesting for cryptography and erasure correcting codes.

## Usage

After you install via something like `pip install pyfinite`, the best
way to get started is to look at the doctest examples in the following
files:

`ffield.py`: See docstring for`FField`and`FElement`classes.- This shows you how to work with finite fields.

`genericmatrix.py`: See docstring for`GenericMatrix`class.- This shows you how to do matrix operations on a generic field.

`rs_code.py`: See docstring for`RSCode`class.- This shows you how to do Reed-Solomon erasure correcting codes.

`file_ecc.py`: See the top-level docstring for the`file_ecc`module.- Shows you how to encode a file into multiple pieces and decode from a subset of those pieces.

For example, after you install `pyfinite` and start the python
interpreter, do something like the following to see help on finite
fields:

>>> from pyfinite import ffield >>> help(ffield.FField)

or if you want to dive right in, you can try something like the following:

>>> from pyfinite import ffield >>> F = ffield.FField(5) # create the field GF(2^5) >>> a = 7 # field elements are denoted as integers from 0 to 2^5-1 >>> b = 15 >>> F.ShowPolynomial(a) # show the polynomial representation of a 'x^2 + x^1 + 1' >>> c = F.Multiply(a,b) # multiply a and b modulo the field generator >>> c 8 >>> F.ShowPolynomial(c) 'x^3'

Alternatively, you can jump into the `genericmatrix.py` package with
something like:

>>> import genericmatrix >>> v = genericmatrix.GenericMatrix((3,3)) >>> v.SetRow(0,[0.0, -1.0, 1.0]) >>> v.SetRow(1,[1.0, 1.0, 1.0]) >>> v.SetRow(2,[1.0, 1.0, -1.0]) >>> v <matrix 0.0 -1.0 1.0 1.0 1.0 1.0 1.0 1.0 -1.0> >>> vi = v.Inverse()

Then for some real fun, you can try experimenting with generic matrix
operations on elements of a finite field! The nice thing about the
`genericmatrix` module is that it only relies on the standard python
arithmetic operators so you can use it for anything with sane `+`,
`-`, `*`, and `/` operators. See the help on `genericmatrix` for
more info.

Finally, if you just want erasure correction, see the docs for the
`rs_code` and `file_ecc` modules via something like

>>> import rs_code, file_ecc >>> help(file_ecc) >>> help(rs_code)

## Future work

This code was written many years ago and hosted on an old MIT web site
under the name `py_ecc` before being moved to github. It is in need of
some love. In particular, it could use:

- Reworking to fix pep8/pylint warnings and generally better python style.
- More documentation.
- More examples.
- Travis setup to verify doctests in both python2 and python3.
- These have been manually verified but it would be nice to have a setup which can run tests on multiple versions of python in an automated way.

To help or contribute please see the main project site at https://github.com/emin63/pyfinite.

## Project details

## Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.