# Ruby Math Examples

This Ruby page uses mathematical functions. It computes square roots and discusses lookup tables.

## Math. Most programming languages provide mathematical methods.

And Ruby is no exception. Many well-known Math functions are ready.

Functions. The sqrt function returns a square root. The sin, cos and tan methods relate parts of a triangle. The two constants PI and E are available.

Constants. Here we call Math methods and use Math constants. This program uses sqrt() on 9, which returns 3. It also prints PI, equal to 3.14, and E, equal to 2.71.

Methods: Please notice how the Math methods, such as sqrt(), use a period after Math.

Constants: To access constants in a module, like PI, we use the Math::PI syntax. Math::E uses the same syntax.

```Based on:

Ruby 2

Ruby program that uses Math

# Use sqrt.
# ... Square root of 9 is 3.
x = Math.sqrt(9)
puts x

# Use pi.
puts Math::PI

# Use e.
puts Math::E

Output

3.0
3.141592653589793
2.718281828459045``` Absolute values. These are never negative. The abs method takes absolute values of numbers. It is not part of the Math class—we do not use the Math module name here.

Result: If the number is negative, abs will return a positive version. It also handles floating point numbers.

```Ruby program that uses abs

# Take absolute values.
value = -1
puts value.abs

value = -1.1
puts value.abs

value = 1
puts value.abs

Output

1
1.1
1``` Sin, cos and tan. Trigonometric functions are available in the Math module. These provide standard results—the cos of zero, for example, is 1.

In mathematics, the trigonometric functions... are functions of an angle. They relate the angles of a triangle to the lengths of its sides.

Trigonometric functions: Wikipedia

```Ruby program that uses sin, cos and tan

# Math provides sin, cos and tan methods.
puts Math::sin(0)
puts Math::cos(0)
puts Math::tan(0)

Output

0.0
1.0
0.0``` Memoization. Sometimes Math methods, and more complex calculations involving many calls, are slow. We can use a memoization approach to avoid calculating the same thing twice.

Here: We use a cache (a Hash) and check to see if it contains the square root of the argument.

Hash

Then: We fetch the square root from the Hash, avoiding sqrt, when possible. We reduce an operation to a lookup.

Tip: For slow computations, this can improve performance. But it will make fast computations slower than before.

```Ruby program that uses memoization, sqrt

def check_sqrt(a, cache)
# See if the cache contains a square root for this argument.
if cache.key?(a)
return cache[a]
end

# Compute square root and memoize it.
cache[a] = Math.sqrt(a)
return cache[a]
end

# Use memoize square root method with Hash.
cache = Hash.new()
puts check_sqrt(9, cache)
puts check_sqrt(9, cache)

Output

3.0
3.0``` A summary. Certain mathematical methods, such as sqrt() and trigonometric identities, are rarely implemented in user code. Ruby provides these methods.

As an optimization, we can cache their results in a lookup table. This classic optimization is known as memoization. A function remembers its previous results by argument.