Trait Arithmetic 

pub trait Arithmetic<T> {
    // Required methods
    fn add(&self, x: T, y: T) -> Result<T, ArithmeticError>;
    fn sub(&self, x: T, y: T) -> Result<T, ArithmeticError>;
    fn mul(&self, x: T, y: T) -> Result<T, ArithmeticError>;
    fn div(&self, x: T, y: T) -> Result<T, ArithmeticError>;
    fn pow(&self, x: T, y: T) -> Result<T, ArithmeticError>;
    fn neg(&self, x: T) -> Result<T, ArithmeticError>;
    fn eq(&self, x: &T, y: &T) -> bool;
}

Encapsulates arithmetic operations on a certain primitive type (or an enum of primitive types).

Unlike operations on built-in integer types, arithmetic operations may be fallible. Additionally, the arithmetic can have a state. This is used, for example, in ModularArithmetic, which stores the modulus in the state.

Required Methods

fn add(&self, x: T, y: T) -> Result<T, ArithmeticError>

Adds two values.

Errors

Returns an error if the operation is unsuccessful (e.g., on integer overflow).

fn sub(&self, x: T, y: T) -> Result<T, ArithmeticError>

Subtracts two values.

Errors

Returns an error if the operation is unsuccessful (e.g., on integer underflow).

fn mul(&self, x: T, y: T) -> Result<T, ArithmeticError>

Multiplies two values.

Errors

Returns an error if the operation is unsuccessful (e.g., on integer overflow).

fn div(&self, x: T, y: T) -> Result<T, ArithmeticError>

Divides two values.

Errors

Returns an error if the operation is unsuccessful (e.g., if y is zero or does not have a multiplicative inverse in the case of modular arithmetic).

fn pow(&self, x: T, y: T) -> Result<T, ArithmeticError>

Raises x to the power of y.

Errors

Returns an error if the operation is unsuccessful (e.g., on integer overflow).

fn neg(&self, x: T) -> Result<T, ArithmeticError>

Negates a value.

Errors

Returns an error if the operation is unsuccessful (e.g., on integer overflow).

fn eq(&self, x: &T, y: &T) -> bool

Checks if two values are equal. Note that equality can be a non-trivial operation; e.g., different numbers may be equal as per modular arithmetic.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Arithmetic<BigUint> for ModularArithmetic<BigUint>

Available on crate feature bigint only.

impl<T, A> Arithmetic<T> for FullArithmetic<T, A>

where A: Arithmetic<T>,

impl<T, Kind> Arithmetic<T> for CheckedArithmetic<Kind>

where T: Clone + PartialEq + Zero + One + CheckedAdd + CheckedSub + CheckedMul + CheckedDiv, Kind: CheckedArithmeticKind<T>, usize: TryFrom<T>,

impl<T> Arithmetic<T> for ModularArithmetic<T>

where T: Copy + PartialEq + NumOps + Zero + One + DoubleWidth, usize: TryFrom<T>,

impl<T> Arithmetic<T> for StdArithmetic

where T: Clone + NumOps + PartialEq + Neg<Output = T> + Pow<T, Output = T>,

impl<T> Arithmetic<T> for WrappingArithmetic

where T: Copy + PartialEq + Zero + One + WrappingAdd + WrappingSub + WrappingMul + WrappingNeg + Div<T, Output = T>, usize: TryFrom<T>,