**Ruby Math Examples: floor, ceil, round and truncate**Use mathematical functions like floor, ceil and truncate. Compute square roots.

dot net perls

**Math.** A stone tablet is covered in dust. On it you read an inscription. It also has some mathematical markings but you start feeling sleepy.

**In Ruby** we invoke built-in Math functions. Sqrt returns a square root. The sin, cos and tan methods relate parts of a triangle. There are two constants: PI and E.

**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.

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__
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__
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.

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*)

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)

3.0
3.0

**Floor, ceil.** The floor and ceil methods are not part of the Math module. We call them directly on a number instance. Here we set a number to 1.1 and use floor and ceil.

**Info** Floor changes 1.1 to 1, and ceil changes 1.1 to 2. The methods go lower and higher to the next integer.

Ruby program that uses floor, ceil

number =

*1.1*
puts number

*
# Use floor to remove the fractional part.
*result1 = number.

__floor__
puts result1

*
# Use ceil to move to the next highest integer.
*result2 = number.

__ceil__
puts result2

*1.1*
1
2

**Truncate.** A number can have a fractional part. The number 1.99 has a fractional part of ".99." With truncate the fractional part is eliminated from the number.

**And** No other changes are made. Truncate can work on positive or negative numbers.

Ruby program that uses truncate

number =

*1.99*
puts number

*
# Truncate removes the fractional part.
*result = number.

__truncate__
puts result

*
# Negative numbers can be truncated too.
*number =

*-1.99*
puts number.

__truncate__
1.99
1
-1

**Round.** On Floats we can use the round() method. This returns the nearest integral value to the value stored by the float. It may move the total value lower or higher.

Ruby program that uses round

number_a =

1.234
number_b =

-1.234
number_c =

1.99
number_d =

-1.99
puts

*":::ROUND number_a, number_b :::"**
# Use round method.
*puts number_a.

__round__
puts number_b.

__round__
puts

*":::ROUND number_c, number_d :::"**
# The nearest integer is returned.
*puts number_c.

__round__
puts number_d.

__round__
:::ROUND number_a, number_b :::

1
-1
:::ROUND number_c, number_d :::

2
-2**Fibonacci numbers.** In the Fibonacci sequence, each number is equal to the two previous numbers added together. This sequence occurs often in nature. And we can compute it with an iterator.

Fibonacci

**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.

© 2007-2021 sam allen. send bug reports to info@dotnetperls.com.