# Ruby | Float Class

In Ruby, Float class is a subclass of Numeric class. The objects of the Float class represents real numbers using the native architecture’s double- precision floating-point representation.

#### Public Instance Methods

1. Arithmetic Operations: This method perform various arithmetic operations on float.
1. Addition: It returns the result of the sum of float and numeric value in floating-point number.
`float + numeric`
2. Subtraction: It returns the result of diffrence of float and numeric value in floating-point number.
`float - numeric`
3. Multiplication: It returns the result of product of float and numeric value in floating-point number.
`float * numeric`
4. Division: It returns the result of division of float and numeric value in floating-point number.
`float / numeric`
5. Modulo: It returns the result of the modulo of float and numeric value in floating-point number.
`float % numeric`
6. Exponent: It returns the result of power of float and numeric value in floating-point number.
`float ** numeric`
7. Unary minus: It returns floating-point number.
`float -@`

Example:

 `# Ruby program to illustrate  ` `# Arithmetic operation ` ` `  `a = ``2``.``1` `b = ``2` ` `  `# Addition ` `c = a + b     ` ` `  `puts ``"addition #{c}"` ` `  `# Subtraction ` `d = a - b     ` ` `  `puts ``"subtraction #{d}"` ` `  `# Multiplication ` `e = a * b    ` ` `  `puts ``"multiplication #{e}"` ` `  `# Division ` `f = a / b    ` ` `  `puts ``"division #{f}"` ` `  `# Modulo ` `g = a % b    ` ` `  `puts ``"modulo  #{g}"` ` `  `# Exponent ` `h = a ** b   ` ` `  `puts ``"exponent #{h}"` ` `  `# Unary minus ` `i= -a        ` ` `  `puts ``"unary minus #{i}"`

Output:

```addition 4.1
subtraction 0.1
multiplication 4.2
division 1.05
modulo  0.1
exponent 4.41
unary minus -2.1
```
2. <=> : This method returns -1, 0, or +1 depends upon float. If float is less then numeric value then it will return -1, if float is equal to numeric value, then it will returns 0, or if float is greater then numeric value, then it will return +1.
`float <=> numeric --> 1, 0, +1 `

Example:

 `# Ruby program to illustrate  ` `# <=> Method ` ` `  `puts ``2``.``1` `<=> ``4`        `puts ``2``.``0` `<=> ``2`        `puts ``4``.``6` `<=> ``2`

Output:

```-1
0
1
```
3. == : This method returns true if the obj is equal to float otherwise it returns false.
`float == obj --> true or false`

Example:

 `# Ruby program to illustrate  ` `# == Method ` ` `  `puts ``3``.``8` `== ``4`         `puts ``3``.``8` `== ``3``.``8`

Output:

```false
true
```
4. abs : This method return absolute value of float.
`float.abs --> numeric`

Example:

 `# Ruby program to illustrate  ` `# abs Method ` ` `  `puts (-``54``.``56``).abs     ` `puts (-``65``.``04``).abs      `

Output:

```54.56
65.04
```
5. ceil : This method returns the smallest Integer greater than or equal to float. The return type of this method is int.
`float.ceil --> int`

Example:

 `# Ruby program to illustrate  ` `# ceil Method ` ` `  `puts (``4``.``1``).ceil       ` `puts (``4``.``0``).ceil       ` `puts (-``4``.``1``).ceil      `

Output:

```5
4
-4
```
6. divmod : This method will return an array that contains the quotient and modulus obtained by dividing num by numeric.
`float.divmod(numeric) --> array`

Example:

 `# Ruby program to illustrate  ` `# divmod Method ` ` `  `p (``45``.``0``.divmod ``5``)    ` `p (``98``.``0``.divmod ``5``)    `

Output:

```
[9, 0.0]
[19, 3.0]
```
7. eql? : This method check if the obj is Float and contains the same value as in float. If they contains same value then it will return true, otherwise return false. The return type of this method is boolean.
`float.eql?(obj) --> true or false`

Example:

 `# Ruby program to illustrate  ` `# eql? Method ` ` `  `puts ``4``.``2``.eql?(``2``)        ` `puts ``1``.``2``.eql?(``1``.``2``)       `

Output:

```false
true
```
8. finite? : This method check if the float is a valid IEEE floating-point number. If float is valid IEEE floating-point number then it will return true otherwise it will return false.
`float.finite? --> true or false`

Example:

 `# Ruby program to illustrate  ` `# finite? Method ` ` `  `puts (``45``.``0``).finite?          ` `puts (``45``.``0``/``0``.``0``).finite?     `

Output:

```true
false
```
9. floor : This method returns largest integer less than or equal to float.
`float.floor --> int`

Example:

 `# Ruby program to illustrate  ` `# floor Method ` ` `  `puts ``2``.``2``. floor           ` `puts (-``4``.``6``).floor         `

Output:

```2
-5
```
10. infinite? : This method returns nil, -1, or +1 it depends upon float. If float is finite, then it return nil, if float is -infinte, then it return -1, or if float is +infinte then it return +1.
`float.infinite? --> nil, -1, +1`

Example:

 `# Ruby program to illustrate  ` `# infinite? Method ` ` `  `puts (``1``.``1``).infinite?             ` `puts (-``1``.``1``/``0``.``0``).infinite?       ` `puts (+``1``.``1``/``0``.``0``).infinite?       ` ` `

Output:

```nil
-1
1
```
11. modulo: This method is similar to Float#% method.
`float.modulo(numeric) --> numeric`

Example:

 `# Ruby program to illustrate  ` `# modulo Method ` ` `  `puts ``32``.``45``.modulo(``20``)       `

Output:

```12.450000000000003
```
12. nan? : This method return true if float is an invalid IEEE floating-point number otherwise it return false. The return type of this method is boolean.
`float.nan? --> true or false`

Example:

 `# Ruby program to illustrate  ` `# nan? Method ` ` `  `puts (-``2``.``2``). nan?            ` `puts (``0``.``0``/``0``.``0``). nan?         `

Output:

```false
true
```
13. round: This method rounds off float to the nearest integer value. The return type of this method is int.
`float..round(digits=0) --> numeri`

Example:

 `# Ruby program to illustrate  ` `# round Method ` ` `  `puts ``6``.``7``.round       ` `puts (-``8``.``9``).round      `

Output:

```7
-9
```
14. to_f : This method return float.
`float.to_f --> float`
15. to_i : This method return float truncate to the integer. The return type of this method is int.
`float.to_i --> int`

Example:

 `# Ruby program to illustrate  ` `# to_i Method ` ` `  `puts ``5``.``6``.to_i    `

Output:

`5`
16. to_int : This method is similar to Float#to_i.
`float.to_int --> int`
17. to_s: This method returns a string that contains a representation of self, as well as a fixed or exponential form of numbering. The call may return NaN, infinity and -infinity.
`float.to_s --> string `
18. truncate : This method is equal to Float#to_i method. The return type of this method is int.
`float.truncate `
19. zero? : This method return true if float is 0.0 otherwise return false. The return type of this method is boolean.
`float.zero? --> true or false`

Example:

 `# Ruby program to illustrate  ` `# zero? Method ` ` `  `puts (``0``.``0``).zero?    ` `puts (``1``.``4``).zero?    `

Output:

```true
false
```
20. Float class contains Constants which are listed as follows:

Constants Description
DIG It holds minimum number of significant decimal digits in a double-precision floating point and it defaults to 15.
EPSILON It holds difference between 1 and the smallest double-precision floating point number greater than 1 and defaults to 2.2204460492503131e-16.
MANT_DIG It holds the number of mantissa digits of base RADIX. Defaults to 53.
MAX It holds largest possible integer in a double-precision floating point number and it defaults to 1.7976931348623157e+308.
MAX_10_EXP It represent the largest positive exponent in a double-precision floating point where 10 raised to this power minus 1. Defaults to 308.
MAX_EXP It is the largest possible exponent value in a double-precision floating point which defaults to 1024.
MIN It is the smallest positive normalized number in a double-precision floating point. Defaults to 2.2250738585072014e-308.
MIN_10_EXP It is the smallest negative exponent in a double-precision floating point where 10 raised to this power minus 1. Defaults to -307.
MIN_EXP It is the smallest possible exponent value in a double-precision floating point. Defaults to -1021
RADIX The radix of floating-point representations or in other words, it is a base of floating-point numbers. Defaults to 2 on most systems, which would represent a base-10 decimal
ROUND It represents the rounding mode for floating-point operations. The values includes are:
-1: if the mode is indeterminate
0: if rounding towards zero
1: if the rounding is nearest to representable value
2: if rounding is towards +infinite
3: if rounding is towards +infinite

NaN It is an expression representing a value which is “not a number“.
INFINITY It is an expression representing positive infinity.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.