286 lines
5.2 KiB
Plaintext
286 lines
5.2 KiB
Plaintext
TITLE Porównanie Musique z typowymi językami programowania
|
|
|
|
BEGIN CSS
|
|
|
|
table, tr, td {
|
|
font-size: 12pt;
|
|
border: 1pt solid #DDDDDD;
|
|
border-collapse: collapse;
|
|
vertical-align: top;
|
|
tab-size: 2;
|
|
}
|
|
|
|
td, th {
|
|
padding: 2px;
|
|
}
|
|
|
|
END CSS
|
|
|
|
BEGIN INTRO
|
|
<h1>Ściągawka Musique, a Python i Ruby</h1>
|
|
Ponieważ Musique jest kierowany do osób posiadających doświadczenie z muzyką algorytmiczną, szybkim sposobem na podstawowe poznanie języka jest porównanie z innymi technologiami w tej dziedzinie. Ten dokument służy bardziej ukazaniu różnic niż omówieniu samego języka.
|
|
END INTRO
|
|
|
|
BEGIN TABLE
|
|
|
|
SECTION Podstawy
|
|
|
|
n Kategoria
|
|
m Musique
|
|
p Python
|
|
r Ruby (SonicPi)
|
|
c Komentarz
|
|
|
|
n Deklaracja zmiennej
|
|
m x := 0
|
|
p x = 0
|
|
r x = 0
|
|
c Zmienne należy zadeklarować by móc z nich korzystać
|
|
|
|
n Aktualizacja wartości zmiennej
|
|
m x = 1
|
|
r x = 1
|
|
p x = 1
|
|
|
|
n Operacje matematyczne
|
|
m x = 10 * 30 - 40 ** 2
|
|
p x = 10 * 30 - 40 ** 2
|
|
r x = 10 * 30 - 40 ** 2
|
|
c Zarówno Python, Ruby jak i Musique posiadają operator potęgi **
|
|
|
|
n Funkcja anonimowa
|
|
m add := (x y | x + y)
|
|
p add = lambda x, y: x + y
|
|
r add = ->(x, y) { x + y }
|
|
|
|
n Deklaracja funkcji
|
|
m add := (x y |
|
|
m say x y,
|
|
m x + y
|
|
m )
|
|
p def add(x, y):
|
|
p print(x, y)
|
|
p return x + y
|
|
r def add(x, y)
|
|
r puts x, y
|
|
r return x + y
|
|
r end
|
|
c Musique nie rozróżnia funkcji anonimowych i zadeklarowanych
|
|
|
|
n Wywoływanie funkcji
|
|
m add 1 3
|
|
p add(1, 3)
|
|
r add 1, 3
|
|
|
|
n Wywołanie funkcji
|
|
n nie przymujących argumentów
|
|
m constant := (say 42, 10);
|
|
m say (call foo)
|
|
p def constant():
|
|
p print(42)
|
|
p return 10
|
|
p print(constant())
|
|
r def constant()
|
|
r puts(42)
|
|
r return 10
|
|
r end
|
|
r puts constant
|
|
|
|
n Instrukcja warunkowa
|
|
m if (n == 42)
|
|
m (say 1)
|
|
m (say 2)
|
|
p if n == 42:
|
|
p print(1)
|
|
p else:
|
|
p print(2)
|
|
r if n == 42
|
|
r puts 1
|
|
r else
|
|
r puts 2
|
|
r end
|
|
|
|
n Wyrażenie warunkowe
|
|
m x := if (n == 42) 1 2
|
|
p x = 1 if n == 42 else 2
|
|
r x = n == 42 ? 1 : 2
|
|
|
|
SECTION Tablice
|
|
|
|
n Kategoria
|
|
m Musique
|
|
p Python
|
|
r Ruby (SonicPi)
|
|
c Komentarz
|
|
|
|
n Tablice
|
|
m x = (1, 2, 3, 4)
|
|
p x = [1, 2, 3, 4]
|
|
r x = [1, 2, 3, 4]
|
|
c W Musique funkcja anonimowa nie przyjmująca argumentów
|
|
c jak i tablica są tożsame.
|
|
|
|
n Nty element tablicy
|
|
m x[n]
|
|
p x[n]
|
|
r x[n]
|
|
|
|
n Aktualizacja ntego elementu tablicy
|
|
m x = update x n 10
|
|
p x[n] = 10
|
|
r x[n] = 10
|
|
|
|
n Tablica od 0 do 9 włącznie
|
|
m x = up 10
|
|
p x = list(range(10))
|
|
r x = [*0..9]
|
|
|
|
n Tablica od 1 do 10 włącznie
|
|
m x = 1 + up 10
|
|
m lub x = range 1 11
|
|
p x = list(range(1, 11))
|
|
r x = [*1..10]
|
|
|
|
n Tablica od 9 do 0 włącznie
|
|
m x = down 10
|
|
m lub x = reverse (up 10)
|
|
p x = list(range(9, -1, -1))
|
|
p lub x = list(reversed(range(10)))
|
|
r x = 9.downto(0).to_a
|
|
|
|
n Iloczyn elementów tablicy
|
|
m fold '* (1 + up 5)
|
|
p functools.reduce(
|
|
p operator.mul, range(1, 6), 1)
|
|
r [*1..5].inject(:*)
|
|
c Musique pozwala zmienić dowolny operator w funkcję
|
|
c poprzez zapis 'operator jak '* w przykładzie
|
|
|
|
n Iteracja po elementach tablicy
|
|
m for (up 5) (i | say i)
|
|
p for i in range(5):
|
|
p print(i)
|
|
r (0..4).each do |i|
|
|
r puts i
|
|
r end
|
|
|
|
n Sortowanie tablicy
|
|
m xs := sort (1, 5, 3, 3, 2)
|
|
p xs = sorted([1, 5, 3, 3, 2])
|
|
r xs = [1, 5, 3, 3, 2].sort
|
|
|
|
n Sortowanie wielu tablic w jedną
|
|
m xs := sort (1, 5, 3, 3, 2)
|
|
m (3, 4, 5) 1 2 3
|
|
p xs = sorted(itertools.chain(
|
|
p [1, 5, 3, 3, 2], [3, 4, 5],
|
|
p [1], [2], [3]
|
|
p ))
|
|
r [[1, 5, 3, 3, 2], [3, 4, 5],
|
|
r [1], [2], [3]
|
|
r ].flatten.sort
|
|
c Wiele operacji na tablicach może być wykonywane na dowolnej kombinacji
|
|
c tablic i pojedyńczych wartości. Tworzy to jedną tablicę wykoniową.
|
|
|
|
SECTION Muzyka
|
|
|
|
n Kategoria
|
|
m Musique
|
|
r SonicPi
|
|
c Komentarz
|
|
|
|
n Zmiana tempa na 90
|
|
m bpm 90
|
|
r use_bpm 90
|
|
|
|
n Zmiana domyślnej długości nuty na półnutę
|
|
m len 1/2
|
|
c w SonicPi nie ma domyślnej długości nuty;
|
|
c za każdym razem trzeba ją definiować
|
|
|
|
n Zmiana oktawy do 4tej
|
|
m oct 4;
|
|
c w SonicPi domyślna oktawa
|
|
c jest ustalona jako 4
|
|
|
|
n C w 4 oktawie
|
|
m play c4
|
|
r play 60
|
|
|
|
n Akord C-dur
|
|
m play (c & e & g)
|
|
m lub play (chord c e g)
|
|
r play :C4
|
|
r play :E4
|
|
r play :G4
|
|
r lub play chord(:C4, :major)
|
|
|
|
n Akord C-dur w 8 oktawie
|
|
m play (c8 & e8 & g8)
|
|
r play :C8
|
|
r play :E8
|
|
r play :G8
|
|
r lub play chord(:C8, :major)
|
|
|
|
n C w 4 oktawie, półnuta
|
|
m play (c4 hn)
|
|
m lub play (c4 (1/2))
|
|
m lub play (c4 0.5)
|
|
r play 60, sustain: 2
|
|
c w SonicPi możliwa jest kontrola obwiedni ADSR za pomocą
|
|
c parametrów attack, delay, sustain i release
|
|
|
|
n Sekwencja C, E i G w oktawie 4, półnuty, <br />zagrane jedna po drugiej
|
|
m play (len (1/2), c4 e4 g4)
|
|
r [:C4, :E4, :G4].each do |i|
|
|
r play i, sustain: 2
|
|
r sleep 2
|
|
r end
|
|
|
|
n Sekwencja C, D, E, F, G,<br/>z nutą A graną przez cały czas trwania sekwencji
|
|
m par a (c, d, e, f, g)
|
|
r in_thread do
|
|
r [:C4, :D4, :E4, :F4, :G4].each do |i|
|
|
r play i
|
|
r sleep 1
|
|
r end
|
|
r end
|
|
r in_thread do
|
|
r play :A4, sustain: 5
|
|
r end
|
|
|
|
n Dwie melodie grane współbieżnie
|
|
m sim (c 4 c 3 c 2) (e 4 e 3 e 2)
|
|
r in_thread do
|
|
r [:C4, :C3, :C2].each do |i|
|
|
r play i
|
|
r sleep 1
|
|
r end
|
|
r end
|
|
r in_thread do
|
|
r [:E4, :E3, :E2].each do |i|
|
|
r play i
|
|
r sleep 1
|
|
r end
|
|
r end
|
|
|
|
n Zagranie losowej nuty spośród C, E, G
|
|
m play (pick (c e g))
|
|
r play choose([:C, :E, :G])
|
|
|
|
n Zagranie sekwencji nut C, E, G w losowej kolejności
|
|
m play (shuffle (c e g))
|
|
r [:C, :E, :G].shuffle().each do |i|
|
|
r play i, sustain: 1
|
|
r sleep 1
|
|
r end
|
|
|
|
n Zagranie sekwencji C, E, G od tyłu
|
|
m play (reverse (c e g))
|
|
r [:C, :E, :G].reverse.each do |i|
|
|
r play i, sustain: 1
|
|
r sleep 1
|
|
r end
|
|
|
|
END TABLE
|