ITEC 120 2007spring ibarland, jpittges

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

lect04b
bad arithmetic

Review

• Order of precedence for boolean and other operators: Use parentheses, if it's at all ambiguous.
• Order of precedence for arithmetic: you can assume everybody knows: first all multiplication/divisons (left-to-right), then all addition/subtractions (left-to-right). (Still, sometimes parentheses can add clarity.)
• / can either mean “call the built-in function integer-division”, or “call the built-in function floating-point-division”, depending on context.
• Casting: a whole special syntax, just to call a function which takes a double and returns a nearby int, and vice versa:

  (double) 5 int m = 13; int n = 5; ((double) m) / ((double) n)

  Also note that behind your back, Java is often converting doubles to ints. (For instance, 3/5.2 and Math.sqrt(4).)
• % is remainder; it is the complement to quotient. I always have to look up (or, type in) how % works with negative numbers.

(Optional) An application of %: public key cryptography

Web traffic is sent on postcards. How to securely communicate your credit-card number to amazon, without any pre-arrangement? “Inconceivable!”?

Amazon might say on their web page:

Our public key pubKey = 37. If you want to send us a secret message privMsg (a two-digit number), multiply your secret number by our public key, and tell us the last two digits (only) of the result: That is, tell us (privMsg * pubKey) % 100. (We can name this result pubMsg.)

Note that this used no pre-arrangement between the sender and the receiver. This is called “public key cryptography”, since eavesdroppers know as much about breaking the code as the sender.

You could break this code, if you could divide by 37 mod 100. (Or more precisely: find the multiplicative inverse of 37, mod 100.) Project: read about the extended Euclidean algorithm for calculating muliplicative inverses. Break this code!

Although this particular scheme is easy to break with a bit of math knowledge (this Extended Euclidean algorithm), the example is to motivate how a public-key system is even conceivable.

Arithmetic errors

• What is 200-110? What about 2.00-1.10?
• What is 7/25*25?
  How about
  7.0/25.0*25.0
  14.0/25.0*25.0
  21.0/25.0*25.0
  Beware, round-off error! It seems small, but sometimes small errors can really add up. (Next time you fly home for thanksgiving, you might give some thought to whether the software controlling the plane is using doubles.)

• We also have the issue of overflow with doubles. Try 1e308 + 1e308. Double.MAX_VALUE. (Keep in mind that 10³⁰⁸ is a ridiculously huge number; there are “only” 10⁸⁰ particles in the universe (electrons, photons, quarks...), 10⁹⁰ is a ten billion times bigger. So 10³⁰⁸ is a number that doesn't correspond to any reasonable physical amount.

  There is another twist to this: we might try to compute numbers which are so close to 0 they can't be represented by a double: Double.MIN_VALUE. Try Double.MIN_VALUE/2. As before, we have a trade-off between float vs double.

• 2000000000 + 2000000000 (?!) What's going on? For int, the computer only keeps about 10 places total (more accurately, 32 binary bits); the biggest and smallets legal int values are Integer.MAX_VALUE and Integer.MIN_VALUE¹ When int isn't big enough, there is another type long.
  How about Long.MAX_VALUE (10 quintrillion). What is the trade off? There is also Short.MAX_VALUE and Byte.MAX_VALUE. (Notice that the digits roughly double.)
• It's not that computers can't do grade-school arithmetic. If nothing else, you could write a program which takes two (long) strings of digits, and adds them exactly. Some languages have precise arithmetic built-in; Mathematica and Lisp are two examples.

  Aside: Java does have a way to do exact arithmetic, but it takes some extra typing:

  java.math.BigInteger ratherLarge1 = new java.math.BigInteger( "987654321098765432109876543210" ); java.math.BigInteger ratherLarge2 = new java.math.BigInteger( "012345678901234567890123456789" ); (ratherLarge1.add(ratherLarge2)).toString();

  (This is a teaser to next week, when we'll talk about state, constructor-methods, and calling constructors with new.)

• We mentioned, that casting raises the specter of silent overflow issues: If casting an int to a double, you are throwing away accuracy. But worse, if you cast a large double to an int, and that double is bigger than Integer.MAX_INT, the cast will silently succeed, with a wildly incorrect value!

  (int) 7e35 // Size of the universe, in nanometers... whereas 2billion nanometers ~ 6ft.

  I'd prefer the computer meekly raise its hand and indicate there might be an error, rather than claim that the universe is 6ft across because of its insistence on only keeping fifteen digits of accuracy.

Edict of Programming: When possible, using int is preferred to double. For instance, the price of an item is often best given in integer cents, rather than double dollars. This will avoid accumulation of small errors, as in 2.00-1.10 vs. 200-110.

Example

Write the following function:

/** Return a nicely formatted String representing a price in dollars.
 * @param cents An amount of money (in cents).
 * @return A String representing cents, in dollars.
 * Examples:
 *   dollarAmount(167) = "$1.67"
 *   dollarAmount(43) = "$0.43"
 *   dollarAmount(__) = ______
 */
String dollarAmount( int cents ) {
  ________________
  }

Note that really, we're relying on the fact that when Java sees + with a String on one side and an int on the other, then it is calling (behind our back) an int-to-String conversion function.

Comparing doubles

Beware numerical inaccuracies: (2.0 - 1.1 == 0.9), or ( (7.0/25.0)*25.0 == 7.0 ).

double x = 2.0 - 1.1;
double y = 0.9;

x == y
// huh?  That's an unexpected answer.  How to debug?

x
// Oh, now it's clear what happened.

Edict of Programming: Do not use == with doubles.

Actually, we should look at an relative difference between two terms, rather than an absolute difference.

Review

We have covered many topics over the last 3.5 weeks:

• types,
• syntax to call a function,
• syntax to declare a function (signature),
• comments (javadoc),
• test cases,
• converting arithmetic formulas into Java,
• return,
• local variables (initializing and declaring) to give a name to sub-computations so that you can use that sub-result later;
• if-else statements
• if-else-if statements
• arithmetic issues

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

©2007, Ian Barland, Radford University Last modified 2007.Aug.27 (Mon)

Please mail any suggestions (incl. typos, broken links) to iba�rlandrad�ford.edu