Struct reckoner::Rational[−][src]

#[repr(transparent)]
pub struct Rational { /* fields omitted */ }

Multiple precision rational value.

Implementations

`impl Rational`[src]

`pub fn add(&self, other: &Self) -> Self`[src]

Add two rational values and return the result.

`pub fn add_integer(&self, other: &Integer) -> Self`[src]

Add a rational value and an integer value and return the rational result.

`pub fn add_assign(&mut self, other: &Self)`[src]

Add two rationals and assign the result to self.

`pub fn add_assign_integer(&mut self, other: &Integer)`[src]

Add a rational value and an integer value and assign the result to self.

`pub fn subtract(&self, other: &Self) -> Self`[src]

Subtract two rational values and return the result.

`pub fn subtract_integer(&self, other: &Integer) -> Self`[src]

Subtract a rational value and an integer value and return the rational result.

`pub fn subtract_assign(&mut self, other: &Self)`[src]

Subtract two rationals and assign the result to self.

`pub fn subtract_assign_integer(&mut self, other: &Integer)`[src]

Subtract a rational value and an integer value and assign the result to self.

`pub fn multiply(&self, other: &Self) -> Self`[src]

Multiply two rational values and return the result.

`pub fn multiply_integer(&self, other: &Integer) -> Self`[src]

Multiply a rational value and an integer value and return the rational result.

`pub fn multiply_assign(&mut self, other: &Self)`[src]

Multiply two rationals and assign the result to self.

`pub fn multiply_assign_integer(&mut self, other: &Integer)`[src]

Multiply a rational value and an integer value and assign the result to self.

`pub fn divide(&self, other: &Self) -> Self`[src]

Divide two rational values and return the result.

`pub fn divide_integer(&self, other: &Integer) -> Self`[src]

Divide a rational value and an integer value and return the rational result.

`pub fn divide_assign(&mut self, other: &Self)`[src]

Divide two rationals and assign the result to self.

`pub fn divide_assign_integer(&mut self, other: &Integer)`[src]

Divide a rational value and an integer value and assign the result to self.

`pub fn absolute_value(&self) -> Self`[src]

Return the absolute value

`pub fn absolute_value_assign(&mut self)`[src]

Assign the absolute value to self

`pub fn negate(&self) -> Self`[src]

Return the additive inverse

`pub fn negate_assign(&mut self)`[src]

Assign the additive inverse to self

`pub fn reciprocal(&self) -> Self`[src]

Return the multiplicative inverse

`pub fn reciprocal_assign(&mut self)`[src]

Assign the multiplicative inverse to self

`impl Rational`[src]

`pub fn new() -> Self`[src]

Create a new rational with a default value of zero (0/1).

Example

use reckoner::Rational;

let r = Rational::new();

assert_eq!(r, (0, 1));

`pub unsafe fn from_raw(raw: *mut mpq_t) -> Self`[src]

Construct a Rational from a raw non-null pointer to creachadair_imath_sys::mpq_t.

Safety

This function must only every be called once for a given pointer, and the pointer must point to an initialized creachadair_imath_sys::mpq_t struct. The recommendation is to only use raw pointers from the Rational::into_raw function.

In ths context, initialized means that the creachadair_imath_sys::mpq_t has been the argument of a call to creachadair_imath_sys::mp_rat_init.

Example

use creachadair_imath_sys::{mp_rat_zero, MP_OK};
use reckoner::Rational;

let a = Rational::from((456, 123));

assert_eq!(a, (456, 123));

let a_raw = Rational::into_raw(a);

unsafe { mp_rat_zero(a_raw) };

let a = unsafe { Rational::from_raw(a_raw) };

assert_eq!(a, (0, 1));

`pub fn into_raw(rational: Rational) -> *mut mpq_t`[src]

Consumes the Rational, returning a wrapped raw pointer.

Example

use creachadair_imath_sys::{mp_rat_add, MP_OK};
use reckoner::Rational;

let a = Rational::from((377, 500));
let b = Rational::from((123, 500));
let c = Rational::new();

let a_raw = Rational::into_raw(a);
let b_raw = Rational::into_raw(b);
let c_raw = Rational::into_raw(c);

let op_res = unsafe { mp_rat_add(a_raw, b_raw, c_raw) };

if op_res != unsafe { MP_OK } {
    panic!("Operation failed.")
}

let a = unsafe { Rational::from_raw(a_raw) };
let b = unsafe { Rational::from_raw(b_raw) };
let c = unsafe { Rational::from_raw(c_raw) };

assert_eq!(a, (377, 500));
assert_eq!(b, (123, 500));
assert_eq!(c, (500, 500));

`pub fn reduce(&mut self)`[src]

Reduces r in-place to lowest terms and canonical form.

Zero is represented as 0/1, one as 1/1, and signs are adjusted so that the sign of the value is carried by the numerator.

Example

use reckoner::Rational;

let mut a = Rational::from((24, 2));
let mut b = Rational::from((24, 3));
let mut c = Rational::from((24, 4));

a.reduce();
b.reduce();
c.reduce();

assert_eq!(a, (12, 1));
assert_eq!(b, (8, 1));
assert_eq!(c, (6, 1));

`pub fn zero(&mut self)`[src]

Set value of integer to zero

Example

use reckoner::Rational;

let mut r = Rational::from((1234567u128, 1346172348u64));

r.zero();

assert_eq!(r, (0, 1));

`pub fn is_integer(&self) -> bool`[src]

Returns true if the denominator is 1.

Example

use reckoner::Rational;

assert!(Rational::from((0, 1)).is_integer());
assert!(Rational::from((1, 1)).is_integer());
assert!(!Rational::from((3, 25)).is_integer());

`pub fn compare(&self, rhs: &Self) -> Ordering`[src]

Compare two rationals

Example

use core::cmp::Ordering;
use reckoner::Rational;

let a = Rational::from((123, 500));
let b = Rational::from((377, 500));

assert_eq!(a.compare(&b), Ordering::Less);
assert_eq!(b.compare(&a), Ordering::Greater);
assert_eq!(a.compare(&a), Ordering::Equal);

`pub fn compare_magnitude(&self, rhs: &Self) -> Ordering`[src]

Compare the magnitude of two rationals, not taking sign into account.

Example

use core::cmp::Ordering;
use reckoner::Rational;

let a = Rational::from((123, 500));
let b = Rational::from((-377, 500));

assert_eq!(a.compare(&b), Ordering::Greater);
assert_eq!(a.compare_magnitude(&b), Ordering::Less);

`pub fn compare_zero(&self) -> Ordering`[src]

Compare a rational to zero.

Example

use core::cmp::Ordering;
use reckoner::Rational;

let a = Rational::from((123, 500));
let b = Rational::from((-377, 500));

assert_eq!(a.compare_zero(), Ordering::Greater);
assert_eq!(b.compare_zero(), Ordering::Less);

`pub fn numerator(&self) -> Integer`[src]

Return a copy of the numerator of the rational value

Example

use reckoner::Rational;

let a = Rational::from((34256, 54587));

assert_eq!(a.numerator(), 34256);

`pub fn denominator(&self) -> Integer`[src]

Return a copy of the denominator of the rational value

Example

use reckoner::Rational;

let a = Rational::from((34256, 54587));

assert_eq!(a.denominator(), 54587);

`pub fn copy_to(&self, other: &mut Self)`[src]

Replaces the value of other with a copy of the value of self. No new memory is allocated unless self has more significant digits than other has allocated.

Example

use reckoner::Rational;

let a = Rational::from((34256, 54587));
let mut b = Rational::new();

a.copy_to(&mut b);

assert_eq!(a, b);
assert_eq!(b, (34256, 54587));

`pub fn to_decimal(&self, rounding_mode: RoundMode, max_precision: u16) -> String`[src]

Converts the value of self to a string in base-10 decimal-point notation. It generates max_precision digits of precision and takes a RoundMode argument that determines how the ratio will be converted to decimal.

Example

use reckoner::{Rational, RoundMode};

let r = Rational::from((1146408, 364913));

assert_eq!(r.to_decimal(RoundMode::HalfUp, 6), "3.141593");
assert_eq!(r.to_decimal(RoundMode::HalfUp, 5), "3.14159");
assert_eq!(r.to_decimal(RoundMode::HalfUp, 4), "3.1416");
assert_eq!(r.to_decimal(RoundMode::HalfUp, 3), "3.142");

Struct reckoner::Rational⎘[−][src]

Implementations

impl Rational[src]

pub fn add(&self, other: &Self) -> Self[src]

pub fn add_integer(&self, other: &Integer) -> Self[src]

pub fn add_assign(&mut self, other: &Self)[src]

pub fn add_assign_integer(&mut self, other: &Integer)[src]

pub fn subtract(&self, other: &Self) -> Self[src]

pub fn subtract_integer(&self, other: &Integer) -> Self[src]

pub fn subtract_assign(&mut self, other: &Self)[src]

pub fn subtract_assign_integer(&mut self, other: &Integer)[src]

pub fn multiply(&self, other: &Self) -> Self[src]

pub fn multiply_integer(&self, other: &Integer) -> Self[src]

pub fn multiply_assign(&mut self, other: &Self)[src]

pub fn multiply_assign_integer(&mut self, other: &Integer)[src]

pub fn divide(&self, other: &Self) -> Self[src]

pub fn divide_integer(&self, other: &Integer) -> Self[src]

pub fn divide_assign(&mut self, other: &Self)[src]

pub fn divide_assign_integer(&mut self, other: &Integer)[src]

pub fn absolute_value(&self) -> Self[src]

pub fn absolute_value_assign(&mut self)[src]

pub fn negate(&self) -> Self[src]

pub fn negate_assign(&mut self)[src]

pub fn reciprocal(&self) -> Self[src]

pub fn reciprocal_assign(&mut self)[src]

impl Rational[src]

pub fn new() -> Self[src]

pub unsafe fn from_raw(raw: *mut mpq_t) -> Self[src]

pub fn into_raw(rational: Rational) -> *mut mpq_t[src]

pub fn reduce(&mut self)[src]

pub fn zero(&mut self)[src]

pub fn is_integer(&self) -> bool[src]

pub fn compare(&self, rhs: &Self) -> Ordering[src]

pub fn compare_magnitude(&self, rhs: &Self) -> Ordering[src]

pub fn compare_zero(&self) -> Ordering[src]

pub fn numerator(&self) -> Integer[src]

pub fn denominator(&self) -> Integer[src]

pub fn copy_to(&self, other: &mut Self)[src]

pub fn to_decimal(&self, rounding_mode: RoundMode, max_precision: u16) -> String[src]

Trait Implementations

impl Add<&'_ Integer> for Rational[src]

type Output = Rational

fn add(self, rhs: &Integer) -> Self::Output[src]

impl Add<&'_ Integer> for &Rational[src]

type Output = Rational

fn add(self, rhs: &Integer) -> Self::Output[src]

impl Add<&'_ Rational> for Rational[src]

type Output = Rational

fn add(self, rhs: &Rational) -> Self::Output[src]

impl Add<&'_ Rational> for &Rational[src]

type Output = Rational

fn add(self, rhs: &Rational) -> Self::Output[src]

impl Add<&'_ Rational> for Integer[src]

type Output = Rational

fn add(self, rhs: &Rational) -> Self::Output[src]

impl Add<&'_ Rational> for &Integer[src]

type Output = Rational

fn add(self, rhs: &Rational) -> Self::Output[src]

impl Add<&'_ i128> for Rational[src]

type Output = Rational

fn add(self, rhs: &i128) -> Self::Output[src]

impl Add<&'_ i128> for &Rational[src]

type Output = Rational

fn add(self, rhs: &i128) -> Self::Output[src]

impl Add<&'_ i16> for Rational[src]

type Output = Rational

fn add(self, rhs: &i16) -> Self::Output[src]

impl Add<&'_ i16> for &Rational[src]

type Output = Rational

fn add(self, rhs: &i16) -> Self::Output[src]

impl Add<&'_ i32> for Rational[src]

type Output = Rational

fn add(self, rhs: &i32) -> Self::Output[src]

impl Add<&'_ i32> for &Rational[src]

type Output = Rational

fn add(self, rhs: &i32) -> Self::Output[src]

impl Add<&'_ i64> for Rational[src]

type Output = Rational

fn add(self, rhs: &i64) -> Self::Output[src]

impl Add<&'_ i64> for &Rational[src]

Struct reckoner::Rational[−][src]

`impl Rational`[src]

`pub fn add(&self, other: &Self) -> Self`[src]

`pub fn add_integer(&self, other: &Integer) -> Self`[src]

`pub fn add_assign(&mut self, other: &Self)`[src]

`pub fn add_assign_integer(&mut self, other: &Integer)`[src]

`pub fn subtract(&self, other: &Self) -> Self`[src]

`pub fn subtract_integer(&self, other: &Integer) -> Self`[src]

`pub fn subtract_assign(&mut self, other: &Self)`[src]

`pub fn subtract_assign_integer(&mut self, other: &Integer)`[src]

`pub fn multiply(&self, other: &Self) -> Self`[src]

`pub fn multiply_integer(&self, other: &Integer) -> Self`[src]

`pub fn multiply_assign(&mut self, other: &Self)`[src]

`pub fn multiply_assign_integer(&mut self, other: &Integer)`[src]

`pub fn divide(&self, other: &Self) -> Self`[src]

`pub fn divide_integer(&self, other: &Integer) -> Self`[src]

`pub fn divide_assign(&mut self, other: &Self)`[src]

`pub fn divide_assign_integer(&mut self, other: &Integer)`[src]

`pub fn absolute_value(&self) -> Self`[src]

`pub fn absolute_value_assign(&mut self)`[src]

`pub fn negate(&self) -> Self`[src]

`pub fn negate_assign(&mut self)`[src]

`pub fn reciprocal(&self) -> Self`[src]

`pub fn reciprocal_assign(&mut self)`[src]

`impl Rational`[src]

`pub fn new() -> Self`[src]

`pub unsafe fn from_raw(raw: *mut mpq_t) -> Self`[src]

`pub fn into_raw(rational: Rational) -> *mut mpq_t`[src]

`pub fn reduce(&mut self)`[src]

`pub fn zero(&mut self)`[src]

`pub fn is_integer(&self) -> bool`[src]

`pub fn compare(&self, rhs: &Self) -> Ordering`[src]

`pub fn compare_magnitude(&self, rhs: &Self) -> Ordering`[src]

`pub fn compare_zero(&self) -> Ordering`[src]

`pub fn numerator(&self) -> Integer`[src]

`pub fn denominator(&self) -> Integer`[src]

`pub fn copy_to(&self, other: &mut Self)`[src]

`pub fn to_decimal(&self, rounding_mode: RoundMode, max_precision: u16) -> String`[src]

`impl Add<&'_ Integer> for Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &Integer) -> Self::Output`[src]

`impl Add<&'_ Integer> for &Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &Integer) -> Self::Output`[src]

`impl Add<&'_ Rational> for Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &Rational) -> Self::Output`[src]

`impl Add<&'_ Rational> for &Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &Rational) -> Self::Output`[src]

`impl Add<&'_ Rational> for Integer`[src]

`type Output = Rational`

`fn add(self, rhs: &Rational) -> Self::Output`[src]

`impl Add<&'_ Rational> for &Integer`[src]

`type Output = Rational`

`fn add(self, rhs: &Rational) -> Self::Output`[src]

`impl Add<&'_ i128> for Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &i128) -> Self::Output`[src]

`impl Add<&'_ i128> for &Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &i128) -> Self::Output`[src]

`impl Add<&'_ i16> for Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &i16) -> Self::Output`[src]

`impl Add<&'_ i16> for &Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &i16) -> Self::Output`[src]

`impl Add<&'_ i32> for Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &i32) -> Self::Output`[src]

`impl Add<&'_ i32> for &Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &i32) -> Self::Output`[src]

`impl Add<&'_ i64> for Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &i64) -> Self::Output`[src]

`impl Add<&'_ i64> for &Rational`[src]

`type Output = Rational`

`fn add(self, rhs: &i64) -> Self::Output`[src]