Software Engineering Theory Assignment 2 Final

#include <iostream>
using namespace std;
class Fraction{
private:
int numer;
int denom;
public:
//default constructor
Fraction(){
numer = 1;
denom = 1;
}
//one parameter
Fraction(int m){
numer = m;
denom = 1;
}
//two parameters
Fraction(int m,int n){
numer = m;
denom = n;
if(n < 0){
numer = 0 - m;
denom = 0 - n;
}
if(m == 0){
numer = 0;
denom = 1;
}
if(n == 0){
exit(1);
}
}
//Copy Constructor
Fraction(const Fraction& other){
numer = other.numer;
denom = other.denom;
}
/*//Destructor
~Fraction();*/
//Copy Assignment Operator
Fraction operator =(const Fraction& fr){
numer = fr.numer;
denom = fr.denom;
return *this;
}
//Unary Arithmetic Operators
//--Unary minus operator
Fraction operator -(){
Fraction temp;
temp.numer = 0 - numer;
temp.denom = denom;
return temp;
}
//--Unary plus operator
Fraction operator +(){
Fraction temp;
temp.numer = 0 + numer;
temp.denom = 0 + denom;
return temp;
}
//Prefix pre-decrement operator for dividendo
Fraction& operator--(){
this->numer = numer - denom;
this->denom = denom;
return *this;
}
//Prefix pre-increment operator for componendo
Fraction& operator++(){
this->numer = numer + denom;
return *this;
}
//Postfix post-decrement operator for lazy dividendo
Fraction operator--(int){
Fraction temp;
temp.numer = numer - denom;
temp.denom = denom;
return temp;
}
//Postfix post-increment operator for lazy componendo
Fraction operator++(int){
Fraction temp;
temp.numer = numer + denom;
temp.denom = denom;
return temp;
}
//GCD
int gcd(int n, int d){
int remaind;
while (d != 0)
{
remaind = n % d;
n = d;
d = remaind;
}
return n;
}
//LCM
int lcm(int x, int y){
int a;
if(x > y){
a = x;
}
else{
a = y;
}
while (true){
if (a % x == 0 && a % y == 0)
return a;
++a;
}
}
void simplify(){
if(denom < 0){
numer *= -1;
denom *= -1;
}
int d = gcd(numer,denom);
numer /= d;
denom /= d;
}
//Binary Arithmetic operators

friend Fraction operator+ (const Fraction&,const Fraction&);
friend Fraction operator- (const Fraction&,const Fraction&);
friend Fraction operator* (const Fraction&,const Fraction&);
friend Fraction operator/ (const Fraction&,const Fraction&);
//Binary Relational operators

//Equal
bool operator== (const Fraction& Frac){
if((numer*Frac.denom) == (Frac.numer*denom)){
return true;
}
else{
return false;
}
}
//Not Equal
bool operator!= (const Fraction& Frac){
if((numer*Frac.denom) != (Frac.numer*denom)){
return true;
}
else{
return false;
}
}
//Less than
bool operator< (const Fraction& Frac){
if((numer*Frac.denom) < (Frac.numer*denom)){
return true;
}
else{
return false;
}
}
//Less than or Equal to
bool operator<= (const Fraction& Frac){
if((numer*Frac.denom) <= (Frac.numer*denom)){
return true;
}
else{
return false;
}
}
//More than
bool operator> (const Fraction& Frac){
if((numer*Frac.denom) > (Frac.numer*denom)){
return true;
}
else{
return false;
}
}
//More than or Equal to
bool operator>= (const Fraction& Frac){
if((numer*Frac.denom) >= (Frac.numer*denom)){
return true;
}
else{
return false;
}
}
//Special Operators
friend Fraction operator! (const Fraction&);
sc_fUnity = Fraction();
sc_fZero = Fraction(0);
void validate (int, int);

friend std::ostream& operator<< (std::ostream &out, const Fraction &Frac);
friend std::istream& operator>> (std::istream &in, Fraction &Frac);
};
//Addition
Fraction operator+ (const Fraction& Frac1,const Fraction& Frac2){
Fraction add;
add.numer = (Frac1.numer*Frac2.denom) + (Frac2.numer*Frac1.denom);
add.denom = Frac1.denom*Frac2.denom;
add.simplify();
return add;
}
//Subtraction
Fraction operator- (const Fraction& Frac1,const Fraction& Frac2){
Fraction sub;
sub.numer = (Frac1.numer*Frac2.denom) - (Frac2.numer*Frac1.denom);
sub.denom = Frac1.denom*Frac2.denom;
sub.simplify();
return sub;
}
//Multiplication
Fraction operator* (const Fraction& Frac1,const Fraction& Frac2){
Fraction mul;
mul.numer = Frac1.numer*Frac2.numer;
mul.denom = Frac1.denom*Frac2.denom;
mul.simplify();
return mul;
}
//Division
Fraction operator/ (const Fraction& Frac1,const Fraction& Frac2){
Fraction divi;
divi.numer = Frac1.numer*Frac2.denom;
divi.denom = Frac1.denom*Frac2.numer;
divi.simplify();
return divi;
}
void validate(int p, int q){

p++;
if (q == 0){
throw "Zero Denominator";
}
}
//Special operators
Fraction operator! (const Fraction& Frac){
Fraction temp;
temp.numer = Frac.denom;
temp.denom = Frac.numer;
return temp;
}
//I/O Operators
//Output
std::ostream& operator<< (std::ostream &out, const Fraction &Frac){
if(Frac.denom == 1){
out << Frac.numer;
}
else{
out << Frac.numer << "/" << Frac.denom;
}
return out;
}
//Input
std::istream& operator>> (std::istream &in, Fraction &Frac){
int p, q;
in >> p >> q;
validate(p, q);
Frac.numer = p;
Frac.denom = q;
Frac.simplify();
return in;
}
int main()
{
cout << "\nTest Fraction Data Type" << endl;
cout << "CONSTRUCTORS" << endl;
cout << "------------" << endl;
Fraction f1(5, 3);
Fraction f2(7.2);
Fraction f3;
cout << "Fraction f1(5, 3) = " << f1 << endl;
cout << "Fraction f2(7.2) = " << f2 << endl;
cout << "Fraction f3 = " << f3 << endl;
cout << "BASIC ASSIGNEMENT OPERATOR" << endl;

cout << "--------------------------" << endl;
cout << "Assignment (Before): f3 = " << f3 << ". f1 = " << f1 << endl;
f3 = f1;
cout << "Assignment (After): f3 = " << f3 << ". f1 = " << f1 << endl;
cout << "UNARY ARITHMETIC OPERATORS" << endl;

cout << "--------------------------" << endl;
f3 = -f1;
cout << "Unary Minus: f3 = " << f3 << ". f1 = " << f1 << endl;
cout << "Pre-decrement. Dividendo" << endl;
//f3 = Fraction::sc_fUnity;
cout << "Pre-Decrement (Before): f3 = " << f3 << ". f1 = " << f1 << endl;
f3 = --f1;
cout << "Pre-Decrement (After): f3 = " << f3 << ". f1 = " << f1 << endl;
cout << "Post-decrement. Lazy Dividendo" << endl;
cout << "Post-Decrement (Before): f3 = " << f3 << ". f1 = " << f1 << endl;
f3 = f1--;
cout << "Post-Decrement (After): f3 = " << f3 << ". f1 = " << f1 << endl;
cout << "Pre-increment. Componendo" << endl;
cout << "Pre-Increment (Before): f3 = " << f3 << ". f1 = " << f1 << endl;
f3 = ++f1;
cout << "Pre-Increment (After): f3 = " << f3 << ". f1 = " << f1 << endl;
cout << "Post-increment. Lazy Componendo" << endl;
cout << "Post-Increment (Before): f3 = " << f3 << ". f1 = " << f1 << endl;
f3 = f1++;
cout << "Post-Increment (After): f3 = " << f3 << ". f1 = " << f1 << endl;
cout << "BINARY ARITHMETIC OPERATORS USING FRIEND FUNCTIONS" << endl;
cout << "--------------------------------------------------" << endl;
f1 = Fraction(5, 12);
f3 = f1 + f2;
cout << "Binary Plus: f3 = " << f3 << ". f1 = " << f1 << ". f2 = " << f2 <<
endl;
f3 = f1 - f2;
cout << "Binary Minus: f3 = " << f3 << ". f1 = " << f1 << ". f2 = " << f2 <<
endl;
f3 = f1 * f2;
cout << "Multiply: f3 = " << f3 << ". f1 = " << f1 << ". f2 = " << f2 << endl;
f3 = f1 / f2;
cout << "Divide: f3 = " << f3 << ". f1 = " << f1 << ". f2 = " << f2 << endl;
//f3 = f1 % f2;
cout << "Residue: f3 = " << f3 << ". f1 = " << f1 << ". f2 = " << f2 << endl;
cout << "BINARY RELATIONAL OPERATORS" << endl;

cout << "---------------------------" << endl;
bool bTest = f1 == f2;
cout << "Equal: Test = " << ((bTest)? "true": "false") << ". f1 = " << f1 << ".
f2 = " << f2 << endl;
bTest = f1 != f2;
cout << "Not Equal: Test = " << ((bTest)? "true": "false") << ". f1 = " << f1
<< ". f2 = " << f2 << endl;
bTest = f1 < f2;
cout << "Less: Test = " << ((bTest)? "true": "false") << ". f1 = " << f1 << ".
f2 = " << f2 << endl;
bTest = f1 <= f2;
cout << "Less Equal: Test = " << ((bTest)? "true": "false") << ". f1 = " << f1
<< ". f2 = " << f2 << endl;
bTest = f1 <= f3;
<< ". f3 = " << f3 << endl;
bTest = f1 > f2;
cout << "Greater: Test = " << ((bTest)? "true": "false") << ". f1 = " << f1 <<
". f2 = " << f2 << endl;
bTest = f1 >= f2;
cout << "Greater Equal: Test = " << ((bTest)? "true": "false") << ". f1 = " <<
f1 << ". f2 = " << f2 << endl;
bTest = f1 >= f3;
f1 << ". f3 = " << f3 << endl;
cout << "SPECIAL OPERATORS" << endl;

cout << "-----------------" << endl;
f3 = !f1;
cout << "Negation: f3 = " << f3 << ". f1 = " << f1 << endl;
return 0;
}
New:
1st Type:
#include <iostream>
#include <cmath>
class Fraction{
private:
int numer;
int denom;
public:
Fraction();
//one parameter
Fraction(int);
//two parameters
Fraction(int,int);
//Copy Constructor
Fraction(const Fraction&);
/*//Destructor
~Fraction();*/

Fraction& operator= (const Fraction&);

Fraction operator- ();
Fraction operator+ ();
//--Prefix pre-decrement operator for dividendo
Fraction& operator--();
//--Prefix pre-increment operator for componendo
Fraction& operator++();
//--Postfix post-decrement operator for lazy dividendo
Fraction operator--(int);
//--Postfix post-increment operator for lazy componendo
Fraction operator++(int);

//Addition
//Subtraction
//Multiplication
//Division

//**Equal
bool operator== (const Fraction&);
//**Not Equal
bool operator!= (const Fraction&);
//**Less than
bool operator< (const Fraction&);
//**Less than or Equal to
bool operator<= (const Fraction&);
//**More than
bool operator> (const Fraction&);
//**More than or Equal to
bool operator>= (const Fraction&);
//Special Operators
//I/O Operators
//sc_fUnity = Fraction();
//sc_fZero = Fraction(0);
//Utility Functions of the Datatype

//Precision
void Precision(int precision){
double d = numer/denom;
numer = floor(d*precision);
denom = precision;
}
//GCD
int remaind;
while (d != 0)
{
remaind = n % d;
n = d;
d = remaind;
}
return n;
}
//LCM
int a;
if(x > y){
a = x;
}
else{
a = y;
}
while (true){
if (a % x == 0 && a % y == 0)
return a;
++a;
}
}
void simplify(){
if(denom < 0){
numer *= -1;
denom *= -1;
}
numer /= d;
denom /= d;
}
};
Fraction::Fraction(){
numer = 1;
denom = 1;
}
//one parameter
Fraction::Fraction(int m){
numer = m;
denom = 1;
}
//two parameters
Fraction::Fraction(int m,int n){
numer = m;
denom = n;
if(n < 0){
numer = 0 - m;
denom = 0 - n;
}
if(m == 0){
numer = 0;
denom = 1;
}
if(n == 0){
exit(1);
}
}
//copy constructor
Fraction::Fraction(const Fraction& other){
}

Fraction& Fraction::operator= (const Fraction& fr){
numer = fr.numer;
denom = fr.denom;
return *this;
}
//Unary Assignment Operators

//Unary Minus
Fraction Fraction::operator- (){
Fraction temp;
temp.denom = denom;
return temp;
}
//Unary Plus
Fraction Fraction::operator+ (){
Fraction temp;
return temp;
}
Fraction& Fraction::operator--(){
return *this;
}
Fraction& Fraction::operator++(){
return *this;
}
Fraction Fraction::operator--(int){
Fraction temp;
temp.denom = denom;
return temp;
}
Fraction Fraction::operator++(int){
Fraction temp;
temp.denom = denom;
return temp;
}
//Binary Arithmetic Operators

//Addition
Fraction add;
add.simplify();
return add;
}
//Subtraction
Fraction sub;
sub.simplify();
return sub;
}
//Multiplication
Fraction mul;
mul.simplify();
return mul;
}
//Division
Fraction divi;
if(Frac2.numer == 0){
throw "Exception";
}
else{
divi.simplify();
return divi;
}
}
//Binary Relational Operators

//Equal
bool Fraction::operator== (const Fraction& Frac){
return true;
}
else{
return false;
}
}
//Not Equal
bool Fraction::operator!= (const Fraction& Frac){
return true;
}
else{
return false;
}
}
//Less than
bool Fraction::operator< (const Fraction& Frac){
return true;
}
else{
return false;
}
}
bool Fraction::operator<= (const Fraction& Frac){
return true;
}
else{
return false;
}
}
//More than
bool Fraction::operator> (const Fraction& Frac){
return true;
}
else{
return false;
}
}
bool Fraction::operator>= (const Fraction& Frac){
return true;
}
else{
return false;
}
}
//Special operators
Fraction temp;
return temp;
}
//I/O Operators
//Output
out << Frac.numer;
}
else{
}
return out;
}

p++;
if (q == 0){
}
}
//Input
int p, q;
in >> p >> q;
validate(p, q);
Frac.numer = p;
Frac.denom = q;
Frac.simplify();
return in;
}
int main()
{
cout << "------------" << endl;
Fraction f1(5, 3);
Fraction f2(7.2);
Fraction f3;

cout << "--------------------------" << endl;
f3 = f1;

cout << "--------------------------" << endl;
f3 = -f1;
f3 = --f1;
f3 = f1--;
f3 = ++f1;
f3 = f1++;
cout << "--------------------------------------------------" << endl;
f3 = f1 + f2;
endl;
f3 = f1 - f2;
endl;
f3 = f1 * f2;
f3 = f1 / f2;
//f3 = f1 % f2;

cout << "---------------------------" << endl;
f2 = " << f2 << endl;
bTest = f1 != f2;
<< ". f2 = " << f2 << endl;
bTest = f1 < f2;
f2 = " << f2 << endl;
bTest = f1 <= f2;
<< ". f2 = " << f2 << endl;
bTest = f1 <= f3;
<< ". f3 = " << f3 << endl;
bTest = f1 > f2;
". f2 = " << f2 << endl;
bTest = f1 >= f2;
f1 << ". f2 = " << f2 << endl;
bTest = f1 >= f3;
f1 << ". f3 = " << f3 << endl;

cout << "-----------------" << endl;
f3 = !f1;
return 0;
}
2nd Type:
#include <iostream>
class Fraction{
private:
int numer;
int denom;
public:
Fraction(){
numer = 1;
denom = 1;
}
//one parameter
Fraction(int m){
numer = m;
denom = 1;
}
//two parameters
Fraction(int m,int n){
numer = m;
denom = n;
if(n < 0){
numer = 0 - m;
denom = 0 - n;
}
if(m == 0){
numer = 0;
denom = 1;
}
if(n == 0){
exit(1);
}
}
//Copy Constructor
Fraction(const Fraction& other){
}
/*//Destructor
~Fraction();*/
Fraction operator =(const Fraction& fr){
numer = fr.numer;
denom = fr.denom;
return *this;
}
Fraction operator -(){
Fraction temp;
temp.denom = denom;
return temp;
}
Fraction operator +(){
Fraction temp;
return temp;
}
Fraction& operator--(){
return *this;
}
Fraction& operator++(){
return *this;
}
Fraction operator--(int){
Fraction temp;
temp.denom = denom;
return temp;
}
Fraction operator++(int){
Fraction temp;
temp.denom = denom;
return temp;
}
//GCD
int remaind;
while (d != 0)
{
remaind = n % d;
n = d;
d = remaind;
}
return n;
}
//LCM
int a;
if(x > y){
a = x;
}
else{
a = y;
}
while (true){
if (a % x == 0 && a % y == 0)
return a;
++a;
}
}
void simplify(){
if(denom < 0){
numer *= -1;
denom *= -1;
}
numer /= d;
denom /= d;
}


//Equal
bool operator== (const Fraction& Frac){
return true;
}
else{
return false;
}
}
//Not Equal
bool operator!= (const Fraction& Frac){
return true;
}
else{
return false;
}
}
//Less than
bool operator< (const Fraction& Frac){
return true;
}
else{
return false;
}
}
bool operator<= (const Fraction& Frac){
return true;
}
else{
return false;
}
}
//More than
bool operator> (const Fraction& Frac){
return true;
}
else{
return false;
}
}
bool operator>= (const Fraction& Frac){
return true;
}
else{
return false;
}
}
//Special Operators
//sc_fUnity = Fraction();
//sc_fZero = Fraction(0);

//I/O Operators
};
//Addition
Fraction add;
add.simplify();
return add;
}
//Subtraction
Fraction sub;
sub.simplify();
return sub;
}
//Multiplication
Fraction mul;
mul.simplify();
return mul;
}
//Division
Fraction divi;
if(Frac2.numer == 0){
throw "Exception";
}
else{
divi.simplify();
return divi;
}
}

p++;
if (q == 0){
}
}
//Special operators
Fraction temp;
return temp;
}
//I/O Operators
//Output
out << Frac.numer;
}
else{
}
return out;
}
//Input
int p, q;
in >> p >> q;
validate(p, q);
Frac.numer = p;
Frac.denom = q;
Frac.simplify();
return in;
}
int main()
{
cout << "------------" << endl;
Fraction f1(5, 3);
Fraction f2(7.2);
Fraction f3;

cout << "--------------------------" << endl;
f3 = f1;

cout << "--------------------------" << endl;
f3 = -f1;
f3 = --f1;
f3 = f1--;
f3 = ++f1;
f3 = f1++;
cout << "--------------------------------------------------" << endl;
f3 = f1 + f2;
endl;
f3 = f1 - f2;
endl;
f3 = f1 * f2;
f3 = f1 / f2;
//f3 = f1 % f2;

cout << "---------------------------" << endl;
f2 = " << f2 << endl;
bTest = f1 != f2;
<< ". f2 = " << f2 << endl;
bTest = f1 < f2;
f2 = " << f2 << endl;
bTest = f1 <= f2;
<< ". f2 = " << f2 << endl;
bTest = f1 <= f3;
<< ". f3 = " << f3 << endl;
bTest = f1 > f2;
". f2 = " << f2 << endl;
bTest = f1 >= f2;
f1 << ". f2 = " << f2 << endl;
bTest = f1 >= f3;
f1 << ". f3 = " << f3 << endl;
cout << "-----------------" << endl;
f3 = !f1;
return 0;
}

Software Engineering Theory Assignment 2 Final

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Software Engineering Theory Assignment 2 Final

Uploaded by

Copyright:

Available Formats

#include <iostream>

using namespace std;

//Binary Arithmetic operators

//Binary Relational operators

void validate (int, int);

void validate(int p, int q){

cout << "BASIC ASSIGNEMENT OPERATOR" << endl;

cout << "UNARY ARITHMETIC OPERATORS" << endl;

cout << "BINARY RELATIONAL OPERATORS" << endl;

cout << "SPECIAL OPERATORS" << endl;

//Copy Assignment Operator

//Unary Arithmetic Operators

//Binary Arithmetic operators

//Binary Relational operators

//Utility Functions of the Datatype

//Copy Assignment Operator

//Unary Assignment Operators

//Binary Arithmetic Operators

//Binary Relational Operators

void validate(int p, int q){

cout << "BASIC ASSIGNEMENT OPERATOR" << endl;

cout << "UNARY ARITHMETIC OPERATORS" << endl;

cout << "BINARY RELATIONAL OPERATORS" << endl;

cout << "SPECIAL OPERATORS" << endl;

//Binary Arithmetic operators

//Binary Relational operators

void validate (int, int);

void validate(int p, int q){

cout << "BASIC ASSIGNEMENT OPERATOR" << endl;

cout << "UNARY ARITHMETIC OPERATORS" << endl;

cout << "BINARY RELATIONAL OPERATORS" << endl;

You might also like