We Keep Coding

How to solve imaginary quadratic roots in java?

I've been trying a lot but it only shows NaN. I'm not sure if I'm doing the right thing.
class Imaginary{
double a = 2;
double b = 3;
double c = 5;
double result = b * b - 4 * a * c;
if(result < 0.0){
double im1 = -2 + (Math.sqrt((result))/ 10);
double im2 = -2 - (Math.sqrt((result))/ 10);
System.out.println("x = " + imaginary1 + " or x = " + imaginary2);
}
}

You need to take negate result to make it positive before taking the square root (taking square roots of negative numbers always results in NaN) and append "i" before printing.
double real = -b / (2*a);
double img = Math.sqrt(-result) / (2*a);
System.out.println("x = " + real + " + " + img +"i or x = " + real + " - " + img + "i");

You shouldn't use sqrt(result) since it will always result in you taking the square root of a negative number (that is your condition for result). Instead try to use a formula (eg completing the square).
Hope it answers your question :)

Since you have a complex root, you need to work with complex numbers to solve the equation. Java lacks builtin support for complex numbers, but you can e.g. use Apache Commons:
if (result < 0.0) {
final Complex cb = new Complex(-b, 0.0);
final Complex root = new Complex(result, 0.0).sqrt();
final Complex r1 = cb.add(root).divide(2 * a);
final Complex r2 = cb.subtract(root).divide(2 * a);
}

I'm not sure how to round this properly in my Java code

I'm fairly new to Java, and I've recently written a code that calculates how much change you would need for x amount of money payed for a y priced item. It works well; my only issue is that whenever there is not any change owed in the hundredths place (ex: $4.60), it will round down to the tenths place ($4.6).
If anybody knows how to fix this, I would be very grateful. I have the code posted below.
class Main {
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
double x;
double y;
double z;
System.out.print("Enter the price of the product: $");
x = scan.nextDouble();
System.out.print("Enter what you payed with: $");
y = scan.nextDouble();
z = (int)Math.round(100*(y-x));
System.out.print("Change Owed: $");
System.out.println((z)/100);
int q = (int)(z/25);
int d = (int)((z%25/10));
int n = (int)((z%25%10/5));
int p = (int)(z%25%10%5);
System.out.println("Quarters: " + q);
System.out.println("Dimes: " + d);
System.out.println("Nickels: " + n);
System.out.println("Pennies: " + p);
}
}
Edit: Thank you to everyone that answered my question! I ended up going with DecimalFormat to solve it, and now it works great.

You can call something like this:
String.format("%.2f", i);
So in your case:
...
System.out.print("Change Owed: $");
System.out.println((String.format("%.2f", z)/100));
...
String.format() is useful whenever you want to round it to certain significant figures. In this case "f" stands for float.

This behavior is expected. You do not want numbers to carry trailing zeroes.
You can use DecimalFormat for representing them as a String with a trailing zero, rounded to two digits.
Example:
DecimalFormat df = new DecimalFormat("#0.00");
double d = 4.7d;
System.out.println(df.format(d));
d = 5.678d;
System.out.println(df.format(d));
Output:
4.70
5.68
You can also add your currency sign to the DecimalFormat:
DecimalFormat df = new DecimalFormat("$#0.00");
Output with currency sign:
$4.70
$5.68
EDIT:
You can even tell DecimalFormat how to round your number by setting the RoundingMode through df.setRoundingMode(RoundingMode.UP);

The String.format() method is my personal preference. For example:
float z;
System.out.println(String.format("Change Owed: $%.2f", (float) ((z) / 100)));
%.2f will round any float ('f' stands for float) off to 2 decimal places, by changing the number before the 'f' you change how many decimal points you round to. Eg:
//3 decimal points
System.out.println(String.format("Change Owed: $%.3f", (float) ((z) / 100)));
//4 decimal points
System.out.println(String.format("Change Owed: $%.4f", (float) ((z) / 100)));
// and so forth...
You may want to do some reading into String.format() if you are starting out with Java. It is a very powerful and useful method.
From what I understand:
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
double x;
double y;
double z;
System.out.print("Enter the price of the product: $");
x = scan.nextDouble();
System.out.print("Enter what you payed with: $");
y = scan.nextDouble();
z = (int) Math.round(100 * (y - x));
System.out.println(String.format("Change Owed: $%.2f", (float) ((z) / 100)));
int q = (int) (z / 25);
int d = (int) ((z % 25 / 10));
int n = (int) ((z % 25 % 10 / 5));
int p = (int) (z % 25 % 10 % 5);
System.out.println("Quarters: " + q);
System.out.println("Dimes: " + d);
System.out.println("Nickels: " + n);
System.out.println("Pennies: " + p);
}
All the best for your future projects!

quadratic equation solver fails to get result in Java

I have code that is supposed to solve a quadratic equation but yields NaN as a result.
I've looked around for 2 days now and I can't find a solution. Any and all advice will be more than appreciated!
package quadratic;
import java.util.Scanner;
public class Formlua {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("enter value of A ");
double a = input.nextDouble();
System.out.println("enter value of B ");
double b = input.nextDouble();
System.out.println("enter value of C ");
double c = input.nextDouble();
double four = 4;
double square = Math.sqrt(b* b - 4 * a * c );
double root1 = (-b + square) / (2*a);
double root2 = (-b - square) / (2*a);
System.out.println("The answer is " + root1 + "and" + root2);
System.out.println("Do you want to continue? y/n");
String user = input.toString();
if(user.equalsIgnoreCase("y"));
}
}

This code:
Math.sqrt(b* b - 4 * a * c );
can result in NaN ("not a number").
If the value of b* b - 4 * a * c is negative, there are solutions only in complex numbers (but not in double data type)
There should be a condition
if (b* b - 4 * a * c<0) {
System.out.println("There is no solution in real numbers");
return;
}

The most likely cause of the problem is Math.sqrt(b*b - 4 * a * c). or one of your input values is NaN (probably not the cause in this situation).
There are two special cases:
b *b < 4 * a * c
and a = 0
if b * b < 4 * a * c your answer is in the complex plane (specifically, not a real number).
if a = 0 then you actually just have a linear equation.
you could try the following code:
package quadratic;
import java.util.Scanner;
public class Formlua {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("enter value of A ");
double a = input.nextDouble();
System.out.println("enter value of B ");
double b = input.nextDouble();
System.out.println("enter value of C ");
double c = input.nextDouble();
if (a == 0){
// 0 = 0*x*x + b*x + c ==> x = -c/b
System.out.println("X = " + Double.toString(-c/b));
} else {
double inner = b * b - 4 * a * c;
if (inner < 0){
inner = -inner;
inner = Math.sqrt(inner);
System.out.println("X = " + Double.toString(-b) + " + " + Double.toString(inner) + "i")
System.out.println(" = " + Double.toString(-b) + " - " + Double.toString(inner) + "i");
} else {
inner = Math.sqrt(inner);
System.out.println("X = " + Double.toString(-b));
if (inner == 0){
} else {
System.out.println("X = " + Double.toString(-b + inner));
System.out.println("X = " + Double.toString(-b - inner));
}
}
}
}
This lets your user input any double values and recieve an answer.

quadratic formula with scanner inputs

Okay so I am a complete Java noob, and I'm trying to create a program for class that runs a quadratic equation using scanner inputs. So far what I've got is this:
import java.util.*;
public class QuadraticFormulaSCN {
public static void main(String[]args) {
System.out.println("insert value for a:");
Scanner scan1 = new Scanner(System.in);
double a = scan1.nextDouble();
System.out.println("insert value for b:");
Scanner scan2 = new Scanner(System.in);
double b = scan2.nextDouble();
System.out.println("insert value for C:");
Scanner scan3 = new Scanner(System.in);
double c = scan3.nextDouble();
double answer =((Math.sqrt(Math.pow(b,2)-(4*a*c))-b)/2);
double final2 =(-b + Math.sqrt(Math.pow(b,2)-(4*a*c)))/2;
System.out.println("The x values are:" + answer + final2);
}
}
But I get a weird output, specifically NaNaN... What do I do to fix this? What am I doing wrong?

I'm a little late to answer, but I corrected your problems (described in the other answers), fixed one of your calculations, and cleaned up your code.
import java.util.*;
public class Test {
public static void main(String[] args)
{
Scanner s = new Scanner(System.in);
System.out.println("Insert value for a: ");
double a = Double.parseDouble(s.nextLine());
System.out.println("Insert value for b: ");
double b = Double.parseDouble(s.nextLine());
System.out.println("Insert value for c: ");
double c = Double.parseDouble(s.nextLine());
s.close();
double answer1 = (-b + Math.sqrt(Math.pow(b, 2) - (4 * a * c))) / (2 * a);
double answer2 = (-b - Math.sqrt(Math.pow(b, 2) - (4 * a * c))) / (2 * a);
if (Double.isNaN(answer1) || Double.isNaN(answer2))
{
System.out.println("Answer contains imaginary numbers");
} else System.out.println("The values are: " + answer1 + ", " + answer2);
}
}

NaN is something you get when the calculation is invalid. Such as dividing by 0 or taking the squareroot of -1.
When I test your code with a = 1, b = 0 and c = -4 the answers is 2.02.0
The formatting is not right and the calculation of final2 is not negated.
Otherwise the code is right.
To improve you could check whether the discriminant is negative.
double d = b*b -4 * a * c;
if (d < 0){
System.out.println("Discriminant < 0, no real solutions" );
return;
}
double x1 = (-b -sqrt(d))/(2*a);
double x2 = (-b +sqrt(d))/(2*a);
System.out.format("The roots of your quadratic formula are %5.3f and %5.3f\n",x1,x2);
Or, if you prefer support for solutions from the complex domain:
if (d < 0) {
System.out.println("Discriminant < 0, only imaginary solutions");
double r = -b / (2 * a);
double i1 = -sqrt(-d) / (2 / a);
double i2 = sqrt(-d) / (2 / a);
System.out.format("The roots of your quadratic formula are (%5.3f + %5.3fi) and (%5.3f + %5.3fi)\n",r, i1, r, i2);
return;
}

You are getting NaN because you are attempting to take the square root of a negative number. In math that's not allowed unless you are allowing complex numbers, e.g. 1 +/- 2i.
This can happen in quadratic formulas when the discriminant (the thing in the square root) is negative, e.g. x^2 + 6*x + 100: b^2 - 4ac = 36 - 400 = -364. Taking the square root of a negative number in Java leads to NaN. (not a number)
To test for NaN, use Double.isNaN and handle the NaN appropriately.
In addition, your calculations are incorrect even if NaN isn't being encountered:
$ java QuadraticFormulaSCN
insert value for a:
1
insert value for b:
5
insert value for C:
6
The x values are:-2.0-2.0
This should have outputted 2.0 and 3.0

You should only do the calculation when
discriminant is equal or greater than zero
if(((Math.pow(b,2)-(4*a*c))>= 0){ /* Calculation here */ }
else {/*error message or complex number calculus*/};

One thing I always try to do is put all my math in appropriate parenthesis to avoid an, all too easy, Order of Operations mistake. The NaN is saying "Not a number." You would also get that message if the user input numbers that could not produce a result, such as a trying to get the square root of a negative number. Also, just as a note, you can save sometime by only using on Scanner for a,b, and c.
public class QuadraticFormula{
public static void main(String[] args){
java.util.Scanner input = new java.util.Scanner(System.in);
double a = input.nextDouble();
double b = input.nextDouble();
double c = input.nextDouble();
double quadPos = (-b + Math.sqrt(Math.pow(b,2)-(4*a*c)))/(2*a);
double quadNeg = (-b - Math.sqrt(Math.pow(b,2)-(4*a*c)))/(2*a);
System.out.println("-b - = " + quadNeg + "\n-b + = " + quadPos);
}
}

Getting accurate roots of quadratic equation

This is the code that I have thus far. The goal of the project is to have the user enter any integers for a, b, c for the ax^2+bx+c equation. For some reason I am not getting the correct roots for any numbers that are input into the program. Can anyone point out my wrong doings?
import java.util.*;
public class Quad_Form {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
double a = 0;
double b = 0;
double c = 0;
double discrim = 0;
double d = 0;
System.out.println("Enter value for 'a'");
String str_a = sc.nextLine();
a = Integer.parseInt(str_a);
System.out.println("Enter value for 'b'");
String str_b = sc.nextLine();
b = Integer.parseInt(str_b);
System.out.println("Enter value for 'c'");
String str_c = sc.nextLine();
c = Integer.parseInt(str_c);
double x1 = 0, x2 = 0;
discrim = (Math.pow(b, 2.0)) - (4 * a * c);
d = Math.sqrt(discrim);
if(discrim == 0){
x1 = (-b + d) / (2* a);
String root_1 = Double.toString(x1);
System.out.println("There is one root at: " + root_1);
}
else {
if (discrim > 0)
x1 = (-b + d) / (2 * a);
x2 = (-b - d) / (2 * a);
String root_1 = Double.toString(x1);
String root_2 = Double.toString(x2);
System.out.println("There are two real roots at:" + root_1 + "and" + root_2);
}
if (discrim < 0){
x1 = (-b + d) / (2 * a);
x2 = (-b - d) / (2 * a);
String root_1 = Double.toString(x1);
String root_2 = Double.toString(x2);
System.out.println("There are two imaginary roots at:" + root_1 + "and" + root_2);
}
}
}

#Smit is right about one of the issues, but there's a second one as well.
Math.sqrt(discrim) won't work when discrim is negative. You should be taking Math.sqrt(Math.abs(discrim)) instead.

a, b, c, d are double and you are parsing them as Integer. So this could be one of problem.
Use
Double.parseDouble();
Another problem is you can not make square root of negative numbers. This will result in NaN. For that use following, but you should handle that properly to get exact result.
Math.sqrt(Math.abs());
Moreover you should use following formula for getting roots
Taken from Wikipedia Quadratic equation
Class Double
Class Math