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 polynomials: 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]
finite_fields = "0.1.0"

Examples

Prime Field

use finite_field::*;

// consider F_5
let char:u32 = 5
let x:FiniteField = FiniteField{
    char:char,
    element:Element::PrimeField(2)
    };
let y:FiniteField = FiniteField{
    char:char,
    element:Element::PrimeField(3)
    };
println!("x + y = {:?}", x + y);
println!("x - y = {:?}", x - y);
println!("x * y = {:?}", x * y);
println!("x / y = {:?}", x / y);

Galois Field

use finite_field::*;

// consider GF(5^3)
let char:u32 = 5
let n:u32 = 3
let primitive_polynomial = Polynomial::get_primitive_polynomial(char, n);
let element1:Element = Element::GaloisField{element:vec![4,2,3,4,3],primitive_polynomial:primitive_polynomial.clone()};
let element2:Element = Element::GaloisField{element:vec![1,2,3,1],primitive_polynomial:primitive_polynomial.clone()};

let x: FiniteField = FiniteField {
    char: char,
    element: element1,
};
let y: FiniteField = FiniteField {
    char: char,
    element: element2,
};
    println!("x + y = {:?}", (x + y).element);
    println!("x - y = {:?}", (x - y).element);
    println!("x * y = {:?}", (x * y).element);
    println!("x / y = {:?}", (x / y).element);

Polynomial over F_p

use finite_field::*;

let char:u32 = 2;

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

let f1: Polynomial = Polynomial {
    char: char,
    coef: vec![element0.clone(), element1.clone()], // 0 + 1*x = x
};
let f2: Polynomial = Polynomial {
    char: char,
    coef: vec![element0.clone(), element1.clone(), element1.clone()], // 0 + 1*x + 1*x^2 = x + x^2
};
println!("f1 + f2 = {:?}", (f1 + f2).coef);
println!("f1 - f2 = {:?}", (f1 - f2).coef);
println!("f1 * f2 = {:?}", (f1 * f2).coef);
println!("f1 / f2 = {:?}", (f1 / f2).coef);
println!("f1 % f2 = {:?}", (f1 % f2).coef);

Polynomial over GF(pⁿ)

Same as above