rational operator - (const rational &left, const rational &right) { rational result( left.numerator() * right.denominator() - right.numerator() * left.denominator(), left.denominator() * right.denominator()); return result; }
// **** 1.Add a square root function to the rational class. **** rational squareRoot(const rational &r) { assert(r.numerator()>0); double top = r.numerator(); double bot = r.denominator(); double topSqrt = sqrt(top); double botSqrt = sqrt(bot); // Estimate if not a perfect square if ((fmod(topSqrt,1)!=0) ||(fmod(botSqrt,1)!=0)) { topSqrt = sqrt(100*top); botSqrt = sqrt(100*bot); } return rational((int)topSqrt, (int)botSqrt); }
// Other functions - not members or friends rational invert(const rational &r) { assert( r.numerator() != 0 ); return rational(r.denominator(), r.numerator()); }
bool operator == (const rational &left, const rational &right) { return (left.numerator() * right.denominator() == left.denominator() * right.numerator()); }
inline SPROUT_CONSTEXPR sprout::rational<IntType> operator-(rational<IntType> const& r) { return sprout::detail::rational_construct_access<IntType>::raw_construct( -r.numerator(), r.denominator() ); }
// Assignments void rational::operator = (const rational &right) { top = right.numerator(); bottom = right.denominator(); }
int main() { constexpr rational<int> test(4, 2); constexpr rational<int> normal = normalised(test); static_assert(normal.numerator() == 2 && normal.denominator() == 1, "..."); }
rational abs(rational const& r) { return rational(std::abs(r.numerator()), r.denominator()); }
bool operator<(rational const& a, rational const& b) { return a.numerator() * b.denominator() < b.numerator() * a.denominator(); }
constexpr rational<Integer> normalised(const rational<Integer>& r) noexcept { return r.numerator() == 0 ? rational<Integer>{ 0, 1 } : rational<Integer>{ r.numerator() / gcd(r.numerator(), r.denominator()), r.denominator() / gcd(r.numerator(), r.denominator()) }; }
bool operator==(rational const& a, rational const& b) { return a.numerator() == b.numerator() and a.denominator() == b.denominator(); }
rational operator/(rational const& lhs, rational const& rhs) { return rational {lhs.numerator() * rhs.denominator(), lhs.denominator() * rhs.numerator()}; }
rational operator-(rational const& r) { return rational{-r.numerator(), r.denominator()}; }
BOOST_CONSTEXPR explicit rational(rational<NewType> const &r) : num(r.numerator()), den(is_normalized(int_type(r.numerator()), int_type(r.denominator())) ? r.denominator() : (BOOST_THROW_EXCEPTION(bad_rational("bad rational: denormalized conversion")), 0)){}
bool operator==(const rational<T2> &f) const { return ((this->_numerator == f.numerator()) && (this->_denominator == f.denominator())); }
inline rational<IntType> operator- (const rational<IntType>& r) { return rational<IntType>(-r.numerator(), r.denominator()); }
//! @Returns the target rational having as numerator and denominator the conversion from the numerator and denominator of the source rational. rational<Target> operator()(rational<Source> const & from) { return rational<Target>(boost::conversion::convert_to<Target>(from.numerator()), boost::conversion::convert_to<Target>(from.denominator())); }