The Math Class Methods

Utilizing the Important

Math Operations of Java!

The Java Math Class

Java provides a Math class to make it easier to perform certain arithmetic operations.

No one should have to stop and write Math methods to calculate the square root of something or raise a base to a power or any of the myriad of arithmetic operations that a programmer might need.

You don’t need to import anything to use Math class methods. It is a class in the java.lang package and is automatically available to any Java program.

The Math Class Subset of MethodsThere are many methods in the Math class if you look up its API on line.

However, we only want to be familiar with a few methods of the Math class and the remainder of them you can look in the Math class API.

The most used methods and what they do are listed on the next slide.

The AP Subset of Math Class Methods

Math Class Method Signatures What the Operation Does

public static int abs ( int x) returns the absolute value of the int value x

public static double abs ( double x) returns the absolute value of the double value x

public static double pow ( double base, double exponent) returns a double that is the power of the base raised to an exponent.

public static double sqrt ( double x) returns the square root value of the double value x

public static double random () returns a random double value in the range [0.0, 1.0) in other words 0.0 inclusive and 1.0 exclusive, or you can say returns a double value x in the range: 0.0 <= x < 1.0.

It is also good to know that there is a constant of the Math class named PI and it is accurate to 15 decimal places. It is declared as

public static final double PI = 3.141592653589793;

Math Class Methods are StaticAll methods of the Math class are public and static. There are no void methods. They all return a numeric value!

Now you are ready for a greater understanding of static. When we use the Math class, we never construct a Math object. In fact, there is no constructor of the Math class and you couldn’t instantiate an object of type Math if you wanted to. So the methods of the Math class were made static. That means when we want to call a Math class method, we just precede the name of the method with the name of the class instead of an object as in …

…. Math.abs(…)

…. Math.pow(…)

…. Math.sqrt(…)

…. Math.random(…)

Absolute Value of an int - abs(int x)

The following code finds the absolute value of an integer value stored in x.

Scanner reader = new Scanner (System .in);

int x = reader.nextInt();

int absoluteValueOfX = Math.abs(x);

After this code, the variable absoluteValueOfX will contain the absolute value of whatever integer (negative or positive) that is entered from the keyboard.

If x holds the value -39, then absoluteValueOfX holds 39.

If x holds the value 39, then absoluteValueOfX holds 39.

Absolute Value of a double- abs(double x)

The following code finds the absolute value of a double value stored in y.

Scanner reader = new Scanner (System .in);

double y = reader.nextDouble();

double absoluteValueOfY = Math.abs(y);

After this code, the variable absoluteValueOfY will contain the absolute value of whatever double (negative or positive) that is entered from the keyboard.

If y holds the value -2.456, then absoluteValueOfY holds 2.456.

If y holds the value 3.18, then absoluteValueOfY holds 3.18.

Power of a Number - pow(double base, double exponent)

The following code finds the power of a base raised to an exponent.

Scanner reader = new Scanner (System.in);

System.out.print(“Enter a number for the base: ”);

double base = reader.nextDouble();

System.out.print(“Enter a number for the exponent: ”);

double exponent = reader.nextDouble();

double result = Math.pow(base , exponent);

After this code, if base holds 2.0 and exponent holds -5.0, then result holds the value -32.0. 2.0 to the -5th power is calculated.

After this code, if base holds 3.0 and exponent holds 4.0, then result holds the value 81.0. 3.0 to the 4th power is calculated.

Square Root of a Number - sqrt(double x)

The following code finds the square root of a value stored in z.

Scanner reader = new Scanner (System.in);

System.out.print(“Enter a number to find the square root of: ”);

double z = reader.nextDouble();

double result = Math.sqrt(z);

After this code, if z holds 2.0, then result holds the value 1.4142135623730951.

After this code, if z holds 16.0, then result holds the value 4.0.

The PI Constant of the Math classThe following code uses the square root method of the Math class and the Math class constant PI which represents the value 3.141592653589793 to 15 decimal places.

double area = 10.0;double radius = Math.sqrt (area / Math.PI);

If you knew the area of a circle, you could find the radius by dividing the area by pi and then taking the square root of that result. Since the sqrt() method needs one parameter of type double, it is ok to place the expression area / math.PI in the parenthesis. That expression will be evaluated first to one value and that one value is the one parameter that is passed to sqrt.

Note: area / Math.PI is a double divided by a double where the result is a double so the conditions for calling the method are satisfied.

Generating Random double Values

Random double Values: 0 <= result < 1.0

The following code randomly chooses a random double value between 0.0 inclusive and 1.0 exclusive and stores it in result.

double result = Math.random();

Therefore, result will hold a value in the range:

0 <= result < 1.0

or we could say 0 <= result < 0.99999999999999999999999999

this can also be stated as …

[0.0, 1.0)

Note: Math.random() will never return 1.0

Random double Values: 0 <= result < 6.0

The following code randomly chooses a random double value between 0.0 inclusive and 6.0 exclusive and stores it in result.

double result = Math.random() * 6;

Therefore, result will hold a value in the range:

0 <= result < 6.0

or we could say 0 <= result < 5.99999999999999999999999999

this can also be stated as …

[0.0, 6.0)

Note: Math.random() * 6 will never return 6.0

Random double Values: 10.3 <= result < 40.8

The following code randomly chooses a random double value between 10.3 inclusive and 40.8 exclusive and stores it in result.

double result = Math.random() * 30.5 + 10.3;

First, Math.random() * 30.5 produces a random double in the range of

0.0 <= random value < 30.5 (not including 30.5) or [0.0, 30.5)

or we could say between 0 and 30.499999999999999999999999

when we add the 10.3 then we get the range:

10.3 <= random value < 40.8 (not including 40.8) or [10.3, 40.8)

So how did we get the 30.5?

Random double Values: 10.3 <= result < 40.8

So if you were beginning here:

Write the code to generate a random double value between 10.3

inclusive and 40.8 exclusive?.

You would subtract 40.8 - 10.3 and get 30.5.

It’s the 30.5 that you take to multiply times Math.random() to get

Math.random() * 30.5

You then simply add back on the 10.3 that you initially

subtracted to get …

Math.random() * 30.5 + 10.3;

No additional ( ) are needed because of order of operations.

Random double Values: -200.0 <= result < 200.0

Write the code to generate a random double value between

-200.0 inclusive and 200.0 exclusive?

You would add 200 to the range numbers to get the new range

of 0.0 to 400.0. Since we know the upper end is exclusive, we

just use 400.0 to multiply times Math.random() to get

Math.random() * 400.0

We then subtract off the 200.0 we added to get …

Math.random() * 400.0 - 200.0;

No additional ( ) are needed since we are generating a double

value and order of operations evaluates everything correctly.

Generating Random int Values

Random int Values: 0 <= result < 5To generate random integers between 0 and 5 inclusive, we need to use casting since there are not separate methods to generate random integers and random doubles with the Math class.

The following code finds a random int value between 0 and 5 inclusive and stores it in result.

int result = (int) (Math.random() * 6);

This should make since, because Math.random() * 6 returns a double between 0.0 and 5.99999999999…

Casting truncates double values, so the resulting range is 0 to 5, because (int) (5.999999999999..) is 5 due to truncation.

Note: (int) (Math.random() * 6) will never return 6!

Random int Values Bug

Be careful in designing your mathematical expression to generate random integers.

What range of values are possible to be stored in result?

int result = (int) (Math.random());

Random int Values Bug Revealed

Be careful in designing your mathematical expression to generate random integers.

What range of values are possible to be stored in result?

int result = (int) (Math.random());

Zero would always be stored in result!!

Why?

Because Math.random() returns a double in the range

from 0 up to but not including 1. So if you cast any value

less than 1 to an (int) the truncation makes it zero.

Random int Values: 1 <= result < 6To generate random integers between 1 and 6 inclusive, we need to add 1 outside of the expression being casted.

The following code finds a random int value between 1 and 6 inclusive and stores it in result.

int result = (int) (Math.random() * 6) + 1;

Note: casting has a very high priority, so Java will cast the expression (Math.random() * 6) before it adds the 1.

It would be incorrect to use:

int result = (int) (Math.random() * 6+ 1); because this code would generate random integers between 0 and 6 instead of 1 and 6.

Note where the red ( ) are.

Random int Values: 101 <= result <= 1000

To generate random integers in the range 101 to 1000 inclusive, we first subtract 101 to the range to get a new range of 0 to 899.

Since the range is inclusive and we want both 101 and 1000 to possibly be generated, then we add 1 to 899 and get 900. This is the number that we mutliply Math.random() by:

(int) (Math.random() * 900) generates integers from 0 to 899.

We then add back the 101 that was initially subtracted to get:

int result = (int) (Math.random() * 900) + 101;

It would be incorrect to use:

int result = (int) (Math.random() * 900 + 101); because this code would generate random integers between 100 and 1000 instead of 101 and 1000.

Random int Values: -500 <= result <= 500

To generate random integers in the range -500 to 500 inclusive, we first add 500 to the range to get a new range of 0 to 1000.

Since the range is inclusive and we want both -500 and 500 to possibly be generated, then we add 1 to 1000 and get 1001. This is the number that we mutliply Math.random() by:

(int) (Math.random() * 1001) generates integers from 0 to 1000.

We then subtract off the 500 we originally added to get:

int result = (int) (Math.random() * 1001) - 500;

Random int Values: 1 <= result < nThe following code finds a random int value between 1 and n inclusive and stores it in result.

int result = (int) (Math.random() * n) + 1;

The following code finds a random int value between 0 and n - 1 inclusive and stores it in result.

int result = (int) (Math.random() * n);

This last line of code may be the one to be the most familiar with, because you may have to randomly select the index of an array or ArrayList of n items that has indices between 0 and n - 1.

Overloading Methods in a ClassSometimes classes contain multiple versions of the same method. This is called Overloading. An example, is the Math class method abs. There are four versions of this method in the Math class API. You saw two of them on the previous slide:

static int abs ( int x)

static double abs ( double x)

additional ones are:

static long abs ( long x)

static float abs ( float x)

How can a class have four different versions of a method? Because when one of these methods is called, Java inspects the parameter and identifies its type so it knows which one to go and execute.

Overloading Methods in a ClassOverloading is using the same method name but a different number, type, or order of parameters in the same class.

Here is another example of overloaded methods in a class:

public double calculateSomething (int x)

public double calculateSomething (int x, int y)

public double calculateSomething (int x, double y)

public double calculateSomething (double x, int y)

public double calculateSomething (double x, double y)

public double calculateSomething (int x, double y, int z)

All of the methods have either a different number of parameters, different type, or different order.