UMBC CS 201,Spring 04
Coding the struct implementation of fraction
Besides the standard operation on fractions, we must also
consider that we can no longer print this type by giving a simple
print specifier, like %d or %c. It's just more complicated than that.
So we need to add a function that can print a fraction in a manner that
is standard.
It might be necessary for us to initialize a fraction to 0. So we'll
need an InitFraction() function.
We would also like to provide a function that allows us to assign some
value to a fraction. So we should write this as well.
These three functions are probably the first that should be written.
<![CDATA[
/************************************************\
* Filename: fraction.c *
* Author: Sue Bogar *
* Date Written: 4/15/98 *
* Section: 101 *
* EMail: bogar@cs.umbc.edu *
* *
* Description: This file contains the functions *
* necessary to work with the structure *
* implementation of the fraction ADT defined in *
* in fraction.h. This set of functions provide *
* the operations needed to work with this type, *
* and include initialization, assignment, and *
* printing of fractions. The standard aritmetic *
* operations on fractions and some supporting *
* supporting functions, for finding the greatest *
* common divisor of two integers and a function *
* for reducing fractions to lowest terms. *
\************************************************/
#include <stdio.h>
#include "fraction.h"
/************************************************
** Function: AddFractions
** Input: f1 and f2 are FRACTIONs to be added
** Output: returns a FRACTION (result) which is the
** sum of f1 and f2,
** reduced to lowest terms
*******************************************/
FRACTION AddFractions (FRACTION f1, FRACTION f2)
{
FRACTION result;
result.whole = f1.whole + f2.whole;
result.denominator = f1.denominator * f2.denominator;
result.numerator = f1.denominator * f2.numerator
+ f2.denominator * f1.numerator;
RedToLowTerms(&result);
return result;
}
/***********************************************
** Function: SubFractions
** Input: f1 and f2 are FRACTIONs to be subtracted
** Output: returns a FRACTION (result) which is the
** the difference, f1 - f2 reduced to
** lowest terms
**************************************/
FRACTION SubFractions (FRACTION f1, FRACTION f2)
{
FRACTION result;
result.whole = f1.whole - f2.whole;
result.denominator = f1.denominator * f2.denominator;
result.numerator = f2.denominator * f1.numerator
- f1.denominator * f2.numerator ;
RedToLowTerms(&result);
return result;
}
/**************************************
** Function: MultFractions
** Input: f1 and f2 are FRACTIONs to be multiplied
** Output: a FRACTION (result) which is the product,
** f1 * f2, reduced to lowest terms
**
**************************************/
FRACTION MultFractions (FRACTION f1, FRACTION f2)
{
FRACTION result;
f1.numerator = f1.denominator * f1.whole
+ f1.numerator;
f1.whole = 0;
f2.numerator = f2.denominator * f2.whole
+ f2.numerator;
f2.whole = 0;
result.whole = 0;
result.numerator = f1.numerator * f2.numerator;
result.denominator = f1.denominator * f2.denominator;
RedToLowTerms(&result);
return result;
}
/**************************************
** Function: DivFractions
** Input: 2 FRACTIONS (f1 and f2) to be divided
** Output: a FRACTION (result) which is the quotient
** of f1 divided by f2, in lowest terms
** Description:
** DivFrace inverts f2 then calls MultFractions
**************************************/
FRACTION DivFractions (FRACTION f1, FRACTION f2)
{
FRACTION result;
int numer, denom;
numer = f2.whole * f2.denominator + f2.numerator;
denom = f2.denominator;
f2.whole = 0;
f2.numerator = denom;
f2.denominator = numer;
result = MultFractions(f1, f2);
return result;
}
/**************************************
** Function: RedToLowTerms
** Input: a pointer to a FRACTION
** Output: the FRACTION being pointed to is reduced
** to lowest terms
** there is no return value
** Description:
** RedToLowTerms takes one argument of type
** FRACTION * and reduces that fraction to lowest
** terms by finding the greatest common divisor
** of the numerator and denominator and dividing
** through by that value.
**************************************/
void RedToLowTerms (FRACTION *fPtr)
{
int gcd, numer, denom;
denom = fPtr -> denominator;
numer = fPtr -> whole * denom
+ fPtr -> numerator;
gcd = GCD (numer, denom);
numer /= gcd;
denom /= gcd;
fPtr -> whole = numer/denom;
fPtr -> numerator = numer % denom;
fPtr -> denominator = denom;
}
/**************************************
** Function: InitFraction
** Input: a pointer to a FRACTION
** Output: the FRACTION pointed to is initialized
** whole = num = 0
** denominator = 1
**
** Note:
** denominator is set to 1 because division
** by 0 is undefined.
**************************************/
void InitFraction (FRACTION *fPtr)
{
fPtr -> whole = 0;
fPtr -> numerator = 0;
fPtr -> denominator = 1;
}
/**************************************
* Function: AssignFraction
* Input: a pointer to a FRACTION
* an integer whole part
* an integer numerator
* an integer denominator
* Output: the corresponding members of the FRACTION
* are initialized to the whole,numerator &
* denominator provided by the caller
**************************************/
void AssignFraction (FRACTION *fPtr, int whole,
int num, int denom)
{
fPtr -> whole = whole;
fPtr -> numerator = num;
fPtr -> denominator = denom;
}
/**************************************
* Function: PrintFraction
* Input: a FRACTION, f
* Ouput: f is printed according to the format
* specified within this code
* Example: 1 1/4
* there is no return value
*
**************************************/
void PrintFraction (FRACTION f)
{
printf("%d %d/%d", f.whole, f.numerator,
f.denominator);
}
/**************************************
* Function: GCD (Greatest Common Divisor)
* Input: two integers
* Output: the greatest common divisor
* of the integers
* Description:
* GCD takes two integer arguments and
* calculates the greatest common divisor of
* those numbers using Euclid's GCD algorithm.
**************************************/
int GCD (int a, int b)
{
int remainder;
remainder = a % b;
while (remainder != 0)
{
a = b;
b = remainder;
remainder = a % b;
}
return b;
}
]]>
Here is the driver that I used to test the functions as I wrote them.
I just kept adding more and more to the main as I continued to write the
functions one by one.
<![CDATA[
/*********************************************
** File: testFrac.c
** Author: S. Bogar
** Date: 4/16/98
** Section: 101
** EMail: bogar@cs.umbc.edu
**
** Driver to test fractions (struct implementation)
*********************************************/
#include <stdio.h>
#include "fraction.h"
int main ()
{
int whole, num, denom;
FRACTION f1, f2, answer;
/* Get two fractions from the user */
/* Fraction 1 */
printf("Enter first fraction:\n");
printf("Enter whole number: ");
scanf("%d", &whole);
printf("Enter numerator: ");
scanf("%d", &num);
printf("Enter denominator: ");
scanf("%d", &denom);
AssignFraction(&f1, whole, num, denom);
/* Fraction 2 */
printf("Enter second fraction:\n");
printf("Enter whole number: ");
scanf("%d", &whole);
printf("Enter numerator: ");
scanf("%d", &num);
printf("Enter denominator: ");
scanf("%d", &denom);
AssignFraction(&f2, whole, num, denom);
/* Print the fractions */
printf("f1 = ");
PrintFraction(f1);
printf ("\n");
printf("f2 = ");
PrintFraction(f2);
printf ("\n\n");
/* Test addition */
answer = AddFractions(f1, f2);
printf("answer to addition = ");
PrintFraction(answer);
printf ("\n\n");
/* Test subtraction */
answer = SubFractions(f1, f2);
printf("answer to subtraction = ");
PrintFraction(answer);
printf ("\n");
/* Test multiplication */
answer = MultFractions(f1, f2);
printf("answer to multiplication = ");
PrintFraction(answer);
printf ("\n");
/* Test division */
answer = DivFractions(f1, f2);
printf("answer to division = ");
PrintFraction(answer);
printf ("\n");
return 0;
}
]]>
Output
<![CDATA[
Enter first fraction:
Enter whole number: 3
Enter numerator: 1
Enter denominator: 2
Enter second fraction:
Enter whole number: 1
Enter numerator: 2
Enter denominator: 3
f1 = 3 1/2
f2 = 1 2/3
answer to addition = 5 1/6
answer to subtraction = 1 5/6
answer to multiplication = 5 5/6
answer to division = 2 1/10
]]>
CSEE
|
201
|
201 S'04
|
lectures
|
news
|
help
Friday, 16-Apr-2004 16:15:02 EDT