Header file for the Rational class: #ifndef RATIONAL_H #define RATIONAL_H class

Question

Header file for the Rational class:

#ifndef RATIONAL_H
#define RATIONAL_H

class Rational
{
public:
Rational( int = 0, int = 1 ); // default constructor
Rational addition( const Rational & ) const; // function addition
Rational subtraction( const Rational & ) const; // function subtraction
Rational multiplication( const Rational & ) const; // function multi.
Rational division( const Rational & ) const; // function division
void printRational () const; // print rational format
void printRationalAsDouble() const; // print rational as double format
private:
int numerator; // integer numerator
int denominator; // integer denominator
void reduce(); // utility function
}; // end class Rational

#endif

Rational Class:

// Member-function definitions for class Rational.
#include "stdafx.h"
#include
#include "Rational.h" // include definition of class Rational
using namespace std;
Rational::Rational(int n, int d)
: numerator(n), denominator(d)
{
reduce(); // store the fraction in reduced form
} // end Rational constructor
Rational Rational::addition(const Rational &a) const
{
Rational t(a.numerator * denominator + a.denominator * numerator,
a.denominator * denominator);
t.reduce(); // store the fraction in reduced form
return t;
} // end function addition
Rational Rational::subtraction(const Rational &s) const
{
Rational t(s.denominator * numerator - denominator * s.numerator,
s.denominator * denominator);
t.reduce(); // store the fraction in reduced form
return t;
} // end function subtraction
Rational Rational::multiplication(const Rational &m) const
{
Rational t(m.numerator * numerator, m.denominator * denominator);
t.reduce(); // store the fraction in reduced form
return t;
} // end function multiplication
Rational Rational::division(const Rational &v) const
{
Rational t(v.denominator * numerator, denominator * v.numerator);
t.reduce(); // store the fraction in reduced form
return t;
} // end function division
void Rational::printRational() const
{
if (denominator == 0) // validates denominator
cout << " DIVIDE BY ZERO ERROR!!!" << ' ';
else if (numerator == 0) // validates numerator
cout << 0;
else
cout << numerator << '/' << denominator;
} // end function printRational
oid Rational::printRationalAsDouble() const
{
cout << static_cast< double >(numerator) / denominator;
} // end function printRationalAsDouble
void Rational::reduce()
{
int largest = numerator > denominator ? numerator : denominator;
int gcd = 0; // greatest common divisor
for (int loop = 2; loop <= largest; ++loop)
if (numerator % loop == 0 && denominator % loop == 0)
gcd = loop;
if (gcd != 0)
{
numerator /= gcd;
denominator /= gcd;
} // end if
} // end function reduction

Explanation / Answer

package deffered;

import java.util.Scanner;

public class Rational {
private int numerator, denominator;

   //-----------------------------------------------------------------
   // Constructor: Sets up the rational number by ensuring a nonzero
   // denominator and making only the numerator signed.
   //-----------------------------------------------------------------
   public Rational (int numer, int denom)
   {
      if (denom == 0)
         denom = 1;

      // Make the numerator "store" the sign
      if (denom < 0)
      {
         numer = numer * -1;
         denom = denom * -1;
      }

      numerator = numer;
      denominator = denom;

      reduce();
   }

   //-----------------------------------------------------------------
   // Returns the numerator of this rational number.
   //-----------------------------------------------------------------
   public int getNumerator ()
   {
      return numerator;
   }

   //-----------------------------------------------------------------
   // Returns the denominator of this rational number.
   //-----------------------------------------------------------------
   public int getDenominator ()
   {
      return denominator;
   }

   //-----------------------------------------------------------------
   // Returns the reciprocal of this rational number.
   //-----------------------------------------------------------------
   public Rational reciprocal ()
   {
      return new Rational (denominator, numerator);
   }

   //-----------------------------------------------------------------
   // Adds this rational number to the one passed as a parameter.
   // A common denominator is found by multiplying the individual
   // denominators.
   //-----------------------------------------------------------------
   public Rational add (Rational op2)
   {
   System.out.println(op2.getDenominator()+" ****8   "+op2.getDenominator());
   System.out.println(denominator+" &&&&&   "+numerator);
      int commonDenominator = denominator * op2.getDenominator();
      int numerator1 = numerator * op2.getDenominator();
      int numerator2 = op2.getNumerator() * denominator;
      int sum = numerator1 + numerator2;
        System.out.println("sum is "+sum );
      return new Rational (sum, commonDenominator);
   }

   //-----------------------------------------------------------------
   // Subtracts the rational number passed as a parameter from this
   // rational number.
   //-----------------------------------------------------------------
   public Rational subtract (Rational op2)
   {
      int commonDenominator = denominator * op2.getDenominator();
      int numerator1 = numerator * op2.getDenominator();
      int numerator2 = op2.getNumerator() * denominator;
      int difference = numerator1 - numerator2;

      System.out.println("difference is "+difference );
      return new Rational (difference, commonDenominator);
   }

   //-----------------------------------------------------------------
   // Multiplies this rational number by the one passed as a
   // parameter.
   //-----------------------------------------------------------------
   public Rational multiply (Rational op2)
   {
      int numer = numerator * op2.getNumerator();
      int denom = denominator * op2.getDenominator();

     
      System.out.println("multiply is "+numer );
      return new Rational (numer, denom);
   }

   //-----------------------------------------------------------------
   // Divides this rational number by the one passed as a parameter
   // by multiplying by the reciprocal of the second rational.
   //-----------------------------------------------------------------
   public Rational divide (Rational op2)
   {
      return multiply (op2.reciprocal());
   }

   //-----------------------------------------------------------------
   // Determines if this rational number is equal to the one passed
   // as a parameter. Assumes they are both reduced.
   //-----------------------------------------------------------------
   public boolean equals (Rational op2)
   {
      return ( numerator == op2.getNumerator() &&
               denominator == op2.getDenominator() );
   }

   //-----------------------------------------------------------------
   // Returns this rational number as a string.
   //-----------------------------------------------------------------
   public String toString ()
   {
      String result;

      if (numerator == 0)
         result = "0";
      else
         if (denominator == 1)
            result = numerator + "";
         else
            result = numerator + "/" + denominator;
   
      return result;
   }

   //-----------------------------------------------------------------
   // Reduces this rational number by dividing both the numerator
   // and the denominator by their greatest common divisor.
   //-----------------------------------------------------------------
   private void reduce ()
   {
      if (numerator != 0)
      {
         int common = gcd (Math.abs(numerator), denominator);

         numerator = numerator / common;
         denominator = denominator / common;
      }
   }

   //-----------------------------------------------------------------
   // Computes and returns the greatest common divisor of the two
   // positive parameters. Uses Euclid's algorithm.
   //-----------------------------------------------------------------
   private int gcd (int num1, int num2)
   {
      while (num1 != num2)
         if (num1 > num2)
            num1 = num1 - num2;
         else
            num2 = num2 - num1;

      return num1;
   }
  
   public double claculateFraction(String frac)
   {
   double ans=0.0;
   String[] add2=frac.split("/");
  
   ans=Integer.parseInt(add2[0])/Integer.parseInt(add2[1]);
  
   return ans;
   }
  
  
   public static void main(String[] args) {
  
  
   Scanner scan=new Scanner(System.in);
System.out.println("please first enter numerator");
   int x1=scan.nextInt();
System.out.println("please first enter denominator");
int y1=scan.nextInt();

System.out.println("please second enter numerator");
int x2=scan.nextInt();
System.out.println("please second enter denominator");
int y2=scan.nextInt();
if(y1==0 || y2==0)
{
System.out.println("denominator should not be zero");
System.exit(0);
}

   Rational r1=new Rational(x1, y1);
   Rational r2=new Rational(x2, y2);
  
   System.out.println("first rational number is"+r1);
   System.out.println("second rational number is"+r2);
  
  
   Rational add=r1.add(r2);
   System.out.println("Addition is "+add);
  
   String add1=add.toString();

System.out.println("Add value in decimal"+add.claculateFraction(add1));
  
  
  
   Rational substract=r1.subtract(r2);
   System.out.println("substract is "+substract);
   String substract1=add.toString();
   System.out.println("substract value in decimal"+add.claculateFraction(substract1));
  

  
   Rational divide=r1.divide(r2);
   System.out.println("divide is "+divide);
   String divide1=add.toString();
   System.out.println("divide value in decimal"+add.claculateFraction(divide1));
  
  
   Rational multiply=r1.multiply(r2);
   System.out.println("divide is "+multiply);
   String multiply1=add.toString();
   System.out.println("divide value in decimal"+add.claculateFraction(multiply1));
}
  
}

Related Questions

Navigate

• Browse (All)
• Browse H
• Subjects

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