Trait gstreamer_sdp::prelude::MulDiv

pub trait MulDiv<RHS = Self> {
    type Output;
    pub fn mul_div_floor(self, num: RHS, denom: RHS) -> Option<Self::Output>;
    pub fn mul_div_round(self, num: RHS, denom: RHS) -> Option<Self::Output>;
    pub fn mul_div_ceil(self, num: RHS, denom: RHS) -> Option<Self::Output>;
}

Trait for calculating val * num / denom with different rounding modes and overflow protection.

Implementations of this trait have to ensure that even if the result of the multiplication does not fit into the type, as long as it would fit after the division the correct result has to be returned instead of None. None only should be returned if the overall result does not fit into the type.

This specifically means that e.g. the u64 implementation must, depending on the arguments, be able to do 128 bit integer multiplication.

Associated Types

type Output

Output type for the methods of this trait.

Loading content...

Required methods

pub fn mul_div_floor(self, num: RHS, denom: RHS) -> Option<Self::Output>

Calculates floor(val * num / denom), i.e. the largest integer less than or equal to the result of the division.

Example

extern crate muldiv;
use muldiv::MulDiv;

let x = 3i8.mul_div_floor(4, 2);
assert_eq!(x, Some(6));

let x = 5i8.mul_div_floor(2, 3);
assert_eq!(x, Some(3));

let x = (-5i8).mul_div_floor(2, 3);
assert_eq!(x, Some(-4));

let x = 3i8.mul_div_floor(3, 2);
assert_eq!(x, Some(4));

let x = (-3i8).mul_div_floor(3, 2);
assert_eq!(x, Some(-5));

let x = 127i8.mul_div_floor(4, 3);
assert_eq!(x, None);

pub fn mul_div_round(self, num: RHS, denom: RHS) -> Option<Self::Output>

Calculates round(val * num / denom), i.e. the closest integer to the result of the division. If both surrounding integers are the same distance (x.5), the one with the bigger absolute value is returned (round away from 0.0).

Example

extern crate muldiv;
use muldiv::MulDiv;

let x = 3i8.mul_div_round(4, 2);
assert_eq!(x, Some(6));

let x = 5i8.mul_div_round(2, 3);
assert_eq!(x, Some(3));

let x = (-5i8).mul_div_round(2, 3);
assert_eq!(x, Some(-3));

let x = 3i8.mul_div_round(3, 2);
assert_eq!(x, Some(5));

let x = (-3i8).mul_div_round(3, 2);
assert_eq!(x, Some(-5));

let x = 127i8.mul_div_round(4, 3);
assert_eq!(x, None);

pub fn mul_div_ceil(self, num: RHS, denom: RHS) -> Option<Self::Output>

Calculates ceil(val * num / denom), i.e. the the smallest integer greater than or equal to the result of the division.

Example

extern crate muldiv;
use muldiv::MulDiv;

let x = 3i8.mul_div_ceil(4, 2);
assert_eq!(x, Some(6));

let x = 5i8.mul_div_ceil(2, 3);
assert_eq!(x, Some(4));

let x = (-5i8).mul_div_ceil(2, 3);
assert_eq!(x, Some(-3));

let x = 3i8.mul_div_ceil(3, 2);
assert_eq!(x, Some(5));

let x = (-3i8).mul_div_ceil(3, 2);
assert_eq!(x, Some(-4));

let x = (127i8).mul_div_ceil(4, 3);
assert_eq!(x, None);

Loading content...

Implementations on Foreign Types

impl<'a, 'b> MulDiv<&'b Bytes> for &'a Bytes

type Output = Bytes

pub fn mul_div_floor(
    self,
    num: &Bytes,
    denom: &Bytes
) -> Option<<&'a Bytes as MulDiv<&'b Bytes>>::Output>

pub fn mul_div_round(
    self,
    num: &Bytes,
    denom: &Bytes
) -> Option<<&'a Bytes as MulDiv<&'b Bytes>>::Output>

pub fn mul_div_ceil(
    self,
    num: &Bytes,
    denom: &Bytes
) -> Option<<&'a Bytes as MulDiv<&'b Bytes>>::Output>

impl<'a> MulDiv<u64> for Default

type Output = Default

pub fn mul_div_floor(
    self,
    num: u64,
    denom: u64
) -> Option<<Default as MulDiv<u64>>::Output>

pub fn mul_div_round(
    self,
    num: u64,
    denom: u64
) -> Option<<Default as MulDiv<u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: u64,
    denom: u64
) -> Option<<Default as MulDiv<u64>>::Output>

impl<'a> MulDiv<&'a u64> for Default

type Output = Default

pub fn mul_div_floor(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Default as MulDiv<&'a u64>>::Output>

pub fn mul_div_round(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Default as MulDiv<&'a u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Default as MulDiv<&'a u64>>::Output>

impl<'a, 'b> MulDiv<&'b Buffers> for &'a Buffers

type Output = Buffers

pub fn mul_div_floor(
    self,
    num: &Buffers,
    denom: &Buffers
) -> Option<<&'a Buffers as MulDiv<&'b Buffers>>::Output>

pub fn mul_div_round(
    self,
    num: &Buffers,
    denom: &Buffers
) -> Option<<&'a Buffers as MulDiv<&'b Buffers>>::Output>

pub fn mul_div_ceil(
    self,
    num: &Buffers,
    denom: &Buffers
) -> Option<<&'a Buffers as MulDiv<&'b Buffers>>::Output>

impl MulDiv<Default> for Default

type Output = Default

pub fn mul_div_floor(
    self,
    num: Default,
    denom: Default
) -> Option<<Default as MulDiv<Default>>::Output>

pub fn mul_div_round(
    self,
    num: Default,
    denom: Default
) -> Option<<Default as MulDiv<Default>>::Output>

pub fn mul_div_ceil(
    self,
    num: Default,
    denom: Default
) -> Option<<Default as MulDiv<Default>>::Output>

impl<'a> MulDiv<u64> for &'a Default

type Output = Default

pub fn mul_div_floor(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Default as MulDiv<u64>>::Output>

pub fn mul_div_round(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Default as MulDiv<u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Default as MulDiv<u64>>::Output>

impl<'a, 'b> MulDiv<&'b Default> for &'a Default

type Output = Default

pub fn mul_div_floor(
    self,
    num: &Default,
    denom: &Default
) -> Option<<&'a Default as MulDiv<&'b Default>>::Output>

pub fn mul_div_round(
    self,
    num: &Default,
    denom: &Default
) -> Option<<&'a Default as MulDiv<&'b Default>>::Output>

pub fn mul_div_ceil(
    self,
    num: &Default,
    denom: &Default
) -> Option<<&'a Default as MulDiv<&'b Default>>::Output>

impl<'a> MulDiv<u64> for Bytes

type Output = Bytes

pub fn mul_div_floor(
    self,
    num: u64,
    denom: u64
) -> Option<<Bytes as MulDiv<u64>>::Output>

pub fn mul_div_round(
    self,
    num: u64,
    denom: u64
) -> Option<<Bytes as MulDiv<u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: u64,
    denom: u64
) -> Option<<Bytes as MulDiv<u64>>::Output>

impl<'a> MulDiv<u64> for &'a Buffers

type Output = Buffers

pub fn mul_div_floor(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Buffers as MulDiv<u64>>::Output>

pub fn mul_div_round(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Buffers as MulDiv<u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Buffers as MulDiv<u64>>::Output>

impl<'a> MulDiv<&'a Bytes> for Bytes

type Output = Bytes

pub fn mul_div_floor(
    self,
    num: &Bytes,
    denom: &Bytes
) -> Option<<Bytes as MulDiv<&'a Bytes>>::Output>

pub fn mul_div_round(
    self,
    num: &Bytes,
    denom: &Bytes
) -> Option<<Bytes as MulDiv<&'a Bytes>>::Output>

pub fn mul_div_ceil(
    self,
    num: &Bytes,
    denom: &Bytes
) -> Option<<Bytes as MulDiv<&'a Bytes>>::Output>

impl<'a> MulDiv<&'a Default> for Default

type Output = Default

pub fn mul_div_floor(
    self,
    num: &Default,
    denom: &Default
) -> Option<<Default as MulDiv<&'a Default>>::Output>

pub fn mul_div_round(
    self,
    num: &Default,
    denom: &Default
) -> Option<<Default as MulDiv<&'a Default>>::Output>

pub fn mul_div_ceil(
    self,
    num: &Default,
    denom: &Default
) -> Option<<Default as MulDiv<&'a Default>>::Output>

impl<'a> MulDiv<&'a ClockTime> for ClockTime

type Output = ClockTime

pub fn mul_div_floor(
    self,
    num: &ClockTime,
    denom: &ClockTime
) -> Option<<ClockTime as MulDiv<&'a ClockTime>>::Output>

pub fn mul_div_round(
    self,
    num: &ClockTime,
    denom: &ClockTime
) -> Option<<ClockTime as MulDiv<&'a ClockTime>>::Output>

pub fn mul_div_ceil(
    self,
    num: &ClockTime,
    denom: &ClockTime
) -> Option<<ClockTime as MulDiv<&'a ClockTime>>::Output>

impl MulDiv<Buffers> for Buffers

type Output = Buffers

pub fn mul_div_floor(
    self,
    num: Buffers,
    denom: Buffers
) -> Option<<Buffers as MulDiv<Buffers>>::Output>

pub fn mul_div_round(
    self,
    num: Buffers,
    denom: Buffers
) -> Option<<Buffers as MulDiv<Buffers>>::Output>

pub fn mul_div_ceil(
    self,
    num: Buffers,
    denom: Buffers
) -> Option<<Buffers as MulDiv<Buffers>>::Output>

impl<'a> MulDiv<u64> for &'a Bytes

type Output = Bytes

pub fn mul_div_floor(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Bytes as MulDiv<u64>>::Output>

pub fn mul_div_round(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Bytes as MulDiv<u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a Bytes as MulDiv<u64>>::Output>

impl<'a, 'b> MulDiv<&'b ClockTime> for &'a ClockTime

type Output = ClockTime

pub fn mul_div_floor(
    self,
    num: &ClockTime,
    denom: &ClockTime
) -> Option<<&'a ClockTime as MulDiv<&'b ClockTime>>::Output>

pub fn mul_div_round(
    self,
    num: &ClockTime,
    denom: &ClockTime
) -> Option<<&'a ClockTime as MulDiv<&'b ClockTime>>::Output>

pub fn mul_div_ceil(
    self,
    num: &ClockTime,
    denom: &ClockTime
) -> Option<<&'a ClockTime as MulDiv<&'b ClockTime>>::Output>

impl<'a, 'b> MulDiv<&'a u64> for &'b Buffers

type Output = Buffers

pub fn mul_div_floor(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Buffers as MulDiv<&'a u64>>::Output>

pub fn mul_div_round(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Buffers as MulDiv<&'a u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Buffers as MulDiv<&'a u64>>::Output>

impl<'a> MulDiv<Buffers> for &'a Buffers

type Output = Buffers

pub fn mul_div_floor(
    self,
    num: Buffers,
    denom: Buffers
) -> Option<<&'a Buffers as MulDiv<Buffers>>::Output>

pub fn mul_div_round(
    self,
    num: Buffers,
    denom: Buffers
) -> Option<<&'a Buffers as MulDiv<Buffers>>::Output>

pub fn mul_div_ceil(
    self,
    num: Buffers,
    denom: Buffers
) -> Option<<&'a Buffers as MulDiv<Buffers>>::Output>

impl<'a> MulDiv<u64> for &'a ClockTime

type Output = ClockTime

pub fn mul_div_floor(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a ClockTime as MulDiv<u64>>::Output>

pub fn mul_div_round(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a ClockTime as MulDiv<u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: u64,
    denom: u64
) -> Option<<&'a ClockTime as MulDiv<u64>>::Output>

impl<'a, 'b> MulDiv<&'a u64> for &'b Bytes

type Output = Bytes

pub fn mul_div_floor(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Bytes as MulDiv<&'a u64>>::Output>

pub fn mul_div_round(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Bytes as MulDiv<&'a u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Bytes as MulDiv<&'a u64>>::Output>

impl<'a> MulDiv<&'a u64> for ClockTime

type Output = ClockTime

pub fn mul_div_floor(
    self,
    num: &u64,
    denom: &u64
) -> Option<<ClockTime as MulDiv<&'a u64>>::Output>

pub fn mul_div_round(
    self,
    num: &u64,
    denom: &u64
) -> Option<<ClockTime as MulDiv<&'a u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: &u64,
    denom: &u64
) -> Option<<ClockTime as MulDiv<&'a u64>>::Output>

impl<'a> MulDiv<&'a u64> for Bytes

type Output = Bytes

pub fn mul_div_floor(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Bytes as MulDiv<&'a u64>>::Output>

pub fn mul_div_round(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Bytes as MulDiv<&'a u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Bytes as MulDiv<&'a u64>>::Output>

impl<'a, 'b> MulDiv<&'a u64> for &'b Default

type Output = Default

pub fn mul_div_floor(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Default as MulDiv<&'a u64>>::Output>

pub fn mul_div_round(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Default as MulDiv<&'a u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b Default as MulDiv<&'a u64>>::Output>

impl<'a> MulDiv<&'a u64> for Buffers

type Output = Buffers

pub fn mul_div_floor(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Buffers as MulDiv<&'a u64>>::Output>

pub fn mul_div_round(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Buffers as MulDiv<&'a u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: &u64,
    denom: &u64
) -> Option<<Buffers as MulDiv<&'a u64>>::Output>

impl MulDiv<ClockTime> for ClockTime

type Output = ClockTime

pub fn mul_div_floor(
    self,
    num: ClockTime,
    denom: ClockTime
) -> Option<<ClockTime as MulDiv<ClockTime>>::Output>

pub fn mul_div_round(
    self,
    num: ClockTime,
    denom: ClockTime
) -> Option<<ClockTime as MulDiv<ClockTime>>::Output>

pub fn mul_div_ceil(
    self,
    num: ClockTime,
    denom: ClockTime
) -> Option<<ClockTime as MulDiv<ClockTime>>::Output>

impl<'a> MulDiv<u64> for ClockTime

type Output = ClockTime

pub fn mul_div_floor(
    self,
    num: u64,
    denom: u64
) -> Option<<ClockTime as MulDiv<u64>>::Output>

pub fn mul_div_round(
    self,
    num: u64,
    denom: u64
) -> Option<<ClockTime as MulDiv<u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: u64,
    denom: u64
) -> Option<<ClockTime as MulDiv<u64>>::Output>

impl<'a> MulDiv<Bytes> for &'a Bytes

type Output = Bytes

pub fn mul_div_floor(
    self,
    num: Bytes,
    denom: Bytes
) -> Option<<&'a Bytes as MulDiv<Bytes>>::Output>

pub fn mul_div_round(
    self,
    num: Bytes,
    denom: Bytes
) -> Option<<&'a Bytes as MulDiv<Bytes>>::Output>

pub fn mul_div_ceil(
    self,
    num: Bytes,
    denom: Bytes
) -> Option<<&'a Bytes as MulDiv<Bytes>>::Output>

impl<'a> MulDiv<&'a Buffers> for Buffers

type Output = Buffers

pub fn mul_div_floor(
    self,
    num: &Buffers,
    denom: &Buffers
) -> Option<<Buffers as MulDiv<&'a Buffers>>::Output>

pub fn mul_div_round(
    self,
    num: &Buffers,
    denom: &Buffers
) -> Option<<Buffers as MulDiv<&'a Buffers>>::Output>

pub fn mul_div_ceil(
    self,
    num: &Buffers,
    denom: &Buffers
) -> Option<<Buffers as MulDiv<&'a Buffers>>::Output>

impl<'a, 'b> MulDiv<&'a u64> for &'b ClockTime

type Output = ClockTime

pub fn mul_div_floor(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b ClockTime as MulDiv<&'a u64>>::Output>

pub fn mul_div_round(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b ClockTime as MulDiv<&'a u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: &u64,
    denom: &u64
) -> Option<<&'b ClockTime as MulDiv<&'a u64>>::Output>

impl<'a> MulDiv<Default> for &'a Default

type Output = Default

pub fn mul_div_floor(
    self,
    num: Default,
    denom: Default
) -> Option<<&'a Default as MulDiv<Default>>::Output>

pub fn mul_div_round(
    self,
    num: Default,
    denom: Default
) -> Option<<&'a Default as MulDiv<Default>>::Output>

pub fn mul_div_ceil(
    self,
    num: Default,
    denom: Default
) -> Option<<&'a Default as MulDiv<Default>>::Output>

impl<'a> MulDiv<ClockTime> for &'a ClockTime

type Output = ClockTime

pub fn mul_div_floor(
    self,
    num: ClockTime,
    denom: ClockTime
) -> Option<<&'a ClockTime as MulDiv<ClockTime>>::Output>

pub fn mul_div_round(
    self,
    num: ClockTime,
    denom: ClockTime
) -> Option<<&'a ClockTime as MulDiv<ClockTime>>::Output>

pub fn mul_div_ceil(
    self,
    num: ClockTime,
    denom: ClockTime
) -> Option<<&'a ClockTime as MulDiv<ClockTime>>::Output>

impl<'a> MulDiv<u64> for Buffers

type Output = Buffers

pub fn mul_div_floor(
    self,
    num: u64,
    denom: u64
) -> Option<<Buffers as MulDiv<u64>>::Output>

pub fn mul_div_round(
    self,
    num: u64,
    denom: u64
) -> Option<<Buffers as MulDiv<u64>>::Output>

pub fn mul_div_ceil(
    self,
    num: u64,
    denom: u64
) -> Option<<Buffers as MulDiv<u64>>::Output>

impl MulDiv<Bytes> for Bytes

type Output = Bytes

pub fn mul_div_floor(
    self,
    num: Bytes,
    denom: Bytes
) -> Option<<Bytes as MulDiv<Bytes>>::Output>

pub fn mul_div_round(
    self,
    num: Bytes,
    denom: Bytes
) -> Option<<Bytes as MulDiv<Bytes>>::Output>

pub fn mul_div_ceil(
    self,
    num: Bytes,
    denom: Bytes
) -> Option<<Bytes as MulDiv<Bytes>>::Output>

impl MulDiv<u64> for u64

type Output = u64

pub fn mul_div_floor(self, num: u64, denom: u64) -> Option<u64>

pub fn mul_div_round(self, num: u64, denom: u64) -> Option<u64>

pub fn mul_div_ceil(self, num: u64, denom: u64) -> Option<u64>

impl MulDiv<i64> for i64

type Output = i64

pub fn mul_div_floor(self, num: i64, denom: i64) -> Option<i64>

pub fn mul_div_round(self, num: i64, denom: i64) -> Option<i64>

pub fn mul_div_ceil(self, num: i64, denom: i64) -> Option<i64>

impl MulDiv<u8> for u8

type Output = u8

pub fn mul_div_floor(self, num: u8, denom: u8) -> Option<u8>

pub fn mul_div_round(self, num: u8, denom: u8) -> Option<u8>

pub fn mul_div_ceil(self, num: u8, denom: u8) -> Option<u8>

impl MulDiv<u16> for u16

type Output = u16

pub fn mul_div_floor(self, num: u16, denom: u16) -> Option<u16>

pub fn mul_div_round(self, num: u16, denom: u16) -> Option<u16>

pub fn mul_div_ceil(self, num: u16, denom: u16) -> Option<u16>

impl MulDiv<u32> for u32

type Output = u32

pub fn mul_div_floor(self, num: u32, denom: u32) -> Option<u32>

pub fn mul_div_round(self, num: u32, denom: u32) -> Option<u32>

pub fn mul_div_ceil(self, num: u32, denom: u32) -> Option<u32>

impl MulDiv<i16> for i16

type Output = i16

pub fn mul_div_floor(self, num: i16, denom: i16) -> Option<i16>

pub fn mul_div_round(self, num: i16, denom: i16) -> Option<i16>

pub fn mul_div_ceil(self, num: i16, denom: i16) -> Option<i16>

impl MulDiv<i8> for i8

type Output = i8

pub fn mul_div_floor(self, num: i8, denom: i8) -> Option<i8>

pub fn mul_div_round(self, num: i8, denom: i8) -> Option<i8>

pub fn mul_div_ceil(self, num: i8, denom: i8) -> Option<i8>

impl MulDiv<i32> for i32

type Output = i32

pub fn mul_div_floor(self, num: i32, denom: i32) -> Option<i32>

pub fn mul_div_round(self, num: i32, denom: i32) -> Option<i32>

pub fn mul_div_ceil(self, num: i32, denom: i32) -> Option<i32>

Loading content...

Implementors

Loading content...