use num_traits::sign::Signed;
use num_traits::Num;
use num_traits::NumOps;
use num_traits::One;
use num_traits::Pow;
use num_traits::Signed as SignedOps;
use num_traits::Zero;
use std::cmp::Ordering;
use std::cmp::PartialEq;
use std::cmp::PartialOrd;
use std::fmt::Debug;
use std::fmt::Display;
use std::ops::Add;
use std::ops::AddAssign;
use std::ops::Div;
use std::ops::DivAssign;
use std::ops::Mul;
use std::ops::MulAssign;
use std::ops::Neg;
use std::ops::Rem;
use std::ops::Sub;
use std::ops::SubAssign;

trait_group! {
    pub trait RationalInt
    : NumOps
    + Debug
    + PartialEq
    + PartialOrd
    + Zero<Output = Self>
    + One<Output = Self>
    + Pow<u32, Output = Self>
    + Neg<Output = Self>
    + Clone
    + Default
}

fn gcd<T>(a: &T, b: &T) -> T
where
    T: Rem<Output = T> + Clone + Zero,
{
    let mut n1 = a.clone();
    let mut n2 = b.clone();
    let mut tmp: T;
    while !n2.is_zero() {
        tmp = n1;
        n1 = n2.clone();
        n2 = tmp % n2;
    }
    n1
}

fn mcm<'a, T>(n1: &'a T, n2: &'a T) -> T
where
    T: Div<Output = T> + Rem<Output = T> + Clone + Zero,
    &'a T: Mul<Output = T>,
{
    let den = gcd(n1, n2);
    n1 * n2 / den
}

#[derive(Debug)]
pub struct Rational<TYPE> {
    num: TYPE,
    den: TYPE,
}

impl<TYPE> Rational<TYPE>
where
    TYPE: Zero + One + Clone + Rem<Output = TYPE> + PartialOrd + Neg<Output = TYPE>,
    for<'a> &'a TYPE: Div<&'a TYPE, Output = TYPE>,
{
    fn simplify(&mut self) {
        if self.num.is_zero() {
            self.den = TYPE::one();
        } else if self.den.is_zero() {
        } else {
            (self.num, self.den) = {
                let n1_opt: TYPE;
                let n1 = if self.den < TYPE::zero() {
                    n1_opt = -self.num.clone();
                    &n1_opt
                } else {
                    &self.num
                };
                let n2_opt: TYPE;
                let n2 = if self.den < TYPE::zero() {
                    n2_opt = -self.den.clone();
                    &n2_opt
                } else {
                    &self.den
                };
                let num_abs_opt: TYPE;
                let num_abs = if self.num < TYPE::zero() {
                    num_abs_opt = -self.num.clone();
                    &num_abs_opt
                } else {
                    &self.num
                };
                let gcd = gcd(num_abs, n2);
                (n1 / &gcd, n2 / &gcd)
            };
        }
    }
}

impl<TYPE> Rational<TYPE>
where
    TYPE: RationalInt,
{
    pub fn new(num: TYPE, den: TYPE) -> Rational<TYPE> {
        let res = den.partial_cmp(&TYPE::zero());
        match res {
            Some(Ordering::Greater) => Rational { num, den },
            Some(Ordering::Less) => Rational {
                num: -num,
                den: -den,
            },
            _ => {
                panic!("Rational denominator cannot be zero or NaN")
            }
        }
    }
}

#[opimps::impl_op(Pow)]
fn pow<TYPE>(self: Rational<TYPE>, exp: u32) -> Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: Pow<u32, Output = TYPE>,
{
    Rational {
        num: self.num.pow(exp),
        den: self.den.pow(exp),
    }
}

#[opimps::impl_op(Pow)]
fn pow<TYPE>(self: &Rational<TYPE>, exp: u32) -> Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: Pow<u32, Output = TYPE>,
{
    Rational {
        num: (&self.num).pow(exp),
        den: (&self.den).pow(exp),
    }
}

#[opimps::impl_ops(Add)]
fn add<TYPE>(self: Rational<TYPE>, rhs: Rational<TYPE>) -> Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    let den = mcm::<TYPE>(&self.den, &rhs.den);
    let a = &self.num * &den;
    let b = &rhs.num * &den;
    let num = &a / &self.den + &b / &rhs.den;
    let mut result: Rational<TYPE> = Rational { num, den };
    result.simplify();
    result
}

#[opimps::impl_ops(Sub)]
fn sub<TYPE>(self: Rational<TYPE>, rhs: Rational<TYPE>) -> Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    let den = mcm::<TYPE>(&self.den, &rhs.den);
    let a = &self.num * &den;
    let b = &rhs.num * &den;
    let num = &a / &self.den - &b / &rhs.den;
    let mut result: Rational<TYPE> = Rational { num, den };
    result.simplify();
    result
}

#[opimps::impl_ops(Mul)]
fn mul<TYPE>(self: Rational<TYPE>, rhs: Rational<TYPE>) -> Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    let num = &self.num * &rhs.num;
    let den = &self.den * &rhs.den;
    let mut result = Rational { num, den };
    result.simplify();
    result
}

#[opimps::impl_ops(Div)]
fn div<TYPE>(self: Rational<TYPE>, rhs: Rational<TYPE>) -> Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    let den = &self.den * &rhs.num;
    let num = &self.num * &rhs.den;
    let mut result = Rational::new(num, den);
    result.simplify();
    result
}

#[opimps::impl_ops(Rem)]
fn rem<TYPE>(self: Rational<TYPE>, rhs: Rational<TYPE>) -> Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    match self.partial_cmp(&rhs) {
        Some(std::cmp::Ordering::Less) => rhs.clone(),
        Some(std::cmp::Ordering::Equal) => Rational::<TYPE>::zero(),
        Some(std::cmp::Ordering::Greater) => {
            let div = self / rhs;
            let num = &div.num / &div.den;
            div - Rational::new(num, TYPE::one())
        }
        None => {
            panic!("Cannot compare")
        }
    }
}

impl<'a, TYPE> AddAssign<&'a Rational<TYPE>> for Rational<TYPE>
where
    TYPE: Zero
        + One
        + Clone
        + Rem<Output = TYPE>
        + PartialOrd
        + Neg<Output = TYPE>
        + Div<Output = TYPE>,
    for<'b> &'b TYPE: Mul<&'b TYPE, Output = TYPE> + Div<&'b TYPE, Output = TYPE>,
{
    fn add_assign(&mut self, rhs: &'a Self) {
        let den = mcm::<TYPE>(&self.den, &rhs.den);
        let a = &self.num * &den;
        let b = &rhs.num * &den;
        let num = &a / &self.den + &b / &rhs.den;
        self.num = num;
        self.den = den;
        self.simplify();
    }
}

impl<TYPE> AddAssign for Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn add_assign(&mut self, rhs: Self) {
        *self += &rhs;
    }
}

impl<'a, TYPE> SubAssign<&'a Rational<TYPE>> for Rational<TYPE>
where
    TYPE: Div<Output = TYPE>
        + Sub<Output = TYPE>
        + Rem<Output = TYPE>
        + Neg<Output = TYPE>
        + Clone
        + Zero
        + One
        + PartialOrd,
    for<'c> &'c TYPE: Mul<&'c TYPE, Output = TYPE> + Div<&'c TYPE, Output = TYPE>,
    for<'b> TYPE: SubAssign<&'b TYPE>,
{
    fn sub_assign(&mut self, rhs: &'a Self) {
        let den = mcm::<TYPE>(&self.den, &rhs.den);
        let a = &self.num * &den;
        let b = &rhs.num * &den;
        let num = &a / &self.den - &b / &rhs.den;
        self.num = num;
        self.den = den;
        self.simplify();
    }
}

impl<TYPE> SubAssign for Rational<TYPE>
where
    TYPE: Div<Output = TYPE>
        + Sub<Output = TYPE>
        + Rem<Output = TYPE>
        + Neg<Output = TYPE>
        + Clone
        + Zero
        + One
        + PartialOrd,
    for<'c> &'c TYPE: Mul<&'c TYPE, Output = TYPE> + Div<&'c TYPE, Output = TYPE>,
    for<'b> TYPE: SubAssign<&'b TYPE>,
{
    fn sub_assign(&mut self, rhs: Self) {
        *self -= &rhs;
    }
}

impl<'a, TYPE> MulAssign<&'a Rational<TYPE>> for Rational<TYPE>
where
    for<'b> TYPE: MulAssign<&'b TYPE>,
    TYPE: PartialOrd + One + Clone + Zero + Rem<Output = TYPE> + Neg<Output = TYPE>,
    for<'c> &'c TYPE: Div<&'c TYPE, Output = TYPE>,
{
    fn mul_assign(&mut self, rhs: &'a Self) {
        self.num *= &rhs.num;
        self.den *= &rhs.den;
        self.simplify();
    }
}

impl<TYPE> MulAssign for Rational<TYPE>
where
    for<'a> TYPE: MulAssign<&'a TYPE>,
    TYPE: PartialOrd + One + Clone + Zero + Rem<Output = TYPE> + Neg<Output = TYPE>,
    for<'c> &'c TYPE: Div<&'c TYPE, Output = TYPE>,
{
    fn mul_assign(&mut self, rhs: Self) {
        *self *= &rhs;
    }
}

impl<'a, TYPE> DivAssign<&'a Rational<TYPE>> for Rational<TYPE>
where
    for<'b> TYPE: MulAssign<&'b TYPE>,
    TYPE: PartialOrd + One + Clone + Zero + Rem<Output = TYPE> + Neg<Output = TYPE>,
    for<'c> &'c TYPE: Div<&'c TYPE, Output = TYPE>,
{
    fn div_assign(&mut self, rhs: &'a Self) {
        self.num *= &rhs.den;
        self.den *= &rhs.num;
        self.simplify()
    }
}

impl<TYPE> DivAssign for Rational<TYPE>
where
    for<'a> TYPE: MulAssign<&'a TYPE>,
    TYPE: PartialOrd + One + Clone + Zero + Rem<Output = TYPE> + Neg<Output = TYPE>,
    for<'c> &'c TYPE: Div<&'c TYPE, Output = TYPE>,
{
    fn div_assign(&mut self, rhs: Self) {
        *self /= &rhs;
        self.simplify()
    }
}

impl<TYPE> Display for Rational<TYPE>
where
    TYPE: RationalInt + Display,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}/{}", self.num, self.den)
    }
}

impl<TYPE> PartialEq for Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn eq(&self, other: &Self) -> bool {
        self.partial_cmp(other) == Some(Ordering::Equal)
    }
}

impl<TYPE> Eq for Rational<TYPE>
where
    TYPE: RationalInt + Eq,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
}

impl<TYPE> PartialOrd for Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        (&self.num * &other.den).partial_cmp(&(&other.num * &self.den))
    }
}

impl<TYPE> Ord for Rational<TYPE>
where
    TYPE: RationalInt + Ord,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn cmp(&self, other: &Self) -> Ordering {
        (&self.num * &other.den).cmp(&(&other.num * &self.den))
    }
}

impl<TYPE> Clone for Rational<TYPE>
where
    TYPE: Clone,
{
    fn clone(&self) -> Self {
        Rational {
            num: self.num.clone(),
            den: self.den.clone(),
        }
    }
}

impl<TYPE> Copy for Rational<TYPE> where TYPE: Copy {}

impl<TYPE> Zero for Rational<TYPE>
where
    TYPE: RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn zero() -> Rational<TYPE> {
        Rational {
            num: TYPE::zero(),
            den: TYPE::one(),
        }
    }

    fn is_zero(&self) -> bool {
        self.num.is_zero() && !self.den.is_zero()
    }
}

impl<TYPE> One for Rational<TYPE>
where
    TYPE: RationalInt + Display,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn one() -> Self {
        Rational {
            num: TYPE::one(),
            den: TYPE::one(),
        }
    }

    fn is_one(&self) -> bool {
        self.num == self.den
    }
}

impl<TYPE> Default for Rational<TYPE>
where
    TYPE: RationalInt + Display,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn default() -> Self {
        Rational::<TYPE>::zero()
    }
}

#[opimps::impl_uni_op(Neg)]
fn neg<TYPE>(self: Rational<TYPE>) -> Rational<TYPE>
where
    TYPE: RationalInt,
{
    Rational::new(-self.num, self.den)
}

#[opimps::impl_uni_op(Neg)]
fn neg<TYPE>(self: &Rational<TYPE>) -> Rational<TYPE>
where
    TYPE: RationalInt,
{
    Rational::new(-self.num.clone(), self.den.clone())
}

impl<TYPE> Num for Rational<TYPE>
where
    TYPE: Num + RationalInt + Display,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn from_str_radix(_: &str, _: u32) -> Result<Self, Self::FromStrRadixErr> {
        Result::Err(Rational::<TYPE>::default())
    }

    type FromStrRadixErr = Self;
}

impl<TYPE> SignedOps for Rational<TYPE>
where
    TYPE: Signed + SignedOps + Display + RationalInt,
    for<'a> &'a TYPE: NumOps<&'a TYPE, TYPE>,
{
    fn abs(&self) -> Self {
        Rational::new(self.num.abs(), self.den.abs())
    }

    fn abs_sub(&self, other: &Self) -> Self {
        if self <= other {
            Rational::<TYPE>::zero()
        } else {
            self.clone() - other.clone()
        }
    }

    fn is_negative(&self) -> bool {
        !self.num.is_zero() && self.num.is_negative() ^ self.den.is_negative()
    }

    fn is_positive(&self) -> bool {
        !self.num.is_zero() && !(self.num.is_positive() ^ self.den.is_positive())
    }

    fn signum(&self) -> Self {
        if self.is_positive() {
            Rational::<TYPE>::one()
        } else if self.is_negative() {
            -Rational::<TYPE>::one()
        } else {
            Rational::<TYPE>::zero()
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::BTreeSet;

    #[test]
    fn test_simplify() {
        let mut r1 = Rational::new(15, 105);
        assert_eq!(Rational::new(1, 7), r1);
        r1.simplify();
        assert_eq!(Rational::new(1, 7), r1);
    }

    #[test]
    fn test_add() {
        let r1 = Rational::new(3, 5);
        let r2 = Rational::new(4, 10);
        let r3 = Rational::new(1, 7);
        let one: Rational<i32> = Rational::<i32>::one();
        assert_eq!(one, r1 + r2);
        assert_eq!(r2 + r1, r1 + r2);
        assert_eq!(r1 + r2 + r3, r3 + r2 + r1);
    }

    #[test]
    fn test_add_assign() {
        let mut r1 = Rational::new(3, 5);
        let r2 = Rational::new(4, 10);
        let r3 = Rational::<i32>::one();
        r1 += r2;
        assert_eq!(r3, r1);
    }

    #[test]
    fn test_sub() {
        let r1 = Rational::new(3, 5);
        let r2 = Rational::new(4, 10);
        let r3 = Rational::new(1, 7);
        assert_eq!(Rational::<i32>::zero(), r1 - r1);
        assert_eq!(Rational::new(-1, 5), r2 - r1);
        assert!(Rational::<i32>::zero() > r3 - r1);
        assert!(Rational::<i32>::zero() > r3 - r2);
        assert!(Rational::<i32>::zero() > r3 - r1);
    }

    #[test]
    fn test_sub_assign() {
        let mut r1 = Rational::new(3, 5);
        let r2 = Rational::new(4, 10);
        let r3 = Rational::new(1, 5);
        r1 -= r2;
        assert_eq!(r3, r1);
    }

    #[test]
    fn test_mul() {
        let r1 = Rational::new(3, 5);
        let r2 = Rational::new(-4, 10);
        let r3 = Rational::new(1, 7);
        assert_eq!(Rational::new(9, 25), r1 * r1);
        assert_eq!(Rational::new(-12, 50), r2 * r1);
        assert_eq!(Rational::new(2, -35), r2 * r3);
    }

    #[test]
    fn test_mul_assign() {
        let r1 = Rational::new(3, 5);
        let r2 = Rational::new(-4, 10);
        let r3 = Rational::new(-12, 50);
        let mut r4 = r1.clone();
        r4 *= r1;
        assert_eq!(Rational::<i32>::new(9, 25), r4);
        let mut r5 = r1.clone();
        r5 *= r2;
        assert_eq!(r3, r5);
    }

    #[test]
    fn test_div() {
        let r1 = Rational::new(3, 5);
        let r2 = Rational::new(-4, 10);
        let r3 = Rational::new(1, 7);
        assert_eq!(Rational::<i32>::one(), r1 / r1);
        assert_eq!(Rational::new(-2, 3), r2 / r1);
        assert_eq!(Rational::new(28, -10), r2 / r3);
    }

    #[test]
    fn test_div_assign() {
        let r1 = Rational::new(3, 5);
        let r2 = Rational::new(-4, 10);
        let r3 = Rational::new(30, -20);
        let mut r4 = r1.clone();
        r4 /= r1;
        assert_eq!(Rational::<i32>::one(), r4);
        let mut r5 = r1.clone();
        r5 /= r2;
        assert_eq!(r3, r5);
    }

    #[test]
    fn test_eq() {
        let r1 = Rational::new(3, 5);
        let r2 = Rational::new(6, 10);
        let r3 = Rational::new(300, 500);
        let r4 = Rational::new(300, -500);
        assert!(r1 == r2);
        assert!(r1 == r3);
        assert!(r1 != r4);
    }

    #[test]
    fn test_ord() {
        let r1 = Rational::new(3, 5);
        let r2 = Rational::new(7, 10);
        let r3 = Rational::new(301, 500);
        let r4 = Rational::new(300, -500);
        let values: Vec<Rational<i32>> = BTreeSet::from([r1, r2, r3, r4])
            .iter()
            .map(|it| it.clone())
            .collect();
        let expected_order = Vec::from([r4, r1, r3, r2]);
        assert_eq!(expected_order, values);
    }

    #[test]
    fn test_gcd() {
        let a = 14;
        let b = 21;
        assert_eq!(7, gcd(&a, &b));
    }

    #[test]
    fn test_mcm() {
        let a = 14;
        let b = 21;
        assert_eq!(42, mcm::<i32>(&a, &b));
    }
}

#[cfg(test)]
mod big_int_tests {
    use super::*;
    use num_bigint::BigInt;
    use std::collections::BTreeSet;

    #[test]
    fn test_gcd() {
        assert_eq!(6, gcd(&12, &18));
        assert_eq!(6, gcd(&18, &12));
    }

    #[test]
    fn test_simplify() {
        let mut r1 = Rational::new(BigInt::from(15), BigInt::from(105));
        assert_eq!(Rational::new(BigInt::from(1), BigInt::from(7)), r1);
        r1.simplify();
        assert_eq!(Rational::new(BigInt::from(1), BigInt::from(7)), r1);
    }

    #[test]
    fn test_add() {
        let r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(4), BigInt::from(10));
        let r3 = Rational::new(BigInt::from(1), BigInt::from(7));
        assert_eq!(Rational::<BigInt>::one(), &r1 + &r2);
        assert_eq!(&r2 + &r1, &r1 + &r2);
        assert_eq!(&r1 + &r2 + &r3, &r3 + &r2 + &r1);
    }

    #[test]
    fn test_add_assign() {
        let mut r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(4), BigInt::from(10));
        r1 += r2;
        assert_eq!(Rational::<BigInt>::one(), r1);
    }

    #[test]
    fn test_sub() {
        let r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(4), BigInt::from(10));
        let r3 = Rational::new(BigInt::from(1), BigInt::from(7));
        assert_eq!(Rational::<BigInt>::zero(), &r1 - &r1);
        assert_eq!(Rational::new(BigInt::from(-1), BigInt::from(5)), &r2 - &r1);
        assert!(Rational::<BigInt>::zero() > &r3 - &r1);
        assert!(Rational::<BigInt>::zero() > &r3 - &r2);
        assert!(Rational::<BigInt>::zero() > r3 - r1);
    }

    #[test]
    fn test_sub_assign() {
        let mut r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(4), BigInt::from(10));
        r1 -= r2;
        assert_eq!(Rational::<BigInt>::new(BigInt::one(), BigInt::from(5)), r1);
    }

    #[test]
    fn test_mul() {
        let r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(-4), BigInt::from(10));
        let r3 = Rational::new(BigInt::from(1), BigInt::from(7));
        assert_eq!(Rational::new(BigInt::from(9), BigInt::from(25)), &r1 * &r1);
        assert_eq!(
            Rational::new(BigInt::from(-12), BigInt::from(50)),
            &r2 * &r1
        );
        assert_eq!(Rational::new(BigInt::from(2), BigInt::from(-35)), r2 * r3);
    }

    #[test]
    fn test_mul_assign() {
        let r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(-4), BigInt::from(10));
        let r3 = Rational::new(BigInt::from(-12), BigInt::from(50));
        let mut r4 = r1.clone();
        r4 *= &r1;
        assert_eq!(
            Rational::<BigInt>::new(BigInt::from(9), BigInt::from(25)),
            r4
        );
        let mut r5 = r1.clone();
        r5 *= r2;
        assert_eq!(r3, r5);
    }

    #[test]
    fn test_div() {
        let r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(-4), BigInt::from(10));
        let r3 = Rational::new(BigInt::from(1), BigInt::from(7));
        assert_eq!(Rational::<BigInt>::one(), &r1 / &r1);
        assert_eq!(Rational::new(BigInt::from(-2), BigInt::from(3)), &r2 / r1);
        assert_eq!(Rational::new(BigInt::from(28), BigInt::from(-10)), r2 / r3);
    }

    #[test]
    fn test_div_assign() {
        let r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(-4), BigInt::from(10));
        let r3 = Rational::new(BigInt::from(30), BigInt::from(-20));
        let mut r4 = r1.clone();
        r4 /= &r1;
        assert_eq!(Rational::<BigInt>::one(), r4);
        let mut r5 = r1.clone();
        r5 /= r2;
        assert_eq!(r3, r5);
    }

    #[test]
    fn test_eq() {
        let r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(6), BigInt::from(10));
        let r3 = Rational::new(BigInt::from(300), BigInt::from(500));
        let r4 = Rational::new(BigInt::from(300), BigInt::from(-500));
        assert!(r1 == r2);
        assert!(r1 == r3);
        assert!(r1 != r4);
    }

    #[test]
    fn test_ord() {
        let r1 = Rational::new(BigInt::from(3), BigInt::from(5));
        let r2 = Rational::new(BigInt::from(7), BigInt::from(10));
        let r3 = Rational::new(BigInt::from(301), BigInt::from(500));
        let r4 = Rational::new(BigInt::from(300), BigInt::from(-500));
        let values: Vec<&Rational<BigInt>> = BTreeSet::from([&r1, &r2, &r3, &r4])
            .iter()
            .map(|it| *it)
            .collect();
        let expected_order = Vec::from([&r4, &r1, &r3, &r2]);
        assert_eq!(expected_order, values);
    }
}