Math Functions

In Java many functions related to math can be found in the class java.lang.Math . If you are planning
on using Java for geometry or trigonometry it is worthwhile to examine the javadoc for java.lang.Math .

Here is an example:
/* Simulates rolling dice depending on how many dice are included on the command line as arguments. Prints out each individual dice result and prints out the sum of all the dice rolls. */ class MathDice { public static void main(String args[]) { try { if(args.length==0) { System.out.println("Usage:"); System.out.println(" java MathDice <# of dice sides for 1st> <# of dice sides for 2nd> ..."); return; } int intSum=0; for(int i=0;i<args.length;i++) { double dblNumberOfSides=Double.valueOf(args[i]).doubleValue(); if(dblNumberOfSides<1.0d) throw new Exception("Invalid number of sides."); dblNumberOfSides=dblNumberOfSides-1.0d; double dblRoll=Math.random()*dblNumberOfSides; dblRoll=Math.rint(dblRoll); dblRoll=dblRoll+1.0d; int intRoll=(int)dblRoll; intSum=intSum+intRoll; System.out.println("Individual roll #"+i+": "+intRoll); } System.out.println("\nSum of all dice: "+intSum); } catch(Exception ex) { ex.printStackTrace(); } } }
The example above accepts dice as arguments on the command line. It uses the static "random" function from java.lang.Math . The "random" function produces a random number from 0.0 to just below 1.0(all values are less than 1.0). If the "dblNumberOfSides" is a value less than 1.0 then we force a new Exception to be thrown because a dice can't have less than 1 side in our virtual dice rolling application. If the Exception is thrown then the code stops execution at its current location and proceeds directly to the code in "catch(Exception ex)". After the "random" function is called we call the "rint" function which stands for round to nearest integer. If the value passed into "rint" is less than 0.5 then the value returned by "rint" is 0.0 . If the value passed into "rint" is greater than 0.5 then the value returned by "rint" is 1.0 . If the value passed into "rint" is equal to 0.5 then the result returned is ambiguous; it could return 0.0d or it could return 1.0d. So, if the user specifies a dice with 6 sides then the number 6 has 1 subtracted from it making it 5 then it is multiplied by "random" which assigns a value from 0 to 5 to the "dblRoll" variable. Next, "rint" is called to round the integer to 0, 1, 2, 3, 4, or 5. Next, 1 is added to that "dblRoll" making the computed roll 1, 2, 3, 4, 5, or 6 which is what is desired as a random number for a 6 sided dice. The result is then added to sum and printed out. After the loop is done executing the sum of all of the dice rolls is printed out. In the next example we will use the "floor" function of Math to select a "random" day of the week that we will cook pasta on. Here is the example:
/* Randomly chooses the day of the week that pasta should be cooked on. */ class MathFloor { public static void main(String args[]) { try { String strDays[]={"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; double dblRandom=Math.random()*((double)strDays.length); double dblFloor=Math.floor(dblRandom); int intFloor=(int)dblFloor; System.out.println("Cook pasta on "+strDays[intFloor]+"."); } catch(Exception ex) { ex.printStackTrace(); } } }
A String array is declared and initialized with the days of the week. A random is generated and multiplied by the length of the array "strDays". Notice how the "length" specifier of array is an int and has to be casted to double to prevent loss of precision. At this point the value in "dblRandom" is a number from 0.0 to just below 7.0 . Next, the "floor" function is called making the value 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 then it is casted to an int. "floor" always round the number passed in down to the nearest integer. For example, 3.1 becomes 3.0, 3.5 becomes 3.0, 3.9 becomes 3.0 . Lastly, that int in "intFloor" is used as an index into the array "strDays" to print out one of the days of the week. The function "ceil" in Math is rarely used in my experiences, but it works similar to "floor" except that it always rounds up to the nearest integer. For example, 5.1 becomes 6.0, 5.5 becomes 6.0, 5.9 becomes 6.0 . In this lesson you learned how to utilize the "random", "rint", "floor", "ceil" functions of the java.lang.Math class. You learned about casting variables to proper primitive classes for using floating point arithmetic.