0

I've got some heavy math to translate, from the apps I originally developed in VB6 to Java, and am running into a few issues with even the most basic equations.

For instance, why does this work,

double QD1=0;
QD1=24+c; QD1=QD1/513;

but this not work

double QD1=0;
QD1=(24+c)/513;

Also, I'm getting some non-linearity out of an equation that is completely linear, using doubles. My system is 64-bit Fedora on a laptop built around 2006 or so. Is this likely to be a processor issue or a coding issue? Would I be better off using C++, or some kind of parser plug in?

Pops
  • 30,199
  • 37
  • 136
  • 151
Paul Adamson
  • 9
  • 3
  • For a math-heavy application where you have the choice of programming language, take a lool into [Julia](http://julialang.org). Having written quite a lot of mathematical code for web applications in the past, Java would not be my choice today. – Ned Jan 09 '14 at 00:13
  • Wow - just skimmed that description - very cool. :D – Paul Adamson Jan 09 '14 at 00:31

3 Answers3

2

It should be

double QD1=0;
QD1=(double)(24+c)/513;

You need to cast integer (24+c) to double type.

Read more about it here.

Alex
  • 11,451
  • 6
  • 37
  • 52
  • thank you - will I need to do this before every segment that is delimited by parentheses? Like (double)(x/y)+(double)(z/y) – Paul Adamson Jan 09 '14 at 00:18
  • Another way is to do: `QD1=(24d+c)/513;` If you divide integer (`x`, `y`, `z` in your case) you should cast it to double. If `x`, `y`, `z` have double type you should not add extra casting. – Alex Jan 09 '14 at 00:20
  • 2
    Or you could just write your number literals as 24.0 and 513.0 so they are doubles, if that was your intent.... :) – Affe Jan 09 '14 at 00:50
  • @PaulAdamson Whenever you divide two integers, you get integer division (which throws away any remainder). If `x` and `y` are integers, then `(double)(x/y)` does integer division on `x` and `y` *first*, because of the second set of `()`. Then it converts the resulting integer to a `double`. But this still throws away the remainder. If you want a fractional result, you need `((double)x/y)` or something. This converts `x` to a `double` before the division, so you will *not* get integer division. – ajb Jan 09 '14 at 00:51
0

For a more complete explanation for problems like this, see the answer to: What are the rules for evaluation order in Java?

Community
  • 1
  • 1
Ned
  • 937
  • 6
  • 10
0

This time, a direct answer:

...why does this work,

double QD1=0;
QD1=24+c; QD1=QD1/513;

QD1 is clearly a double. To Java, 24 is an integer constant. If c is an integer type, c is added to 24 using integer arithmetic and the result is converted to double and then assigned to QD1. If c is a floating point type, 24 is promoted to double, added to c and the double result is assigned to QD1. Either way, the division of QD1 is a double divided by an integer constant. The integer constant is promoted to double and floating point division is performed with a double result assigned to QD1.

but this doesn't.

double QD1=0;
QD1=(24+c)/513;

In this case, if c is an integer type, the entire expression on the right-hand side operates on integers and returns an integer type. In Java, integer division truncates any fractional part which might result if the division were instead performed using floating point values and operators. Once evaluation of the right-hand side has completed, the integer result is promoted to double before assigning it to QD1, but by then, the fractional part of the intended result has already been lost.

The way to prevent this particular problem in practice is to always provide a fractional part to all integer constants used in floating point calculations. E.g. Change the code in both examples to use 24.0 and 513.0 for the constants. Always do this even in code which works as expected. Future edits may "break" the implementation when integer types are not intended.

Ned
  • 937
  • 6
  • 10