Die Programmiersprache Ruby (German Edition)

negativ?
INF.infinite? # => 1
-INF.infinite? # => −1
NAN.infinite? # => nil

ZERO.nan? # => false: ist dies keine Zahl?
INF.nan? # => false
NAN.nan? # => true
    Die Klasse
Float
definiert ein paar Methoden zum Runden von Zahlen. Die meisten dieser Methoden sind auch von
Numeric
definiert, daher lassen sie sich mit Zahlen beliebigen Typs verwenden:
# Rundungsmethoden
1.1.ceil # => 2: Aufrunden: kleinste Ganzzahl >= Argument
-1.1.ceil # => −1: Aufrunden: kleinste Ganzzahl >= Argument
1.9.floor # => 1: Abrunden: größte Ganzzahl <= Argument
-1.9.floor # => −2: Abrunden: größte Ganzzahl <= Argument
1.1.round # => 1: auf nächste Ganzzahl runden
0.5.round # => 1: runde Richtung unendlich, wenn genau zwischen zwei Ganzzahlen
-0.5.round # => −1: oder runde Richtung negativ unendlich
1.1.truncate # => 1: Nachkommastellen abschneiden: Richtung null runden
-1.1.to_i # => −1: Synonym für truncate
    Float
definiert zudem noch ein paar weitere interessante Methoden und Konstanten:
# Absolutwert und Signum
-2.0.abs # => 2.0: absoluter Wert
-2.0<=>0.0 # => −1: verwende Operator <=>, um sign einer Zahl zu berechnen

# Konstanten
Float::MAX # => 1.79769313486232e+308: kann plattformabhängig sein
Float::MIN # => 2.2250738585072e-308
Float::EPSILON # => 2.22044604925031e-16: Abstand zwischen nebeneinanderliegenden Floats
    9.3.2 Das Modul Math
    Das Modul
Math
definiert die Konstanten
PI
und
E
sowie trigonometrische und logarithmische Methoden, dazu noch ein paar andere Funktionen. Die Methoden von
Math
sind »Modulfunktionen« (siehe „7.5.3 Einbindbare Namensraummodule“ ), was bedeutet, dass sie über den Namensraum
Math
aufgerufen oder eingebunden und als »globale« Funktionen genutzt werden können. Hier sehen Sie ein paar Beispiele:
# Konstanten
Math::PI # => 3.14159265358979
Math::E # => 2.71828182845905

# Wurzeln
Math.sqrt(25.0) # => 5.0: Quadratwurzel
27.0**(1.0/3.0) # => 3.0: Kubikwurzel wird mit dem Operator ** berechnet

# Logarithmen
Math.log10(100.0) # => 2.0: Logarithmus zur Basis 10
Math.log(Math::E**3) # => 3.0: natürlicher Logarithmus (zur Basis e)
Math.log2(8) # => 3.0: Logarithmus zur Basis 2. Ruby 1.9 und neuer.
Math.log(16, 4) # => 2.0: zweites Argument von log() ist die Basis. Ruby 1.9.
Math.exp(2) # => 7.38905609893065: wie Math::E**2

# Trigonometrie
include Math # Spart Tippaufwand: Wir können jetzt das Präfix Math weglassen.
sin(PI/2) # => 1.0: Sinus. Argument ist in rad, nicht in Grad.
cos(0) # => 1.0: Cosinus.
tan(PI/4) # => 1.0: Tangens.
asin(1.0)/PI # => 0.5: Arcus Sinus. Siehe auch acos und atan.
sinh(0) # => 0.0: Sinus Hyperbolicus. Auch cosh, tanh.
asinh(1.0) # => 0.0: Areasinus Hyperbolicus. Auch acosh, atanh.

# Umwandeln eines kartesischen Punktes (x,y) in Polarkoordinaten (theta, r)
theta = atan2(y,x) # Winkel zwischen x-Achse und der Linie (0,0)-(x,y)
r = hypot(x,y) # Hypotenuse: sqrt(x**2 + y**2)

# Float x aufteilen in Bruchanteil f und Exponent e, so dass x = f*2**e
f,e = frexp(1024.0) # => [0.5, 11]
x = ldexp(f, e) # => 1024: berechne x = f*2**e

# Fehlerfunktion
erf(0.0) # => 0.0: Fehlerfunktion
erfc(0.0) # => 1.0: 1-erf(x): Komplementäre Fehlerfunktion
    9.3.3 Dezimalarithmetik
    Die Klasse
BigDecimal
aus der Standardbibliothek ist eine nützliche Alternative zu
Float
, insbesondere für Finanzberechnungen, in denen Sie die Rundungsfehler vermeiden wollen, die sich bei einer Binär-Gleitkommazahl ergeben können (siehe „3.1.4 Binärfließkomma und Rundungsfehler“ ).
BigDecimal
-Objekte können eine unbegrenzt große Zahl an signifikanten Stellen und praktisch eine unbegrenzte Größe haben (Exponenten können bis über eine Milliarde gehen). Wichtiger ist noch, dass sie Dezimalarithmetik verwenden und eine exakte Kontrolle über die Vorgehensweise beim Runden bieten. Hier sehen Sie ein Beispiel für
BigDecimal
:
require "bigdecimal" # Lädt Standardbibliothek
dime = BigDecimal("0.1") # Dem Konstruktor einen String übergeben, keinen Float
4*dime-3*dime == dime # true bei BigDecimal, aber false bei Float
# Berechne monatliche Rate einer Hypothek mit BigDecimal
# Bankrundung verwenden, Berechnung auf 20 Ziffern beschränken
BigDecimal.mode(BigDecimal::ROUND_MODE, BigDecimal::ROUND_HALF_EVEN)
BigDecimal.limit(20)
principal = BigDecimal("200000") # Immer Strings an Konstruktoren übergeben
apr = BigDecimal("6.5") # Jährlicher Zinssatz
years = 30 # Laufzeit in Jahren
payments = years*12 # Zwölf monatliche Raten pro Jahr
interest = apr/100/12 # Zinssatz pro Monat
x =