2.9. Using the Math Class¶

Games would be boring if the same thing happened each time you played the game. Games often use random numbers to generate different possibilities. You need to know how to use the Math.random() method to generate a random number.

There are lots of mathematical methods that you might want to use in your programs like Math.abs (absolute value). These methods are in the Math class defined in the java.lang package. These are static methods which means you can call them by just using ClassName.methodName() without creating an object or just the method name if they are called from within the same class.

Note

Static methods (also called class methods) are called using the class name and the dot operator . followed by the method name, for example Math.random(). You do not need to create an object of the class to use them.

The Math.random() method returns a number greater than or equal to 0.0, and less than 1.0.

Try out the following code. Run it several times to see what it prints each time.

You can use Math.random and a cast to integer to return a random integer between some starting and ending value. The code below will create a random integer from 0 to 9. Remember that casting a double value to integer (int) will throw away any values after the decimal point.

Coding Exercise

Run the code below several times to see how the value changes each time. The program returns a random integer between 0 and 9, inclusive. How could you change the code to return a random integer from 1 to 10, inclusive? Modify the code and see if your answer is correct.

Note

Math.random() returns a random number between 0.0-0.99.
(int)(Math.random()*range) + min moves the random number into a range starting from a minimum number.
The range is the (max number - min number + 1).

Here are some examples that move a random number into a specific range.

// Math.random() returns a random number between 0.0-0.99.
double rnd = Math.random();

// rnd1 is an integer in the range 0-9 (including 9).
int rnd1 = (int)(Math.random()*10);

// rnd2 is in the range 1-10 (including 10). The parentheses are necessary!
int rnd2 = (int)(Math.random()*10) + 1;

// rnd3 is in the range 5-10 (including 10). The range is 10-5+1 = 6.
int rnd3 = (int)(Math.random()*6) + 5;

// rnd4 is in the range -10 up to 9 (including 9). The range is doubled (9 - -10 + 1 = 20) and the minimum is -10.
int rnd4 = (int)(Math.random()*20) - 10;

Check your understanding

2-9-3: Which of the following would be true about 40% of the time?

Math.random() < 0.4
This is true about 40% of the time since Math.random returns a value from 0 to not quite 1.
Math.random() > 0.4
This will be true about 60% of the time.
Math.random() == 0.4
Do not use == with double values! Remember that Math.random can return any number between 0 and not quite 1 (about .99999999).

2-9-4: Which of the following would return a random number from 1 to 5 inclusive?

((int) (Math.random() * 5))
This would be a number between 0 and 4.
((int) (Math.random() * 6))
This would be a number between 0 and 5.
((int) (Math.random() * 5) + 1)
The first part would return a number between 0 and 4 and when you add 1 you get a number from 1 to 5 inclusive.

2-9-5: Which of the following would return a random number from 0 to 10 inclusive?

((int) (Math.random() * 10))
This would be a number between 0 and 9.
((int) (Math.random() * 11))
This would be a number between 0 and 10.
((int) (Math.random() * 10) + 1)
The first part would return a number between 0 and 9 and when you add 1 you get a number from 1 to 10 inclusive.

2-9-6: Which of the following would be true about 75% of the time?

Math.random() < 0.25
This is true about 25% of the time, since it will be a number from 0 to not quite 1.
Math.random() > 0.25
This is true about 75% of the time, since it will be a number from 0 to not quite 1.
Math.random() == 0.25
Do not use == with double values! Remember that Math.random can return any number between 0 and not quite 1 (about .99999999).

Sample Problem

2-9-7: Which of the following statements assigns a random integer between 25 and 60, inclusive, to rn?

int rn = (int) (Math.random() * 25) + 36;
Remember that (int)(Math.random()*range) + min moves the random number into a range starting from a minimum number. We want the minimum number to be 25, but the minimum number here would be 36.
int rn = (int) (Math.random() * 25) + 60;
Remember that (int)(Math.random()*range) + min moves the random number into a range starting from a minimum number. We want the minimum number to be 25, but the minimum number here would be 60.
int rn = (int) (Math.random() * 26) + 60;
Remember that (int)(Math.random()*range) + min moves the random number into a range starting from a minimum number. Here the min is 25. We want the minimum number to be 25, but the minimum number here would be 60.
int rn = (int) (Math.random() * 36) + 25;
Yes, (int)(Math.random()*36) + 25 moves the random number into a range of 36 numbers starting from a minimum number 25 up to 60. The range is (max number - min number + 1) which is (60-25 +1) = 36.
int rn = (int) (Math.random() * 60) + 25;
This would give us random numbers from 25 to 85. Remember that you can compute the range you need with (max number - min number + 1).

Other Math functions that you can use are:

int abs(int) : Returns the absolute value of an int value (which is the value of a number without its sign, for example Math.abs(-4) = 4).
double abs(double) : Returns the absolute value of a double value.
double pow(double, double) : Returns the value of the first parameter raised to the power of the second parameter.
double sqrt(double) : Returns the positive square root of a double value.
double random() : Returns a double value greater than or equal to 0.0 and less than 1.0 (not including 1.0!).

2.9.1. Programming Challenge : Random Numbers¶

You may have a combination lock on your locker at school where you have to spin the dial to 3 separate numbers from 0 up to 40. What if you forgot your combination? Would you be able to guess it?

Write code that will generate 3 random integers from 0 up to 40 (but not including 40) using Math.random() in the Active Code window below. Run it a couple times to see it generate different numbers.
How many times would you need to run it to guess your combination correctly? Let’s have the code compute the number of permutations possible in your combination lock using Math.pow(number,exponent). For example, if you had 2 dials on your combination lock where each dial can be set to a digit from 0-9 (10 digits), there are 10² possible permutations. In Java, this would be written as Math.pow(10,2) which means 10 to the power of 2. If you start listing all the permutations possible, you can tell that there are 10² or 100 possible permutations for a 2 dial lock from 0-9.

00, 01, 02, 03, 04, 05, 06, 07, 08, 09
10, 11, 12, 13, 14, 15, 16, 17, 18, 19
...
90, 91, 92, 93, 94, 95, 96, 97, 98, 99

Now what about the combination lock for this challenge? It has 3 dials with 0-40 (not including 40) numbers possible on each dial. In general, the formula to use is NumbersPerDial^{numberOfDials}. Write this using the Math.pow() method in your code and save it into a variable and print out.

Complete the combination lock challenge below.

public class MathChallenge
{
   public static void main(String[] args)
   {
     // 1. Use Math.random() to generate 3 integers from 0-40 (not including 40) and print them out.

// 2. Calculate the number of combinations to choose 3 numbers between 0-40 (not including 40) using Math.pow() and print it out.
     // For example, Math.pow(10,2) is 10^2 and the number of permutations to choose 2 numbers between 0-9.

}
}
====
import static org.junit.Assert.*;
 import org.junit.*;;
 import java.io.*;
 import java.util.ArrayList;

public class RunestoneTests extends CodeTestHelper
 {

@Test
     public void test1()
     {
         String output = getMethodOutput("main");
         String[] lines = output.split("\\s+");

boolean passed = lines.length >= 2;

passed = getResults("2+ lines of output", lines.length + " lines of output", "Expected output", passed);
         assertTrue(passed);
     }

@Test
     public void test2()
     {
         String output = getMethodOutput("main");

boolean passed = output.contains("6400");

passed = getResults("true", "" + passed, "Prints 40^3", passed);
         assertTrue(passed);
     }

@Test
     public void test3()
     {
         String code = getCode();
         int num = countOccurences(code, "Math.random()");

boolean passed = num >= 3;
         passed = getResults("3 or more", ""+num, "Calls to Math.random()", passed);
         assertTrue(passed);
     }

@Test
     public void test4()
     {
         String code = getCode();
         int num = countOccurences(code, "Math.pow(");

boolean passed = num >= 1;
         passed = getResults("1 or more", ""+num, "Calls to Math.pow(...)", passed);
         assertTrue(passed);
     }

@Test
     public void test5() {
         int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;

String output = "";
         String[] lines;
         int[] nums = new int[4];
         int countUniqueNums = 0;

for (int i = 0; i < 1000; i++) {
             output = getMethodOutput("main");
             lines = output.split("\\s+");

if (lines.length == nums.length) {
                 nums[0] = Integer.parseInt(lines[0]);
                 nums[1] = Integer.parseInt(lines[1]);
                 nums[2] = Integer.parseInt(lines[2]);

min = Math.min(min, Math.min(nums[0], Math.min(nums[1], nums[2])));
                 max = Math.max(max, Math.max(nums[0], Math.max(nums[1], nums[2])));

if (nums[0] != nums[1] && nums[1] != nums[2])
                     countUniqueNums++;
             }
         }

boolean passed = min == 0 && max == 39 && countUniqueNums > 5;
         getResults("Min: " + 0 + "\nMax: " + 39, "Min: " + min + "\nMax: " + max, "Checking random results", passed);
         assertTrue(passed);
     }
 }

Here’s another challenge that is a lot of fun! Can you use random numbers to make dancing turtles? This idea was suggested by Zac Martin’s class.

Complete the random numbers using Math.random() in the correct ranges to choose x, y coordinates for the turtle.

import java.util.*;
import java.awt.*;

public class DancingTurtles
{
  public static void main(String[] args)
  {

World world = new World(500,400);
      Turtle yertle = new Turtle(world);

// This is a loop that runs 10 times (you will learn to write loops in Unit 4)
     for(int i=1; i <= 10; i++)
     {
       // Can you choose a randomX between 0-500?
       // Can you adjust for the 20 pixel width of the turtle,
       // so it doesn't get cut off at the edges?
       // Move the range from 20 to 480.
       int randomX =
       // Can you choose a randomY between 0-400?
       // Can you adjust for the 20 pixel height of the turtle,
       // so it doesn't get cut off at the edges?
       // Move the range from 20 to 380.
       int randomY =

yertle.moveTo(randomX, randomY);
       yertle.turnRight();

// Can you choose a random red, green, and blue value between 0-255?
       int randomR =
       int randomG =
       int randomB =

yertle.setColor(new Color(randomR, randomG, randomB));

} // end of loop
      world.show(true);
  }
}
====
import static org.junit.Assert.*;
import org.junit.*;;
import java.io.*;

public class RunestoneTests extends CodeTestHelper
{
    public RunestoneTests() {
        super("DancingTurtles");
    }

@Test
    public void test1()
    {
        String code = getCode();
        int numRandom = countOccurences(code, "Math.random()");

boolean passed = numRandom >= 5;
        passed = getResults("5+", ""+numRandom, "5+ calls to Math.random()", passed);
        assertTrue(passed);
    }

@Test
    public void test2()
    {
       boolean passed = checkCodeContainsNoRegex("Random numbers for 0-255 colors (256 values)","Math.random() * 256");
       assertTrue(passed);
    }
}

2.9.2. Summary¶

Static Math methods can be called using Math.method(); for each method.
The following static Math methods are part of the Java Quick Reference:
- int abs(int) : Returns the absolute value of an int value (which means no negatives).
- double abs(double) : Returns the absolute value of a double value.
- double pow(double, double) : Returns the value of the first parameter raised to the power of the second parameter.
- double sqrt(double) : Returns the positive square root of a double value.
- double random() : Returns a double value greater than or equal to 0.0 and less than 1.0 (not including 1.0)!
The values returned from Math.random can be manipulated to produce a random int or double in a defined range.
(int)(Math.random()*range) + min moves the random number into a range starting from a minimum number. The range is the (max number - min number + 1). For example, to get a number in the range of 5 to 10, use the range 10-5+1 = 6 and the min number 5: (int)(Math.random()*6) + 5).

You have attempted of activities on this page