Trait arithmetic_eval::arith::Arithmetic[−][src]

pub trait Arithmetic<T> {
    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;
}
Expand description

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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[src]

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.

Implementors

impl Arithmetic<BigUint> for ModularArithmetic<BigUint>[src]

fn add(&self, x: BigUint, y: BigUint) -> Result<BigUint, ArithmeticError>[src]

fn sub(&self, x: BigUint, y: BigUint) -> Result<BigUint, ArithmeticError>[src]

fn mul(&self, x: BigUint, y: BigUint) -> Result<BigUint, ArithmeticError>[src]

fn div(&self, x: BigUint, y: BigUint) -> Result<BigUint, ArithmeticError>[src]

fn pow(&self, x: BigUint, y: BigUint) -> Result<BigUint, ArithmeticError>[src]

fn neg(&self, x: BigUint) -> Result<BigUint, ArithmeticError>[src]

fn eq(&self, x: &BigUint, y: &BigUint) -> bool[src]

impl<T> Arithmetic<T> for ModularArithmetic<T> where
    T: Copy + PartialEq + NumOps + Zero + One + DoubleWidth,
    usize: TryFrom<T>, [src]

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

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

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

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

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

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

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

impl<T> Arithmetic<T> for StdArithmetic where
    T: Clone + NumOps + PartialEq + Neg<Output = T> + Pow<T, Output = T>, [src]

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

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

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

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

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

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

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

impl<T> Arithmetic<T> for WrappingArithmetic where
    T: Copy + PartialEq + Zero + One + WrappingAdd + WrappingSub + WrappingMul + WrappingNeg + Div<T, Output = T>,
    usize: TryFrom<T>, [src]

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

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

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

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

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

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

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

impl<T, A> Arithmetic<T> for FullArithmetic<T, A> where
    A: Arithmetic<T>, [src]

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

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

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

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

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

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

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

impl<T, Kind> Arithmetic<T> for CheckedArithmetic<Kind> where
    T: Clone + PartialEq + Zero + One + CheckedAdd + CheckedSub + CheckedMul + CheckedDiv,
    Kind: CheckedArithmeticKind<T>,
    usize: TryFrom<T>, [src]

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

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

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

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

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

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

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