Struct cyclic::modular::Modular

pub struct Modular<const N: u32>(pub u32);

Methods

impl<const N: u32> Modular<{ N }>

A ring type taking values in Z/nZ, for any positive n.

Examples

use cyclic::modular::Modular;

const N: u32 = 6;
let r = Modular::<N>::new(2);
let s = Modular::<N>::new(3);

assert_eq!((r * s).0, 0);

use cyclic::modular::Modular;

let r = Modular::<3>::new(1);
let s = Modular::<4>::new(1);

let absurd = r + s;

pub fn new(val: u32) -> Self

pub fn pow(self, exp: u32) -> Self

Trait Implementations

impl<const N: u32> Add<Modular<N>> for Modular<{ N }>

Adds ring elements modulo N.

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<const N: u32> AddAssign<Modular<N>> for Modular<{ N }>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<const N: u32> Clone for Modular<N>

fn clone(&self) -> Modular<N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: u32> Copy for Modular<N>

impl<const N: u32> Debug for Modular<N>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<const N: u32> Div<Modular<N>> for Modular<{ N }>

Divides field elements modulo N.

Division is implemented with the extended Euclidean algorithm. There might be cases where the naive exponentiation algorithm is slightly faster; it might be worth feature-flagging this.

Panics

This currently panics for composite N; as const generics are stabilized I hope to promote this to a compile-time check with a where is_prime({ N }) clause. This panic can be disabled by compiling with the composite_order_division feature.

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self::Output

Performs the / operation.

impl<const N: u32> DivAssign<Modular<N>> for Modular<{ N }>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<const N: u32> From<u32> for Modular<{ N }>

fn from(n: u32) -> Self

Performs the conversion.

impl<const N: u32> Mul<Modular<N>> for Modular<{ N }>

Multiplies ring elements modulo N.

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

Performs the * operation.

impl<const N: u32> MulAssign<Modular<N>> for Modular<{ N }>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<const N: u32> Neg for Modular<{ N }>

Returns the additive inverse of a ring element.

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const N: u32> PartialEq<Modular<N>> for Modular<{ N }>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<const N: u32> Sub<Modular<N>> for Modular<{ N }>

Subtracts ring elements modulo N.

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<const N: u32> SubAssign<Modular<N>> for Modular<{ N }>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.