# [−][src]Trait sp_arithmetic::PerThing

```pub trait PerThing: Sized + Saturating + Copy + Default + Eq + PartialEq + Ord + PartialOrd + Bounded + Debug {
type Inner: BaseArithmetic + Unsigned + Copy + Debug;
type Upper: BaseArithmetic + Copy + From<Self::Inner> + TryInto<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Unsigned + Debug;

const ACCURACY: Self::Inner;

fn deconstruct(self) -> Self::Inner;
fn from_parts(parts: Self::Inner) -> Self;
fn from_fraction(x: f64) -> Self;
fn from_rational_approximation<N>(p: N, q: N) -> Self    where        N: Clone + Ord + From<Self::Inner> + TryInto<Self::Inner> + TryInto<Self::Upper> + Div<N, Output = N> + Rem<N, Output = N> + Add<N, Output = N> + Unsigned;

fn zero() -> Self { ... }
fn is_zero(&self) -> bool { ... }
fn one() -> Self { ... }
fn is_one(&self) -> bool { ... }
fn from_percent(x: Self::Inner) -> Self { ... }
fn square(self) -> Self { ... }
fn mul_floor<N>(self, b: N) -> N    where        N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Unsigned,
{ ... }
fn mul_ceil<N>(self, b: N) -> N    where        N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Unsigned,
{ ... }
fn saturating_reciprocal_mul<N>(self, b: N) -> N    where        N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Saturating + Unsigned,
{ ... }
fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N    where        N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Saturating + Unsigned,
{ ... }
fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N    where        N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Saturating + Unsigned,
{ ... }
}```

Something that implements a fixed point ration with an arbitrary granularity `X`, as parts per `X`.

## Associated Types

### `type Inner: BaseArithmetic + Unsigned + Copy + Debug`

The data type used to build this per-thingy.

### `type Upper: BaseArithmetic + Copy + From<Self::Inner> + TryInto<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Unsigned + Debug`

A data type larger than `Self::Inner`, used to avoid overflow in some computations. It must be able to compute `ACCURACY^2`.

## Associated Constants

### `const ACCURACY: Self::Inner`

The accuracy of this type.

## Required methods

### `fn deconstruct(self) -> Self::Inner`

Consume self and return the number of parts per thing.

### `fn from_parts(parts: Self::Inner) -> Self`

Build this type from a number of parts per thing.

### `fn from_fraction(x: f64) -> Self`

Converts a fraction into `Self`.

### `fn from_rational_approximation<N>(p: N, q: N) -> Self where    N: Clone + Ord + From<Self::Inner> + TryInto<Self::Inner> + TryInto<Self::Upper> + Div<N, Output = N> + Rem<N, Output = N> + Add<N, Output = N> + Unsigned, `

Approximate the fraction `p/q` into a per-thing fraction. This will never overflow.

The computation of this approximation is performed in the generic type `N`. Given `M` as the data type that can hold the maximum value of this per-thing (e.g. u32 for perbill), this can only work if `N == M` or `N: From<M> + TryInto<M>`.

Note that this always rounds down, i.e.

```// 989/100 is technically closer to 99%.
assert_eq!(
Percent::from_rational_approximation(989u64, 1000),
Percent::from_parts(98),
);```

## Provided methods

### `fn zero() -> Self`

Equivalent to `Self::from_parts(0)`.

### `fn is_zero(&self) -> bool`

Return `true` if this is nothing.

### `fn one() -> Self`

Equivalent to `Self::from_parts(Self::ACCURACY)`.

### `fn is_one(&self) -> bool`

Return `true` if this is one.

### `fn from_percent(x: Self::Inner) -> Self`

Build this type from a percent. Equivalent to `Self::from_parts(x * Self::ACCURACY / 100)` but more accurate.

### `fn square(self) -> Self`

Return the product of multiplication of this value by itself.

### `fn mul_floor<N>(self, b: N) -> N where    N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Unsigned, `

Multiplication that always rounds down to a whole number. The standard `Mul` rounds to the nearest whole number.

```// round to nearest
assert_eq!(Percent::from_percent(34) * 10u64, 3);
assert_eq!(Percent::from_percent(36) * 10u64, 4);

// round down
assert_eq!(Percent::from_percent(34).mul_floor(10u64), 3);
assert_eq!(Percent::from_percent(36).mul_floor(10u64), 3);```

### `fn mul_ceil<N>(self, b: N) -> N where    N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Unsigned, `

Multiplication that always rounds the result up to a whole number. The standard `Mul` rounds to the nearest whole number.

```// round to nearest
assert_eq!(Percent::from_percent(34) * 10u64, 3);
assert_eq!(Percent::from_percent(36) * 10u64, 4);

// round up
assert_eq!(Percent::from_percent(34).mul_ceil(10u64), 4);
assert_eq!(Percent::from_percent(36).mul_ceil(10u64), 4);```

### `fn saturating_reciprocal_mul<N>(self, b: N) -> N where    N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Saturating + Unsigned, `

Saturating multiplication by the reciprocal of `self`. The result is rounded to the nearest whole number and saturates at the numeric bounds instead of overflowing.

`assert_eq!(Percent::from_percent(50).saturating_reciprocal_mul(10u64), 20);`

### `fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N where    N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Saturating + Unsigned, `

Saturating multiplication by the reciprocal of `self`. The result is rounded down to the nearest whole number and saturates at the numeric bounds instead of overflowing.

```// round to nearest
assert_eq!(Percent::from_percent(60).saturating_reciprocal_mul(10u64), 17);
// round down
assert_eq!(Percent::from_percent(60).saturating_reciprocal_mul_floor(10u64), 16);```

### `fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N where    N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Rem<N, Output = N> + Div<N, Output = N> + Mul<N, Output = N> + Add<N, Output = N> + Saturating + Unsigned, `

Saturating multiplication by the reciprocal of `self`. The result is rounded up to the nearest whole number and saturates at the numeric bounds instead of overflowing.

```// round to nearest
assert_eq!(Percent::from_percent(61).saturating_reciprocal_mul(10u64), 16);
// round up
assert_eq!(Percent::from_percent(61).saturating_reciprocal_mul_ceil(10u64), 17);```

## Implementors

### `impl PerThing for PerU16`[src]

#### `fn deconstruct(self) -> Self::Inner`[src]

Consume self and return the number of parts per thing.

#### `fn from_parts(parts: Self::Inner) -> Self`[src]

Build this type from a number of parts per thing.

#### `fn from_fraction(x: f64) -> Self`[src]

NOTE: saturate to 0 or 1 if x is beyond `[0, 1]`

### `impl PerThing for Perbill`[src]

#### `fn deconstruct(self) -> Self::Inner`[src]

Consume self and return the number of parts per thing.

#### `fn from_parts(parts: Self::Inner) -> Self`[src]

Build this type from a number of parts per thing.

#### `fn from_fraction(x: f64) -> Self`[src]

NOTE: saturate to 0 or 1 if x is beyond `[0, 1]`

### `impl PerThing for Percent`[src]

#### `fn deconstruct(self) -> Self::Inner`[src]

Consume self and return the number of parts per thing.

#### `fn from_parts(parts: Self::Inner) -> Self`[src]

Build this type from a number of parts per thing.

#### `fn from_fraction(x: f64) -> Self`[src]

NOTE: saturate to 0 or 1 if x is beyond `[0, 1]`

### `impl PerThing for Permill`[src]

#### `fn deconstruct(self) -> Self::Inner`[src]

Consume self and return the number of parts per thing.

#### `fn from_parts(parts: Self::Inner) -> Self`[src]

Build this type from a number of parts per thing.

#### `fn from_fraction(x: f64) -> Self`[src]

NOTE: saturate to 0 or 1 if x is beyond `[0, 1]`

### `impl PerThing for Perquintill`[src]

#### `fn deconstruct(self) -> Self::Inner`[src]

Consume self and return the number of parts per thing.

#### `fn from_parts(parts: Self::Inner) -> Self`[src]

Build this type from a number of parts per thing.

#### `fn from_fraction(x: f64) -> Self`[src]

NOTE: saturate to 0 or 1 if x is beyond `[0, 1]`