Math class

1. Trigonometric functions in Java

When we studied rounding numbers earlier, we got acquainted with the Math class and some of its methods. We will now look at this class in more detail.

As the name implies, the Math class contains methods for the mathematical operations most frequently used by programmers. Here are the most interesting ones:

double sin(double d)

double cos(double d)

double tan(double d)

double asin(double d)

double acos(double d)

double atan(double d)

double sinh(double d)

double cosh(double d)

double tanh(double d)

The Math.sin(), Math.cos() and Math.tan() methods take an angle expressed in radians. To convert an angle from degrees to radians and vice versa, the Math class offers two special methods:

double toRadians(double angdeg)

double toDegrees(double angrad)

By the way, in addition to methods, the Math class also has two constant variables (static fields of the class):

double Math.PI

double Math.E

All these functions can be very useful to you if you decide to write your own games, work with graphics, or simply calculate the length of a path on a map.

For example, if you want to calculate sin(45°), here's how you do it:

Math.sin( Math.toRadians(45) )

Here's an example:

public class Main
{
   public static int N = 10;

   public static void drawValue(double y)
   {
     int value = (int) (y * N) + N;
     for (int i = 0; i < 2 * N; i++)
     {
       char c = i == N ? '|': '.';
       if (i == value)
         c = '*';
       System.out.print(c);
     }
     System.out.println();
   }

   public static void main(String[] args)
   {
     for (int i = 0; i < 10 * N; i++)
     {
       double x = i * 1.0 / N;
       double y = Math.sin(x);
       drawValue(y);
     }
   }
}

9

Task

New Java Syntax, level 9, lesson 1

Locked

Integer literals

Four public fields, corresponding to the four integer types, are declared in the Solution class. When declared, these fields are initialized with various values stored in integer literals. But the program doesn't compile, and you need to fix it. To do this, make the fewest possible changes to the va

Open

2. Algebraic functions in Java

In most cases, high school math is enough for a programmer: even sines and cosines are very rarely found in code. Most often they are needed when working with games, maps or game engines. 90% of programmers never encounter this.

But besides geometry, programmers sometimes have to use algebraic functions. And, of course, the Math class contains the most common ones:

double sqrt(double a)

double cbrt(double a)

double pow(double a, double b)

double exp(double a)

double log(double a)

double log10(double a)

double log1p(double x)

double expm1(double x)

If you want the square or cube root of a number, the sqrt(a) and cbrt(a) methods are at your service.

The square root can be calculated as follows:

Math.sqrt(2)

If you want to get a root of a higher power, then use the exponentiation method: a to the power of ¼ is the fourth root, etc.

Math.pow(2, 0.25)

For logarithms and exponents, there are the log(a) (natural logarithm) and exp(x) (exponential) methods. To calculate the base-10 logarithm, we have log10(a).

If you want the logarithm of a number b to base a, use this simple formula: loga(b) = ln(b) / ln(a)

Useful methods

If you are performing calculations involving very small values of x, then the last two functions — log1p() and expm1() — may be useful to you.

When adding very small and very large double variables, you will often find that very small values are simply ignored (discarded) as insignificant. In fact, this will happen if you use the log() and exp() methods. To solve this, programmers came up with functions that return only the "small significant part"

Example:

Suppose you want to calculate the natural logarithm of 1 + x, where x is 10-20. You can't simply pass this number to the log() method, since if you add 1 and 10-20, you get 1. 10-20 is such a small number that it will be completely discarded when the numbers are added.

Because mathematics often involves calculating the log() of numbers close to 1, programmers came up with a way to get around this problem: instead of passing the number itself to the method, pass only its difference from 1.

9

Task

New Java Syntax, level 9, lesson 1

Locked

Floating point literals

Seven public fields are declared and initialized in the Solution class. They are initialized with various values stored in floating point literals. But the program doesn't compile, and you need to fix it. To do this, change the field types so they match the values. Do not change the field names or v

Open

3. Minimum and maximum

Two more useful functions are min(a, b) and max(a, b). As you probably already guessed, the first returns the minimum of two numbers:

Math.min(a, b)

And the second returns the maximum of two numbers:

Math.max(a, b)

Why do we need these functions when you can always write if or even use the ternary operator (a < b ? a: b)?

It's all about the readability of the code. Sometimes your code is overloaded with if statements and you want to use more compact notation. Let's compare:

int x = 0;
if (x-5+y*20 < x*x+y*y)
   x = x-5+y*20;
else
   x = x*x+y*y;

int x = x-5+y*20 < x*x+y*y ? x-5+y*20 : x*x+y*y;

int a = x-5+y*20;
int b = x*x+y*y;
int x = a < b ? a : b;

int x = Math.min(x-5+y*20, x*x+y*y);

4. Minimum and maximum of several numbers

There's another great way to use the min() and max() methods.

To calculate the minimum (or maximum) of several numbers or variables. It's very convenient to make nested calls to these methods.

Here's how to find the minimum of 3 numbers:

Math.min(a, Math.min(b, c))

So what? It's super convenient: calculate the minimum of two numbers, and then return the minimum of this number and the third number.

The minimum of four numbers is obtained in the same way:

Math.min(a, Math.min(b, Math.min(с, d)))

That said, we can write this formula a little more clearly:

Math.min(Math.min(a, b), Math.min(c, d))

It all works the same for the max() method.

Using the if-else operator or ternary operator would make these code snippets a little more cumbersome. But using the min() and max() methods is just perfect.

9

Task

New Java Syntax, level 9, lesson 1

Locked

String literals

A public string field is declared and initialized in the Solution class. But the string is too long and difficult to read. For better readability, you need to split it into 5 substrings and concatenate them with the "+" (string concatenation) operator, like this: - first line: "Always write code as

Open

9

Task

New Java Syntax, level 9, lesson 1

Locked

Character literals

Four public character fields are declared in the Solution class. Some values have been assigned to them. The program doesn't compile. You need to fix this without changing the character values. All the fields are static — this is necessary in order to access them in the main() method. You can see th

Open