REDUCE FRACTIONS: Client Program: Frac data: Output: THANKS IN ADVANCE! Add a pr

Question

REDUCE FRACTIONS:

Client Program:

Frac data:

Output:

THANKS IN ADVANCE!

Add a private "simplify)" function to your class and call it from the appropriate member functions. (If you write your code the way that 90% of students write it, there will be 6 places where you need to call it. But if you call it a different number of times and your class works, that's also fine.) The best way to do this is to make the function a void function with no parameters that reduces the calling object Recall that "simplifying" or "reducing" a fraction is a separate task from converting it from an improper fraction to a mixed number. Make sure you keep those two tasks separate in your mind For now (until you get down to the part of the assignment where you improve your insertion operator) your fractions will still be printed as improper fractions, not mixed numbers. In other words, 19/3 will still be 19/3, not 6+1/3. Make sure that your class will reduce ANY fraction, not just the fractions that are tested in the provided client program. Fractions should not be simply reduced upon output, they should be stored in reduced form at all times. In ather words, you should ensure that all fraction objects are reduced before the end of any member function. To put it yet another way: each member function must be able to assume that all fraction objects are in simple form when it begins execution. You must create your own algorithm for reducing fractions. Don't look up an already existing algorithm for reducing fractions or finding GCF. The point here is to have you practice solving the problem on your own. In particular, don't use Euclid's algorithm. Don't worry about being efficient. It's fine to have your function check every possible facto, even if it would be more efficient to just check prime numbers, Just create something of your own that works correctly on ANY fraction. Your simplify() function should also ensure that the denominator is never negative. If the denominator is negative, fix this by multiplying numerator and denominator by -1 Better Insertion Operator [10 points] Now modify your overloaded

Explanation / Answer

Below is your code

fraction.cpp

#include "fraction.h"

namespace cs_Fraction {

using namespace std;

Fraction::Fraction(int inNumerator, int inDenominator) {
assert(inDenominator != 0);
numerator = inNumerator;
denominator = inDenominator;
this->simplify();
}

ostream& operator<< (ostream& out, const Fraction& right) {
if (abs(right.numerator) >= abs(right.denominator)) {
out << right.numerator/right.denominator;
if (right.numerator%right.denominator != 0) {
out << "+" << abs(right.numerator%right.denominator) << "/" << right.denominator;
}
}
else if (right.numerator == 0) {
out << 0;
}
else {
out << right.numerator << "/" << right.denominator;
}
return out;
}

istream& operator>> (istream& in, Fraction& right) {
int temp = 0;
right.denominator = 1;
in >> right.numerator;
if (in.peek() == '+') {
in.ignore();
temp = right.numerator;
in >> right.numerator;
}
if (in.peek() == '/') {
in.ignore();
in >> right.denominator;
}
if (temp < 0) {
right.numerator *= -1;
}
right.numerator += temp*right.denominator;
right.simplify();
return in;
}

bool operator< (const Fraction& left, const Fraction& right) {
return (left.numerator*right.denominator < right.numerator*left.denominator);
}

bool operator<= (const Fraction& left, const Fraction& right) {
return (left.numerator*right.denominator <= right.numerator*left.denominator);
}

bool operator> (const Fraction& left, const Fraction& right) {
return (left.numerator*right.denominator > right.numerator*left.denominator);
}

bool operator>= (const Fraction& left, const Fraction& right) {
return (left.numerator*right.denominator >= right.numerator*left.denominator);
}

bool operator== (const Fraction& left, const Fraction& right) {
return (left.numerator*right.denominator == right.numerator*left.denominator);
}

bool operator!= (const Fraction& left, const Fraction& right) {
return (left.numerator*right.denominator != right.numerator*left.denominator);
}

Fraction operator+ (const Fraction& left, const Fraction& right) {
Fraction result(left.numerator*right.denominator+
right.numerator*left.denominator,
left.denominator*right.denominator);
return result;
}

Fraction operator- (const Fraction& left, const Fraction& right) {
Fraction result(left.numerator*right.denominator -
right.numerator*left.denominator,
left.denominator*right.denominator);
return result;
}

Fraction operator* (const Fraction& left, const Fraction& right) {
Fraction result(left.numerator*right.numerator,
left.denominator*right.denominator);
return result;
}

Fraction operator/ (const Fraction& left, const Fraction& right) {
Fraction result(left.numerator*right.denominator,
left.denominator*right.numerator);
return result;
}

Fraction Fraction::operator+=(const Fraction &right) {
*this = *this + right;
return *this;
}

Fraction Fraction::operator-=(const Fraction &right) {
*this = *this - right;
return *this;
}

Fraction Fraction::operator*=(const Fraction &right) {
*this = *this * right;
return *this;
}

Fraction Fraction::operator/=(const Fraction &right) {
*this = *this / right;
return *this;
}

Fraction Fraction::operator++ () {
numerator += denominator;
return *this;
}

Fraction Fraction::operator++ (int) {
Fraction temp(numerator, denominator);
numerator += denominator;
return temp;
}

Fraction Fraction::operator-- () {
numerator -= denominator;
return *this;
}
  
  
  
  
  
  
Fraction Fraction::operator-- (int) {
Fraction temp(numerator, denominator);
numerator -= denominator;
return temp;
}
  
  
  
  

void Fraction::simplify() {
if (denominator <0) { // denominator will be positive
numerator *= -1;
denominator *= -1;
}
long i = (min(abs(numerator), abs(denominator)));
if (i != 0) {

// this construct allows simplify() to work whether i is prime or not
if (numerator%i==0 && denominator%i ==0) {
numerator /= i;
denominator /= i;
}
else {
for (long j = i/2; j>1; j--) {
// look for factors of i, starting at i/2
if (numerator%j==0 && denominator%j==0) {
numerator /= j;
denominator /= j;
j = (min(numerator, denominator))/2; // recursive idea
}
}
}
}
}
} // end namespace

fraction.h

#ifndef FRACTION_H
#define FRACTION_H

#include <iostream>
#include <cassert>
#include <cmath>

namespace cs_Fraction {

class Fraction {
public:
Fraction(int inNumerator = 0, int inDenominator = 1);
friend std::ostream& operator<<(std::ostream& out, const Fraction& right);
friend std::istream& operator>>(std::istream& in, Fraction& right);
friend bool operator< (const Fraction& left, const Fraction& right);
friend bool operator<= (const Fraction& left, const Fraction& right);
friend bool operator> (const Fraction& left, const Fraction& right);
friend bool operator>= (const Fraction& left, const Fraction& right);
friend bool operator== (const Fraction& left, const Fraction& right);
friend bool operator!= (const Fraction& left, const Fraction& right);
friend Fraction operator+ (const Fraction& left, const Fraction& right);
friend Fraction operator- (const Fraction& left, const Fraction& right);
friend Fraction operator* (const Fraction& left, const Fraction& right);
friend Fraction operator/ (const Fraction& left, const Fraction& right);
Fraction operator+= (const Fraction& right);
Fraction operator-= (const Fraction& right);
Fraction operator*= (const Fraction& right);
Fraction operator/= (const Fraction& right);
Fraction operator++ ();
Fraction operator++ (int);
Fraction operator-- ();
Fraction operator-- (int);

private:
int numerator;
int denominator;
void simplify();
};

} // namespace end

#endif

Related Questions

Navigate

• Browse (All)
• Browse R
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.