Enum fraction::GenericFraction

pub enum GenericFraction<T> where
    T: Clone + Integer,  {
    Rational(Sign, Ratio<T>),
    Infinity(Sign),
    NaN,
}

Generic implementation of the fraction type

Examples

use fraction::GenericFraction;

type F = GenericFraction<u8>;

let first = F::new (1u8, 2u8);
let second = F::new (2u8, 8u8);

assert_eq! (first + second, F::new (3u8, 4u8));

Since GenericFraction keeps its sign explicitly and independently of the numerics, it is not recommended to use signed types, although it's completely valid with the cost of target type capacity.

use fraction::GenericFraction;

type F = GenericFraction<i8>;

let first = F::new (1, 2);
let second = F::new (2, 8);

assert_eq! (first + second, F::new (3, 4));

Variants

Rational(Sign, Ratio<T>)Infinity(Sign)NaN

Methods

impl<T> GenericFraction<T> where     T: Clone + Integer,

pub fn new_generic<N, D>(     sign: Sign,     num: N,     den: D ) -> Option<GenericFraction<T>> where     N: GenericInteger + PartialOrd,     D: GenericInteger + PartialOrd,     T: GenericInteger,

Constructs a new fraction with the specified numerator and denominator Handles gracefully signed integers even if the storage type is unsigned and vise versa The arguments can be of any integer types imlementing the necessary traits

Examples

use fraction::{GenericFraction, Sign};
type F = GenericFraction<u16>;

let f12 = F::new_generic(Sign::Plus, 1i8, 2u8).unwrap();
let f34 = F::new_generic(Sign::Plus, 3i16, 4u32).unwrap();
let f56 = F::new_generic(Sign::Plus, 5i64, 6u128).unwrap();
let f78 = F::new_generic(Sign::Plus, 7usize, 8isize).unwrap();

assert_eq! ((*f12.numer().unwrap(), *f12.denom().unwrap()), (1u16, 2u16));
assert_eq! ((*f34.numer().unwrap(), *f34.denom().unwrap()), (3u16, 4u16));
assert_eq! ((*f56.numer().unwrap(), *f56.denom().unwrap()), (5u16, 6u16));
assert_eq! ((*f78.numer().unwrap(), *f78.denom().unwrap()), (7u16, 8u16));

pub fn new<N, D>(num: N, den: D) -> GenericFraction<T> where     N: Into<T>,     D: Into<T>,

Constructs a new fraction with the specified numerator and denominator

The arguments must me either of T type, or implement Into<T> trait.

Examples

use fraction::GenericFraction;
type F = GenericFraction<u16>;

let _f = F::new(1u8, 2u16);

pub fn new_neg<N, D>(num: N, den: D) -> GenericFraction<T> where     N: Into<T>,     D: Into<T>,

Constructs a new negative fraction with the specified numerator and denominator

The arguments must be either of T type, or implement Into<T> trait.

Examples

use fraction::GenericFraction;
type F = GenericFraction<u16>;

let _f = F::new_neg (1u8, 2u16);

pub fn new_raw(num: T, den: T) -> GenericFraction<T>

Constructs a new fraction without types casting, checking for denom == 0 and reducing numbers.

You must be careful with this function because all the other functionality parts rely on the numbers to be reduced. That said, in the normal case 2/4 has to be reduced to 1/2, but it will not happen with new_raw.

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

let _f = F::new_raw (1u8, 2u8);

pub fn new_raw_neg(num: T, den: T) -> GenericFraction<T>

The same as fn new_raw, but produces negative fractions.

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

let _f = F::new_raw_neg (1u8, 2u8);

pub fn new_nan() -> GenericFraction<T>

Deprecated

: Use ::nan()

Constructs NaN value
DEPRECATED! Use nan

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

let _nan = F::new_nan ();

pub fn new_inf() -> GenericFraction<T>

Deprecated

: Use ::infinity()

Constructs INF value
DEPRECATED! Use infinity

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

let _nan = F::new_inf ();

pub fn new_inf_neg() -> GenericFraction<T>

Deprecated

: Use ::neg_infinity()

Constructs negative INF value DEPRECATED! Use neg_infinity

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

let _nan = F::new_inf_neg ();

pub fn numer(&self) -> Option<&T>

Returns a reference to the numerator value

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

let fra = F::new (5u8, 6u8);
assert_eq! (5, *fra.numer ().unwrap ());

pub fn denom(&self) -> Option<&T>

Returns a reference to the denominator value

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

let fra = F::new (5u8, 6u8);
assert_eq! (6, *fra.denom ().unwrap ());

pub fn sign(&self) -> Option<Sign>

Returns a reference to the sign value

Examples

use fraction::{ GenericFraction, Sign };
type F = GenericFraction<u8>;


let fra = F::new (5u8, 6u8);
assert_eq! (Sign::Plus, fra.sign ().unwrap ());

let fra = F::new_neg (5u8, 6u8);
assert_eq! (Sign::Minus, fra.sign ().unwrap ());


let fra = F::new_inf ();
assert_eq! (Sign::Plus, fra.sign ().unwrap ());

let fra = F::new_inf_neg ();
assert_eq! (Sign::Minus, fra.sign ().unwrap ());


let fra = F::new_nan ();
assert_eq! (None, fra.sign ());

pub fn from_fraction<F>(from: GenericFraction<F>) -> GenericFraction<T> where     T: From<F>,     F: Clone + Integer,

Generates a GenericFraction from a GenericFraction simply casting underlying values of F into T.

use fraction::{ Fraction, GenericFraction };
type F8 = GenericFraction<u8>;

let fra8 = F8::new (5u8, 6u8);
assert_eq! (Fraction::new (5u64, 6u64), Fraction::from_fraction(fra8));

pub fn into_big(self) -> BigFraction where     T: Into<BigUint>,

Deprecated

: Use BigFraction::from_fraction instead

Generates a new BigFraction from the current one DEPRECATED! Use BigFraction::from_fraction instead

Examples

use fraction::{ BigFraction, GenericFraction };
type F = GenericFraction<u8>;

let fra = F::new (5u8, 6u8);
assert_eq! (BigFraction::new (5u8, 6u8), fra.into_big());

pub fn format_as_float(&self) -> Option<String> where     T: Clone + GenericInteger,

Deprecated

: Use format_as_decimal instead

Returns a float representation of the fraction with precision up to 64 digits

DEPRECATED! Use format_as_decimal

Returns None in case we couldn't write the result into a string, e.g. not enough RAM.

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! ("0.5", &F::new (1u8, 2u8).format_as_float ().unwrap ());
assert_eq! ("0.8", &F::new (8u8, 10u8).format_as_float ().unwrap ());
assert_eq! (&F::new (1u8, 3u8).format_as_float().unwrap(), "0.3333333333333333333333333333333333333333333333333333333333333333");

pub fn format_as_decimal(&self, precision: usize) -> Option<String> where     T: Clone + GenericInteger,

Returns a decimal representation of the fraction

If you have a fraction "1/2", in decimal it should be "0.5".

Returns None in case we couldn't write the result into a string, e.g. not enough RAM.

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! ("0.5", &F::new (1u8, 2u8).format_as_decimal (1).unwrap ());
assert_eq! ("0.8", &F::new (8u8, 10u8).format_as_decimal (2).unwrap ());
assert_eq! (&F::new (1u8, 3u8).format_as_decimal(32).unwrap(), "0.33333333333333333333333333333333");

pub fn from_decimal_str(src: &str) -> Result<Self, ParseError> where     T: CheckedAdd + CheckedMul,

Parse a decimal string into a fraction and return the result. Returns ParseError::OverflowError if there's not enough space in T to represent the decimal (use BigFraction in such a case) Returns ParseError::ParseIntError if the string contains incorrect junk data (e.g. non-numeric characters). May return ParseIntError if there is not enough volume in T to read whole part of the number into it.

Examples

use fraction::Fraction;

let f = Fraction::from_decimal_str ("1.5");
assert_eq! (f, Ok (Fraction::new(3u8, 2u8)));

impl<T: Clone + Integer> GenericFraction<T>

pub fn nan() -> Self

Returns NaN value

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::nan (), F::new (0, 0));

pub fn infinity() -> Self

Returns positive Infinity value

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::infinity (), F::new (1, 0));

pub fn neg_infinity() -> Self

Returns negative Infinity value

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::neg_infinity (), F::new_neg (1, 0));

pub fn neg_zero() -> Self

Returns zero with negative sign

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::neg_zero (), F::new_neg (0, 1));

pub fn min_positive_value() -> Self where     T: Bounded,

Returns minimal value greater than zero

Examples

use fraction::GenericFraction;
type F8 = GenericFraction<u8>;
type F16 = GenericFraction<u16>;

assert_eq! (F8::min_positive_value (), F8::new (1u8, 255u8));
assert_eq! (F16::min_positive_value (), F16::new (1u16, 65535u16));

pub fn is_nan(&self) -> bool

Returns true if the value is NaN

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert! (F::nan ().is_nan ());
assert! (F::new (0, 0).is_nan ());

pub fn is_infinite(&self) -> bool

Returns true if the value is Infinity (does not matter positive or negative)

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert! (F::infinity ().is_infinite ());
assert! (F::new (1u8, 0).is_infinite ());
assert! (F::new_neg (1u8, 0).is_infinite ());

pub fn is_finite(&self) -> bool

Returns true if the value is not Infinity (does not matter positive or negative)

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert! (! F::infinity ().is_finite ());
assert! (! F::new (1u8, 0).is_finite ());
assert! (! F::new_neg (1u8, 0).is_finite ());

pub fn is_normal(&self) -> bool

Returns true if the number is neither zero, Infinity or NaN

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert! (! F::nan ().is_normal ());
assert! (! F::infinity ().is_normal ());
assert! (! F::neg_infinity ().is_normal ());
assert! (! F::new (0, 1u8).is_normal ());
assert! (! F::neg_zero ().is_normal ());

pub fn classify(&self) -> FpCategory

Returns the floating point category of the number

Examples

use std::num::FpCategory;
use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::nan ().classify (), FpCategory::Nan);
assert_eq! (F::infinity ().classify (), FpCategory::Infinite);
assert_eq! (F::new (0, 1u8).classify (), FpCategory::Zero);
assert_eq! (F::new (1u8, 1u8).classify (), FpCategory::Normal);

pub fn floor(&self) -> Self

Returns the largest integer less than or equal to the value

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::new (7u8, 5u8).floor (), F::new (5u8, 5u8));

pub fn ceil(&self) -> Self

Returns the smallest integer greater than or equal to the value

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::new (7u8, 5u8).ceil (), F::new (10u8, 5u8));

pub fn round(&self) -> Self

Returns the nearest integer to the value (.5 goes up)

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::new (7u8, 5u8).round (), F::new (5u8, 5u8));
assert_eq! (F::new (8u8, 5u8).round (), F::new (10u8, 5u8));
assert_eq! (F::new (3u8, 2u8).round (), F::new (4u8, 2u8));
assert_eq! (F::new (1u8, 2u8).round (), F::new (2u8, 2u8));

pub fn trunc(&self) -> Self

Returns the integer part of the value

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::new (7u8, 5u8).trunc (), F::new (5u8, 5u8));
assert_eq! (F::new (8u8, 5u8).trunc (), F::new (5u8, 5u8));

pub fn fract(&self) -> Self

Returns the fractional part of a number

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::new (7u8, 5u8).fract (), F::new (2u8, 5u8));
assert_eq! (F::new (8u8, 5u8).fract (), F::new (3u8, 5u8));

pub fn abs(&self) -> Self

Returns the absolute value of self

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::nan ().abs (), F::nan ());
assert_eq! (F::infinity ().abs (), F::infinity ());
assert_eq! (F::neg_infinity ().abs (), F::infinity ());
assert_eq! (F::new (1u8, 2u8).abs (), F::new (1u8, 2u8));
assert_eq! (F::new_neg (1u8, 2u8).abs (), F::new (1u8, 2u8));

pub fn signum(&self) -> Self

Returns a number that represents the sign of self

• 1.0 if the number is positive, +0.0 or INFINITY
• -1.0 if the number is negative, -0.0 or NEG_INFINITY
• NAN if the number is NAN

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::new (1u8, 2u8).signum (), F::new (1u8, 1u8));
assert_eq! (F::new (0u8, 1u8).signum (), F::new (1u8, 1u8));
assert_eq! (F::infinity ().signum (), F::new (1u8, 1u8));
assert_eq! (F::new_neg (1u8, 2u8).signum (), F::new_neg (1u8, 1u8));
assert_eq! (F::neg_zero ().signum (), F::new_neg (1u8, 1u8));
assert_eq! (F::neg_infinity ().signum (), F::new_neg (1u8, 1u8));
assert_eq! (F::nan ().signum (), F::nan ());

pub fn is_sign_positive(&self) -> bool

Returns true if the sign is positive

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert! (F::new (1u8, 2u8).is_sign_positive ());
assert! (F::infinity ().is_sign_positive ());
assert! (! F::nan ().is_sign_positive ());

pub fn is_sign_negative(&self) -> bool

Returns true if the sign is negative

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert! (F::new_neg (1u8, 2u8).is_sign_negative ());
assert! (F::neg_zero ().is_sign_negative ());
assert! (F::neg_infinity ().is_sign_negative ());
assert! (! F::nan ().is_sign_negative ());

pub fn mul_add(&self, a: Self, b: Self) -> Self

self.clone () * a + b

Added for interface compatibility with float types

pub fn recip(&self) -> Self

Takes the reciprocal (inverse) of the value (1/x)

Examples

use fraction::GenericFraction;
type F = GenericFraction<u8>;

assert_eq! (F::new (1u8, 2u8).recip (), F::new (2u8, 1u8));
assert_eq! (F::new (0u8, 1u8).recip (), F::infinity ());
assert_eq! (F::infinity ().recip (), F::new (0u8, 1u8));
assert_eq! (F::nan ().recip (), F::nan ());

Trait Implementations

impl<T, F> TryToConvertFrom<GenericFraction<F>> for GenericFraction<T> where     T: TryToConvertFrom<F> + Clone + Integer,     F: Clone + Integer,

fn try_to_convert_from(src: GenericFraction<F>) -> Option<Self>

impl<T: Clone + Integer> PartialOrd<GenericFraction<T>> for GenericFraction<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Clone + Integer> PartialEq<GenericFraction<T>> for GenericFraction<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> From<BigUint> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     BigUint: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: BigUint) -> GenericFraction<T>

Performs the conversion.

impl<T> From<BigInt> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     BigInt: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: BigInt) -> GenericFraction<T>

Performs the conversion.

impl<T> From<u8> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     u8: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: u8) -> GenericFraction<T>

Performs the conversion.

impl<T> From<i8> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     i8: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: i8) -> GenericFraction<T>

Performs the conversion.

impl<T> From<u16> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     u16: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: u16) -> GenericFraction<T>

Performs the conversion.

impl<T> From<i16> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     i16: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: i16) -> GenericFraction<T>

Performs the conversion.

impl<T> From<u32> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     u32: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: u32) -> GenericFraction<T>

Performs the conversion.

impl<T> From<i32> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     i32: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: i32) -> GenericFraction<T>

Performs the conversion.

impl<T> From<u64> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     u64: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: u64) -> GenericFraction<T>

Performs the conversion.

impl<T> From<i64> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     i64: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: i64) -> GenericFraction<T>

Performs the conversion.

impl<T> From<u128> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     u128: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: u128) -> GenericFraction<T>

Performs the conversion.

impl<T> From<i128> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     i128: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: i128) -> GenericFraction<T>

Performs the conversion.

impl<T> From<usize> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     usize: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: usize) -> GenericFraction<T>

Performs the conversion.

impl<T> From<isize> for GenericFraction<T> where     T: Clone + Integer + GenericInteger + CheckedAdd + CheckedMul + CheckedSub,     isize: GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + PartialOrd,

fn from(val: isize) -> GenericFraction<T>

Performs the conversion.

impl<T: Clone + Integer + CheckedAdd + CheckedMul + CheckedSub> From<f32> for GenericFraction<T>

fn from(val: f32) -> GenericFraction<T>

Performs the conversion.

impl<T: Clone + Integer + CheckedAdd + CheckedMul + CheckedSub> From<f64> for GenericFraction<T>

fn from(val: f64) -> GenericFraction<T>

Performs the conversion.

impl<T, N, D> From<(N, D)> for GenericFraction<T> where     T: Clone + Integer,     N: Display,     D: Display,

fn from(pair: (N, D)) -> GenericFraction<T>

Performs the conversion.

impl<T: Clone> Clone for GenericFraction<T> where     T: Clone + Integer,

fn clone(&self) -> GenericFraction<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Copy for GenericFraction<T> where     T: Copy + Integer,

Copy semantics to be applied for the target type, but only if T also has it.

impl<T: Clone + Integer> Eq for GenericFraction<T>

impl<T: Debug> Debug for GenericFraction<T> where     T: Clone + Integer,

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Display + Eq + One + Clone + Integer> Display for GenericFraction<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Clone + Integer> Sub<GenericFraction<T>> for GenericFraction<T>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl<'a, T> Sub<&'a GenericFraction<T>> for &'a GenericFraction<T> where     T: Clone + Integer,

type Output = GenericFraction<T>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> GenericFraction<T>

Performs the - operation.

impl<T: Clone + Integer> Add<GenericFraction<T>> for GenericFraction<T>

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<'a, T> Add<&'a GenericFraction<T>> for &'a GenericFraction<T> where     T: Clone + Integer,

type Output = GenericFraction<T>

The resulting type after applying the + operator.

fn add(self, other: Self) -> GenericFraction<T>

Performs the + operation.

impl<T: Clone + Integer> Mul<GenericFraction<T>> for GenericFraction<T>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<'a, T> Mul<&'a GenericFraction<T>> for &'a GenericFraction<T> where     T: Clone + Integer,

type Output = GenericFraction<T>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> GenericFraction<T>

Performs the * operation.

impl<T: Clone + Integer> Div<GenericFraction<T>> for GenericFraction<T>

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl<'a, T> Div<&'a GenericFraction<T>> for &'a GenericFraction<T> where     T: Clone + Integer,

type Output = GenericFraction<T>

The resulting type after applying the / operator.

fn div(self, other: Self) -> GenericFraction<T>

Performs the / operation.

impl<T: Clone + Integer> Rem<GenericFraction<T>> for GenericFraction<T>

type Output = Self

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self

Performs the % operation.

impl<'a, T> Rem<&'a GenericFraction<T>> for &'a GenericFraction<T> where     T: Clone + Integer,

type Output = GenericFraction<T>

The resulting type after applying the % operator.

fn rem(self, other: Self) -> GenericFraction<T>

Performs the % operation.

impl<T: Clone + Integer> Neg for GenericFraction<T>

type Output = GenericFraction<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<'a, T: Clone + Integer> Neg for &'a GenericFraction<T>

type Output = GenericFraction<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Clone + Integer> AddAssign<GenericFraction<T>> for GenericFraction<T>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<'a, T> AddAssign<&'a GenericFraction<T>> for GenericFraction<T> where     T: Clone + Integer,

fn add_assign(&mut self, other: &'a Self)

Performs the += operation.

impl<T: Clone + Integer> SubAssign<GenericFraction<T>> for GenericFraction<T>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<'a, T> SubAssign<&'a GenericFraction<T>> for GenericFraction<T> where     T: Clone + Integer,

fn sub_assign(&mut self, other: &'a Self)

Performs the -= operation.

impl<T: Clone + Integer> MulAssign<GenericFraction<T>> for GenericFraction<T>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<'a, T> MulAssign<&'a GenericFraction<T>> for GenericFraction<T> where     T: Clone + Integer,

fn mul_assign(&mut self, other: &'a Self)

Performs the *= operation.

impl<T: Clone + Integer> DivAssign<GenericFraction<T>> for GenericFraction<T>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<'a, T> DivAssign<&'a GenericFraction<T>> for GenericFraction<T> where     T: Clone + Integer,

fn div_assign(&mut self, other: &'a Self)

Performs the /= operation.

impl<T: Clone + Integer> RemAssign<GenericFraction<T>> for GenericFraction<T>

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<'a, T> RemAssign<&'a GenericFraction<T>> for GenericFraction<T> where     T: Clone + Integer,

fn rem_assign(&mut self, other: &'a Self)

Performs the %= operation.

impl<T: Clone + Integer + Hash> Hash for GenericFraction<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl<T: Clone + Integer + PartialEq + ToPrimitive> ToPrimitive for GenericFraction<T>

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64.

fn to_u64(&self) -> Option<u64>

Converts the value of self to an u64.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize.

fn to_u8(&self) -> Option<u8>

Converts the value of self to an u8.

fn to_u16(&self) -> Option<u16>

Converts the value of self to an u16.

fn to_u32(&self) -> Option<u32>

Converts the value of self to an u32.

fn to_u128(&self) -> Option<u128>

Converts the value of self to an u128.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32.

impl<T: Clone + Integer> Num for GenericFraction<T>

type FromStrRadixErr = ParseRatioError

fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix <= 36.

impl<T: Bounded + Clone + Integer> Bounded for GenericFraction<T>

fn min_value() -> Self

returns the smallest finite number this type can represent

fn max_value() -> Self

returns the largest finite number this type can represent

impl<T: Clone + Integer> Zero for GenericFraction<T>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

impl<T: Clone + Integer> One for GenericFraction<T>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool where     Self: PartialEq<Self>,

Returns true if self is equal to the multiplicative identity.

impl<T> CheckedSub for GenericFraction<T> where     T: Clone + Integer + CheckedAdd + CheckedSub + CheckedMul,

fn checked_sub(&self, other: &Self) -> Option<GenericFraction<T>>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<T> CheckedAdd for GenericFraction<T> where     T: Clone + Integer + CheckedAdd + CheckedSub + CheckedMul,

fn checked_add(&self, other: &Self) -> Option<GenericFraction<T>>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<T> CheckedMul for GenericFraction<T> where     T: Clone + Integer + CheckedMul,

fn checked_mul(&self, other: &Self) -> Option<GenericFraction<T>>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<T> CheckedDiv for GenericFraction<T> where     T: Clone + Integer + CheckedDiv + CheckedMul,

fn checked_div(&self, other: &Self) -> Option<GenericFraction<T>>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<T: Clone + Integer> Signed for GenericFraction<T>

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl<T> Serialize for GenericFraction<T> where     T: Clone + Integer,     T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where     __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de, T> Deserialize<'de> for GenericFraction<T> where     T: Clone + Integer,     T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where     __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> ToInputValue for GenericFraction<T> where     T: Clone + Integer + Display,

fn to_input_value(&self) -> InputValue

Performs the conversion.

impl<T> FromInputValue for GenericFraction<T> where     T: Clone + Integer + CheckedAdd + CheckedMul + CheckedSub + Num + One,

fn from_input_value(value: &InputValue) -> Option<Self>

Performs the conversion.

impl<T> GraphQLType for GenericFraction<T> where     T: Clone + Integer + CheckedAdd + CheckedMul + CheckedSub + Display,

type Context = ()

The expected context type for this GraphQL type

type TypeInfo = ()

Type that may carry additional schema information

fn name(_: &()) -> Option<&str>

The name of the GraphQL type to expose.

fn meta<'r>(info: &(), registry: &mut Registry<'r>) -> MetaType<'r>

The meta type representing this GraphQL type.

fn resolve(     &self,     _: &(),     _: Option<&[Selection]>,     _: &Executor<Self::Context> ) -> Value

Resolve the provided selection set against the current object.

fn resolve_field(     &self,     info: &Self::TypeInfo,     field_name: &str,     arguments: &Arguments,     executor: &Executor<Self::Context> ) -> Result<Value, FieldError>

Resolve the value of a single field on this type.

fn resolve_into_type(     &self,     info: &Self::TypeInfo,     type_name: &str,     selection_set: Option<&[Selection]>,     executor: &Executor<Self::Context> ) -> Result<Value, FieldError>

Resolve this interface or union into a concrete type

fn concrete_type_name(     &self,     context: &Self::Context,     info: &Self::TypeInfo ) -> String

Return the concrete type name for this instance/union.

impl<T> ToSql for GenericFraction<T> where     T: Clone + GenericInteger + From<u8> + Debug,

fn to_sql(     &self,     ty: &Type,     buf: &mut Vec<u8> ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

Converts the value of self into the binary format of the specified Postgres Type, appending it to out.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be converted to the specified Postgres Type.

fn to_sql_checked(     &self,     ty: &Type,     out: &mut Vec<u8> ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

An adaptor method used internally by Rust-Postgres.

impl<T> FromSql for GenericFraction<T> where     T: Clone + GenericInteger + From<u16>,

fn from_sql(     _ty: &Type,     raw: &[u8] ) -> Result<Self, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql_null(     ty: &Type ) -> Result<Self, Box<dyn Error + 'static + Sync + Send>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable(     ty: &Type,     raw: Option<&[u8]> ) -> Result<Self, Box<dyn Error + 'static + Sync + Send>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.