Trait Average 

pub trait Average<RHS = Self> {
    type Output;

    // Required method
    fn average(self, other: RHS) -> Self::Output;
}

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow: the result is always exact or within a half of the exact value, so it always fits in the same type as the inputs.

Required Associated Types

type Output

Required Methods

fn average(self, other: RHS) -> 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 Average for f32

fn average(self, other: f32) -> f32

Computes the average (arithmetic mean) of two floating-point numbers.

For finite values the result is the correctly rounded average: the nearest representable value, with ties going to the value with the even mantissa. The computation avoids intermediate overflow and underflow, so extreme values average correctly. If either value is infinite or NaN, the result is whatever (x + y) / 2.0 produces.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = f32

impl Average for f64

fn average(self, other: f64) -> f64

Computes the average (arithmetic mean) of two floating-point numbers.

For finite values the result is the correctly rounded average: the nearest representable value, with ties going to the value with the even mantissa. The computation avoids intermediate overflow and underflow, so extreme values average correctly. If either value is infinite or NaN, the result is whatever (x + y) / 2.0 produces.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = f64

impl Average for i8

fn average(self, other: i8) -> i8

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i8

impl Average for i16

fn average(self, other: i16) -> i16

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i16

impl Average for i32

fn average(self, other: i32) -> i32

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i32

impl Average for i64

fn average(self, other: i64) -> i64

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i64

impl Average for i128

fn average(self, other: i128) -> i128

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = i128

impl Average for isize

fn average(self, other: isize) -> isize

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = isize

impl Average for u8

fn average(self, other: u8) -> u8

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u8

impl Average for u16

fn average(self, other: u16) -> u16

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u16

impl Average for u32

fn average(self, other: u32) -> u32

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u32

impl Average for u64

fn average(self, other: u64) -> u64

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u64

impl Average for u128

fn average(self, other: u128) -> u128

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = u128

impl Average for usize

fn average(self, other: usize) -> usize

Computes the average (arithmetic mean) of two numbers, rounding to the nearest integer. Two-way ties are broken by rounding to the even integer.

The average is computed without overflow; the result always fits in the same type as the inputs. This is equivalent to average_round with Nearest.

$$ f(x, y) = \begin{cases} a & \text{if} \quad a \in \Z, \\ \lfloor a \rfloor & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is even}, \\ \lceil a \rceil & \text{if} \quad a \notin \Z \ \text{and} \ \lfloor a \rfloor \ \text{is odd,} \end{cases} $$

where $a = \frac{x + y}{2}$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Output = usize

Implementors