use super::{Rational, RationalScalar};
use crate::{One, Zero};
use core::iter::{Product, Sum};
use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
impl<T: RationalScalar> Add for Rational<T> {
type Output = Self;
#[inline]
fn add(self, rhs: Self) -> Self {
let q_lhs = self.num.div_euclid(self.den);
let r_lhs = self.num.rem_euclid(self.den);
let q_rhs = rhs.num.div_euclid(rhs.den);
let r_rhs = rhs.num.rem_euclid(rhs.den);
let g = self.den.gcd(&rhs.den);
let d_reduced = rhs.den / g;
let mut frac_num = r_lhs * d_reduced + r_rhs * (self.den / g);
let frac_den = self.den * d_reduced;
let mut int_part = q_lhs + q_rhs;
if frac_num >= frac_den {
frac_num = frac_num - frac_den;
int_part = int_part + T::one();
}
let g_frac = frac_num.gcd(&frac_den);
let frac_num = frac_num / g_frac;
let frac_den = frac_den / g_frac;
let num = if int_part < T::zero() {
(int_part + T::one()) * frac_den - (frac_den - frac_num)
} else {
int_part * frac_den + frac_num
};
Self::reduce(num, frac_den)
}
}
impl<T: RationalScalar> Sub for Rational<T> {
type Output = Self;
#[inline]
fn sub(self, rhs: Self) -> Self {
self + (-rhs)
}
}
impl<T: RationalScalar> Mul for Rational<T> {
type Output = Self;
#[inline]
fn mul(self, rhs: Self) -> Self {
let g1 = self.num.gcd(&rhs.den);
let g2 = rhs.num.gcd(&self.den);
let num = (self.num / g1) * (rhs.num / g2);
let den = (self.den / g2) * (rhs.den / g1);
Self::reduce(num, den)
}
}
impl<T: RationalScalar> Div for Rational<T> {
type Output = Self;
#[inline]
fn div(self, rhs: Self) -> Self {
if rhs.num.is_zero() {
panic!("Rational division by zero");
}
let g1 = self.num.gcd(&rhs.num);
let g2 = rhs.den.gcd(&self.den);
let num = (self.num / g1) * (rhs.den / g2);
let den = (self.den / g2) * (rhs.num / g1);
Self::reduce(num, den)
}
}
impl<T: RationalScalar> Neg for Rational<T> {
type Output = Self;
#[inline]
fn neg(self) -> Self {
Self {
num: -self.num,
den: self.den,
}
}
}
impl<T: RationalScalar> AddAssign for Rational<T> {
#[inline]
fn add_assign(&mut self, rhs: Self) {
*self = *self + rhs;
}
}
impl<T: RationalScalar> SubAssign for Rational<T> {
#[inline]
fn sub_assign(&mut self, rhs: Self) {
*self = *self - rhs;
}
}
impl<T: RationalScalar> MulAssign for Rational<T> {
#[inline]
fn mul_assign(&mut self, rhs: Self) {
*self = *self * rhs;
}
}
impl<T: RationalScalar> DivAssign for Rational<T> {
#[inline]
fn div_assign(&mut self, rhs: Self) {
*self = *self / rhs;
}
}
impl<T: RationalScalar> Sum for Rational<T> {
#[inline]
fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
iter.fold(Self::zero(), |acc, x| acc + x)
}
}
impl<T: RationalScalar> Product for Rational<T> {
#[inline]
fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
iter.fold(Self::one(), |acc, x| acc * x)
}
}