Ruby | Clase flotante – Barcelona Geeks

En Ruby, la clase Float es una subclase de la clase Numeric. Los objetos de la clase Float representan números reales utilizando la representación de punto flotante de precisión doble de la arquitectura nativa.

Métodos de instancia pública

Operaciones aritméticas: este método realiza varias operaciones aritméticas en float .

Suma: Devuelve el resultado de la suma de flotante y valor numérico en número de punto flotante.
```
float + numeric
```
Resta: Devuelve el resultado de la diferencia de flotante y valor numérico en número de coma flotante.
```
float - numeric
```
Multiplicación: Devuelve el resultado del producto de float y valor numérico en número de coma flotante.
```
float * numeric
```
División: Devuelve el resultado de la división de float y valor numérico en número de punto flotante.
```
float / numeric
```
Módulo: Devuelve el resultado del módulo de float y valor numérico en número de punto flotante.
```
float % numeric
```
Exponente: Devuelve el resultado de la potencia del flotante y el valor numérico en número de punto flotante.
```
float ** numeric
```
Menos unario: devuelve un número de coma flotante.
```
float -@
```

Ejemplo:

# 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}"

Producción:

addition 4.1
subtraction 0.1
multiplication 4.2
division 1.05
modulo  0.1
exponent 4.41
unary minus -2.1

<=> : este método devuelve -1, 0 o +1 dependiendo de float . Si float es menor que el valor numérico, devolverá -1, si float es igual al valor numérico, devolverá 0, o si float es mayor que el valor numérico, devolverá +1.
```
float <=> numeric --> 1, 0, +1 
```
Ejemplo:

# Ruby program to illustrate

# <=> Method



puts 2.1 <=> 4

puts 2.0 <=> 2

puts 4.6 <=> 2

Producción:
```
-1
0
1
```
== : este método devuelve verdadero si el obj es igual a float ; de lo contrario, devuelve falso.
```
float == obj --> true or false
```
Ejemplo:

# Ruby program to illustrate

# == Method



puts 3.8 == 4

puts 3.8 == 3.8

Producción:
```
false
true
```
abs : este método devuelve el valor absoluto de float .
```
float.abs --> numeric
```
Ejemplo:

# Ruby program to illustrate

# abs Method



puts (-54.56).abs

puts (-65.04).abs

Producción:
```
54.56
65.04
```
ceil : este método devuelve el entero más pequeño mayor o igual que float . El tipo de retorno de este método es int.
```
float.ceil --> int
```
Ejemplo:

# Ruby program to illustrate

# ceil Method



puts (4.1).ceil

puts (4.0).ceil

puts (-4.1).ceil

Producción:
```
5
4
-4
```
divmod : este método devolverá una array que contiene el cociente y el módulo obtenidos al dividir num por numérico.
```
float.divmod(numeric) --> array
```
Ejemplo:

# Ruby program to illustrate

# divmod Method



p (45.0.divmod 5)

p (98.0.divmod 5)

Producción:
```
 
[9, 0.0]
[19, 3.0]
```
eql? : Este método verifica si el obj es Float y contiene el mismo valor que en float . Si contienen el mismo valor, devolverá verdadero, de lo contrario devolverá falso. El tipo de retorno de este método es booleano .
```
float.eql?(obj) --> true or false
```
Ejemplo:

# Ruby program to illustrate

# eql? Method



puts 4.2.eql?(2)

puts 1.2.eql?(1.2)

Producción:
```
false
true
```
¿finito? : este método comprueba si el flotante es un número de punto flotante IEEE válido. Si float es un número de punto flotante IEEE válido, devolverá verdadero; de lo contrario, devolverá falso.
```
float.finite? --> true or false
```
Ejemplo:

# Ruby program to illustrate

# finite? Method



puts (45.0).finite?

puts (45.0/0.0).finite?

Producción:
```
true
false
```
floor : este método devuelve el entero más grande menor o igual que float .
```
float.floor --> int
```
Ejemplo:

# Ruby program to illustrate

# floor Method



puts 2.2. floor

puts (-4.6).floor

Producción:
```
2
-5
```
¿infinito? : este método devuelve nil, -1 o +1 , depende de float . Si float es finito, devuelve nil , si float es -infinito, devuelve -1 , o si float es +infinito, devuelve +1 .
```
float.infinite? --> nil, -1, +1
```
Ejemplo:

# Ruby program to illustrate

# infinite? Method



puts (1.1).infinite?

puts (-1.1/0.0).infinite?

puts (+1.1/0.0).infinite?



Producción:
```
nil
-1
1
```
módulo: Este método es similar al método Float#%.
```
float.modulo(numeric) --> numeric
```
Ejemplo:

# Ruby program to illustrate

# modulo Method

puts 32.45.modulo(20)

Producción:
```
12.450000000000003
```
¿yaya? : este método devuelve verdadero si float es un número de punto flotante IEEE no válido; de lo contrario, devuelve falso. El tipo de retorno de este método es booleano .
```
float.nan? --> true or false
```
Ejemplo:

# Ruby program to illustrate

# nan? Method



puts (-2.2). nan?

puts (0.0/0.0). nan?

Producción:
```
false
true
```
round: este método redondea float al valor entero más cercano. El tipo de retorno de este método es int .
```
float..round(digits=0) --> numeric
```
Ejemplo:

# Ruby program to illustrate

# round Method



puts 6.7.round

puts (-8.9).round

Producción:
```
7
-9
```
to_f : este método devuelve float .
```
float.to_f --> float
```
to_i : este método devuelve float truncado al entero. El tipo de retorno de este método es int .
```
float.to_i --> int
```
Ejemplo:

# Ruby program to illustrate

# to_i Method

puts 5.6.to_i

Producción:
```
5
```
to_int : este método es similar a Float#to_i.
```
float.to_int --> int
```
to_s : este método devuelve una string que contiene una representación de sí mismo, así como una forma de numeración fija o exponencial. La llamada puede devolver NaN, infinito e -infinito.
```
float.to_s --> string 
```
truncar : este método es igual al método Float#to_i. El tipo de retorno de este método es int.
```
float.truncate 
```
¿cero? : este método devuelve verdadero si float es 0.0; de lo contrario, devuelve falso. El tipo de retorno de este método es booleano.
```
float.zero? --> true or false
```
Ejemplo:

# Ruby program to illustrate

# zero? Method



puts (0.0).zero?

puts (1.4).zero?

Producción:
```
true
false
```

La clase flotante contiene constantes que se enumeran a continuación:

constantes	Descripción
EXCAVAR	Tiene un número mínimo de dígitos decimales significativos en un punto flotante de doble precisión y su valor predeterminado es 15.
EPSILON	Mantiene la diferencia entre 1 y el número de punto flotante de precisión doble más pequeño mayor que 1 y el valor predeterminado es 2.2204460492503131e-16.
MANT_DIG	Contiene el número de dígitos de mantisa de base RADIX. El valor predeterminado es 53.
MÁX.	Contiene el entero más grande posible en un número de punto flotante de doble precisión y su valor predeterminado es 1,7976931348623157e+308.
MAX_10_EXP	Representa el exponente positivo más grande en un punto flotante de precisión doble donde 10 elevado a esta potencia menos 1. El valor predeterminado es 308.
MAX_EXP	Es el valor de exponente más grande posible en un punto flotante de doble precisión que por defecto es 1024.
MÍN.	Es el número normalizado positivo más pequeño en un punto flotante de precisión doble. El valor predeterminado es 2.2250738585072014e-308.
MIN_10_EXP	Es el exponente negativo más pequeño en un punto flotante de precisión doble donde 10 elevado a esta potencia menos 1. El valor predeterminado es -307.
MIN_EXP	Es el valor de exponente más pequeño posible en un punto flotante de precisión doble. El valor predeterminado es -1021
BASE	La base de las representaciones de punto flotante o, en otras palabras, es una base de números de punto flotante. El valor predeterminado es 2 en la mayoría de los sistemas, lo que representaría un decimal de base 10
REDONDO	Representa el modo de redondeo para operaciones de punto flotante. Los valores incluidos son: -1: si la moda es indeterminada 0: si el redondeo es hacia cero 1: si el redondeo es el más cercano al valor representable 2: si el redondeo es hacia +infinito 3: si el redondeo es hacia +infinito
Yaya	Es una expresión que representa un valor que “ no es un número ”.
INFINITO	Es una expresión que representa el infinito positivo.

Referencia: https://ruby-doc.org/core-2.4.0/Float.html

Publicación traducida automáticamente

Artículo escrito por ankita_saini y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Métodos de instancia pública

Deja una respuesta Cancelar la respuesta