(Error in documentation?) Math operator precedence problem

Question

Hello,
I apologize in advance, while I do know programming (I'm a PHP and Perl programmer) I'm fairly new to Java so this may well be a silly question, but that's why I am here. I hope you'll show me where my error is so I can finally set this to rest before it drives me mad :)
(Also, I hope I'm posting this in the right forum?)
So, I am taking a Java class, and the question in the homework related to operand precendence. When dealing with multiplication, division and addition, things were fine, the documentation is clear and it also makes sense math-wise (multiplication comes before addition, etc etc).
However, we got this exercise to solve:
If u=2, v=3, w=5, x=7 and y=11, find the value assuming int variables:
u++ / v+u++ *w
Now, according to the operator precedence table (http://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html) the unary operator u++ comes first, before multiplication, division and addition.
This would mean I could rewrite the exercise as:
((u+1)/v) + ((u+1)*w) = (3/3) + (4*5) = 1+20 = 21
However, if I run this in Java, the result I get is 15.
I tried breaking up the result for the two values in the Java code, so I could see where the problem is with my calculation.
For
System.out.println(u++ /v);
I get 0
For
System.out.println("u++ *w");
I get 15
My professor suggested I attempt to change the values from int to float, so I can see if the division came out to be something illogical. I did so, and now I get:
For
System.out.println(u++ /v);
I get 0.66667
For
System.out.println("u++ *w");
I get 15.0000
Which means that for the first operation (the division) the division happens on 2/3 (which is 0.6667) and only afterwards the u value is increased. That is, the u++ operation is done after the division, not before. The same happens with the multiplication; when that is carried out, the value of u is now 3 (after it was raised by one in the previous operation) and the first to be carried out is the multiplication (3*5=15) and only then the u++.
That is entirely against the documentation.
This is the script I wrote to test the issue:
public class MathTest {
     public static void main (String [] args) {
          float u=2, v=3, w=5, x=7, y=11;
          System.out.println("Initial value for 'u': " + u);
          float tmp1 = u++ /v;
          System.out.println("u++ /v = " + tmp1);
          System.out.println("First ++ value for 'u': " + u);
          float tmp2 = u++ *w;
          System.out.println("u++ *w= " + tmp2);
          System.out.println("Second ++ value for 'u': " + u);
          System.out.println(tmp1+tmp2);
The output:
Initial value for 'u': 2.0
u++ /v = 1.0
First ++ value for 'u': 3.0
u++ *w= 20.0
Second ++ value for 'u': 4.0
21.0
Clearly, the ++ operation is done after the division and after the multiplication.
Am I missing something here? Is the documentation wrong, or have I missed something obvious? This is driving me crazy!
Thanks in advance,
Mori

Answer 1

>
The fact that u++ is evaluated but in the calculation itself the "previously stored" value of u is used is completely confusing.
>
Yes it can be confusing - and no one is claiming otherwise. Here are some more thread links from other users about the same issue.
Re: Code Behavior is different in C and Java.
Re: diffcult to understand expression computaion having operator such as i++
Operator Precedence for Increment Operator
>
So, when they explain that ++ has a higher precedence, the natural thing to consider is that you "do that first" and then do the rest.
>
And, as you have discovered, that would be wrong and, to a large degree, is the nut of the issue.
What you just said illustrates the difference between 'precedence' and 'evaluation order'. Precedence determines which operators are evaluated first. Evaluation order determines the order that the 'operands' of those operators are evaluated. Those are two different, but related, things.
See Chapter 15 Expressions
>
This chapter specifies the meanings of expressions and the rules for their evaluation.
>
Sections in the chapter specify the requirements - note the word 'guarantees' in the quoted text - see 15.7.1
Also read carefully section 15.7.2
>
15.7. Evaluation Order
The Java programming language guarantees that the operands of operators appear to be evaluated in a specific evaluation order, namely, from left to right.
15.7.1. Evaluate Left-Hand Operand First
The left-hand operand of a binary operator appears to be fully evaluated before any part of the right-hand operand is evaluated.
If the operator is a compound-assignment operator (§15.26.2), then evaluation of
the left-hand operand includes both remembering the variable that the left-hand
operand denotes and fetching and saving that variable's value for use in the implied
binary operation.
15.7.2. Evaluate Operands before Operation
The Java programming language guarantees that every operand of an operator (except the conditional operators &&, ||, and ? appears to be fully evaluated before any part of the operation itself is performed.
15.7.3. Evaluation Respects Parentheses and Precedence
The Java programming language respects the order of evaluation indicated explicitly by parentheses and implicitly by operator precedence.
>
So when there are multiple operators in an expression 'precedence' determines which is evaluated first. And, the chart in your link shows 'postfix' is at the top of the list.
But, as the quote from the java language spec shows, the result of 'postfix' is the ORIGINAL value before incrementation. If it makes it easier for then consider that this 'original' value is saved on the stack or a temp variable for use in the calculation for that operand.
Then the evalution order determines how the calculation proceeds.
It may help to look at a different, simpler, but still confusing example. What should the value of 'test' be in this example?
i = 0;
test = i++; The value of 'test' will be zero. The value of i++ is the 'original' value before incrementing and that 'original' value is assigned to 'test'.
At the risk of further confusion here are the actual JVM instructions executed for your example. I just used
javap -c -l Test1to disassemble this. I manually added the actual source code so you can try to follow this
        int u = 2;
   4:iconst_2       
   5:istore  5
        int v = 3;
   7:iconst_3       
   8:istore          6
        int w = 5;
  10:iconst_5       
  11:istore          7
        int z;
        z = z = u++ / v + u++ * w;
   13:  iload   5
   15:  iinc    5, 1
   18:  iload   6
   20:  idiv
   21:  iload   5
   23:  iinc    5, 1
   26:  iload   7
   28:  imul
   29:  iadd
   30:  dup
   31:  istore  8
   33:  istore  8The Java Virtual Machine Specification has all of the JVM instructions and what they do.
http://docs.oracle.com/javase/specs/jvms/se7/jvms7.pdf
Your assignment to z and formula starts with line 13: above
13: iload 5 - 'Load int from local variable' page 466
15: iinc 5, 1 - 'Increment local variable by constant' page 465
18: iload 6 - another load
20: idiv - do the division page
21: iload 5 - load variable 5 again
23: iinc 5, 1 - inc variable 5 again
26: iload 7 - load variable 7
28: imul - do the multiply
29: iadd - do the addition
30: dup - duplicate the top stack value and put it on the stack
31: istore 8 - store the duplicated top stack value
33: istore 8 - store the original top stack value
Note the description of 'iload'
>
The value of the local variable at index
is pushed onto the operand stack.
>
IMPORTANT - now note the description of 'iinc'
>
The value const is first sign-extended to an int, and then
the local variable at index is incremented by that amount.
>
The 'iload' loads the ORIGINAL value of the variable and saves it on the stack.
Then the 'iinc' increments the VARIABLE value - it DOES NOT increment the ORIGINAL value which is now on the stack.
Now note the description of 'idiv'
>
The values are popped
from the operand stack. The int result is the value of the Java
programming language expression value1 / value2. The result is
pushed onto the operand stack.
>
The two values on the stack include the ORIGINAL value of the variable - not the incremented value.
The above three instructions explain the result you are seeing. For postfix the value is loaded onto the stack and then the variable itself (not the loaded original value) is incremented.
Then you can see what this line does
  21:  iload   5 - load variable 5 againIt loads the variable again. This IS the incremented value. It was incremented by the 'iinc' on line 15 that I discussed above.
Sorry to get so detailed but this question seems to come up a lot and maybe now you have enough information and doc links to explore this to any level of detail that you want.