rubedo

Ruby w swoim standardowym wyposażeniu posiada bardzo dobre wsparcie dla matematyki, które wychodzi daleko poza standardowe funkcje, które znamy z modułów math innych języków programowania. Odkryjmy więc na nowo piękno matematyki - z Rubim.

Przedziały

Przedział jest obiektem standardowej klasy Range. Możemy je tworzyć na dwa sposoby:

a = 1..9        # => 1..9
b = 1...9       # => 1...9

Różnica między nimi jest taka, że dwie kropki tworzą przedział od-do prawostronnie domknięty, a trzy kropki - otwarty. Przekonajmy się, że to prawda:

a.to_a      # => [1, 2, 3, 4, 5, 6, 7, 8, 9]
b.to_a      # => [1, 2, 3, 4, 5, 6, 7, 8]

Przedziały tworzymy tak, że wartość mniejsza musi byc zawsze po lewej stronie:

(-1..2).to_a      # [-1, 0, 1, 2]
(2..-1).to_a      # []

Nic nie stoi na przeszkodzie, byśmy tworzyli przedziały ograniczone liczbami rzeczywistymi:

-2.5..4     # -2.5..4

Mechanika konwersji przedziałów nie pozwala na stworzenie tablicy z przedziału liczb zmiennoprzecinkowych - nieprawidłowe jest wywołanie (-2.5..4).to_a

Przedziały nieliczbowe

Ruby pozwala nam na tworzenie przedziałów nie tylko z liczb, ale i znaków i Stringów:

('a'..'z').to_a                   # ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", 
                                  # "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", 
                                  # "u", "v", "w", "x", "y", "z"]

("aa".."bf").to_a                 # ["aa", "ab", "ac", "ad", "ae", "af", "ag", "ah", 
                                  # "ai", "aj", "ak", "al", "am", "an", "ao", "ap", 
                                  # "aq", "ar", "as", "at", "au", "av", "aw", "ax", 
                                  # "ay", "az", "ba", "bb", "bc", "bd", "be", "bf"]

Przykłady

r1 = 'a'..'z'                # => "a".."z"
r2 = 1..10                   # => 1..10
r3 = 1...10                  # => 1...10

r1.min                       # => "a"
r2.max                       # => 10
r3.max                       # => 9
r3.end                       # => 10
r1.include? 'c'              # => true
r2.include? 5                # => true
r2 === 5                     # => true
r2.include? 12               # => false

r1.each { |c| print c }      # => "a".."z"
# Wyjście: abcdefghijklmnopqrstuvwxyz

Przedziały logiczne

Poświęciłem im cały wpis. Warto zajrzeć, gdyż konstrukcja posiada całkiem ciekawe zastosowania.

Liczby w Rubim

Język Ruby obsługuje wszystkie mniej lub bardziej standardowe typy liczbowe. Prześledźmy parę przykładów:

a = 5               # => 5
a.class             # => Fixnum
a/2                 # => 2
a%2                 # => 1
b = a/2.0           # => 2.5
b.class             # => float
b.round             # => 3
b.floor             # => 2
b.ceil              # => 3
(-1.25).abs         # => 1.25
1.zero?             # => false
0.zero?             # => true
3.between? 1, 5     # => true
3.between? 6, 10     # => false

# Potęgujemy
2**16               # => 65536

# Konwersje
5.to_s              # => "5"
(-2.4).to_s         # => "-2.4"
"-2.4".to_i         # => "-2"
"-2.4".to_f         # => "-2.4"

# Największy wspólny dzielnik
120.gcd 72          # => 24
# Najmniejsza wspólna wielokrotność
6.lcm 9             # => 18
# Jedno i drugie:
6.gcdlcm 9          # => [3, 18]

# Sposoby zapisu liczb
# Dziewięc milionów sto dwadzieścia pięć tysięcy pięćset siedemnaście
a = 9125517         # => 9125517
# Da się czytelniej:
a = 9_125_517

# Różne systemy liczbowe
a = 0x6c            # => 108
b = 0o72            # => 58
b = 072             # => 58
c = 0b10011001      # => 153

Dzielimy przez zero

Dobrze widzisz. Przez zero. O ile działanie to na typach całkowitych jest niewykonalne, o tyle na floatach daje całkiem "normalny" wynik:

a = 1.0/0                 # => Infinity
a.class                   # => float
a.infinite?               # => 1
(-1.0/0).infinite?        # => -1
a + 5                     # => Infinity
a/5                       # => Infinity
1/a                       # => 0
a/a                       # => NaN

r = -a..5                 # => -Infinity..5
r.include? 3              # => true

A co z dużymi liczbami?

Nic. Programujesz w Rubim, nie masz się czym stresować. Nie wierzysz?

a = 2**128    # => 340282366920938463463374607431768211456
a.class       # Bignum
a = a - 1     # => 340282366920938463463374607431768211455

Liczby zespolone

Biblioteka standardowa Rubiego daje nam bardzo wygodne wsparcie dla liczb zespolonych.

require 'complex'       # => true

a = Complex(1, 3)       # => Complex(1, 3)
b = Complex(-1.5, 5.17) # => Complex(-1.5, 5.17)
# Synonim:
a = 1 + 3.im            # => Complex(1, 3)

2.im                    # => Complex(0, 2)
a.real                  # => 1
a.image                 # => 3
a.conj                  # => Complex(1, -3)
a.abs                   # => 3.16227766016838
# kwadrat modułu
a.abs2                  # => 10
# argument w radianach
a.angle                 # => 1.24904577239825

a.polar                 # [3.16227766016838, 1.24904577239825]

a.to_s                  # => "1+3i"

a + b                   # => Complex(-0.5, 8.17)
a/b			# => Complex(0.483455203613664, -0.333691064878239)
Complex::I**2           # => Complex(-1, 0)
Math::E**(Math::PI*Complex::I)
# => Complex(-1.0, 1.22460635382238e-016)
# Zwrócmy uwagę na pewną niedokładność części urojonej

Moduł Math

Moduł ten znamy z wielu innych języków programowania. Pozwala liczyć pierwiastki arytmetyczne, logarytmy naturalne, dziesiętne, eksponenty, funkcje trygonometryczne, arcusy, funkcje hiperboliczne i arcusy tychże. Oprócz tego zawiera parę ciekawych metod (ri!), w tym hypot:

include Math    # => Object

hypot(3, 4)     # => 5.0

Metoda zwraca oczywiście długość przeciwprostokątnej trójkąta o danych dwóch przyprostokątnych.

Rozwiązujemy układ równań liniowych

Rozwiążmy następujący układ równań:

a + 2b = 3
4a + 5b = 6

W Rubim mamy do tego gotowe metody:

require 'mathn'                  # => true

m = Matrix[[1, 2], [4, 5]]       # => Matrix[[1, 2], [4, 5]]
y = Matrix.column_vector([3, 6]) # => Matrix[[3], [6]]
(m.inv*y)                        # => Matrix[[-1], [2]]

I mamy rozwiązanie. a = -1, b = 2. Prawda, że proste? :-)

Przyznam, że w niedalekiej przyszłości planuję napisać nieco więcej o matematycznych możliwościach Rubiego. Bo są one imponujące - odczułem to na własnej, realizując w nim projekt do obliczeń numerycznych w elektronice.