Trait CheckedMulAddMul 

pub trait CheckedMulAddMul<Y = Self, Z = Self, W = Self> {
    type Output;

    // Required method
    fn checked_mul_add_mul(self, y: Y, z: Z, w: W) -> Option<Self::Output>;
}

Adds the products of two pairs of numbers, returning None if the result is not representable.

Required Associated Types

type Output

Required Methods

fn checked_mul_add_mul(self, y: Y, z: Z, w: W) -> Option<Self::Output>

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

impl CheckedMulAddMul for i8

fn checked_mul_add_mul(self, y: i8, z: i8, w: i8) -> Option<i8>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i8

impl CheckedMulAddMul for i16

fn checked_mul_add_mul(self, y: i16, z: i16, w: i16) -> Option<i16>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i16

impl CheckedMulAddMul for i32

fn checked_mul_add_mul(self, y: i32, z: i32, w: i32) -> Option<i32>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i32

impl CheckedMulAddMul for i64

fn checked_mul_add_mul(self, y: i64, z: i64, w: i64) -> Option<i64>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i64

impl CheckedMulAddMul for i128

fn checked_mul_add_mul(self, y: i128, z: i128, w: i128) -> Option<i128>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i128

impl CheckedMulAddMul for isize

fn checked_mul_add_mul(self, y: isize, z: isize, w: isize) -> Option<isize>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = isize

impl CheckedMulAddMul for u8

fn checked_mul_add_mul(self, y: u8, z: u8, w: u8) -> Option<u8>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u8

impl CheckedMulAddMul for u16

fn checked_mul_add_mul(self, y: u16, z: u16, w: u16) -> Option<u16>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u16

impl CheckedMulAddMul for u32

fn checked_mul_add_mul(self, y: u32, z: u32, w: u32) -> Option<u32>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u32

impl CheckedMulAddMul for u64

fn checked_mul_add_mul(self, y: u64, z: u64, w: u64) -> Option<u64>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u64

impl CheckedMulAddMul for u128

fn checked_mul_add_mul(self, y: u128, z: u128, w: u128) -> Option<u128>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u128

impl CheckedMulAddMul for usize

fn checked_mul_add_mul(self, y: usize, z: usize, w: usize) -> Option<usize>

Adds the products of two pairs of numbers, returning None if the result cannot be represented.

$$ f(x, y, z, w) = \begin{cases} xy + zw & \text{if} \quad xy + zw \ \text{is representable} \\ \operatorname{None} & \text{otherwise} \end{cases} $$

The products are formed at double width, so a product that does not fit does not by itself make the result unrepresentable.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = usize

Implementors