Table of Contents

1. finite fields
2. What makes it different from other libraries?
   1. Pros:
   2. Cons:
3. Usage
4. Examples
   1. Prime Field
   2. Galois Field
   3. Polynomial over F_p
   4. Polynomial over GF(pⁿ)

finite fields

A Rust library for operations on finite field, featuring:

• Sum, difference, product, and quotient of elements F_p
• Sum, difference, product, and quotient of elements GF(pⁿ)
• Obtaining the primitive polynomial
• Sum, difference, product, quotient, and remainder of polynomial over F_p
• Sum, difference, product, quotient, and remainder of polynomial over GF(pⁿ)

What makes it different from other libraries?

Pros:

• Can be calculated with F_p, GF(pⁿ) for any prime and any multiplier, not limited to a char 2.
• Can freely compute four types of element: prime, Galois, polynomial of prime, and polynomial of Galois.
• Each can be calculated with +-*/, so you can write natural code.

Cons:

• It takes longer than other libraries because it is not optimized for each character.

Usage

Add this to your Cargo.toml:

[dependencies]
galois_field = "0.1.3"

Examples

Prime Field

use galois_field::*;

fn main() {
    let char: u32 = 2;
    let n = 4;

    let primitive_polynomial = Polynomial::get_primitive_polynomial(char, n);
    let x:FiniteField = FiniteField{
        char: char,
        element:Element::GaloisField{element:vec![0,1],primitive_polynomial:primitive_polynomial.clone()} // i.e. [0,1] = x -> 2 over GF(2^4)
    };
    let y:FiniteField = FiniteField{
        char: char,
        element:Element::GaloisField{element:vec![0,0,1,1],primitive_polynomial:primitive_polynomial.clone()} // i.e. [0,0,1,1] = x^3 + x^2 -> 12 over GF(2^4)
    };

    println!("x + y = {:?}", (x.clone() + y.clone()).element);
    println!("x - y = {:?}", (x.clone() - y.clone()).element);
    println!("x * y = {:?}", (x.clone() * y.clone()).element);
    println!("x / y = {:?}", (x.clone() / y.clone()).element);
}

Galois Field

use galois_field::*;

fn main(){
    // consider GF(2^4)
    let char: u32 = 2;
    let n = 4;
    let primitive_polynomial = Polynomial::get_primitive_polynomial(char, n);
    let x:FiniteField = FiniteField{
        char: char,
        element:Element::GaloisField{element:vec![0,1],primitive_polynomial:primitive_polynomial.clone()} // i.e. [0,1] = x -> 2 over GF(2^4)
    };
    let y:FiniteField = FiniteField{
        char: char,
        element:Element::GaloisField{element:vec![0,0,1,1],primitive_polynomial:primitive_polynomial.clone()} // i.e. [0,0,1,1] = x^3 + x^2 -> 12 over GF(2^4)
    };
    println!("x + y = {:?}", (x.clone() + y.clone()).element);
    println!("x - y = {:?}", (x.clone() - y.clone()).element);
    println!("x * y = {:?}", (x.clone() * y.clone()).element);
    println!("x / y = {:?}", (x.clone() / y.clone()).element);

}

Polynomial over F_p

use galois_field::*;

fn main() {
    // character
    let char: u32 = 2;

    let element0:FiniteField = FiniteField{
        char: char,
        element:Element::PrimeField{element:0} // 0 in F_5
    };
    let element1:FiniteField = FiniteField{
        char: char,
        element:Element::PrimeField{element:1} // 1 in F_5
    };


    let f: Polynomial = Polynomial {
        coef: vec![element1.clone(),element0.clone(),element0.clone(),element0.clone(),element1.clone()]
    };
    let g: Polynomial = Polynomial {
        coef: vec![element1.clone(),element0.clone(),element0.clone(),element1.clone(),element1.clone()]
    };
    println!("f + g = {:?}", (f.clone()+g.clone()).coef);
    println!("f - g = {:?}", (f.clone()-g.clone()).coef);
    println!("f * g = {:?}", (f.clone()*g.clone()).coef);
    println!("f / g = {:?}", (f.clone()/g.clone()).coef);
    println!("f % g = {:?}", (f.clone()%g.clone()).coef);

}

Polynomial over GF(pⁿ)

Same as above