Homework SourseC Beginner Program Code Mathematics with Functions General
C++ Beginner Program Code - Mathematics with Functions
General description
This assignment is all about designing functions to be as broadly useful as possible: providing them with the information they need to do their job (via parameters, either by value or reference); and having them hand back their results (either via the reference parameters or the return statement).
Your task
Write a program that allows the user to select a mathematical operation to solve. Each operation will be implemented as a function; a single \"helper\" function will gather the operands needed for the selected operation. Some of these operations can \"break\" under certain conditions (e.g. divide by 0), so the functions must be able to flag any errors by returning an error code or OK if the operation was successful.
Use incremental development
Develop this program one function at a time.
Implement everything in main prior to the invocation of acquireOperands.
Next turn all function prototypes into function stubs. After this, you should be able to compile your program without any errors.
Now you can begin implementing the functions, start with the \"helper\" function for operand input.
For each function, use your main function to test it locally or on Cloud 9 with various values.
After you believe your function works, test it on your own and then submit your file to have zyBooks further test the function.
Once you have received full credit on the unit tests for that function, you can begin to layout and implement the next function.
Once all the functions are completed and tested, complete the main function to properly drive the program.
The functions
acquireOperands: acquires the values for the specified operation and places them into reference parameters
1 const string reference parameter (requested operation)
3 integer reference parameters (for up to 3 operands)
returns number of user inputs acquired by this function
e.g. the \"division\" operation has 2 inputs and thus the function would return the value 2.
In many large programs, lots of developers work on various things. We return the quantity of inputs here because this allows others to check our work and know exactly which operand variables have valid values.
division: calculates floating point result of a / b
2 integer value parameters (for operands)
1 double reference parameter (for result)
returns the constant for \"Divide by 0\" or the constant for \"OK\"
Pythagorean equation: solve for hypotenuse c such that c = sqrt(a^2 + b^2)
2 integer value parameters (for operands)
1 double reference parameter (for result)
returns the constant for \"OK\"
3 integer value parameters (for operands)
2 double reference parameters (for two roots)
returns the constant for \"OK\", or \"Divide by 0\", or \"Negative Discriminant\"
Do not simplify the quadratic equation in any way based on input values such as a = 0.
Notes
the operation is acquired in main and then provided to acquireOperands
acquireOperands must request exactly the number of inputs required for the provided operation
the operation functions provide multiple \"return\" values by using the return statement and reference parameters
results are communicated via the reference parameters
the return statement is used for the error code/constant
no input or output statements in any of the operation functions - all i/o is in either main or acquireOperands
main function
Once you have your functions written and tested, you can write main:
Repeatedly acquire the user operation choice if it is anything other than \"division\" or \"pythagorean\" or \"quadratic\", output a message \"Operation not supported\", and continue to prompt until a proper choice is made.
acquireOperands is invoked for you, when it completes the proper operands should be filled with values
now you can invoke the appropriate operation function, and display the output similar to the examples:
Equation:
either a Result: or an Error:
Output strings for potential errors
Operation not supported.
Cannot divide by zero.
Cannot take square root of a negative number.
Quadratic roots should be output in ascending order when outputting the results in main.
Double roots (two roots of the same value) should only be output once when outputting results in main.
Starter code
Use the starter code provided below by copy and pasting it into a development environment, such as Cloud 9. After pasting it, go through the code and read all the comments to help familiarize yourself with the starter code. Do not delete the comments, they are there to help guide you and provide insight as to what purpose certain code blocks have. When implementing a code block, it will most often go immediately below the comment, this allows a second viewer to read your comment and then your code, allowing the newcomer to read and interpret the code with the background knowledge or overview given in the comment.
Example Executions
Inputs
Output
Inputs
Output
Inputs
Output
b2 b-t 2a a, CSolution
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
const int OK = 0;
const int DIV_ZERO = 1;
const int SQRT_ERR = 2;
/// @brief calculate quotient for provided values
///
/// @param a the dividend of the equation
/// @param b the divisor of the equation
/// @param result reference to place the quotient in
/// @return returns the integer representing the state of the calculation
/// using constants for OK and DIV_ZERO
int division(int a, int b, double &result)
{
result = a/b;
return result;
}
/// @brief calculate c for the pythagorean theorem a^2 + b^2 = c^2
///
/// @param a the value of a in the equation
/// @param b the value of b in the equation
/// @param c reference for the c calculation
/// @return returns the integer representing the state of the calculation
/// using constant for OK
int pythagorean(int a, int b, double &c)
{
c=sqrt(a^2+b^2);
return c;
}
/// @brief calculate the roots to the quadratic formula for a polynomial of
/// the form a*x^2 + b*x + c = 0. Returns errant state when necessary.
/// Do not simplify equation in any way based on inputs such as a = 0.
///
/// @param a the coefficient of x^2 in the polynomial equation
/// @param b the coefficient of x in the polynomial equation
/// @param c the last value of the polynomial equation
/// @param root1 reference for the first root of the quadratic formula
/// @param root2 reference for the second root of the quadratic formula
/// @return returns the integer representing the state of the calculation
/// using constants for OK, DIV_ZERO, and SQRT_ERR
int quadratic(int a, int b, int c, double &root1, double &root2)
{
double determinant = b*b - 4*a*c;
if (determinant > 0) {
root1 = (-b + sqrt(determinant)) / (2*a);
root2 = (-b - sqrt(determinant)) / (2*a);
}
else if (determinant == 0) {
root1 = (-b + sqrt(determinant)) / (2*a);
root2 = 0;
}
else {
root1 = -b/(2*a);
root2 =sqrt(-determinant)/(2*a);
}
return 1;
}
/// @brief acquire the proper number of numeric inputs based on operation string
///
/// The numeric inputs are set into x, y, and z in that order;
/// the number of numeric inputs acquired is returned to the caller.
/// Not all operations require all three values:
/// do not set the variables of operands that are not needed.
///
/// @param op the operation to be performed such as division
/// @param x the first numeric input
/// @param y the second numeric input
/// @param z the third numeric input
/// @return the number of numeric inputs that were acquired
int acquireOperands(const string &op, int &x, int &y, int &z)
{
if(op == \"division\")
{
double result;
cout<<\"Enter your first number: \";
cin>>x;
cout<<\"Enter your second number: \";
cin>>y;
if(y==0)
{
cout<<\"Error: Cannot divide by zero.\"<<endl;
}
else
{
division(x,y,result);
cout<<\"Result: \"<<result<<endl;
}
}
if(op == \"pythagorean\")
{
double result;
cout<<\"Enter your first number: \";
cin>>x;
cout<<\"Enter your second number: \";
cin>>y;
pythagorean(x,y,result);
cout<<\"Result: \"<<result<<endl;
}
if(op == \"quadratic\")
{
double root1,root2;
cout<<\"Enter your first number: \";
cin>>x;
cout<<\"Enter your second number: \";
cin>>y;
cout<<\"Enter your third number: \";
cin>>z;
quadratic(x,y,z,root1,root1);
cout<<\"Result: \"<<root1<<\" , \"<<root2<<endl;
}
}
/// @brief main driver for the mathematics program
int main()
{
string operation;
int number1;
int number2;
int number3;
int numOperands;
int result;
int count =0;
do{
// Acquire the operation the user wishes to perform
cout << \"Please choose an operation: \";
cin >> operation;
cout << endl;
if(!((operation.compare(\"division\")) || (operation.compare(\"pythagorean\")) || (operation.compare(\"pythagorean\"))))
{
count =1;
cout<<\"Error: Operation not supported.\";
}
// TODO: keep acquiring an operation from the user as long as the
// user has typed an invalid operation.
// Output the invalid operation error with every iteration.
}while(!((operation.compare(\"division\")) || (operation.compare(\"pythagorean\")) || (operation.compare(\"pythagorean\"))));
// Acquire user numerical inputs
// All remaining cin statements will exist in acquireOperands
numOperands = acquireOperands(operation, number1, number2, number3);
// TODO: test your functions as you develop them. Once
// you are sure the function is working correctly, move to the
// next function. Once you have completed all the functions
// comment out or eliminate your \"testing\" code and
// continue writing main
// TODO: Perform the operation specified by the user
// For the specified operation, output the equation followed
// by either the error or the result (but never both).
return 0;
}
