Assistance with C Program: Solving for Delta - c

Question

I need to make a program in C that takes 3 coefficients, a, b, c, then solves for Delta. It then takes Delta and decides what Function to send it to determine it's output.
/*
*Program Name: COP 2220-10018 Project 4
*
* Author: Nathan Gamble
*
* Description: Find Delta, solve for roots.
*
* Input: Coefficients a, b, c.
*
* Output: Roots
*/
#include <stdio.h>
#include <math.h>
int main (void)
{
//Local Declarations
float a;
float b;
float c;
float delta;
//Statements
printf("Input coefficient a.\n");
scanf("%.2f", &a);
printf("Input coefficient b.\n");
scanf("%.2f", &b);
printf("Input coefficient c.\n");
scanf("%.2f", &c);
printf("%fx^2 + %fx + %f\n", &a, &b, &c);
//Process
delta = (b * b) - (4 * a * c);
if (delta > 0) twoRoots(a, b, c, delta);
else if (delta = 0) oneRoot(a, b, c, delta);
else if (delta < 0) noRoots();
return;
} // End main
/*
*Program Name: COP 2220-10018 Project 4
*
* Author: Nathan Gamble
*
* Description: To solve for the two roots.
*
* Input: None
*
* Output: Root one, Root two.
*/
#include <stdio.h>
#include <math.h>
int twoRoots ()
{
//Local Declarations
float xOne;
float xTwo;
float delta;
float deltaRoot;
float a;
float b;
printf("There are two distinct roots.\n");
deltaRoot = sqrt(delta);
xOne = (-b + deltaRoot) / (2*a);
xTwo = (-b - deltaRoot) / (2*a);
printf("%.2f", &xOne);
printf("%.2f", &xTwo);
return;
} // End twoRoots
/*
*Program Name: COP 2220-10018 Project 4
*
* Author: Nathan Gamble
*
* Description: To solve for the one root.
*
* Input: None
*
* Output: Root one.
*/
#include <stdio.h>
#include <math.h>
int oneRoot ()
{
//Local Declarations
float xOne;
float xTwo;
float deltaRoot;
float a;
float b;
printf("There is exactly one distinct root./n");
xOne = -b / (2*a);
printf("%.2f", &xOne);
return;
} // End oneRoot
/*
*Program Name: COP 2220-10018 Project 4
*
* Author: Nathan Gamble
*
* Description: To inform the roots are complex.
*
* Input: None
*
* Output: Statement.
*/
#include <stdio.h>
#include <math.h>
int noRoots ()
{
//Local Declarations
printf("There are two distinct complex roots./n");
return;
} // End noRoots
When I run it, I get the following Output:
Input coefficient a.
1
Input coefficient b.
Input coefficient c.
0.000000x^2 + 882156984598706310000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000.000000x + 0.000000
Process returned 16384 (0x4000) execution time : 10.641 s
Press any key to continue.
I only input 1, for a, and then it spits outt he remainder of the main method.

Answer 1

Few things that jump out first:
printf("Input coefficient a.\n");
scanf("%f", &a); // you were scanning for 0.2f .. any reason why?
printf("Input coefficient b.\n");
scanf("%f", &b);
printf("Input coefficient c.\n");
scanf("%f", &c);
your printf is also wrong .. change it to this:
printf("%0.2fx^2 + %0.2fx + %0.2f\n", a, b, c); // you were printing the addresses of a,b,c .. printf just needs the name of variables not their addresses
Output after doing above changes:
$ ./test
Input coefficient a.
1.5
Input coefficient b.
2.5
Input coefficient c.
3.5
1.50x^2 + 2.50x + 3.50
Fixed code: ( ask me if you have questions about any part )
#include <stdio.h>
#include <math.h>
// function declarations
void twoRoots (float a,float b,float delta);
void oneRoot (float a,float b,float delta);
int main (void)
{
//Local Declarations
float a;
float b;
float c;
float delta;
float solution;
printf("Input coefficient a.\n");
scanf("%f", &a);
printf("Input coefficient b.\n");
scanf("%f", &b);
printf("Input coefficient c.\n");
scanf("%f", &c);
printf("%0.2fx^2 + %0.2fx + %0.2f\n", a, b, c);
delta = (float)(b*b) - (float)(4.0 * a * c);
printf("delta = %0.2f\n",delta);
if (delta > 0){
twoRoots(a,b,delta);
}else if (delta == 0) {
oneRoot(a,b,delta);
}else if (delta < 0.0){
printf("There are no real roots\n");
}
return 0;
}
void twoRoots (float a,float b,float delta)
{
float xOne;
float xTwo;
float deltaRoot;
printf("There are two distinct roots.\n");
deltaRoot = sqrt(delta);
xOne = (-b + deltaRoot) / (2*a);
xTwo = (-b - deltaRoot) / (2*a);
printf("%.2f", xOne);
printf("%.2f", xTwo);
}
void oneRoot(float a,float b,float delta)
{
float xOne;
float xTwo;
float deltaRoot;
printf("There is exactly one distinct root\n");
xOne = -b / (2*a);
printf("%.2f", xOne);
}
Output1:
$ ./test
Input coefficient a.
1.1
Input coefficient b.
5.5
Input coefficient c.
2.2
1.10x^2 + 5.50x + 2.20
delta = 20.57
There are two distinct roots.
-0.44-4.56
Output2:
$ ./test
Input coefficient a.
1
Input coefficient b.
4
Input coefficient c.
4
1.00x^2 + 4.00x + 4.00
delta = 0.00
There is exactly one distinct root
-2.00
Output3:
$ ./test
Input coefficient a.
1
Input coefficient b.
3
Input coefficient c.
9
1.00x^2 + 3.00x + 9.00
delta = -27.00
There are no real roots
I optimised the code and made it a whole lot more efficient here :
http://pastebin.com/GS65PvH6

Answer 2

I think that the problem comes from the fact that 1 is recognized as an int and not a float.
When you write %.2f scanf expects you to input a float. If it detects something else it fails and does not read any other scanf requests as specified in the man page.

Answer 3

Your immediate problem lies here:
scanf ("%.2f", &a);
You can put a length limiter on the value to be scanned but you probably shouldn't be trying to limit what's input anyway.
In any case, the .2 option you're using is not valid for scanf, it's a printf thing controlling the precision of the output.
The ISO standard states that scanf needs "an optional decimal integer greater than zero that specifies the maximum field width (in characters)". So there's no way using just scanf to limit how many digits are allowed after the decimal point.
Use this instead:
scanf ("%f", &a);
including for the other scanf calls.
As to further problems, there are a few, some of which are below. I haven't provided an exhaustive list as the problem specific to your question is the scanf format string.
First, you want to print the values of those variables rather than their addresses:
printf ("%fx^2 + %fx + %f\n", a, b, c);
Second, you pass the variables a/b/c/delta to your functions but you do not receive them. You need to declare them something like:
int twoRoots (float a, float b, float c, float delta)
and ensure you remove any local variable declarations for those names so that they don't hide the passed-in ones (or cause compilation errors).