I was recently writing some tests for our VHDL expression evaluator and was amazed by the the result of evaluting -16 ** 2. I expected 256, but it wasn't.

Can you guess the output of running this process?

     process is
     begin
          report "-5 mod (-3) : " & integer'image(-5 mod (-3));
          report "(-5) mod (-3) : " & integer'image((-5) mod (-3));
          report "-(5 mod (-3)) : " & integer'image(-(5 mod (-3)));
          report "-16 ** 2 : " & integer'image(-16 ** 2);
          report "(-16) ** 2 : " & integer'image((-16) ** 2);
          report "-(16 ** 2) : " & integer'image(-(16 ** 2));
          wait;
     end process ;

The output is:

     # ** Note: -5 mod (-3) : 1
     # ** Note: (-5) mod (-3) : -2
     # ** Note: -(5 mod (-3)) : 1
     # ** Note: -16 ** 2 : -256
     # ** Note: (-16) ** 2 : 256
     # ** Note: -(16 ** 2) : -256

It turns out unary minus has a lower priority than the modulo and exponentiation operator. I had to consult the LRM again to find this list of operator priorities (from high to low):

  • **, abs, not
  • *, /, mod, rem
  • +, - (unary versions)
  • +, -, &
  • sll, srl, sla, sra, rol, ror
  • =, /=, <, <=, >, >=, ?=, ?/=, ?<, ?<=, ?>, ?>=
  • and, or, nand, nor, xor, xnor

So be careful when you are typing expressions; make sure you use enough parentheses.

P.S: You may have noticed that I wrote -5 mod (-3) and not -5 mod -3. The latter, -5 mod -3, is not valid VHDL. This again is because unary minus has lower priority than the modulo operator.