rug 0.8.0

// Copyright © 2016–2017 University of Malta

// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.

use {Assign, Integer};
use ext::gmp as xgmp;
use gmp_mpfr_sys::gmp::{self, mpq_t};
use inner::{Inner, InnerMut};
use std::cmp::Ordering;
use std::error::Error;
use std::ffi::CStr;
use std::i32;
use std::marker::PhantomData;
use std::mem;
use std::ops::Deref;
use std::os::raw::{c_char, c_int};

/// An arbitrary-precision rational number.
///
/// A rational number is made up of a numerator
/// [`Integer`](struct.Integer.html) and denominator
/// [`Integer`](struct.Integer.html). After rational number functions,
/// the number is always in canonical form, that is, the denominator
/// is always greater than zero, and there are no common factors. Zero
/// is stored as 0/1.
///
/// # Examples
///
/// ```rust
/// use rug::Rational;
/// let r = Rational::from((-12, 15));
/// let recip = Rational::from(r.recip_ref());
/// assert_eq!(recip, (-5, 4));
/// assert_eq!(recip.to_f32(), -1.25);
/// // The numerator and denominator are stored in canonical form.
/// let (num, den) = r.into_numer_denom();
/// assert_eq!(num, -4);
/// assert_eq!(den, 5);
/// ```
///
/// The `Rational` type supports various functions. Most methods have
/// three versions: one that consumes the operand, one that mutates
/// the operand, and one that borrows the operand.
///
/// ```rust
/// use rug::Rational;
///
/// // 1. consume the operand
/// let a = Rational::from((-15, 2));
/// let abs_a = a.abs();
/// assert_eq!(abs_a, (15, 2));
///
/// // 2. mutate the operand
/// let mut b = Rational::from((-17, 2));
/// b.abs_mut();
/// assert_eq!(b, (17, 2));
///
/// // 3. borrow the operand
/// let c = Rational::from((-19, 2));
/// let r = c.abs_ref();
/// let abs_c = Rational::from(r);
/// assert_eq!(abs_c, (19, 2));
/// // c was not consumed
/// assert_eq!(c, (-19, 2));
/// ```
pub struct Rational {
    inner: mpq_t,
}

impl Rational {
    /// Constructs a new arbitrary-precision rational number with
    /// value 0.
    ///
    /// # Examples
    /// ```rust
    /// use rug::Rational;
    /// let r = Rational::new();
    /// assert_eq!(r, 0);
    /// ```
    #[inline]
    pub fn new() -> Rational {
        unsafe {
            let mut ret: Rational = mem::uninitialized();
            gmp::mpq_init(ret.inner_mut());
            ret
        }
    }

    /// Creates a `Rational` from an `f32` if it is finite, losing no
    /// precision.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// use std::f32;
    /// let r = Rational::from_f32(-17125e-3).unwrap();
    /// assert_eq!(r, "-17125/1000".parse::<Rational>().unwrap());
    /// let inf = Rational::from_f32(f32::INFINITY);
    /// assert!(inf.is_none());
    /// ```
    #[inline]
    pub fn from_f32(val: f32) -> Option<Rational> {
        Rational::from_f64(val.into())
    }

    /// Creates a `Rational` from an `f64` if it is finite, losing no
    /// precision.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// use std::f64;
    /// let r = Rational::from_f64(-17125e-3).unwrap();
    /// assert_eq!(r, "-17125/1000".parse::<Rational>().unwrap());
    /// let inf = Rational::from_f64(f64::INFINITY);
    /// assert!(inf.is_none());
    /// ```
    #[inline]
    pub fn from_f64(val: f64) -> Option<Rational> {
        if val.is_finite() {
            let mut r = Rational::new();
            r.assign_f64(val).unwrap();
            Some(r)
        } else {
            None
        }
    }

    /// Parses a `Rational` number.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r1 = Rational::from_str_radix("ff/a", 16).unwrap();
    /// assert_eq!(r1, (255, 10));
    /// let r2 = Rational::from_str_radix("+ff0/a0", 16).unwrap();
    /// assert_eq!(r2, (0xff0, 0xa0));
    /// assert_eq!(*r2.numer(), 51);
    /// assert_eq!(*r2.denom(), 2);
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if `radix` is less than 2 or greater than 36.
    #[inline]
    pub fn from_str_radix(
        src: &str,
        radix: i32,
    ) -> Result<Rational, ParseRationalError> {
        let mut r = Rational::new();
        r.assign_str_radix(src, radix)?;
        Ok(r)
    }

    /// Checks if a `Rational` number can be parsed.
    ///
    /// If this method does not return an error, neither will any
    /// other function that parses a `Rational` number. If this method
    /// returns an error, the other functions will return the same
    /// error.
    ///
    /// The string must contain a numerator, and may contain a
    /// denominator; the numerator and denominator are separated with
    /// a `'/'`. The numerator can start with an optional minus or
    /// plus sign.
    ///
    /// Whitespace is not allowed anywhere in the string, including in
    /// the beginning and end and around the `'/'`.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    ///
    /// let valid1 = Rational::valid_str_radix("12/23", 4);
    /// let r1 = Rational::from(valid1.unwrap());
    /// assert_eq!(r1, (2 + 4 * 1, 3 + 4 * 2));
    /// let valid2 = Rational::valid_str_radix("12/yz", 36);
    /// let r2 = Rational::from(valid2.unwrap());
    /// assert_eq!(r2, (2 + 36 * 1, 35 + 36 * 34));
    ///
    /// let invalid = Rational::valid_str_radix("12 / 23", 4);
    /// let invalid_f = Rational::from_str_radix("12 / 23", 4);
    /// assert_eq!(invalid.unwrap_err(), invalid_f.unwrap_err());
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if `radix` is less than 2 or greater than 36.
    pub fn valid_str_radix(
        src: &str,
        radix: i32,
    ) -> Result<ValidRational, ParseRationalError> {
        use self::ParseErrorKind as Kind;
        use self::ParseRationalError as Error;

        assert!(radix >= 2 && radix <= 36, "radix out of range");
        let bytes = src.as_bytes();
        let (skip_plus, iter) = match bytes.get(0) {
            Some(&b'+') => (&bytes[1..], bytes[1..].iter()),
            Some(&b'-') => (bytes, bytes[1..].iter()),
            _ => (bytes, bytes.iter()),
        };
        let mut got_digit = false;
        let mut denom = false;
        let mut denom_non_zero = false;
        for b in iter {
            if *b == b'/' {
                if denom {
                    return Err(Error {
                        kind: Kind::TooManySlashes,
                    });
                }
                if !got_digit {
                    return Err(Error {
                        kind: Kind::NumerNoDigits,
                    });
                }
                got_digit = false;
                denom = true;
                continue;
            }
            let digit_value = match *b {
                b'0'...b'9' => *b - b'0',
                b'a'...b'z' => *b - b'a' + 10,
                b'A'...b'Z' => *b - b'A' + 10,
                _ => Err(Error {
                    kind: Kind::InvalidDigit,
                })?,
            };
            if digit_value >= radix as u8 {
                return Err(Error {
                    kind: Kind::InvalidDigit,
                });
            }
            got_digit = true;
            if denom && digit_value > 0 {
                denom_non_zero = true;
            }
        }
        if !got_digit && denom {
            return Err(Error {
                kind: Kind::DenomNoDigits,
            });
        } else if !got_digit {
            return Err(Error {
                kind: Kind::NoDigits,
            });
        }
        if denom && !denom_non_zero {
            return Err(Error {
                kind: Kind::DenomZero,
            });
        }
        let v = ValidRational {
            bytes: skip_plus,
            radix,
        };
        Ok(v)
    }

    /// Converts to an [`Integer`](struct.Integer.html), rounding
    /// towards zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let pos = Rational::from((139, 10));
    /// let posi = pos.to_integer();
    /// assert_eq!(posi, 13);
    /// let neg = Rational::from((-139, 10));
    /// let negi = neg.to_integer();
    /// assert_eq!(negi, -13);
    /// ```
    #[inline]
    pub fn to_integer(&self) -> Integer {
        let mut i = Integer::new();
        self.copy_to_integer(&mut i);
        i
    }

    /// Converts to an [`Integer`](struct.Integer.html) inside `i`,
    /// rounding towards zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Integer, Rational};
    /// let mut i = Integer::new();
    /// assert_eq!(i, 0);
    /// let pos = Rational::from((139, 10));
    /// pos.copy_to_integer(&mut i);
    /// assert_eq!(i, 13);
    /// let neg = Rational::from((-139, 10));
    /// neg.copy_to_integer(&mut i);
    /// assert_eq!(i, -13);
    /// ```
    #[inline]
    pub fn copy_to_integer(&self, i: &mut Integer) {
        unsafe {
            gmp::mpz_set_q(i.inner_mut(), self.inner());
        }
    }

    /// Converts to an `f32`, rounding towards zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// use rug::rational::SmallRational;
    /// use std::f32;
    /// let min = Rational::from_f32(f32::MIN).unwrap();
    /// let minus_small = min - &*SmallRational::from((7, 2));
    /// // minus_small is truncated to f32::MIN
    /// assert_eq!(minus_small.to_f32(), f32::MIN);
    /// let times_three_two = minus_small * &*SmallRational::from((3, 2));
    /// // times_three_two is too small
    /// assert_eq!(times_three_two.to_f32(), f32::NEG_INFINITY);
    /// ```
    #[inline]
    pub fn to_f32(&self) -> f32 {
        let f = self.to_f64();
        // f as f32 might round away from zero, so we need to clear
        // the least significant bits of f.
        // * If f is a nan, we do NOT want to clear any mantissa bits,
        //   as this may change f into +/- infinity.
        // * If f is +/- infinity, the bits are already zero, so the
        //   masking has no effect.
        // * If f is subnormal, f as f32 will be zero anyway.
        if !f.is_nan() {
            let u = unsafe { mem::transmute::<_, u64>(f) };
            // f64 has 29 more significant bits than f32.
            let trunc_u = u & (!0 << 29);
            let trunc_f = unsafe { mem::transmute::<_, f64>(trunc_u) };
            trunc_f as f32
        } else {
            f as f32
        }
    }

    /// Converts to an `f64`, rounding towards zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// use rug::rational::SmallRational;
    /// use std::f64;
    ///
    /// // An `f64` has 53 bits of precision.
    /// let exact = 0x1f_1234_5678_9aff_u64;
    /// let den = 0x1000_u64;
    /// let r = Rational::from((exact, den));
    /// assert_eq!(r.to_f64(), exact as f64 / den as f64);
    ///
    /// // large has 56 ones
    /// let large = 0xff_1234_5678_9aff_u64;
    /// // trunc has 53 ones followed by 3 zeros
    /// let trunc = 0xff_1234_5678_9af8_u64;
    /// let j = Rational::from((large, den));
    /// assert_eq!(j.to_f64(), trunc as f64 / den as f64);
    ///
    /// let max = Rational::from_f64(f64::MAX).unwrap();
    /// let plus_small = max + &*SmallRational::from((7, 2));
    /// // plus_small is truncated to f64::MAX
    /// assert_eq!(plus_small.to_f64(), f64::MAX);
    /// let times_three_two = plus_small * &*SmallRational::from((3, 2));
    /// // times_three_two is too large
    /// assert_eq!(times_three_two.to_f64(), f64::INFINITY);
    /// ```
    #[inline]
    pub fn to_f64(&self) -> f64 {
        unsafe { gmp::mpq_get_d(self.inner()) }
    }

    /// Returns a string representation for the specified `radix`.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r1 = Rational::from(0);
    /// assert_eq!(r1.to_string_radix(10), "0");
    /// let r2 = Rational::from((15, 5));
    /// assert_eq!(r2.to_string_radix(10), "3");
    /// let r3 = Rational::from((10, -6));
    /// assert_eq!(r3.to_string_radix(10), "-5/3");
    /// assert_eq!(r3.to_string_radix(5), "-10/3");
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if `radix` is less than 2 or greater than 36.
    #[inline]
    pub fn to_string_radix(&self, radix: i32) -> String {
        make_string(self, radix, false)
    }

    /// Assigns from an `f32` if it is finite, losing no precision.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// use std::f32;
    /// let mut r = Rational::new();
    /// let ret = r.assign_f32(12.75);
    /// assert!(ret.is_ok());
    /// assert_eq!(r, (1275, 100));
    /// let ret = r.assign_f32(f32::NAN);
    /// assert!(ret.is_err());
    /// assert_eq!(r, (1275, 100));
    /// ```
    #[inline]
    pub fn assign_f32(&mut self, val: f32) -> Result<(), ()> {
        self.assign_f64(val.into())
    }

    /// Assigns from an `f64` if it is finite, losing no precision.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let mut r = Rational::new();
    /// let ret = r.assign_f64(12.75);
    /// assert!(ret.is_ok());
    /// assert_eq!(r, (1275, 100));
    /// let ret = r.assign_f64(1.0 / 0.0);
    /// assert!(ret.is_err());
    /// assert_eq!(r, (1275, 100));
    /// ```
    #[inline]
    pub fn assign_f64(&mut self, val: f64) -> Result<(), ()> {
        if val.is_finite() {
            unsafe {
                gmp::mpq_set_d(self.inner_mut(), val);
            }
            Ok(())
        } else {
            Err(())
        }
    }

    /// Parses a `Rational` number from a string.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let mut r = Rational::new();
    /// let ret = r.assign_str("1/0");
    /// assert!(ret.is_err());
    /// r.assign_str("-24/2").unwrap();
    /// assert_eq!(*r.numer(), -12);
    /// assert_eq!(*r.denom(), 1);
    /// ```
    #[inline]
    pub fn assign_str(&mut self, src: &str) -> Result<(), ParseRationalError> {
        self.assign_str_radix(src, 10)
    }

    /// Parses a `Rational` number from a string with the specified
    /// radix.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let mut r = Rational::new();
    /// r.assign_str_radix("ff/a", 16).unwrap();
    /// assert_eq!(r, (255, 10));
    /// r.assign_str_radix("+ff0/a0", 16).unwrap();
    /// assert_eq!(r, (255, 10));
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if `radix` is less than 2 or greater than 36.
    #[inline]
    pub fn assign_str_radix(
        &mut self,
        src: &str,
        radix: i32,
    ) -> Result<(), ParseRationalError> {
        self.assign(Rational::valid_str_radix(src, radix)?);
        Ok(())
    }

    /// Borrows the numerator as an `Integer`.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r = Rational::from((12, -20));
    /// // r will be canonicalized to -3 / 5
    /// assert_eq!(*r.numer(), -3)
    /// ```
    #[inline]
    pub fn numer(&self) -> &Integer {
        unsafe {
            let ptr = gmp::mpq_numref_const(self.inner());
            &*(ptr as *const Integer)
        }
    }

    /// Borrows the denominator as an
    /// [`Integer`](struct.Integer.html).
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r = Rational::from((12, -20));
    /// // r will be canonicalized to -3 / 5
    /// assert_eq!(*r.denom(), 5);
    /// ```
    #[inline]
    pub fn denom(&self) -> &Integer {
        unsafe {
            let ptr = gmp::mpq_denref_const(self.inner());
            &*(ptr as *const Integer)
        }
    }

    /// Borrows the numerator and denominator as
    /// [`Integer`](struct.Integer.html) values.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r = Rational::from((12, -20));
    /// // r will be canonicalized to -3 / 5
    /// let (num, den) = r.as_numer_denom();
    /// assert_eq!(*num, -3);
    /// assert_eq!(*den, 5);
    /// ```
    #[inline]
    pub fn as_numer_denom(&self) -> (&Integer, &Integer) {
        (self.numer(), self.denom())
    }

    /// Borrows the numerator and denominator mutably. The number is
    /// canonicalized when the borrow ends. The denominator must not
    /// be zero when the borrow ends.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    ///
    /// let mut r = Rational::from((3, 5));
    /// {
    ///     let mut num_den = r.as_mut_numer_denom();
    ///     // change r from 3/5 to 4/8, which is equal to 1/2
    ///     *num_den.num() += 1;
    ///     *num_den.den() += 3;
    ///     // borrow ends here
    /// }
    /// let num_den = r.as_numer_denom();
    /// assert_eq!(*num_den.0, 1);
    /// assert_eq!(*num_den.1, 2);
    /// ```
    ///
    /// If the mutable value is leaked, the denominator is lost when
    /// the borrow ends.
    ///
    /// ```rust
    /// use rug::Rational;
    /// use std::mem;
    ///
    /// let mut r = Rational::from((3, 5));
    /// {
    ///     let mut num_den = r.as_mut_numer_denom();
    ///     // try change r from 3/5 to 4/8
    ///     *num_den.num() += 1;
    ///     *num_den.den() += 3;
    ///     // forget num_den, so no canonicalization takes place
    ///     mem::forget(num_den)
    ///     // borrow ends here, but nothing happens
    /// }
    /// // because of the leak, 4/8 has become 4/1
    /// let num_den = r.as_numer_denom();
    /// assert_eq!(*num_den.0, 4);
    /// assert_eq!(*num_den.1, 1);
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if the denominator is zero when the borrow ends.
    pub fn as_mut_numer_denom(&mut self) -> MutNumerDenom {
        // We swap in a denominator of 1 so that if the
        // `MutNumerDenom` is leaked, we don't end up with an
        // uncanonicalized rational number.
        unsafe {
            let numer_ptr = gmp::mpq_numref(self.inner_mut());
            let denom_ptr = gmp::mpq_denref(self.inner_mut());
            let mut acting_denom = Integer::from(1);
            mem::swap(acting_denom.inner_mut(), &mut *denom_ptr);
            MutNumerDenom {
                num: &mut *(numer_ptr as *mut Integer),
                den_place: &mut *(denom_ptr as *mut Integer),
                den_actual: acting_denom,
            }
        }
    }

    /// Borrows the numerator and denominator mutably without
    /// canonicalizing aftwerwards.
    ///
    /// # Safety
    ///
    /// This function is unsafe because it does not canonicalize the
    /// rational number when the borrow ends. The rest of the library
    /// assumes that `Rational` structures keep their numerators and
    /// denominators canonicalized.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    ///
    /// let mut r = Rational::from((3, 5));
    /// {
    ///     let (num, den) = unsafe {
    ///         r.as_mut_numer_denom_no_canonicalization()
    ///     };
    ///     // Add one to r by adding den to num. Since num and den
    ///     // are relatively prime, r remains canonicalized.
    ///     *num += &*den;
    /// }
    /// assert_eq!(r, (8, 5));
    /// ```
    #[inline]
    pub unsafe fn as_mut_numer_denom_no_canonicalization(
        &mut self,
    ) -> (&mut Integer, &mut Integer) {
        (
            &mut *(gmp::mpq_numref(self.inner_mut()) as *mut _),
            &mut *(gmp::mpq_denref(self.inner_mut()) as *mut _),
        )
    }

    /// Converts into numerator and denominator integers.
    ///
    /// This function reuses the allocated memory and does not
    /// allocate any new memory.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r = Rational::from((12, -20));
    /// // r will be canonicalized to -3 / 5
    /// let (num, den) = r.into_numer_denom();
    /// assert_eq!(num, -3);
    /// assert_eq!(den, 5);
    /// ```
    #[inline]
    pub fn into_numer_denom(mut self) -> (Integer, Integer) {
        let (mut numer, mut denom) = unsafe { mem::uninitialized() };
        {
            let mut self_numer_denom = self.as_mut_numer_denom();
            mem::swap(&mut numer, self_numer_denom.num());
            mem::swap(&mut denom, self_numer_denom.den());
            // do not canonicalize uninitialized values
            mem::forget(self_numer_denom);
        }
        mem::forget(self);
        (numer, denom)
    }

    /// Borrows a negated copy of the `Rational` number.
    ///
    /// The returned object implements `Deref` with a `Rational`
    /// target. This method performs a shallow copy and negates it,
    /// and negation does not change the allocated data.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r = Rational::from((7, 11));
    /// let neg_r = r.as_neg();
    /// assert_eq!(*neg_r, (-7, 11));
    /// // methods taking &self can be used on the returned object
    /// let reneg_r = neg_r.as_neg();
    /// assert_eq!(*reneg_r, (7, 11));
    /// assert_eq!(*reneg_r, r);
    /// ```
    #[inline]
    pub fn as_neg(&self) -> BorrowRational {
        let mut ret = BorrowRational {
            inner: self.inner,
            phantom: PhantomData,
        };
        let size = self.numer().inner().size.checked_neg().expect("overflow");
        unsafe {
            (*gmp::mpq_numref(&mut ret.inner)).size = size;
        }
        ret
    }

    /// Borrows an absolute copy of the `Rational` number.
    ///
    /// The returned object implements `Deref` with a `Rational`
    /// target. This method performs a shallow copy and possibly
    /// negates it, and negation does not change the allocated data.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r = Rational::from((-7, 11));
    /// let abs_r = r.as_abs();
    /// assert_eq!(*abs_r, (7, 11));
    /// // methods taking &self can be used on the returned object
    /// let reabs_r = abs_r.as_abs();
    /// assert_eq!(*reabs_r, (7, 11));
    /// assert_eq!(*reabs_r, *abs_r);
    /// ```
    #[inline]
    pub fn as_abs(&self) -> BorrowRational {
        let mut ret = BorrowRational {
            inner: self.inner,
            phantom: PhantomData,
        };
        let size = self.numer().inner().size.checked_abs().expect("overflow");
        unsafe {
            (*gmp::mpq_numref(&mut ret.inner)).size = size;
        }
        ret
    }

    /// Borrows a reciprocal copy of the `Rational` number.
    ///
    /// The returned object implements `Deref` with a `Rational`
    /// target. This method performs some shallow copying, swapping
    /// numerator and denominator and making sure the sign is in the
    /// numerator.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let r = Rational::from((-7, 11));
    /// let recip_r = r.as_recip();
    /// assert_eq!(*recip_r, (-11, 7));
    /// // methods taking &self can be used on the returned object
    /// let rerecip_r = recip_r.as_recip();
    /// assert_eq!(*rerecip_r, (-7, 11));
    /// assert_eq!(*rerecip_r, r);
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if the value is zero.
    pub fn as_recip(&self) -> BorrowRational {
        let (self_num, self_den) = self.as_numer_denom();
        let (self_num, self_den) = (self_num.inner(), self_den.inner());
        assert_ne!(self_num.size, 0, "division by zero");
        let mut ret = BorrowRational {
            inner: unsafe { mem::uninitialized() },
            phantom: PhantomData,
        };
        let (ret_num, ret_den) = unsafe {
            let num = &mut *gmp::mpq_numref(&mut ret.inner);
            let den = &mut *gmp::mpq_denref(&mut ret.inner);
            (num, den)
        };
        *ret_num = *self_den;
        *ret_den = *self_num;
        if self_num.size < 0 {
            ret_num.size = self_den.size.checked_neg().expect("overflow");
            ret_den.size = self_num.size.checked_neg().expect("overflow");
        }
        ret
    }

    /// Returns the same result as `self.cmp(&0)`, but is faster.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// use std::cmp::Ordering;
    /// assert_eq!(Rational::from((-5, 7)).cmp0(), Ordering::Less);
    /// assert_eq!(Rational::from(0).cmp0(), Ordering::Equal);
    /// assert_eq!(Rational::from((5, 7)).cmp0(), Ordering::Greater);
    /// ```
    pub fn cmp0(&self) -> Ordering {
        self.numer().cmp0()
    }

    math_op1! {
        Rational;
        gmp::mpq_abs;
        /// Computes the absolute value.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// let r = Rational::from((-100, 17));
        /// let abs = r.abs();
        /// assert_eq!(abs, (100, 17));
        /// ```
        fn abs();
        /// Computes the absolute value.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// let mut r = Rational::from((-100, 17));
        /// r.abs_mut();
        /// assert_eq!(r, (100, 17));
        /// ```
        fn abs_mut;
        /// Computes the absolute value.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// let r = Rational::from((-100, 17));
        /// let rr = r.abs_ref();
        /// let abs = Rational::from(rr);
        /// assert_eq!(abs, (100, 17));
        /// ```
        fn abs_ref -> AbsRef;
    }

    /// Clamps the value within the specified bounds.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let min = (-3, 2);
    /// let max = (3, 2);
    /// let too_small = Rational::from((-5, 2));
    /// let clamped1 = too_small.clamp(&min, &max);
    /// assert_eq!(clamped1, (-3, 2));
    /// let in_range = Rational::from((1, 2));
    /// let clamped2 = in_range.clamp(&min, &max);
    /// assert_eq!(clamped2, (1, 2));
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if the maximum value is less than the minimum value.
    #[inline]
    pub fn clamp<'a, 'b, Min, Max>(
        mut self,
        min: &'a Min,
        max: &'b Max,
    ) -> Rational
    where
        Rational: PartialOrd<Min>
            + PartialOrd<Max>
            + Assign<&'a Min>
            + Assign<&'b Max>,
    {
        self.clamp_mut(min, max);
        self
    }

    /// Clamps the value within the specified bounds.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let min = (-3, 2);
    /// let max = (3, 2);
    /// let mut too_small = Rational::from((-5, 2));
    /// too_small.clamp_mut(&min, &max);
    /// assert_eq!(too_small, (-3, 2));
    /// let mut in_range = Rational::from((1, 2));
    /// in_range.clamp_mut(&min, &max);
    /// assert_eq!(in_range, (1, 2));
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if the maximum value is less than the minimum value.
    pub fn clamp_mut<'a, 'b, Min, Max>(&mut self, min: &'a Min, max: &'b Max)
    where
        Rational: PartialOrd<Min>
            + PartialOrd<Max>
            + Assign<&'a Min>
            + Assign<&'b Max>,
    {
        if (&*self).lt(min) {
            self.assign(min);
            assert!(!(&*self).gt(max), "minimum larger than maximum");
        } else if (&*self).gt(max) {
            self.assign(max);
            assert!(!(&*self).lt(min), "minimum larger than maximum");
        }
    }

    /// Clamps the value within the specified bounds.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// let min = (-3, 2);
    /// let max = (3, 2);
    /// let too_small = Rational::from((-5, 2));
    /// let r1 = too_small.clamp_ref(&min, &max);
    /// let clamped1 = Rational::from(r1);
    /// assert_eq!(clamped1, (-3, 2));
    /// let in_range = Rational::from((1, 2));
    /// let r2 = in_range.clamp_ref(&min, &max);
    /// let clamped2 = Rational::from(r2);
    /// assert_eq!(clamped2, (1, 2));
    /// ```
    ///
    /// # Panics
    ///
    /// Panics if the maximum value is less than the minimum value.
    #[inline]
    pub fn clamp_ref<'a, Min, Max>(
        &'a self,
        min: &'a Min,
        max: &'a Max,
    ) -> ClampRef<'a, Min, Max>
    where
        Rational: PartialOrd<Min>
            + PartialOrd<Max>
            + Assign<&'a Min>
            + Assign<&'a Max>,
    {
        ClampRef {
            ref_self: self,
            min,
            max,
        }
    }

    math_op1! {
        Rational;
        xgmp::mpq_inv_check_0;
        /// Computes the reciprocal.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// let r = Rational::from((-100, 17));
        /// let recip = r.recip();
        /// assert_eq!(recip, (-17, 100));
        /// ```
        ///
        /// # Panics
        ///
        /// Panics if the value is zero.
        fn recip();
        /// Computes the reciprocal.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// let mut r = Rational::from((-100, 17));
        /// r.recip_mut();
        /// assert_eq!(r, (-17, 100));
        /// ```
        ///
        /// # Panics
        ///
        /// Panics if the value is zero.
        fn recip_mut;
        /// Computes the reciprocal.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// let r = Rational::from((-100, 17));
        /// let rr = r.recip_ref();
        /// let recip = Rational::from(rr);
        /// assert_eq!(recip, (-17, 100));
        /// ```
        fn recip_ref -> RecipRef;
    }

    /// Rounds the number upwards (towards plus infinity) and returns
    /// it as an [`Integer`](struct.Integer.html).
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// // -3.7
    /// let r1 = Rational::from((-37, 10));
    /// let i1 = r1.ceil();
    /// assert_eq!(i1, -3);
    /// // 3.3
    /// let r2 = Rational::from((33, 10));
    /// let i2 = r2.ceil();
    /// assert_eq!(i2, 4);
    /// ```
    #[inline]
    pub fn ceil(self) -> Integer {
        let (mut num, den) = self.into_numer_denom();
        unsafe {
            xgmp::num_den_ceil(num.inner_mut(), num.inner(), den.inner());
        }
        num
    }

    /// Rounds the number upwards (towards plus infinity).
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Rational};
    /// // -3.7
    /// let mut r = Rational::from((-37, 10));
    /// r.ceil_mut();
    /// assert_eq!(r, -3);
    /// // 3.3
    /// r.assign((33, 10));
    /// r.ceil_mut();
    /// assert_eq!(r, 4);
    /// ```
    #[inline]
    pub fn ceil_mut(&mut self) {
        unsafe {
            let (num, den) = self.as_mut_numer_denom_no_canonicalization();
            xgmp::num_den_ceil(num.inner_mut(), num.inner(), den.inner());
            den.assign(1);
        }
    }

    /// Rounds the number upwards (towards plus infinity).
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Integer, Rational};
    /// let mut ceil = Integer::new();
    /// // -3.7
    /// let r1 = Rational::from((-37, 10));
    /// ceil.assign(r1.ceil_ref());
    /// assert_eq!(ceil, -3);
    /// // 3.3
    /// let r2 = Rational::from((33, 10));
    /// ceil.assign(r2.ceil_ref());
    /// assert_eq!(ceil, 4);
    /// ```
    #[inline]
    pub fn ceil_ref(&self) -> CeilRef {
        CeilRef { ref_self: self }
    }

    /// Rounds the number downwards (towards minus infinity) and
    /// returns it as an [`Integer`](struct.Integer.html).
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// // -3.7
    /// let r1 = Rational::from((-37, 10));
    /// let i1 = r1.floor();
    /// assert_eq!(i1, -4);
    /// // 3.3
    /// let r2 = Rational::from((33, 10));
    /// let i2 = r2.floor();
    /// assert_eq!(i2, 3);
    /// ```
    #[inline]
    pub fn floor(self) -> Integer {
        let (mut num, den) = self.into_numer_denom();
        unsafe {
            xgmp::num_den_floor(num.inner_mut(), num.inner(), den.inner());
        }
        num
    }

    /// Rounds the number downwards (towards minus infinity).
    ///
    /// ```rust
    /// use rug::{Assign, Rational};
    /// // -3.7
    /// let mut r = Rational::from((-37, 10));
    /// r.floor_mut();
    /// assert_eq!(r, -4);
    /// // 3.3
    /// r.assign((33, 10));
    /// r.floor_mut();
    /// assert_eq!(r, 3);
    /// ```
    #[inline]
    pub fn floor_mut(&mut self) {
        unsafe {
            let (num, den) = self.as_mut_numer_denom_no_canonicalization();
            xgmp::num_den_floor(num.inner_mut(), num.inner(), den.inner());
            den.assign(1);
        }
    }

    /// Rounds the number downwards (towards minus infinity).
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Integer, Rational};
    /// let mut floor = Integer::new();
    /// // -3.7
    /// let r1 = Rational::from((-37, 10));
    /// floor.assign(r1.floor_ref());
    /// assert_eq!(floor, -4);
    /// // 3.3
    /// let r2 = Rational::from((33, 10));
    /// floor.assign(r2.floor_ref());
    /// assert_eq!(floor, 3);
    /// ```
    #[inline]
    pub fn floor_ref(&self) -> FloorRef {
        FloorRef { ref_self: self }
    }

    /// Rounds the number to the nearest integer and returns it as an
    /// [`Integer`](struct.Integer.html).
    ///
    /// When the number lies exactly between two integers, it is
    /// rounded away from zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// // -3.5
    /// let r1 = Rational::from((-35, 10));
    /// let i1 = r1.round();
    /// assert_eq!(i1, -4);
    /// // 3.7
    /// let r2 = Rational::from((37, 10));
    /// let i2 = r2.round();
    /// assert_eq!(i2, 4);
    /// ```
    #[inline]
    pub fn round(self) -> Integer {
        let (mut num, den) = self.into_numer_denom();
        unsafe {
            xgmp::num_den_round(num.inner_mut(), num.inner(), den.inner());
        }
        num
    }

    /// Rounds the number to the nearest integer.
    ///
    /// When the number lies exactly between two integers, it is
    /// rounded away from zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Rational};
    /// // -3.5
    /// let mut r = Rational::from((-35, 10));
    /// r.round_mut();
    /// assert_eq!(r, -4);
    /// // 3.7
    /// r.assign((37, 10));
    /// r.round_mut();
    /// assert_eq!(r, 4);
    /// ```
    #[inline]
    pub fn round_mut(&mut self) {
        unsafe {
            let (num, den) = self.as_mut_numer_denom_no_canonicalization();
            xgmp::num_den_round(num.inner_mut(), num.inner(), den.inner());
            den.assign(1);
        }
    }

    /// Rounds the number to the nearest integer.
    ///
    /// When the number lies exactly between two integers, it is
    /// rounded away from zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Integer, Rational};
    /// let mut round = Integer::new();
    /// // -3.5
    /// let r1 = Rational::from((-35, 10));
    /// round.assign(r1.round_ref());
    /// assert_eq!(round, -4);
    /// // 3.7
    /// let r2 = Rational::from((37, 10));
    /// round.assign(r2.round_ref());
    /// assert_eq!(round, 4);
    /// ```
    #[inline]
    pub fn round_ref(&self) -> RoundRef {
        RoundRef { ref_self: self }
    }

    /// Rounds the number towards zero and returns it as an
    /// [`Integer`](struct.Integer.html).
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::Rational;
    /// // -3.7
    /// let r1 = Rational::from((-37, 10));
    /// let i1 = r1.trunc();
    /// assert_eq!(i1, -3);
    /// // 3.3
    /// let r2 = Rational::from((33, 10));
    /// let i2 = r2.trunc();
    /// assert_eq!(i2, 3);
    /// ```
    #[inline]
    pub fn trunc(self) -> Integer {
        let (mut num, den) = self.into_numer_denom();
        unsafe {
            xgmp::num_den_trunc(num.inner_mut(), num.inner(), den.inner());
        }
        num
    }

    /// Rounds the number towards zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Rational};
    /// // -3.7
    /// let mut r = Rational::from((-37, 10));
    /// r.trunc_mut();
    /// assert_eq!(r, -3);
    /// // 3.3
    /// r.assign((33, 10));
    /// r.trunc_mut();
    /// assert_eq!(r, 3);
    /// ```
    #[inline]
    pub fn trunc_mut(&mut self) {
        unsafe {
            let (num, den) = self.as_mut_numer_denom_no_canonicalization();
            xgmp::num_den_trunc(num.inner_mut(), num.inner(), den.inner());
            den.assign(1);
        }
    }

    /// Rounds the number towards zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Integer, Rational};
    /// let mut trunc = Integer::new();
    /// // -3.7
    /// let r1 = Rational::from((-37, 10));
    /// trunc.assign(r1.trunc_ref());
    /// assert_eq!(trunc, -3);
    /// // 3.3
    /// let r2 = Rational::from((33, 10));
    /// trunc.assign(r2.trunc_ref());
    /// assert_eq!(trunc, 3);
    /// ```
    #[inline]
    pub fn trunc_ref(&self) -> TruncRef {
        TruncRef { ref_self: self }
    }

    math_op1! {
        Rational;
        xgmp::mpq_fract;
        /// Computes the fractional part of the number.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// // -100/17 = -5 15/17
        /// let r = Rational::from((-100, 17));
        /// let fract = r.fract();
        /// assert_eq!(fract, (-15, 17));
        /// ```
        fn fract();
        /// Computes the fractional part of the number.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// // -100/17 = -5 15/17
        /// let mut r = Rational::from((-100, 17));
        /// r.fract_mut();
        /// assert_eq!(r, (-15, 17));
        /// ```
        fn fract_mut;
        /// Computes the fractional part of the number.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use rug::Rational;
        /// let r = Rational::from((-100, 17));
        /// let rr = r.fract_ref();
        /// let fract = Rational::from(rr);
        /// assert_eq!(fract, (-15, 17));
        /// ```
        fn fract_ref -> FractRef;
    }

    /// Computes the fractional and truncated parts of the number.
    ///
    /// The initial value of `trunc` is ignored.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Integer, Rational};
    /// // -100/17 = -5 15/17
    /// let r = Rational::from((-100, 17));
    /// let (fract, trunc) = r.fract_trunc(Integer::new());
    /// assert_eq!(fract, (-15, 17));
    /// assert_eq!(trunc, -5);
    /// ```
    #[inline]
    pub fn fract_trunc(mut self, mut trunc: Integer) -> (Rational, Integer) {
        self.fract_trunc_mut(&mut trunc);
        (self, trunc)
    }

    /// Computes the fractional and truncated parts of the number.
    ///
    /// The initial value of `trunc` is ignored.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Integer, Rational};
    /// // -100/17 = -5 15/17
    /// let mut r = Rational::from((-100, 17));
    /// let mut whole = Integer::new();
    /// r.fract_trunc_mut(&mut whole);
    /// assert_eq!(r, (-15, 17));
    /// assert_eq!(whole, -5);
    /// ```
    #[inline]
    pub fn fract_trunc_mut(&mut self, trunc: &mut Integer) {
        unsafe {
            xgmp::mpq_fract_trunc(
                self.inner_mut(),
                trunc.inner_mut(),
                self.inner(),
            );
        }
    }

    /// Computes the fractional and truncated parts of the number.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Integer, Rational};
    /// // -100/17 = -5 15/17
    /// let r = Rational::from((-100, 17));
    /// let r_ref = r.fract_trunc_ref();
    /// let (mut fract, mut trunc) = (Rational::new(), Integer::new());
    /// (&mut fract, &mut trunc).assign(r_ref);
    /// assert_eq!(fract, (-15, 17));
    /// assert_eq!(trunc, -5);
    /// ```
    #[inline]
    pub fn fract_trunc_ref(&self) -> FractTruncRef {
        FractTruncRef { ref_self: self }
    }

    /// Computes the fractional and floor parts of the number.
    ///
    /// The fractional part cannot be negative. The initial value of
    /// `floor` is ignored.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Integer, Rational};
    /// // -100/17 = -6 + 2/17
    /// let r = Rational::from((-100, 17));
    /// let (fract, floor) = r.fract_floor(Integer::new());
    /// assert_eq!(fract, (2, 17));
    /// assert_eq!(floor, -6);
    /// ```
    #[inline]
    pub fn fract_floor(mut self, mut floor: Integer) -> (Rational, Integer) {
        self.fract_floor_mut(&mut floor);
        (self, floor)
    }

    /// Computes the fractional and floor parts of the number.
    ///
    /// The fractional part cannot be negative. The initial value of
    /// `floor` is ignored.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Integer, Rational};
    /// // -100/17 = -6 + 2/17
    /// let mut r = Rational::from((-100, 17));
    /// let mut floor = Integer::new();
    /// r.fract_floor_mut(&mut floor);
    /// assert_eq!(r, (2, 17));
    /// assert_eq!(floor, -6);
    /// ```
    #[inline]
    pub fn fract_floor_mut(&mut self, floor: &mut Integer) {
        unsafe {
            xgmp::mpq_fract_floor(
                self.inner_mut(),
                floor.inner_mut(),
                self.inner(),
            );
        }
    }

    /// Computes the fractional and floor parts of the number.
    ///
    /// The fractional part cannot be negative.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Integer, Rational};
    /// // -100/17 = -6 + 2/17
    /// let r = Rational::from((-100, 17));
    /// let r_ref = r.fract_floor_ref();
    /// let (mut fract, mut floor) = (Rational::new(), Integer::new());
    /// (&mut fract, &mut floor).assign(r_ref);
    /// assert_eq!(fract, (2, 17));
    /// assert_eq!(floor, -6);
    /// ```
    #[inline]
    pub fn fract_floor_ref(&self) -> FractFloorRef {
        FractFloorRef { ref_self: self }
    }

    /// Computes the fractional and ceil parts of the number.
    ///
    /// The fractional part cannot greater than zero. The initial
    /// value of `ceil` is ignored.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Integer, Rational};
    /// // 100/17 = 6 - 2/17
    /// let r = Rational::from((100, 17));
    /// let (fract, ceil) = r.fract_ceil(Integer::new());
    /// assert_eq!(fract, (-2, 17));
    /// assert_eq!(ceil, 6);
    /// ```
    #[inline]
    pub fn fract_ceil(mut self, mut ceil: Integer) -> (Rational, Integer) {
        self.fract_ceil_mut(&mut ceil);
        (self, ceil)
    }

    /// Computes the fractional and ceil parts of the number.
    ///
    /// The fractional part cannot be greater than zero. The initial
    /// value of `ceil` is ignored.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Integer, Rational};
    /// // 100/17 = 6 - 2/17
    /// let mut r = Rational::from((100, 17));
    /// let mut ceil = Integer::new();
    /// r.fract_ceil_mut(&mut ceil);
    /// assert_eq!(r, (-2, 17));
    /// assert_eq!(ceil, 6);
    /// ```
    #[inline]
    pub fn fract_ceil_mut(&mut self, ceil: &mut Integer) {
        unsafe {
            xgmp::mpq_fract_ceil(
                self.inner_mut(),
                ceil.inner_mut(),
                self.inner(),
            );
        }
    }

    /// Computes the fractional and ceil parts of the number.
    ///
    /// The fractional part cannot be greater than zero.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use rug::{Assign, Integer, Rational};
    /// // 100/17 = 6 - 2/17
    /// let r = Rational::from((100, 17));
    /// let r_ref = r.fract_ceil_ref();
    /// let (mut fract, mut ceil) = (Rational::new(), Integer::new());
    /// (&mut fract, &mut ceil).assign(r_ref);
    /// assert_eq!(fract, (-2, 17));
    /// assert_eq!(ceil, 6);
    /// ```
    #[inline]
    pub fn fract_ceil_ref(&self) -> FractCeilRef {
        FractCeilRef { ref_self: self }
    }
}

ref_math_op1! { Rational; gmp::mpq_abs; struct AbsRef {} }

#[derive(Clone, Copy)]
pub struct ClampRef<'a, Min, Max>
where
    Rational: PartialOrd<Min>
        + PartialOrd<Max>
        + Assign<&'a Min>
        + Assign<&'a Max>,
    Min: 'a,
    Max: 'a,
{
    ref_self: &'a Rational,
    min: &'a Min,
    max: &'a Max,
}

impl<'a, Min, Max> From<ClampRef<'a, Min, Max>> for Rational
where
    Rational: PartialOrd<Min>
        + PartialOrd<Max>
        + Assign<&'a Min>
        + Assign<&'a Max>,
    Min: 'a,
    Max: 'a,
{
    #[inline]
    fn from(t: ClampRef<'a, Min, Max>) -> Rational {
        let mut ret = Rational::new();
        ret.assign(t);
        ret
    }
}

impl<'a, Min, Max> Assign<ClampRef<'a, Min, Max>> for Rational
where
    Rational: PartialOrd<Min>
        + PartialOrd<Max>
        + Assign<&'a Min>
        + Assign<&'a Max>,
    Min: 'a,
    Max: 'a,
{
    #[inline]
    fn assign(&mut self, src: ClampRef<'a, Min, Max>) {
        if src.ref_self.lt(src.min) {
            self.assign(src.min);
            assert!(!(&*self).gt(src.max), "minimum larger than maximum");
        } else if src.ref_self.gt(src.max) {
            self.assign(src.max);
            assert!(!(&*self).lt(src.min), "minimum larger than maximum");
        } else {
            self.assign(src.ref_self);
        }
    }
}

ref_math_op1! { Rational; xgmp::mpq_inv_check_0; struct RecipRef {} }

pub struct CeilRef<'a> {
    ref_self: &'a Rational,
}

from_borrow! { CeilRef<'a> => Integer }

impl<'a> Assign<CeilRef<'a>> for Integer {
    #[inline]
    fn assign(&mut self, src: CeilRef<'a>) {
        unsafe {
            xgmp::mpq_ceil(self.inner_mut(), src.ref_self.inner());
        }
    }
}

pub struct FloorRef<'a> {
    ref_self: &'a Rational,
}

from_borrow! { FloorRef<'a> => Integer }

impl<'a> Assign<FloorRef<'a>> for Integer {
    #[inline]
    fn assign(&mut self, src: FloorRef<'a>) {
        unsafe {
            xgmp::mpq_floor(self.inner_mut(), src.ref_self.inner());
        }
    }
}

pub struct RoundRef<'a> {
    ref_self: &'a Rational,
}

from_borrow! { RoundRef<'a> => Integer }

impl<'a> Assign<RoundRef<'a>> for Integer {
    #[inline]
    fn assign(&mut self, src: RoundRef<'a>) {
        unsafe {
            xgmp::mpq_round(self.inner_mut(), src.ref_self.inner());
        }
    }
}

pub struct TruncRef<'a> {
    ref_self: &'a Rational,
}

from_borrow! { TruncRef<'a> => Integer }

impl<'a> Assign<TruncRef<'a>> for Integer {
    #[inline]
    fn assign(&mut self, src: TruncRef<'a>) {
        unsafe {
            xgmp::mpq_trunc(self.inner_mut(), src.ref_self.inner());
        }
    }
}

ref_math_op1! { Rational; xgmp::mpq_fract; struct FractRef {} }

pub struct FractTruncRef<'a> {
    ref_self: &'a Rational,
}

impl<'a> From<FractTruncRef<'a>> for (Rational, Integer) {
    #[inline]
    fn from(src: FractTruncRef<'a>) -> (Rational, Integer) {
        let mut pair =
            <(Rational, Integer) as Default>::default();
        (&mut pair.0, &mut pair.1).assign(src);
        pair
    }
}

impl<'a> Assign<FractTruncRef<'a>> for (&'a mut Rational, &'a mut Integer) {
    #[inline]
    fn assign(&mut self, src: FractTruncRef<'a>) {
        unsafe {
            xgmp::mpq_fract_trunc(
                self.0.inner_mut(),
                self.1.inner_mut(),
                src.ref_self.inner(),
            );
        }
    }
}

pub struct FractFloorRef<'a> {
    ref_self: &'a Rational,
}

impl<'a> From<FractFloorRef<'a>> for (Rational, Integer) {
    #[inline]
    fn from(src: FractFloorRef<'a>) -> (Rational, Integer) {
        let mut pair =
            <(Rational, Integer) as Default>::default();
        (&mut pair.0, &mut pair.1).assign(src);
        pair
    }
}

impl<'a> Assign<FractFloorRef<'a>> for (&'a mut Rational, &'a mut Integer) {
    #[inline]
    fn assign(&mut self, src: FractFloorRef<'a>) {
        unsafe {
            xgmp::mpq_fract_floor(
                self.0.inner_mut(),
                self.1.inner_mut(),
                src.ref_self.inner(),
            );
        }
    }
}

pub struct FractCeilRef<'a> {
    ref_self: &'a Rational,
}

impl<'a> From<FractCeilRef<'a>> for (Rational, Integer) {
    #[inline]
    fn from(src: FractCeilRef<'a>) -> (Rational, Integer) {
        let mut pair =
            <(Rational, Integer) as Default>::default();
        (&mut pair.0, &mut pair.1).assign(src);
        pair
    }
}

impl<'a> Assign<FractCeilRef<'a>> for (&'a mut Rational, &'a mut Integer) {
    #[inline]
    fn assign(&mut self, src: FractCeilRef<'a>) {
        unsafe {
            xgmp::mpq_fract_ceil(
                self.0.inner_mut(),
                self.1.inner_mut(),
                src.ref_self.inner(),
            );
        }
    }
}

#[derive(Clone, Copy)]
pub struct BorrowRational<'a> {
    inner: mpq_t,
    phantom: PhantomData<&'a Rational>,
}

impl<'a> Deref for BorrowRational<'a> {
    type Target = Rational;
    #[inline]
    fn deref(&self) -> &Rational {
        let ptr = (&self.inner) as *const _ as *const _;
        unsafe { &*ptr }
    }
}

pub fn make_string(r: &Rational, radix: i32, to_upper: bool) -> String {
    assert!(radix >= 2 && radix <= 36, "radix out of range");
    let (num, den) = r.as_numer_denom();
    let n_size = unsafe { gmp::mpz_sizeinbase(num.inner(), radix) };
    let d_size = unsafe { gmp::mpz_sizeinbase(den.inner(), radix) };
    // n_size + d_size + 3 for '-', '/' and nul
    let size = n_size.checked_add(d_size).unwrap().checked_add(3).unwrap();
    let mut buf = Vec::<u8>::with_capacity(size);
    let case_radix = if to_upper { -radix } else { radix };
    unsafe {
        buf.set_len(size);
        gmp::mpq_get_str(
            buf.as_mut_ptr() as *mut c_char,
            case_radix as c_int,
            r.inner(),
        );
        let nul_index = buf.iter().position(|&x| x == 0).unwrap();
        buf.set_len(nul_index);
        String::from_utf8_unchecked(buf)
    }
}

/// A validated string that can always be converted to a `Rational`.
///
/// See the [`Rational::valid_str_radix`][valid] method.
///
/// # Examples
///
/// ```rust
/// use rug::Rational;
/// use rug::rational::ValidRational;
/// // This string is correct in radix 10, it cannot fail.
/// let s = "123/456";
/// let valid: ValidRational = match Rational::valid_str_radix(s, 10) {
///     Ok(valid) => valid,
///     Err(_) => unreachable!(),
/// };
/// let r = Rational::from(valid);
/// assert_eq!(r, (123, 456));
/// ```
///
/// [valid]: ../struct.Rational.html#method.valid_str_radix
#[derive(Clone, Debug)]
pub struct ValidRational<'a> {
    bytes: &'a [u8],
    radix: i32,
}

impl<'a> Assign<ValidRational<'a>> for Rational {
    #[inline]
    fn assign(&mut self, rhs: ValidRational) {
        let mut v = Vec::<u8>::with_capacity(rhs.bytes.len() + 1);
        v.extend_from_slice(rhs.bytes);
        v.push(0);
        let err = unsafe {
            let c_str = CStr::from_bytes_with_nul_unchecked(&v);
            gmp::mpq_set_str(self.inner_mut(), c_str.as_ptr(), rhs.radix.into())
        };
        assert_eq!(err, 0);
        unsafe {
            gmp::mpq_canonicalize(self.inner_mut());
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
/// An error which can be returned when parsing a `Rational` number.
///
/// # Examples
///
/// ```rust
/// use rug::Rational;
/// use rug::rational::ParseRationalError;
/// // This string is not a rational number.
/// let s = "something completely different (_!_!_)";
/// let error: ParseRationalError = match Rational::valid_str_radix(s, 4) {
///     Ok(_) => unreachable!(),
///     Err(error) => error,
/// };
/// println!("Parse error: {:?}", error);
/// ```
pub struct ParseRationalError {
    kind: ParseErrorKind,
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
enum ParseErrorKind {
    InvalidDigit,
    NoDigits,
    NumerNoDigits,
    DenomNoDigits,
    TooManySlashes,
    DenomZero,
}

impl Error for ParseRationalError {
    fn description(&self) -> &str {
        use self::ParseErrorKind::*;
        match self.kind {
            InvalidDigit => "invalid digit found in string",
            NoDigits => "string has no digits",
            NumerNoDigits => "string has no digits for numerator",
            DenomNoDigits => "string has no digits for denominator",
            TooManySlashes => "more than one / found in string",
            DenomZero => "string has zero denominator",
        }
    }
}

/// Used to borrow the numerator and denominator of a
/// [`Rational`](../struct.Rational.html) number mutably.
///
/// The [`Rational`](../struct.Rational.html) number is canonicalized
/// when the borrow ends.
///
/// See the [`Rational::as_mut_numer_denom`][mutnumden] method.
///
/// # Examples
///
/// ```rust
/// use rug::Rational;
///
/// let mut r = Rational::from((3, 5));
/// {
///     let mut num_den = r.as_mut_numer_denom();
///     // change r from 3/5 to 4/8, which is equal to 1/2
///     *num_den.num() += 1;
///     *num_den.den() += 3;
///     // borrow ends here
/// }
/// let num_den = r.as_numer_denom();
/// assert_eq!(*num_den.0, 1);
/// assert_eq!(*num_den.1, 2);
/// ```
///
/// [mutnumden]: ../struct.Rational.html#method.as_mut_numer_denom
pub struct MutNumerDenom<'a> {
    num: &'a mut Integer,
    den_place: &'a mut Integer,
    den_actual: Integer,
}

impl<'a> MutNumerDenom<'a> {
    /// Gets the mutable numerator.
    #[inline]
    pub fn num(&mut self) -> &mut Integer {
        self.num
    }
    /// Gets the mutable denominator.
    #[inline]
    pub fn den(&mut self) -> &mut Integer {
        &mut self.den_actual
    }
    /// Gets the mutable numerator and denominator.
    #[inline]
    pub fn num_den(&mut self) -> (&mut Integer, &mut Integer) {
        (self.num, &mut self.den_actual)
    }
}

impl<'a> Drop for MutNumerDenom<'a> {
    #[inline]
    fn drop(&mut self) {
        assert_ne!(self.den_actual.cmp0(), Ordering::Equal, "division by zero");
        unsafe {
            // We can finally place the actual denominator in its
            // proper place inside the rational number.
            mem::swap(&mut self.den_actual, self.den_place);

            let rat_num = self.num.inner_mut();
            let rat_den = self.den_place.inner_mut();
            let mut canon: mpq_t = mem::uninitialized();
            let canon_num_ptr = gmp::mpq_numref(&mut canon);
            let canon_den_ptr = gmp::mpq_denref(&mut canon);
            mem::swap(rat_num, &mut *canon_num_ptr);
            mem::swap(rat_den, &mut *canon_den_ptr);
            gmp::mpq_canonicalize(&mut canon);
            mem::swap(rat_num, &mut *canon_num_ptr);
            mem::swap(rat_den, &mut *canon_den_ptr);
        }
    }
}

impl Inner for Rational {
    type Output = mpq_t;
    #[inline]
    fn inner(&self) -> &mpq_t {
        &self.inner
    }
}

impl InnerMut for Rational {
    #[inline]
    unsafe fn inner_mut(&mut self) -> &mut mpq_t {
        &mut self.inner
    }
}