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()));
}
