Java program stops working without warning

There is nothing in the code in your snippet that will (directly) cause the program to "stop without warning".

• There are no syntax errors (etcetera) that would cause a build to fail. (And that matches what you report.)

• Giving "bad" input to Math.sqrt won't cause it to stop, or even throw an exception. The javadoc says: "[Returns] the positive square root of a. If the argument is NaN or less than zero, the result is NaN." i.e. bad input will give you a NaN value.

• Bad input wouldn't cause the arithmetic before the sqrt call to throw exceptions. The JLS says (for the floating point + and - operators) "[i]f either operand is NaN, the result is NaN."

So the immediate cause of your application's stopping must be somewhere else in your application.

I expect that what is happening is that some other part of your code is throwing an exception when it gets an unexpected result from this method (maybe a NaN) ... and your application is squashing the exception.

I understand the problem now.

What is happening is that the arithmetic and/or calls to sqrt and pow >>are<< generating NaN values. When you test a NaN value using any of the relational operators, the result of the expression is always false. So that means that your code that none of the println calls is made.

Your code is not actually stopping. Rather it is completing normally without producing any output.

And the underlying reason that the calculations are producing NaN values is ... as @duffymo has pointed out ... that you have implemented the geometric formulae incorrectly.

For the record, NaN values have peculiar behaviour when they are used in a relation expressions. For instance:

    double x = 0.0 / 0.0;  // generate a NaN
    System.out.println(0.0 == x);
    System.out.println(0.0 != x);
    System.out.println(0.0 < x);
    System.out.println(0.0 > x);
    System.out.println(x == x);
    System.out.println(x != x);
    System.out.println(x < x);
    System.out.println(x > x);

All will of the above will print "false". Yes, all of them!

The only way to test for a NaN is to use Double.isNaN(double) or Float.isNaN(float).

Here are two links that I believe describe the problem you want to solve pretty well:

http://mathworld.wolfram.com/AcuteTriangle.html

and

http://mathworld.wolfram.com/ObtuseTriangle.html

Here's how I might write it. I didn't test it exhaustively:

package cruft;

/**
 * Junk description here
 * @author Michael
 * @link
 * @since 9/8/12 10:19 PM
 */

public class Triangle {

    private final Point p1;
    private final Point p2;
    private final Point p3;

    public static void main(String args[]) {
        if (args.length > 5) {
            Point p1 = new Point(Double.valueOf(args[0]), Double.valueOf(args[1]));
            Point p2 = new Point(Double.valueOf(args[2]), Double.valueOf(args[3]));
            Point p3 = new Point(Double.valueOf(args[4]), Double.valueOf(args[5]));
            Triangle triangle = new Triangle(p1, p2, p3);
            double angle = triangle.calculateAngle();
            System.out.println(triangle);
            if (angle > 0.0) {
                System.out.println("obtuse");
            } else if (angle < 0.0) {
                System.out.println("acute");
            } else {
                System.out.println("right triangle");
            }
        } else {
            System.out.println("Usage: Triangle x1 y1 x2 y2 x3 y3");
        }
    }

    public Triangle(Point p1, Point p2, Point p3) {
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
    }

    public double calculateAngle(){
        double a = Point.distance(this.p1, this.p2);
        double b = Point.distance(this.p2, this.p3);
        double c = Point.distance(this.p3, this.p1);
        return Math.acos(a*a + b*b - c*c)/2.0/a/b;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("Triangle");
        sb.append("{p1=").append(p1);
        sb.append(", p2=").append(p2);
        sb.append(", p3=").append(p3);
        sb.append('}');
        return sb.toString();
    }
}

class Point {
    public final double x;
    public final double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public static double distance(Point q1, Point q2) {
        double dx = Math.abs(q1.x-q2.x);
        double dy = Math.abs(q1.y-q2.y);
        if (dx > dy) {
            double r = dy/dx;
            return dx*Math.sqrt(1.0+r*r);
        } else {
            double r = dx/dy;
            return dy*Math.sqrt(1.0+r*r);
        }
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append('(').append(x);
        sb.append(',').append(y);
        sb.append(')');
        return sb.toString();
    }
}