Ruby Language
Nombres

Remarques

Numeric
  Integer
    Fixnum    # 1
    Bignum    # 10000000000000000000
  Float       # 1.0
  Complex     # (1+0i)
  Rational    # Rational(2, 3) == 2/3
  BigDecimal  # not loaded by default

require "bigdecimal"

Créer un entier

0       # creates the Fixnum 0
123     # creates the Fixnum 123
1_000   # creates the Fixnum 1000. You can use _ as separator for readability

Par défaut, la notation est la base 10. Cependant, il existe d'autres notations intégrées pour différentes bases:

0xFF    # Hexadecimal representation of 255, starts with a 0x
0b100   # Binary representation of 4, starts with a 0b
0555    # Octal representation of 365, starts with a 0 and digits

Conversion d'une chaîne en entier

Vous pouvez utiliser la méthode Integer pour convertir une String en un Integer :

Integer("123")      # => 123
Integer("0xFF")     # => 255
Integer("0b100")    # => 4
Integer("0555")     # => 365

Vous pouvez également passer un paramètre de base à la méthode Integer pour convertir des nombres à partir d'une certaine base

Integer('10', 5)    # => 5
Integer('74', 8)    # => 60
Integer('NUM', 36)  # => 30910

Notez que la méthode déclenche une ArgumentError si le paramètre ne peut pas être converti:

Integer("hello")
# raises ArgumentError: invalid value for Integer(): "hello"
Integer("23-hello")
# raises ArgumentError: invalid value for Integer(): "23-hello"

Vous pouvez également utiliser la méthode String#to_i . Cependant, cette méthode est légèrement plus permissive et a un comportement différent de Integer :

"23".to_i         # => 23
"23-hello".to_i   # => 23
"hello".to_i      # => 0

String#to_i accepte un argument, la base pour interpréter le nombre comme String#to_i :

"10".to_i(2) # => 2
"10".to_i(3) # => 3
"A".to_i(16) # => 10

Conversion d'un nombre en chaîne

Fixnum # to_s prend un argument de base facultatif et représente le nombre donné dans cette base:

2.to_s(2)   # => "10"
3.to_s(2)   # => "11"
3.to_s(3)   # => "10"
10.to_s(16) # => "a"

Si aucun argument n'est fourni, alors il représente le nombre en base 10

2.to_s # => "2"
10423.to_s # => "10423"

Division de deux nombres

Lorsque vous divisez deux nombres, faites attention au type que vous voulez en retour. Notez que la division de deux entiers appellera la division entière . Si votre objectif est d'exécuter la division float, au moins un des paramètres doit être de type float .

Division entière:

3 / 2 # => 1

Division flottante

3 / 3.0 # => 1.0

16 / 2 / 2    # => 4
16 / 2 / 2.0  # => 4.0
16 / 2.0 / 2  # => 4.0
16.0 / 2 / 2  # => 4.0

Nombres rationnels

Rational représente un nombre rationnel comme numérateur et dénominateur:

r1 = Rational(2, 3)
r2 = 2.5.to_r
r3 = r1 + r2
r3.numerator   # => 19
r3.denominator # => 6
Rational(2, 4) # => (1/2)

Autres façons de créer un Rational

Rational('2/3')  # => (2/3)
Rational(3)      # => (3/1)
Rational(3, -5)  # => (-3/5)
Rational(0.2)    # => (3602879701896397/18014398509481984)
Rational('0.2')  # => (1/5)
0.2.to_r         # => (3602879701896397/18014398509481984)
0.2.rationalize  # => (1/5)
'1/4'.to_r       # => (1/4)

Nombres complexes

1i     # => (0+1i)
1.to_c # => (1+0i)
rectangular = Complex(2, 3)  # => (2+3i)
polar       = Complex('1@2') # => (-0.4161468365471424+0.9092974268256817i)

polar.rectangular # => [-0.4161468365471424, 0.9092974268256817]
rectangular.polar # => [3.605551275463989, 0.982793723247329]
rectangular + polar # => (1.5838531634528576+3.909297426825682i)

Numéros pairs et impairs

Le even? méthode peut être utilisée pour déterminer si un nombre est pair

4.even?      # => true
5.even?      # => false

L' odd? méthode peut être utilisée pour déterminer si un nombre est impair

4.odd?       # => false
5.odd?       # => true

Chiffres d'arrondi

La méthode round arrondit un nombre supérieur si le premier chiffre après sa décimale est supérieur ou égal à 5 ​​et s’élève si ce chiffre est inférieur ou égal à 4. Cela prend un argument optionnel pour la précision que vous recherchez.

4.89.round        # => 5
4.25.round        # => 4
3.141526.round(1) # => 3.1
3.141526.round(2) # => 3.14
3.141526.round(4) # => 3.1415

Les nombres à virgule flottante peuvent également être arrondis à l'entier inférieur inférieur au nombre avec la méthode d' floor

4.9999999999999.floor # => 4

Ils peuvent également être arrondis au nombre entier le plus faible supérieur au nombre utilisant la méthode ceil

4.0000000000001.ceil  # => 5