Mathematica Dla Niecierpliwych (Całość)

Mathematica dla ©
niecierpliwych
Miros aw Majewski
Fragment tekstu Konferencja MathPAD 2010

ksi ki
przygotowywanej
Wydzia Matematyki i Informatyki
do druku. Uniwersytet Miko aja Kopernika
© M.M
Toru , 15-19 sierpnia, 2010

Spis rzeczy
1 Wprowadzenie do programu Mathematica........................... 1
1.1 Mathematica jako podręczny kalkulator ...........................................................................3
1.1.1 Arytmetyka ......................................................................................................................................... 3
1.1.2 Funkcje trygonometryczne, logarytmiczne ..........................................................................5
1.2 Rozwiązujemy równania ......................................................................................................... 8
1.3 Zmienne ...........................................................................................................................................9
1.4 Funkcje ..........................................................................................................................................12
1.4.1 Problemy z deklaracjami ........................................................................................................... 13
1.5 Operacje na wyrażeniach matematycznych ..................................................................15
1.6 Elementy analizy matematycznej ......................................................................................18
1.7 Szukamy pomocy ......................................................................................................................20
1.7.1 Duże i małe litery .......................................................................................................................... 20
1.7.2 Nawiasy ............................................................................................................................................. 21
1.7.3 Równość nie jest równa równości .........................................................................................21
1.7.4 Kolor ma też jakieś znaczenie ..................................................................................................22
1.7.5 Pomoc w programie ..................................................................................................................... 22
2 Grafika 2D w programie Mathematica ...............................25

2.1 Wykresy funkcji jednej zmiennej ...................................................................................... 25
2.2 Wykresy równań parametrycznych ................................................................................. 28
2.2.1 Proporcje i zakres wykresu ...................................................................................................... 29
2.2.2 Osie układu współrzędnych, siatka i ramka ......................................................................30
2.2.3 Styl wykresów w 2D .....................................................................................................................32
2.3 Wykresy krzywych parametrycznych .............................................................................37
2.4 Wykresy we współrzędnych biegunowych ...................................................................41
2.5 Wykresy równań w postaci uwikłanej ............................................................................ 45
3 Grafika 3D w programie Mathematica ...............................47

3.1 Wykresy funkcji dwu zmiennych ...................................................................................... 47
3.2 Wykresy równań parametrycznych ................................................................................. 51
3.3 Wykresy równań uwikłanych i nierówności ................................................................ 54
3.4 Wykresy we współrzednych sferycznych ......................................................................59
3.5 Wykresy otrzymane z obrotu krzywych ........................................................................ 61
3.6 Wykresy funkcji dwu zmiennych inaczej .......................................................................63
4 Animacja i manipulacja ................................................ 67

4.1 Podstawy procedury Manipulate ................................................................................... 67
4.2 Różne twarze procedury Manipulate ........................................................................... 72
I
M. Majewski
4.3 Panele z suwakami 2D i kolorem .......................................................................................75

4.4 Organizacja informacji na panelach Manipulate ......................................................77
4.5 Panele z zakładkami ................................................................................................................79
4.6 Hybrydy Manipulate i TabView ...................................................................................... 80
Literatura ....................................................................82
II
Przedmowa
Od wielu lat zajmuję się tak zwanymi Systemami Algebry Komputerowej (ang.
Computer Algebra Systems, lub krótko CAS). Programy te mogą uczynić zarówno
nauczanie matematyki, jak i uczenie się matematyki, znacznie bardziej efektywnym
oraz, co jest również ważne, bardziej interesującym. Na codzień używam programu
Scientific Notebook jako mojej tablicy elektronicznej do wykładania takich
przedmiotów jak algebra liniowa, rachunek różniczkowy czy matematyka skończona.
Od wielu lat nie biorę do ręki kredy czy pisaka. Każdy mój wykład powstaje w sali
wykładowej na laptopie i jest rzutowany na ekran. Bezpośrednio po wykładzie moi
studenci mogą otrzymać notatki z wykładu w postaci elektronicznej, jako plik PDF, lub
drukowanej.
W sytuacjach, gdy zachodzi potrzeba zrobienia bardziej skomplikowanej ilustracji do
wykładu, lub napisania krótkiego programu, zazwyczaj używam programu MuPAD,
znanego obecnie jako Matlab Symbolic Maths Toolbox. Program Mathematica jest
ostatnim dodatkiem do arsenału moich narzędzi dydaktycznych. Przyczyn jest tu kilka
– MuPAD nie istnieje już w wersji niezależnej, a startowanie go z wnętrza programu
Matlab zabiera zbyt wiele czasu; Mathematica jest idealnym środowiskiem do
operowania strukturami matematycznymi, nawet tymi bardziej skomplikowanymi,
oraz ma wręcz niezwykłe możliwości graficzne. Na dodatek Mathematica posiada tę
niezwykłą procedurę Manipulate, która pozwala w kilka sekund zamienić każdy
przykład w interaktywne laboratorium.
Przedstawiony tu materiał powstał z doświadczeń i materiałów zgromadzonych przez
lata nauczania z komputerem. Pewne z pokazanych tu przykładów pochodzą z moich
wcześniejszych książek, z notatek do wykładów, oraz licznych eksperymentów z
różnymi programami matematycznymi. Wiele z załączonych tu zadań, podobnie jak
tytuł tego tekstu, zostało wzięte z mojej książki MuPAD dla niecierpliwych. Pokazane tu
środowisko i przykłady pochodzą z programu Mathematica wersja 7. Wszystkie
omówione tu przykłady zostały wielokrotnie przetestowane w różnych sytuacjach i z
różnymi parametrami. Nie wykluczam jednak możliwych pomyłek podczas
kopiowania przykładów z programu Mathematica oraz formatowania tekstu.
Wreszcie warto wspomnieć co czytelnik może znaleźć w tym opracowaniu i jak to
może wykorzystać. Mathematica jest programem bogatym w liczne narzędzia, funkcje
i wiele subtelności. Jest to niezmierzone morze wiadomości, które jest w stanie
oszołomić, lub nawet zniechęcić, początkującego użytkownika. Trzeba wielu lat na to,
aby poznać ten program dogłębnie. Tymczasem nauczyciel czy student potrzebuje
niewielki fragment tej wiedzy, tylko najpotrzebniejsze rzeczy, te których będzie
używał na lekcji czy do rozwiązania stosunkowo prostego problemu matematycznego.
Jak tytuł tego opracowania wskazuje, mam zamiar omówić tu wybrane i tylko
najpotrzebniejsze elementy programu.
Przedstawiony tu tekst jest fragmentem książki tego samego autora przygotowywanej
do druku. W tym opracowaniu czytelnik znajdzie tylko cztery rozdziały. We
wprowadzeniu omówimy najpotrzebniejsze rzeczy, które są potrzebne do tego aby
moc rozpocząć pracę z programem Mathematica. Jest to absolutne minimum, bez
którego trudno byłoby czytać pozostałe rozdziały. Czasem czytelnik może odczuwać
brak pewnych wiadomości. Pewne z nich z zostaną omówione w dalszych rozdziałach.
M. Majewski
Wiele rzeczy można znaleźć w bogatej pomocy programu Mathematica.

Rozdział drugi jest wprowadzeniem do grafiki 2D w programie Mathematica. Jeszcze
raz, jest to tylko absolutne minimum wystarczające do tego, aby zrobić podstawowe
wykresy szkolne czy uniwersyteckie do takich przedmiotów jak rachunek
różniczkowy czy algebra. Tu, przy okazji, omawiam sposoby ręcznej edycji wykresów
— dodawanie napisów, strzałek, zmiany kolorów itp. Po długim czasie wykładania z
CAS uważam, że jest to bardzo użyteczna funkcja w przypadku, gdy chcemy szybko
poprawić wykres tak, aby uczeń lub student mógł lepiej zrozumieć co wykres
przedstawia.
Rozdział trzeci poświęcam grafice w 3D. Tu naszym głównym zadaniem będzie
poznanie sposobów wizualizacji powierzchni i krzywych zadanych za pomocą różnego
rodzaju równań i układów współrzędnych. Wykresy w przestrzeni wymagają znacznie
większej znajomości szczegółów technicznych, np. sposobów posługiwania się
kolorem, przezroczystością wykresu, itp. Tylko najbardziej niezbędne elementy tej
wiedzy zostaną tu omówione.
Rozdział czwarty jest pewnego rodzaju odskocznią od niezbędności jaką sobie
postawiłem przy pisaniu tego tekstu. Omawiam tu manipulację obiektami graficznymi,
choć nie tylko, ich animację i tworzenie interaktywnych paneli, które mogą być
wspaniałą pomocą dydaktyczna w eksploracjach matematycznych.
Inne tematy pojawią się w pełnej wersji tej książki.
Na koniec jeszcze parę słów o tym jak czytać ten tekst. Jak wiem z doświadczenia,
samo czytanie nie wystarcza aby poznać możliwości programu. W tym, jak i wielu
innych przypadkach, czytanie powinno być aktywne – czytajmy zatem z włączonym
programem Mathematica. Każdy fragment kodu przepisujemy samodzielnie do
programu. Wbrew wszelkim pozorom samodzielnie wpisywanie kodu do programu
też nas wiele uczy i jest to akurat najbardziej niezbędny kawałek wiedzy. Następnie
powodujemy wykonanie kodu i sprawdzamy jaki otrzymaliśmy wynik. To jest drugi
bardzo ważny element doświadczenia. Jeśli coś nam nie wyszło tak jak się
spodziewaliśmy, to zastanówmy się dlaczego. Często czerwone tło wykresu lub
czerwone napisy są pierwszą informacją o błędach w kodzie. Sprawdźmy również co
się stanie jak zmienimy parametry w naszym przykładzie. Takie eksperymenty
pomogą nam później wydobyć z programu wiele specyficznych rzeczy.
Każdy ważniejszy fragment tego tekstu zawiera kilka przykładów do samodzielnego
wykonania. W takim przypadku radzę nie kopiować wcześniej zrobionych
przykładów, tylko wpisać nowy kod bez zaglądania na wcześniejsze strony tego
tekstu. W ten sposób możemy sprawdzić ile zapamiętaliśmy z lektury tego tekstu. Jest
to również ważny element utrwalania zdobytej wiedzy.
Mirek Majewski, Abu Dhabi, maj 2010
IV
1
Wprowadzenie do programu
Mathematica
Zaczynając pracę z jakimkolwiek programem warto poświęcić kilka chwil na poznanie
otoczenia, w którym będziemy pracować. W przypadku programu Mathematica jest to
bogaty zestaw palet i oferta wielopoziomowej pomocy, które w tej chwili możemy
spokojnie pominąć i pozostawić na odpowiedniejszy moment. Dla nas w tej chwili
najważniejszy jest pusty notatnik na ekranie. Tu będziemy wpisywać nasze polecenia i
tu będziemy oczekiwać wyników. Na wielu typach ekranów domyślny notatnik używa
zbyt małych znaków aby można było wygodnie pracować. Dobrym i sprawdzonym
rozwiązaniem jest wyszukanie w menu FormatScreen Environment opcji Presentation.
W wyniku takiego wyboru otrzymujemy notatnik, który idealnie nadaje się do pracy
indywidualnej, jak również do prezentacji w trakcie lekcji czy wykładu.
Aby zapoznać się ze sposobem pracy w programie Mathematica wpiszemy nasze
pierwsze polecenie i wykonamy je. Zacznijmy od najbardziej naturalnego polecenia
jakie zadajemy programom komputerowym, np. aby rozwiązał nam jakieś proste
równanie, coś w rodzaju x 2  5x − 1  0. Polecenie rozwiązania takiego równania
może mieć postać:
Solve[x^2  5 x ‐ 1  0, x]
Aby uniknąć pomyłek już na samym początku zauważmy kilka istotnych rzeczy.
Mathematica rozróżnia pomiędzy dużymi i małymi literami. Polecenie Solve będzie
zrozumiane przez program, natomiast polecenie solve już nie. Wszystkie polecenia
zdefiniowane w programie Mathematica, nazwy funkcji i operatorów zaczynają się od
dużej litery, np. Solve, Simplify, Expand, Sin, Cos, etc. Drugą istotną sprawą jest
nawias przy Solve, jest to nawias kwadratowy. W każdym poleceniu, czy funkcji,
używamy nawiasów kwadratowych do wpisania argumentów polecenia czy funkcji.
Mamy zatem Sin[x], Cos[x], Expand[(x‐1)^3], Simplify[Sin[x]^4‐Cos[x]^4],
itd. Do tych spraw będziemy wracać jeszcze wielokrotnie. A oto kolejne istotne
elementy występujące w naszym poleceniu. Wyrażenie x^2 oznacza x 2 , natomiast 5 x
oznacza 5 ∗ x lub po prostu 5x. W tym ostatnim przypadku nie musimy pisać symbolu
mnożenia, wystarczy spacja.
Zauważmy ponadto, że równości w równaniach wpisujemy używając symbolu "".
Pojedynczy symbol "" ma nieco inne znaczenie w programie Mathematica.
Mirosław Majewski
Teraz jesteśmy gotowi do wykonania naszego pierwszego polecenia. Ustawmy

wskaźnik myszy gdzieś na obszarze linii z poleceniem Solve i jednocześnie wciśnijmy
dwa klawisze [Shift][Enter]. Jeśli wpisaliśmy nasze polecenie poprawnie, to na ekranie
powinien pojawić się wynik. Jeśli były jakieś błędy w naszym poleceniu, to albo
otrzymamy komunikat o błędzie, albo nasze polecenie zostanie powtórzone bez
zmian. Poniższy obrazek pokazuje notatnik programu z wpisanymi i wykonanymi
kilkoma poleceniami.
Uwaga techniczna Polecenia w programie Mathematica często używają pewnych, z góry

ustalonych słów np. Solve, Expand, itd.. Słowa takie nazywać będziemy nazwami procedur
lub krótko procedurami. Procedury są programami, które zostały napisane przez twórców
programu Mathematica lub przez jego użytkowników. Zazwyczaj użytkownik nie zna lub nie
chce znać zawartości procedury. Wystarczy, że zna nazwę procedury i wie jak jej używać. W
dalszej części tej książki będziemy odróżniać nazwy procedur od poleceń ich używających.
Zauważmy przy tym, że dana procedura może być użyta na wiele sposobów, często do
różnych typów obiektów matematycznych, np. procedura Solve może być użyta do
rozwiązywania różnych typów równań.
Zanim pójdziemy dalej w poznawaniu programu, przyjrzyjmy się jeszcze przez chwilę
pewnym specyficznym elementom notatnika. Każda linia kodu i wyników
poprzedzona jest wyrażeniem In[nr]: lub Out[nr]:. Linie In[nr] oznaczają
input czyli wpisane przez nas polecenia, linie Out[nr] oznaczają wyniki obliczone i
wyświetlone przez program Mathematica. Każde polecenie, jak i wynik, ma numer
pokazujący w jakiej kolejności wpisywaliśmy i wykonywaliśmy polecenia. Kolejność
ta nie koniecznie musi zgadzać się z kolejnością w jakiej polecenia występują na
ekranie.
Drugą widoczną na obrazku cechą notatnika są nawiasy kwadratowe na prawym
obrzeżu notatnika. Każdy z tych nawiasów wskazuje obszar jakiegoś bloku elementów
2
Mathematica dla niecierpliwych
notatnika, np. blok danego polecenia, blok wyniku, blok polecenia i odpowiadającego
mu wyniku, blok rozdziału, itd. Każdy blok może być skasowany poprzez wybranie
odpowiadającego mu nawiasu na prawym marginesie i wciśnięcie klawisza [Delete].
Pomiędzy dwa kolejne bloki możemy wstawić nowe polecenie lub tekst. Wystarczy w
tym celu ustawić wskaźnik myszy w odpowiednie miejsce, a kiedy zamieni się w
poziomą kreskę, kliknąć i zacząć wpisywać nowe polecenie.
Podobnie postępujemy jeśli chcemy wpisać w notatniku dowolny tekst. Ustawiamy
wskaźnik myszy w odpowiednim miejscu, klikamy aby rozpocząć wpisywanie i
następnie wciskając [Alt][7] zamienić dany blok w tekst. Jeśli chcemy, aby nasz
notatnik był podobny do dokumentów jakie tworzymy w MS Word, czy innym
programie do edycji tekstów, to kolejne sekwencje klawiszy z [Alt] mają następujący
efekt: tytuł ([Alt][1]), podtytuł ([Alt][2]), podpodtytuł ([Alt][3]), sekcja ([Alt][4]),
podsekcja ([Alt][5]), podpodsekcja ([Alt][6]), tekst ([Alt][7]), kod ([Alt][8]), input
([Alt][9]). Bloki input oraz kod mają podobne własności ale mogą różnić się wyglądem
na ekranie.
Po tych bardzo wstępnych uwagach możemy przystąpić do poznawania możliwości
programu Mathematica.
1.1 Mathematica jako podręczny kalkulator
1.1.1 Arytmetyka
Na początek zauważmy, że Mathematica posiada bardzo bogatą kolekcję funkcji do
obliczeń, jak te wykonywane przez nas codziennie z użyciem kalkulatora. Mamy
zatem wszelkie funkcje arytmetyczne: , −, , /, potęgę (wyrażenie 2 3 zapisujemy jako
2^3), oraz pierwiastek (wyrażenie 2 zapisujemy jako Sqrt[2]). Mamy do
dyspozycji często używaną w matematyce operację silnia "!". Z pomocą tych operacji
możemy tworzyć dowolnie skomplikowane wyrażenia i obliczać ich wartości, np.
(234 ‐ 456)*(752  345)/((23  34)*(75 ‐ 32)  (78*99))
− 81178
3391
34!
295232799039604140847618609643520000000
Sqrt[1  2  2^2  2^3  2^4  2^5]
3 7
Bardziej skomplikowane wyrażenia pierwiastkowe zapisujemy używając symbolu
potęgi, np. 3 1  2  2 2  2 3  2 4  2 5  zapiszemy jako
3
Mirosław Majewski
(1  2  2^2  2^3  2^4  2^5)^(1/3)

3 2/3 3 7
To samo wyrażenie może być zapisane z użyciem polecenia Power, tak jak poniżej:
Power[1  2  2^2  2^3  2^4  2^5, 1/3]
3 2/3 3 7
Zauważmy przy tym, że wyrażenie do obliczenia może być podane w postaci liniowej,
jak powyżej, lub w postaci dwuwymiarowego wyrażenia jakie zazwyczaj widzimy w
podręcznikach matematyki, np.
234 − 456 752  345

23  34 75 − 32  78  99
Pisanie wyrażeń w tej postaci jest możliwe za pomocą odpowiednich palet symboli.
Możemy je znaleźć w menu Palettes i dalej np. Classroom Assistant, lub Basic Math
Assistant. Ponieważ na dalszych stronach tego tekstu będziemy używać licznych
poleceń korzystających głównie z zapisu liniowego, opis palet i ich wykorzystania
zostawimy sobie na inną okazję.
Wreszcie zauważmy dość istotną cechę programu Mathematica. Jak każdy inny CAS,
Mathematica stara się podawać wyniki w postaci symbolicznej, a więc 23  2
zamiast 4. 941 1, 1 zamiast 0. 1, itd. Jeśli zatem chcemy aby program podawał nam
10
wyniki w postaci numerycznej, to musimy go do tego w jakiś sposób zachęcić.
Sposobów zachęty jest conajmniej trzy.
Możemy zapisać jedną z liczb w postaci dziesiętnej, np. zamiast 234 napisać 234.0, to
wystarczy aby Mathematica podała cały wynik w postaci dziesiętnej.
(234.0 ‐ 456)*(752  345)/((23  34)*(75 ‐ 32)  (78*99))
Możemy użyć polecenia N[wyrażenie]
N[(234 ‐ 456)*(752  345)/((23  34)*(75 ‐ 32)  (78*99))]
lub
(234 ‐ 456)*(752  345)/((23  34)*(75 ‐ 32)  (78*99)) //N
Każde z tych poleceń wyprodukuje wynik −23. 9393. Na szczególną jednak uwagę
zasługuje polecenie środkowe. Tu możemy zażądać dodatkowej precyzji wyniku, np.
wynik z dokładnością do 50 miejsc po przecinku otrzymamy przez użycie
dodatkowego parametru.
N[(234 ‐ 456)*(752  345)/((23  34)*(75 ‐ 32)  (78*99)), 50]
−23. 939250958419345325862577410793276319669713948688
Ostatnie z trzech powyżej podanych poleceń zostało użyte w tzw. postaci postfix, czyli
4
operator podany jest na końcu polecenia, tu //N . Z pewnych powodów jest to bardzo
wygodny sposób wykonywania pewnych operacji nie tylko arytmetycznych. Do tego
problemu wrócimy przy innej okazji.
Na zakończenie tego krótkiego rozdziału poświeconego arytmetyce warto wspomnieć
o dwu najczęściej używanych w matematyce stałych:  oraz e. Zapisujemy je jako Pi
oraz E. Mamy zatem:
N[Pi, 50]
3. 1415926535897932384626433832795028841971693993751
oraz
N[E, 50]
2. 7182818284590452353602874713526624977572470937000
Ćwiczenia
1. Oblicz dziesiętną wartość ułamka 123/456 z dokładnością 10, 100, oraz 1000
miejsc po przecinku.
2. Oblicz  oraz e z dokładnością 150 miejsc po przecinku.
1.1.2 Funkcje trygonometryczne, logarytmiczne

W programie Mathematica mamy do dyspozycji wszystkie znane nam funkcje
trygonometryczne, logarytmiczne i potęgowe. Są tu między innymi funkcje
wymienione w poniżej załączonej tabeli.
Funkcja Zapis w programie Mathematica i przykład użycia

sin x Sin[3 Pi/15]
cos x Cos[3 Pi/15]
tan x Tan[3 Pi/15]
cotx Cot[3 Pi/15]
arcsin x ArcSin[1/2]
arccos x ArcCos[1/2]
arctan x ArcTan[Sqrt[3]]
arccot x ArcCot[Sqrt[3]]
Niezmiernie ważne jest zauważenie, że funkcje trygonometryczne używają

argumentów wyrażonych w radianach, a nie stopniach.
5
Mirosław Majewski
Mamy zatem dla przykładu:

Sin[1] // N
0.841471
Sin[Pi]
0
Sin[Pi/2]
1
Sin[Pi/4]
1
2
Podobnie jest w drugą stronę. Funkcje odwrotne do funkcji trygonometrycznych
podają wyniki w postaci radianów, np.
ArcSin[1/Sqrt[2]]

4
ArcTan[Sqrt[3]]

3
W przypadku, gdy zamiast radianów mamy do czynienia ze stopniami, to prostym
sposobem możemy spowodować aby Mathematica rozumiała nasze potrzeby. Dla
przykładu obliczenie sin 15 ∘ możliwe jest za pomocą polecenia:
Sin[15 *Pi/180]
3 −1
2 2
Drugą ważną grupą funkcji w matematyce szkolnej, czy uniwersyteckiej, są funkcje
wykładnicze i logarytmiczne.
Mamy zatem:
Funkcja Zapis w programie Mathematica i przykład użycia

ln x Log[E*E]
log 10 x Log[10,10234.0]
log 2 x Log[2,15.]
log a x Log[a,x]
ex Exp[x] lub E^x
an Power[a,n]
6
Oto kilka przykładów pokazujących jak te funkcje mogą być stosowane.

Log[E*E]
2
Log[10, 10234]
log10234
log10
Zauważmy, że jak zawsze, Mathematica stara się podać wynik w postaci symbolicznej.
Jeśli jednak zależy nam na wyniku w postaci liczby dziesiętnej, to wystarczy
zasugerować tę potrzebę w znany nam już sposób.
Log[10, 10234.]
4.01005
Log[2, 15.]
3.90689
Log[a, b]
logb
loga
Exp[x]
ex
Power[a, b]
ab
Tu warto wspomnieć o interesującej własności programu Mathematica — jeśli
zamiast pojedynczych argumentów będziemy podawać argumenty w postaci list, to
wynik również otrzymamy w postaci listy, w której każdy element został poddany
odpowiedniej operacji. Dla przykładu podniesienie do 3 potęgi wszystkich wyrazów
pewnego ciągu może być wykonane jednym poleceniem,
Power[{a, b, c}, n]
a n , b n , c n 
lub tak, gdy chcemy utworzyć ciąg potęg pewnego wyrażenia
Power[a, {1, 2, 3, 4, 5}]
a, a 2 , a 3 , a 4 , a 5 
lub nawet tak,
Power[{a, b, c, d, e}, {1, 2, 3, 4, 5}]
a, b 2 , c 3 , d 4 , e 5 
W tym ostatnim przypadku musimy pamiętać, aby oba ciągi miały tę samą liczbę
elementów.
7
Mirosław Majewski
W podobny sposób zachowują się inne operacje i funkcje w programie Mathematica

jeśli zastosujemy je do ciągów wyrażeń. Dla przykładu mamy:
{a, b, c}  {d, e, f}
a  d, b  e, c  f
{a, b, c}/{d, e, f}
 a , be , c 
d f
Log[{a, b, c}]
loga, logb, logc
Sin[{a, b, c}]
sina, sinb, sinc
Do operacji na ciągach wrócimy w innym odpowiedniejszym momencie.
1.2 Rozwiązujemy równania

Drugą ważną operacją, jaka nie zawsze występuje w kalkulatorach, jest
rozwiązywanie równań lub nawet układów równań. Rozwiązywanie równań jest
bardzo bogatym tematem i w tym rozdziale ograniczymy się tylko do kilku
elementarnych przykładów.
Zacznijmy zatem od tego, że każde równanie powinno być podane w postaci:
lewa strona  prawa strona
Piszemy zatem x^2‐10, a nie x^2‐10. Dalej, do rozwiązania większości równań,
wystarczy nam polecenie Solve z drobnymi modyfikacjami. Oto kilka prostych
przykładów.
Solve[x^2 ‐ 3 x  1  0, x]
1 1
x → 2
3 − 5 , x → 2
3  5 
Solve[x^3 ‐ 3 x  1  x^2 ‐ 2 x  3, x]
x → 2, x → − 3 −1 , x → −1 2/3 
W podobny sposób rozwiązujemy układy równań. Zauważmy, że to bardzo
przypomina to co zobaczyliśmy przy okazji funkcji Power. Tu również grupujemy
równania, oraz zmienne dla których chcemy otrzymać rozwiązania, używając
nawiasów klamrowych.
Solve[{x  y  1, x ‐ 2 y  2}, {x, y}]
4
x → 3
, y → − 13 
A oto nieco bardziej skomplikowany przykład z algebry liniowej:
8
Solve[{x  2 y ‐ z  2, x ‐ y  z  4, 2 x  y ‐ z  5},{x, y, z}]

x → 3, y → 0, z → 1
Funkcja Solve może mieć wiele interesujących zastosowań. Dla przykładu, punkty
przecięcia okręgu x 2  y 2  1 z prostą y  12 x  12 można otrzymać za pomocą
prostego polecenia,
Solve[{x^2y^21, yx/21/2}, {x, y}]
3 4
x → −1, y → 0, x → 5
,y → 5

Na zakończenie tego bardzo krótkiego wstępu do rozwiązywania równań z

programem Mathematica zauważmy pewną ważną rzecz. W każdym z powyższych
przypadków rozwiązania mają postać x → a. Jest to bardzo dogodne w sytuacji
pojedynczych przykładów, gdzie od razu widzimy jakie wartości otrzymujemy dla
poszczególnych niewiadomych. Jeśli jednak chcemy te wyniki wykorzystać w dalszych
obliczeniach to wygodniejsze byłoby otrzymanie ich w postaci listy, gdzie każdy
element jest wartością odpowiedniego rozwiązania. Inaczej mówiąc chcemy aby
wykonanie polecenia
Solve[{x2*y‐z2, x‐yz4, 2*xy‐z5},{x, y, z}]
dało nam wynik 3, 0, 1. To jednak wymaga zapoznania się ze zmiennymi i funkcjami w
programie Mathematica.
Ćwiczenia
Rozwiąż następujące równania lub układy równań w programie Mathematica.
1. x 2 − 49  0
2. x2  x − 6  0
3. 20x 2 − 31x − 9  0
4. x 2 − 3x − 1  0
5. x 2 − 6x  1  0
6. x 2  7x  9  0
7. x 2  y 2  4xy − 1  0, rozwiąż ze względu na zmienną x, a następnie jeszcze raz
ze względu na y.
8. x 3 − x 2  x  1  0
9. x − 2y  7 i x 2  4y 2  37
10. x  y  1 i 16x 2  y 2  65
11. y − x  a i 2x 2  xy  y 2  8
9
Mirosław Majewski
1.3 Zmienne
Każdemu obiektowi w programie Mathematica możemy przyporządkować jakąś
zmienną, lub inaczej mówiąc możemy mu nadać nazwę. W takim przypadku zamiast
za każdym razem wpisywać cały obiekt, np. system równań, łatwiej będzie posłużyć
się jego nazwą. Oto jak to wygląda w przypadku równań.
Nasz układ równań otrzymuje nazwę równania. Zauważmy, że nazwa może zawierać
specyficzne polskie litery. Niestety system w którym edytuję ten tekst nie pozwala mi
na to.
rownania  {x  y  1, x ‐ 2 y  2}
x  y  1, x − 2y  2
Teraz nazywamy nasze zmienne i dokładamy średnik na końcu polecenia, aby
Mathematica nie wyświetlała niepotrzebnego na ekranie wyniku.
zmienne  {x, y};
Po tych nazwaniach możemy rozwiązać system równań bez wypisywania od nowa
równań i zmiennych.
rozwiazania  Solve[rownania, zmienne]
4
x → 3
, y → − 13 
4
Otrzymany wynik jest zbiorem/listą zawierającym listę z dwu reguł x → 3
oraz
y → − 13 . Naszym zadaniem będzie wyłuskanie z tego liczb 43 oraz − 13 .
W programie Mathematica mamy operację podstawiania. Działa ona w następujący
sposób, polecenie
f(x)/. x‐a
zamieni w f(x) wszystkie wystąpienia zmiennej x na a. Możemy więc zastosować je
do pojedynczej zmiennej, pary zmiennych, lub innej struktury zwierającej zmienną x.
Oto jak to wygląda w naszym przypadku,
r1  x /. rozwiazania
4
3
r2  y/. rozwiazania
− 13
A następnie odrzucamy zbędne nawiasy klamrowe,

r1  r1[[1]]
4
3
10
r2  r2[[1]]
− 13
Teraz możemy już bez problemu operować naszymi rozwiązaniami dalej, np.
r1‐r2
5
3
Polecenia z podwójnym nawiasem kwadratowym mogą się wydawać dziwne, ale w

gruncie rzeczy łatwe do wyjaśnienia. Symbol [1] oznacza indeks czyli pozycję
elementu na liście, natomiast zewnętrzny nawias [ ] jest niczym innym jak nawiasem
wewnątrz, którego wpisujemy argument [1]. Mamy tu więc jakby operację listy lub
zbioru na argumentach. Oto nieco szerszy przykład pokazujący jak to działa.
Tworzymy listę A, a następnie wybieramy z niej jeden z elementów, w naszym
przykładzie jest to element czwarty.
A  {1, 2, 3, 4, 5}^2  11
12, 15, 20, 27, 36
A[[4]]
27
Przyjrzyjmy się jeszcze przez moment jak działa operacja podstawiania w nieco
bardziej złożonej sytuacji. Polecenie
rozw  Solve[{x^2  y^2  1, y  x/2  1/2}, {x, y}]
daje nam nieco bardziej skomplikowaną strukturę
3 4
x → −1, y → 0, x → 5
,y → 5

Załóżmy, że chcemy jednocześnie wydobyć z niej wszystkie rozwiązania. W tym celu

używamy nowej zmiennej u i jej przypisujemy otrzymane rozwiązania.
u  {x, y} /. rozw
−1 0
3 4
5 5
To co otrzymaliśmy jest już macierzą, ale i w jej przypadku mamy dostęp do każdego
elementu,
x1  u[[1, 1]]
−1
x2  u[[2, 1]]
3
5
y1  u[[1, 2]]
0
11
Mirosław Majewski
y2  u[[2, 2]]
4
5
Teraz należy tylko zapamiętać, że pierwszy numer w parze [n,m] oznacza wiersz
macierzy, a drugi kolumnę, w której znajduje się dane rozwiązanie. Kolumny
zazwyczaj odpowiadają kolejnym zmiennym x, y, itd., numery wierszy są numerami
poszczególnych par (trójek, itd.) rozwiązań.
Ćwiczenia
Wpisz deklaracje następujących wyrażeń
1. pierwiastek x 1
2. drugiPierwiastek 2
1
1x− x
3. wielomian 3x 3  2x 2  x  1
4. ułamki b  1 1  1  1
a x b  a1 1 c 1
1
x
b a 1x
5. dużoPierwiastków a a a a x
1.4 Funkcje
Funkcje i relacje są istotą matematyki. Używamy ich w każdej dyscyplinie
matematycznej. Możemy je również definiować w programie Mathematica. Oto kilka
przykładów
Tak definiujemy funkcje jednej zmiennej
f[x_] : x^2  3 x  2
g[x_] : 2 Sin[3 x]  3 Cos[5 x]
A tak ich używamy w naszych dalszych obliczeniach,
f[a  1]
a  1 2  3a  1  2
g[Pi/4]
3
2 −
2
Zwróćmy uwagę na kilka istotnych rzeczy w tych deklaracjach. W naszych

przykładach po lewej stronie mamy litery f lub g. Są to nazwy naszych funkcji.
Możemy mieć tu dowolne inne nazwy. Wybierając nazwy dla naszych funkcji, lub
zmiennych, warto przestrzegać pewnych konwencji. Ponieważ wszystkie funkcje w
12
programie Mathematica zaczynają się od dużej litery to, dla odróżnienia, powinniśmy
zaczynać nasze funkcje od małych liter. Zazwyczaj, jeśli nie prowadzi to do
niepotrzebnych komplikacji, używamy nazw bardzo krótkich. Jeśli z jakiegoś powodu
nazwa funkcji musi być bardziej opisowa wówczas używamy jednego słowa lub kilku
połączonych w odpowiedni sposób, np. poleDwuOkregow. Jak widzimy nazwa zaczyna
się od małej litery, ale każde kolejne słowo już od dużej.
W deklaracji funkcji zmienna, lub zmienne, po lewej stronie mają znak podkreślenia.
Są to zmienne, za które możemy podstawić dowolne wyrażenia. Wreszcie symbol :
powoduje, że wyrażenie po prawej stronie pozostanie bez wartości w momencie
deklaracji, a jego wartość za każdym razem zostanie wyliczona od nowa w zależności
od wartości jakie podstawimy za zmienne.
Oto kilka innych przykładów deklaracji funkcji i ich użycia,
h[x_, y_] : 3 x^5  2 x^3
h[11, 23]
485815
s[x_, y_, n_] : Expand[(x  y)^n]
s[a, b, 5]
a 5  5a 4 b  10a 3 b 2  10a 2 b 3  5ab 4  b 5
Podany tu sposób deklaracji funkcji pozwala również na łatwe deklaracje funkcji
rekurencyjnych. Oto jak możemy szybko utworzyć sobie deklarację funkcji
rekurencyjnej produkującej wyrazy ciągu Fibonacciego.
Zaczynamy od deklaracji dwu pierwszych wyrazów,
fibo[1]  1;
fibo[2]  1;
i dalej deklaracja już całej funkcji,
fibo[n_] : fibo[n ‐ 1]  fibo[n ‐ 2]
Teraz możemy wyliczyć dowolny wyraz ciągu Fibonacciego.
fibo[17]
1597
Tak zdefiniowana funkcja rekurencyjna nie jest zbyt szybka i ma ograniczenia
odnośnie liczby kroków rekurencji, dlatego powinna być stosowana raczej dla małych
wartości argumentu. Bardziej efektywna metoda deklaracji funkcji rekurencyjnych
pojawi się przy innej okazji.
Na zakończenie omawiania deklaracji funkcji warto wspomnieć jak można szybko
utworzyć pewną liczbę wyrazów ciągu mając jego wzór. Dla przykładu pierwsze 15
wyrazów ciągu Fibonacciego utworzymy za pomocą następującego polecenia.
13
Mirosław Majewski
Table[fibo[n],{n, 1, 15}]
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610
1.4.1 Problemy z deklaracjami

Notatnik, w którym pracujemy przez dłuższy czas, może w pewnym momencie zacząć
sprawiać nam kłopoty. Są to najczęściej problemy wynikające z istnienia, już
niepotrzebnych, starych deklaracji. Oto przykład, pokazujący jak ten mechanizm
działa. Deklarujemy dwie zmienne x i y przypisując im odpowiednio wartości 1 i 2.
x1;
y2;
W tej sytuacji wykonanie polecenia, w którym występują x i y zastępuje te zmienne
ich aktualnymi wartościami, np.
xy
3
Dalej możemy zadeklarować funkcję używającą symboli x i y. Tu jeszcze nic złego się
nie dzieje.
f[x_] : x^2  3 x ‐ 1
Natomiast jeśli w tym momencie zechcemy sprawdzić jak nasza funkcja wygląda, lub
użyć jej do zbudowania bardziej złożonej funkcji, to już zaczyna działać istnienie
deklaracji dla x.
f[x]  2 f[x]^2
21
Mogą nas np. spotkać takie niespodzianki jak ta poniżej,
Solve[f[x] 0, x]
General::ivar: 1 is not a valid variable 
Solve[False,1]
Otrzymaliśmy tutaj komunikat informujący nas o błędzie oraz wynik, który nie ma dla
nas już większego znaczenia. Aby uniknąć takich niespodzianek warto od czasu do
czasu zlikwidować stare deklaracje i uwolnić zmienne, których najczęściej używamy.
Polecenie Clear[x] uwolni zmienną x od jej aktualnej wartości. Polecenie
Clear[x,y] zrobi to samo ale dla obu zmiennych. Mamy zatem,
Clear[x]
i dalej już wszystko działa jak tego oczekujemy.
Solve[f[x]  0, x]
1 1
x→ 2
−3 − 13  , x → 2
 13 − 3
14
Ćwiczenia
Napisz deklaracje poniżej wymienionych funkcji, a następnie wylicz ich wartości dla
x  2 oraz x  3 .
1. fx  1  2x  1
2. gx  1
2
3x − 3x  5
3. hx  x 4  2x 2  4
4. Frx  1 1  1
1 1
1− x 1 1− 1x
5. Rtsx  x − 2x  3x − 4x  x
1.5 Operacje na wyrażeniach matematycznych

Jednym z najbardziej podstawowych elementów pracy w matematyce jest
przekształcanie wyrażeń algebraicznych i trygonometrycznych. Mamy tu do czynienia
z rozkładaniem i zwijaniem wielomianów, upraszczaniem funkcji wymiernych i
wieloma innymi operacjami zaliczanymi często do matematyki elementarnej. W tym
krótkim rozdziale omówimy pewne podstawowe procedury występujące w programie
Mathematica.
Na początek zadeklarujmy sobie wielomian A, a następnie zobaczmy co Mathematica
może z nim zrobić.
A  (x ‐ 3)^2*(x ‐ 1)^3*(x ‐ 5)
x − 5x − 3 2 x − 1 3
Teraz możemy rozwinąć nasz wielomian,
B  Expand[A]
x 6 − 14x 5  75x 4 − 196x 3  263x 2 − 174x  45
Otrzymany wynik możemy zwinąć do postaci wyjściowej,
Factor[B]
x − 5x − 3 2 x − 1 3
Mathematica uprości większość elementarnych wyrażeń matematycznych,
Simplify[Sin[2*x]^2  Cos[2*x]^2]
1
15
Mirosław Majewski
Simplify[Sin[3*x] * Cos[3*x]]
1 sin6x
2
Simplify[Exp[x]*Exp[3*x]‐Exp[x]*Exp[2*x]]
e 3x e x − 1
Mathematica może również uprościć dowolne wyrażenie korzystając z podanych jej
założeń. Tu, dla przykładu, pokazujemy jak uprościć wyrażenie uwzględniając znak
zmiennej występującej w wyrażeniu.
Simplify[Sqrt[x*(Sqrt[x]  x)^2]]
xx  x  3
To samo polecenie, ale z dodatkowym założeniem x  0 daje zupełnie inny wynik.

Simplify[Sqrt[x*(Sqrt[x]  x)^2], x  0]
x 3/2  x
Na zakończenie zajmijmy się jeszcze przez chwilę wielomianami. Oto wielomian dwu
zmiennych Px, y  xy  axy  x 2 y − axy 2  x  ax. Wielomian ten może być zwinięty
względem dowolnej zmiennej w nim występującej lub względem wszystkich
zmiennych. Oto jak to wygląda w praktyce.
P  x*y  a*x*y  x^2*y ‐ a*x*y^2  x  a*x
−axy 2  axy  ax  x 2 y  xy  x
Teraz w zależności od potrzeb używamy procedury Collect z odpowiednim
parametrem.
Collect[P, x]
x−ay 2  ay  a  y  1  x 2 y
Collect[P, y]
yax  x 2  x − axy 2  ax  x
Collect[P, {x, y}]
x−ay 2  a  1y  a  1  x 2 y
W rachunku całkowym jak i w algebrze przekształcamy czasem wyrażenia wymierne
do postaci tzw. ułamków prostych, czyli sumy wyrażeń wymiernych, w których
mianownik jest wielomianem nierozkładalnym, co najwyżej stopnia drugiego, a
licznik jest wielomianem stopnia zerowego, lub co najwyżej pierwszego. W programie
Mathematica rozkładanie wyrażeń wymiernych na ułamki proste wykonujemy za
pomocą procedury Apart. Zacznijmy, zatem od zadeklarowania wyrażenia
wymiernego a następnie zobaczmy, co z niego otrzymamy za pomocą procedury
Apart.
16
w  x^2/(x^3 ‐ 3*x  2)
x2
3
x − 3x  2
Apart[w]
4  5  1
9x  2 9x − 1 3x − 1 2
Ćwiczenia
1. Rozwiń następujące wyrażenia:
a. 2x  3 2
b. 4x 2 − 1 2
c. x − 1 2 x − 3 4
d. x − 2x − 3 5 x − 4 2
e. 1  x n , dla n  2, 3, 4, 5.
2. Rozwiń następujące wyrażenia z funkcjami trygonometrycznymi:
a. sin x  cos x 3
b. 1  sin x 5
cos x
c. tanx  1
d. cotx 2  1
3. Zapisz w postaci iloczynu dwumianów:
a. 2x 2 − 3x 3
b. 4x 4 − 5x 2  1
c. 9x 2  21x  10
d. 6x 2 − 4x − 4x 3  x 4  1
e. 1 1x 1  1 1x 1
y1 2 2 1−y 2 2
4. Uprość następujące wyrażenia:
a. cos x sin y  cos y sin x
b. 5x  10x 2  10x 3  5x 4  x 5  1
c. 1 1x 1  1 1x 1
y1 2 2 1−y 2 2
5
1  3x
d.
1  3x3  9x
2 − 3
e.
2  3
5. Rozwiń na ułamki częściowe:
a. x7
x2 − x − 6
17
Mirosław Majewski
2
b. 50x3  20x 6
x  2x 2  x
1.6 Elementy analizy matematycznej

Różniczkowanie i całkowanie są podstawowymi czynnościami w analizie
matematycznej. Mamy tam jeszcze parę innych czynności, o których wspomnimy
dalej. Na początek zacznijmy od zdefiniowania wyrażenia wymiernego z jedną
zmienną x.
w  x^2/(x^3 ‐ x  1)
x2
3
x −x1
Teraz wyliczmy jego pierwszą pochodną,
D[w, x]
2x x 2 3x 2 − 1
−
x3 − x  1 x 3 − x  1
2
W podobny sposób możemy wyliczyć drugą pochodną i kolejne,

D[w,x,x]
6x 3 2 2x 2 3x 2 − 1 2 4x3x 2 − 1
−   −
x 3 − x  1 2 x3 − x  1 x 3 − x  1 3 x 3 − x  1 2
Oto inny przykład gdzie wyliczamy trzecią pochodną wyrażenia trygonometrycznego.
h  Sin[x]/(x  1)^2
sinx
x  1 2
D[h, x, x, x]
6 sinx 24 sinx cosx 18 cosx
3
− 5
− 2

x  1 x  1 x  1 x  1 4
Pochodne cząstkowe funkcji wielu zmiennych otrzymujemy w identyczny sposób jak
pochodne funkcji jednej zmiennej.
u  (Sin[x]  Cos[y])*(Cos[x] ‐ Sin[y])
sinx  cosycosx − siny
Teraz możemy wyliczyć drugą pochodna mieszaną.
D[u, x, y]
sinx siny − cosx cosy
Mathematica równie łatwo wylicza całki — zarówno oznaczone, jak i te nieoznaczone.
18
Integrate[x^2  3*x  1, x]
x 3  3x 2  x
3 2
Dotychczas przeprowadzaliśmy operacje na wyrażeniach matematycznych, te same
operacje możemy wykonywać na wcześniej zadeklarowanych funkcjach. Jest tu kilka
istotnych różnic, o których warto pamiętać.
Zacznijmy zatem od zadeklarowania funkcji.
f[x_] : 1/(1  x^3)
No, a teraz, skoro już zdefiniowaliśmy sobie funkcję, to możemy wyliczyć jej pochodną
i całkę. Mamy zatem pochodną,
D[f[x], x]
− 3x 2
x  1 2
3
całkę nieoznaczoną,
Integrate[f[x], x]
2x−1
tan −1
− 1 logx 2 − x  1  1 logx  1 
3
6 3 3
całkę oznaczoną w granicach od x  0 do x  5,
Integrate[f[x], {x, 0, 5}]
1  3   3 log 12   6 3 tan −1 3 3 
18 7
oraz całkę oznaczoną w granicach od zera do nieskończoności.
Integrate[f[x], {x, 0, Infinity}]
2
3 3
Inną czynnością na lekcjach rachunku różniczkowego jest znajdowanie granic funkcji i
ciągów. Na początek zajmijmy się granicami funkcji. Zbadajmy granice funkcji znanej z
poprzedniego przykładu, w dwu punktach, dla x  0, oraz dla x  −1, gdzie występuje
nieciągłość drugiego rodzaju.
f[x_] : 1/(1  x^3)
Dla x  0 dostajemy wynik bez większego problemu.
Limit[f[x], x ‐ 0]
1
Oto granica tej funkcji w punkcie x  −1 z lewej strony,
Limit[f[x], x ‐ ‐1, Direction ‐ 1]
−
19
Mirosław Majewski
a następnie granica tej samej funkcji z prawej strony

Limit[f[x], x ‐ ‐1, Direction ‐ ‐1]

Zauważmy jak określa się tu granice lewostronne i prawostronne. Kierunek określa
się tu od zera do punktu x  1 lub x  −1. Czyli granica lewostronna oznaczona jest
parametrem Direction ‐ 1, natomiast prawostronna parametrem Direction ‐
‐1.
Podobnie wyliczamy granice ciągów. Dla przykładu, granica ciągu e n  1  1/n n dla n
zmierzającego do nieskończoności ma postać,
e[n_] : (1  1/n)^n
Limit[e[n], n ‐ Infinity]
e
Zauważmy, że mogliśmy zadeklarować nasz ciąg używając małej litery e. To głównie
dlatego, że Mathematica używa dużych liter do oznaczania swoich stałych i procedur.
Ćwiczenia
Napisz polecenia deklarujące, a następnie obliczające, pochodne i całki podanych
poniżej funkcji.
1. y x3  x2  x  1

2. y 
sin x  cos x
3. y 
tan x  cot x
2
4. y e 1xx

5. y  1x
1  x  x2
1.7 Szukamy pomocy

Nazwy, a szczególnie mało znane nazwy poleceń języka programu komputerowego,
dość często ‘wylatują nam z głowy’. Tak jest również w przypadku nazw procedur jak
również składni poleceń w programie Mathematica. Warto zatem poznać parę
sposobów jak ustrzec się błędów.
Na początek przypomnijmy sobie pewne, już wcześniej poznane, rzeczy. Większość z
nich jest niezmiernie ważna dla początkującego użytkownika programu Mathematica.
1.7.1 Duże i małe litery

Wszystkie nazwy procedur i tzw. słów kluczowych w programie Mathematica
zaczynają się od dużej litery. Nazwy składające się z kilku słów pisane są w taki
20
sposób, że poszczególne słowa pisane są razem i każde z zaczyna się z dużej litery, np.
PlotStyle, ColorData, ControlType, itd. Jeśli deklarujemy nasze własne nazwy
zmiennych czy procedur to powinniśmy zaczynać je od małej litery aby odróżnić je od
tych już istniejących w programie.
1.7.2 Nawiasy
Mathematica używa różnych rodzajów nawiasów do zupełnie różnych celów.
Wpisanie złego nawiasu powoduje, że program nie rozumie naszego polecenia
poprawnie i nawet jeśli otrzymamy wynik to będzie on zły.
1. Nawiasy kwadratowe używane są do wpisywania argumentów poleceń czy
funkcji, np. Sin[x], Solve[x^2‐10,x]. Używamy ich również do
oznaczania indeksów wyrazów w ciągach lub bardziej złożonych strukturach.
2. Nawiasy klamrowe używane są do tworzenia list, np. {x,0,1}, {n, 1, 15},
itd.
3. Nawiasy okrągłe używane są do grupowania wyrażeń we wzorach, np.
(1x)^2, (Sin[x]/(Cos[x]1))^2
4. Nawiasy okrągłe z gwiazdką są ignorowane przez program, a zatem mogą
służyć jako komentarz, np. (* A ten tekst nic nie znaczy *). Taki
fragment wpisany na obszarze dowolnego polecenia Mathematica zignoruje.
5. /. jest używany w celu zastosowania określonych reguł do wyrażenia po
prawej stronie, np. x^2 /. x‐5 podstawi wartość 5 w wyrażeniu x^2.
Zauważmy przy tym, że to podstawienie jest tymczasowe. Jeśli za chwilę
zechcemy użyć zmiennej x to okaże się, że ma ona ciągle swoją dotychczasową
wartość.
6. // pozwala otrzymać wartość wyrażenia po lewej stronie przekształconego
funkcją użytą po prawej stronie, np. polecenie x^2  1  0 //Solve
spowoduje rozwiązanie równania po lewej stronie.
1.7.3 Równość nie jest równa równości

Podobnie jak w przypadku nawiasów, równości mogą być pisane na kilka sposobów i
za każdym razem będą spełniały inną rolę.
1. Znak równości "" używany jest do przypisania danej nazwie wartości, również
wyrażenia ze zmienną, np. A1, Bx^25. Wyrażenie po lewej stronie jest tylko
etykietą wyrażenia po prawej stronie. Nie jest ono funkcją w żadnym
przypadku. Dlatego nie możemy takiego wyrażenia użyć w postaci A[x] czy
A[2.5].
2. Znak podwójnej równości używany jest jako symbol relacji równości, np.
x^2‐1x. Używamy go miedzy innymi do konstruowania równań.
21
Mirosław Majewski
3. Znak ":" używany jest do deklarowania funkcji, np. f[x_] : 1/(1  x^3).
W takim przypadku wyrażenie po lewej stronie jest nazwą funkcji, zmienna z
podkreśleniem jest zmienną, za którą możemy podstawiać wartości, wyrażenie
po prawej stronie jest definicją naszej funkcji.
1.7.4 Kolor ma też jakieś znaczenie

Pisząc nawet proste polecenia w programie Mathematica zauważyliśmy, że dość
często zmienia się kolor poszczególnych elementów polecenia.
1. Niebieski kolor oznacza zawsze wyrażenia nieznane w danym momencie w
programie. Dla przykładu wpisując zmienną x lub słowo solve Mathematica
wyświetli je na niebiesko. Dlatego, jeśli coś wyświetla się nam na niebiesko
powinniśmy zastanowić się, czy jest tam błąd i jaki. Zmienne wolne, czyli takie,
które nie mają przypisanej wartości powinny być zatem niebieskie.
2. Kolor czarny zawsze oznacza wyrażenia znane programowi Mathematica, w
tym zmienne wyświetlane na czarno są zmiennymi z przypisanymi już
wcześniej wartościami. Dla przykładu podczas wpisywania słowa Solve
Mathematica wyświetla je na niebiesko aż do momentu, gdy wpiszemy ostatnią
literę. Po wpisaniu ostatniej litery słowo Solve będzie już wyświetlone na
czarno. Inny przykład, zmienna x po wykonaniu polecenia przypisującego jej
jakąś wartość, np. x2 będzie wyświetlona na czarno. Wartość przypisaną
zmiennej możemy usunąć za pomocą polecenia Clear, np. Clear[x],
Clear[x,y], itd.
3. Nawiasy bez pary są wyświetlane kolorem zbliżonym do różowego.
Natychmiast po zamknięciu danej pary nawiasów ich kolor zmieni się na
czarny.
1.7.5 Pomoc w programie

Mathematica posiada dość bogaty system pomocy. Wiele rzeczy znajdziemy w menu
Help. Tu najczęściej przeszukiwaną opcją jest tzw. Function Navigator. Tu znajdziemy
listę wszystkich procedur programu Mathematica pogrupowanych tematycznie. Po
wybraniu tematu, a następnie odpowiedniej procedury dostaniemy szczegółową
informację o procedurze oraz wiele interesujących przykładów zastosowania
procedury. Każdy z tych przykładów może być skopiowany do naszego notatnika i
użyty do naszych eksperymentów. Rysunek 1.1 pokazuje pomoc dla procedury Plot.
22
Rys 1.1 Nawigator funkcji w programie Mathematica

W wielu przypadkach, gdy składnia naszych poleceń odbiega od poprawnej,
Mathematica wyświetla komunikat informujący co jest źle w naszym poleceniu.
Komunikat zakończony jest znakiem , który jest odnośnikiem do odpowiedniego
miejsca w pomocy. Dla przykładu polecenie
Plot[x^2, {}]
spowoduje wyświetlenie komunikatu
Plot::pllim: Range specification {} is not of the form {x, xmin, xmax}. 
Wciśnięcie  skieruje nas do odpowiedniej strony w pomocy, gdzie jest
dokładniejsza informacja dotycząca naszego problemu.
Wreszcie na koniec warto wspomnieć o użytecznym skrócie do systemu pomocy.
Przypuśćmy, że znamy nazwę procedury, lub się jej domyślamy, której chcemy użyć,
ale nie pamiętamy dokładnie składni polecenia dla tej procedury. W takim przypadku
wpisujemy ? i nazwę procedury lub słowa kluczowego. Dla przykładu, załóżmy że
chcemy otrzymać wykres funkcji cos x, cos x 2 , cos x 3 oraz cos x 4 i domyślamy się, że
procedura wykonująca ten wykres może mieć nazwę Plot lub coś w tym rodzaju.
Wpisując polecenie ?Plot otrzymamy szczegółową informację jak napisać polecenie
wykonujące wykres naszych funkcji. Tu, na stronie pomocy zauważymy interesujący
wykres, na którym obszar pod funkcją jest wypełniony kolorem szarym i odbywa się
to za sprawą parametru Filling. Kolejne polecenie ?Filling pokaże nam
dokładniej jak zastosować ten parametr i dalej już możemy samodzielnie napisać
polecenie wykonujące nasz wykres.
23
Mirosław Majewski
Plot[{Cot[x],Cot[x^2],Cot[x^3],Cot[x^4]}, {x,‐Pi,Pi},Filling ‐ Axis]
No i w ten sposób doszliśmy do wykresów w programie Mathematica, a to już jest

tematem następnego rozdziału.
Ćwiczenia
Znajdź w pomocy programu Mathematica informację o poniżej wymienionych
procedurach. Napisz kilka poleceń ilustrujących działanie tych procedur.
TrigExpand
PowerExpand
TrigReduce
24
2
Grafika 2D w programie Mathematica
Jednym z najważniejszych zastosowań CAS jest wizualizacja matematyczna.
Możliwość precyzyjnego pokazania obiektów matematycznych na rysunku jest tym
czego brakowało w tradycyjnych narzędziach matematycznych. Program Mathematica
posiada bardzo interesujące możliwości graficzne. Mamy tu nie tylko bogactwo
procedur do wykresów funkcji, zarówno tych w 2D jak i 3D, ale również bardzo
interesujące rozwiązania do wizualizacji obiektów złożonych, które nie są wyrażone
za pomocą funkcji. Nasz przegląd zaczniemy od grafiki na płaszczyźnie i skupimy się
na tych rodzajach wykresów, które mają znaczenie w nauczaniu matematyki.
Najprostsza forma polecenia wykonującego wykres funkcji ma postać:
Plot[Funkcja[x],{x,xmin,xmax}]
Podstawą polecenia jest bardzo uniwersalna funkcja Plot. W nawiasie kwadratowym
mamy wymienioną funkcję. Jest to albo wyrażenie ze zmienną, albo nazwa wcześniej
zdefiniowanej funkcji. Dalej następują parametry. W najprostszym przypadku jest to
tylko, tak jak powyżej, deklaracja zakresu zmiennej względem której robimy wykres.
Mamy tu wymienioną zmienną, potem dolną granicę tej zmiennej, a następnie jej
górną granicę zgrupowane nawiasem kwadratowym. Oto prosty przykład,
Plot[x^2,{x,‐1,1}]
Jeśli zechcemy zrobić wykres kilku funkcji to grupujemy je, również nawiasem
klamrowym, w jeden obiekt, np.
Plot[{x,x^2,x^3,x^4},{x,‐1,1}]
W miarę przybywania parametrów, polecenie robiące wykres może się bardzo
skomplikować, ale o tym za chwile. Teraz zajmijmy się konkretami.
2.1 Wykresy funkcji jednej zmiennej

Na początek zajmiemy się wykresami funkcji i składnią poleceń do robienia wykresów
funkcji. Przypuśćmy zatem na początek, że mamy do czynienia z dość tajemniczo
wyglądającą funkcją fx  2 −x cos 10x . Użyjemy tej funkcji do kilku eksperymentów
pokazujących jak Mathematica może nam wykreślić i zmodyfikować wykres
odpowiednio do naszych potrzeb. Aby jakoś podkreślić fakt, że cały czas mamy do
czynienia z tą samą funkcją damy jej nazwę oscylator i dalej, w miarę potrzeby,
będziemy używać zawsze tej nazwy.
Mirosław Majewski
oscylator[x_] : 2^(‐x*Cos[10 Pi x])

Plot[oscylator[t], {t, 0, Pi}]
0.5 1.0 1.5 2.0 2.5 3.0
Skoro mamy już wykres funkcji oscylator, to możemy zobaczyć co się stanie jeśli
dołożymy do tego wykresu parę innych rzeczy, np. funkcje y  x, y  2 x , y  2 −x .
Plot[{oscylator[x], x, 2^(‐x), 2^(x)}, {x, 0, Pi}]
0.5 1.0 1.5 2.0 2.5 3.0
Tu Mathematica wykonała za nas parę czynności, których zakodowanie wymagałoby

trochę czasu. Mamy wykresy czterech funkcji, każda w innym kolorze. W druku,
wszystkie one będą niestety szare lub czarne. Patrząc na ten wykres, nawet ten
wydrukowany, możemy się jednak domyślić wielu rzeczy, np. linia u góry dotykająca
wierzchołków oscylatora jest wykresem funkcji y  2 x , linia dotykająca dolnych
wierzchołków wykresu jest wykresem funkcji y  2 −x , i wreszcie linia prosta
przecinająca wykres na ukos to y  x. Co jednak zrobić, gdy mamy mieszaninę
wykresów nakładających się na siebie? Rozwiązaniem są narzędzia Graphics Inspector
i Drawing Tools. Znajdziemy je wciskając prawy przycisk myszy na grafice i wybierając
dalej z menu. Pokazaliśmy je na załączonym rysunku 2.1.
26
Rys. 2.1 Drawing Tools i Graphics Inspector

Tu z łatwością zauważymy, że panel Drawing Tools zawiera bardzo podobne narzędzia,
jak te w prostych programach do rysowania na komputerze. Mamy więc wybieranie
poszczególnych elementów wykresu, dorysowywanie linii, strzałek, prostokątów,
okręgów, wielokątów, itp. Graphics Inspector pozwala na pokolorowanie w
odpowiedni sposób wybranych elementów, nadanie im odpowiedniej grubości linii,
itp. Mając te narzędzia możemy z łatwością uzupełnić wykres odpowiednimi
napisami, strzałkami, i innymi rzeczami.
Na rysunku 2.2 pokazujemy jeszcze raz nasz wykres, ale z licznymi poprawkami i
dodatkami. Wzory tu widoczne zostały utworzone odpowiednimi poleceniami w
programie, a następnie skopiowane na wykres. Zauważmy również, że przy edycji
wzorów na wykresach bardzo użyteczna może być paleta Writing Assistant. No i
jeszcze jedna ważna sprawa, jeśli zechcemy ponownie wykonać polecenie, które nam
wykonało ten wykres, to w odróżnieniu od paru innych programów CAS, nic złego się
nie stanie. Nowy wykres zostanie wykonany, ale ten z poprawkami zostanie dalej w
notatniku. W ten sposób możemy wykonać serię rysunków, a następnie wybrać ten
optymalny dla nas.
Uwaga techniczna Zarówno ta, jak i inne ilustracje na dalszych stronach tego tekstu, zostały
zapisane bezpośrednio z programu Mathematica jako pliki wektorowe EPS. W pewnych
przypadkach, gdy grafika była bardzo skomplikowana z licznymi przezroczystymi
wypełnieniami, wykres był zapisany jako TIF (format rastrowy). W każdym przypadku
wciśnięcie prawego guzika myszy na rysunku do zapisania pokazuje menu gdzie wybieramy
Save Graphics as i dalej wybieramy odpowiedni format dla naszego pliku graficznego.
27
Mirosław Majewski
8
2.466, 2.453
x cos 10 x
2
6
y 2x
4
y=x
0.5 1.0 1.5 2.0 2.5 3.0
Rys. 2.2 Wykres po poprawkach z użyciem narzędzi

Po zapoznaniu się z narzędziami do modyfikacji grafiki, możemy przystąpić do
systematycznego przeglądu poleceń graficznych i ich parametrów.
2.2 Wybrane parametry użyteczne w wykresach 2D

Parametry w poleceniach wykresów przychodzą zawsze po deklaracji zakresu
zmiennej, względem której robimy wykres. Możemy tu mieć dwie grupy parametrów
– te dotyczące ogólnego kształtu wykresu oraz te dotyczące poszczególnych funkcji
jakie wykreślamy. Jeśli wykreślamy kilka funkcji na raz to parametry każdej z nich
powinny być zgrupowane nawiasem klamrowym. W takim przypadku, polecenia
grafiki robią się dość rozbudowane i skomplikowane. Możemy zapobiec temu dzieląc
polecenie na kilka linii. Efekt ten uzyskamy wciśnięciem klawisza [Enter] w miejscu
gdzie chcemy podzielić nasz kod. Struktura takiego polecenia może wyglądać jak
poniżej.
Plot[{f1[x],f2[x],f3[x]},{x,a,b},
PlotStyle‐{
{parametry dla funkcji f1},
{parametry dla funkcji f2},
{parametry dla funkcji f3}
},
parametr ogolny wykresu,
inny parametr ogolny wykresu,
jeszcze inny parametr ogolny wykresu
]
Jeśli mamy wykres tylko jednej funkcji to sytuacja się znacznie upraszcza, znikają nam
pewne nawiasy klamrowe.
28
2.2.1 Proporcje i zakres wykresu

Wprawdzie już w momencie pisania polecenia Plot musimy zadeklarować zakres
zmiennej dla której robimy wykres, ale ciągle jeszcze pozostają wartości funkcji, które
też czasem chcemy jakoś ograniczyć lub powiększyć. Robimy to za pomocą parametru
PlotRange‐{y‐min,y‐max}
W pewnych sytuacjach możemy sobie uprościć zadanie podając parametr
PlotRange‐liczba, i w takim przypadku wykres jest robiony od ‐liczba do
liczba. Oto jak to wygląda w przypadku wykresu funkcji oscylator i jej dodatków.
Plot[{oscylator[x], x, 2^(‐x), 2^(x)}, {x, 0, Pi},
PlotRange ‐{0, Pi}
]
3.0
2.5
2.0
1.5
1.0
0.5
0.0 0.5 1.0 1.5 2.0 2.5 3.0
Wielokrotnie wykresy otrzymane w CAS mają zniekształcone proporcje jednostek

jednej osi w stosunku do drugiej osi. Jest to spowodowane tym, że programy CAS
starają się wykonać rysunek jak najbardziej użyteczny do dalszych zastosowań –
najczęściej do drukowania. Dla przykładu, czytelnik może z łatwością zauważyć, że
każdy z wykresów w tym rozdziale ma inne długości jednostek na osi OX i osi OY.
Możemy tego z łatwością uniknąć deklarując w odpowiedni sposób AspectRatio.
PlotRange ‐ {0, Pi},
AspectRatio ‐ Automatic
]
29
Mirosław Majewski
3.0
2.5
2.0
1.5
1.0
0.5
0.0 0.5 1.0 1.5 2.0 2.5 3.0
Tu otrzymaliśmy wykres w którym jednostki na każdej osi mają tę samą długość. Inne
wartości AspectRatio powodują otrzymanie wykresów o specyficznych proporcjach
wymiarów.
Parametr AspectRatio proporcje wykresu

AspectRatio ‐ Automatic osie mają równe jednostki
AspectRatio ‐ 1 1:1
AspectRatio ‐ 3/4 4:3 (jak ekran TV)
AspectRatio ‐ a/b b:a
2.2.2 Osie układu współrzędnych, siatka i ramka

W licznych przypadkach zachodzi potrzeba dokonania zmian w tym jak wykreślane są
osie układu współrzędnych, dołożenia do wykresu siatki czy ramki.
Siatkę dla naszego wykresu możemy zdefiniować bardzo precyzyjnie podając punkty,
gdzie powinny wystąpić linie siatki, np. tak
GridLines ‐ {{1, 2, 3}, {0.5, 1, 1.5, 2, 2.5, 3}}]
Tu pierwszy nawias klamrowy zawiera przecięcia się linii siatki z osią 0X, drugi
nawias przecięcia się siatki z osia 0Y. A oto całe polecenie i otrzymany wykres.
PlotRange ‐ {0, Pi},
AspectRatio ‐ 3/4,
GridLines ‐ {{1, 2, 3}, {0.5, 1, 1.5, 2, 2.5, 3}}
]
30
3.0
2.5
2.0
1.5
1.0
0.5
0.0 0.5 1.0 1.5 2.0 2.5 3.0
Jeśli nie zależy nam na dokładnym manipulowaniu liniami siatki to sama deklaracja
GridLines ‐ Automatic
powinna zupełnie wystarczyć. Tu warto zwrócić uwagę na to, że deklaracja siatki może być
bardzo skomplikowana. Możemy zadeklarować grubość linii siatki, ich kolory, rodzaj linii,
itp. To zagadnienie zostawiamy czytelnikom do samodzielnych eksploracji.
Deklaracja osi układu współrzędnych może być równie bogata w szczegóły jak w
przypadku parametru GridLines. My zostaniemy przy kilku najważniejszych
opcjach.
W nielicznych przypadkach może być konieczne usunięcie osi układu współrzędnych
z wykresu. Są to na ogół przypadki, kiedy bardziej istotna jest artystyczna wartość
wykresu niż jego dokładność. Oto nasz oscylator bez osi układu współrzędnych,
oscylator[x_] : 2^(‐x*Cos[10 Pi x])
Plot[oscylator[t], {t, 0, Pi},
Axes ‐ False
]
31
Mirosław Majewski
Wykres w takiej postaci nie daje zbyt dużo informacji, ale może znakomicie służyć do
sprawdzenia wiedzy studentów czy uczniów. Dajmy im taki wykres wraz z
równaniem funkcji, i poprośmy, aby dorysowali do tego układ współrzędnych i
jednostki na osiach.
W przypadku bardzo skomplikowanych wykresów możemy chcieć wykreślić je z
ramką, skalą dookoła i siatką. Oto przykład takiego wykresu,
Plot[oscylator[t], {t, 0, 3 Pi},
Frame ‐ True,
GridLines ‐ Automatic
]
30
25
20
15
10
0
0 2 4 6 8
2.2.3 Styl wykresów w 2D

Każda z wykreślanych krzywych może być wykreślona z domyślnymi parametrami
lub specyficznymi parametrami przez nas zdefiniowanymi. Mamy tu szczególne
bogactwo możliwości – kolory, grubość, rodzaj linii, rodzaj i kolor wypełnienia, itd.
Większość tych efektów uzyskamy poprzez zadeklarowanie odpowiedniej listy
parametrów zwanych PlotStyle. W przypadku wykresu tylko jednej funkcji jest to
dość prosta sprawa, deklarujemy odpowiednie parametry i grupujemy je w nawiasie
klamrowym, tak jak poniżej,
Plot[oscylator[t], {t, 0, 2 Pi},
PlotStyle ‐ {Red, Dotted, Thick}
]
32
12
10
1 2 3 4 5 6
Deklaracja stylu wykresów w przypadku kilku funkcji jednocześnie nieco się

komplikuje. Wróćmy więc na chwilę do wykresu gdzie mieliśmy do czynienia z
kilkoma funkcjami jednocześnie. Tu deklarujemy w zakresie jednego PlotStyle
parametry dla każdej z funkcji w osobnym nawiasie klamrowym, a następnie
zawijamy te nawiasy klamrowe w grupujący je kolejny nawias klamrowy. Poniżej
pokazany kod pokazuje jak to można zrobić. Przypominam, podział kodu na
poszczególne linie uzyskujemy za pomocą klawisza [Enter]. Wcięcia w tym kodzie nie
są konieczne, ale pozwalają nam rozróżnić poszczególne fragmenty deklaracji.
Plot[{oscylator[x], x, 2^(‐x), 2^x}, {x, 0, Pi},
PlotStyle ‐ {
{Red, Thin}, (* parametry dla funkcji oscylator *)
{Blue, Dashed, Thick}, (* parametry dla funkcji yx *)
{Orange, Thick}, (* parametry dla funkcji 2^(‐x) *)
{Green, Thick} (* parametry dla funkcji 2^x *)
}
]
0.5 1.0 1.5 2.0 2.5 3.0
33
Mirosław Majewski
Jeśli zależy nam na bardziej specjalnych kolorach, czy niestandardowej grubości linii,
to możemy deklarować te rzeczy samodzielnie, ale to wymaga trochę eksperymentów.
Zauważmy jeszcze jedną istotną własność wykresów w programie Mathematica.
Poszczególne krzywe układane są na wykresie jako kolejne warstwy. Wykres
pierwszej funkcji będzie na spodzie, wykres drugiej funkcji na niej, itd. To sprawia, że
grube linie umieszczone w górnej warstwie wykresu będą przykrywały to co poniżej.
To oczywiście jest łatwo naprawić poprzez ustalenie odpowiedniej kolejności funkcji
w deklaracji Plot. Oto przykład, w którym łączymy te wszystkie rzeczy jednocześnie.
Plot[{x, 2^x, 2^(‐x), oscylator[x]}, {x, 0, Pi},
PlotStyle ‐ {
(* parametry dla funkcji yx *)
{RGBColor[0.6, 0.6, 0.8], Dashed, Thickness[0.05]},
(* parametry dla funkcji 2^x *)
{RGBColor[0.1, 0.8, 0], Thickness[0.02]},
(* parametry dla funkcji 2^(‐x) *)
{RGBColor[0.1, 0, 0.8], Thick},
(* parametry dla funkcji oscylator *)
{Red, Thin}
},
(* Tu zaczynaja sie parametry ogolne wykresu *)
GridLines ‐ Automatic, Frame ‐ Automatic
]
0
0.0 0.5 1.0 1.5 2.0 2.5 3.0
W ostatnim wykresie pojawiły się dwa nowe elementy: kolor RGB i grubość linii
zadane liczbami. Kolor definiujemy za pomocą trzech lub czterech liczb. Są to
składniki koloru – czerwony, zielony, niebieski i przezroczystość. Każdy z tych
składników reprezentujemy liczbą z przedziału [0,1], gdzie 0 interpretujemy jako
brak danego składnika, a 1 jako pełne nasycenie danym składnikiem koloru. W
przypadku przezroczystości jest odwrotnie, 0 oznacza kolor kompletnie
przezroczysty, natomiast 1 pozbawiony kompletnie przezroczystości. Nas interesują
wartości pośrednie.
34
Grubość linii zadeklarowana jako Thickness[0.002] jest bliska temu co określane

jest jako Thin, Thickness[0.004] oznacza już zdecydowanie grubsze linie.
Zanim przejdziemy do poszczególnych rodzajów wykresów zajmijmy się przez
moment dekoracjami wykresu. Mam tu na myśli kolorowe wypełnienia, tło dla
wykreślanych krzywych i pewnie parę innych podobnych rzeczy.
Plot[oscylator[t], {t, 0, Pi},
PlotStyle ‐ {Red, Thin},
Filling ‐ 1,
Background ‐ RGBColor[0.84, 0.95, 0.84]
]
Wypełnienia okolic wykresu mogą być w pewnym zakresie kontrolowane przez

użytkownika. Możemy, dla przykładu zdecydować do jakiego poziomu wykres będzie
wypełniany, np. do osi, do górnej granicy wykresu, lub do dolnej granicy wykresu.
Odpowiada to parametrom Axis, Top, Bottom. Poniżej pokazujemy wykres
wypełniony do górnej granicy wykresu.
35
Mirosław Majewski
Zdarza się, że wykonujemy wykresy, na których mamy kilka funkcji wypełnionych. Tu

zdając się na domyślne parametry uzyskujemy czasem bardzo interesujące wykresy.
Oto jeden z nich. W tym przypadku rezygnujemy na chwilę z naszej funkcji
oscylator na rzecz paru funkcji trygonometrycznych. Przy okazji zastosujemy prosty
parametr dodający etykietę do wykresu (PlotLabel).
Plot[
{Cos[x],Cos[2 x],Cos[3 x],Cos[4 x],Cos[5 x]}, {x, ‐Pi, Pi},
Filling ‐ Axis,
PlotLabel ‐ "Funkcje" Cos[nx]
]
Uwaga techniczna Dotychczas prezentowane w tym dokumencie wykresy były zapisywane jako
pliki EPS a następnie importowane do tekstu. W przypadku wykresów z wypełnieniami
pojawiały się zniekształcenia kolorów. Wobec czego ostatnie trzy wykresy zapisane zostały
jako pliki rastrowe TIF i dopiero takie wstawiane w tekst.
Ćwiczenia
1. Wykonaj wykres funkcji y  x sin x dla x  −1. . 1. Zastosuj parametr
PlotPoints ‐ 500 aby otrzymać dokładniejszy wykres? Zbadaj jak działa
parametr PlotPoints dla bardzo małych wartości, np. 3, 5, 10.
2. Wykonaj wykresy następujących funkcji. Zmodyfikuj je tak, aby jak najlepiej
pokazać szczególne miejsca na wykresie.
a. y  1  cos26x
1x
b. y  sin 3x cos 5x
c. y  sin x2
1−x
2
d. y  1  2x − x
sin x  1
36
2.3 Wykresy krzywych parametrycznych

Teraz kiedy wiemy już co zrobić aby wykres wyglądał tak jak my tego chcemy,
możemy przyjrzeć się wykresom krzywych zadanych w postaci innej niż funkcyjna. Na
początek zajmiemy się krzywymi zadanymi równaniem parametrycznym, czyli
x, y  xt, yt. Do wykreślania takich krzywych mamy osobną procedurę
ParametricPlot. Reszta wygląda podobnie jak w przypadku wykresów funkcji. Oto
przykład takiego wykresu. Wykreślamy krzywą o równaniu
x, y  sin 3t  cos 5t, sin 2t  cos 7t, w zakresie parametru t ∈ 0, 2. Wykres jest z
ramką dookoła, z jasno‐żółtym tłem, a sama krzywa jest koloru czerwonego,
pogrubiona.
ParametricPlot[
{Sin[3 t]*Cos[5 t], Sin[2 t]*Cos[7 t]}, {t, 0, 2 Pi},
PlotStyle ‐ {Red, Thick},
Frame ‐ True,
Background ‐ LightYellow
]
1.0
0.5
0.0
0.5
1.0
1.0 0.5 0.0 0.5 1.0
Zauważmy że funkcje definiujące krzywą parametryczną zostały wymienione w

nawiasie klamrowym. Ponadto nowym elementem w tym wykresie jest kolor tła, tutaj
jasno‐żółty (LightYellow). Mathematica posiada niedużą listę nazwanych kolorów. Są
nimi: Red, Green, Blue, Black, White, Gray, Cyan, Magenta, Yellow, Brown, Orange,
Pink, Purple, oraz te same w wersji rozjaśnionej, czyli LightRed, LightGreen, itd.
Kolory możemy również definiować sami, jeśli tylko mamy taką potrzebę. Oto
przykład w którym używamy naszych własnych kolorów oraz mieszamy kilka
wykresów w jeden za pomocą procedury Show.
37
Mirosław Majewski
Na początek deklaracje naszych kolorów,

kawaZMlekiem  RGBColor[0.8789, 0.7578, 0.6289];
szczypiorek  RGBColor[0.5742, 0.6992, 0.2851];
storczyk  RGBColor[0.7539, 0.1914, 2187];
Teraz deklaracje obiektów do wykreślenia,
param1 : ParametricPlot[
{Sin[3 t]*Cos[5 t], Sin[2 t]*Cos[7 t]}, {t, 0, 2 Pi},
PlotStyle ‐ {storczyk, Thick},
Frame ‐ True,
AspectRatio ‐ 1
];
param2 : ParametricPlot[{Sin[t], Cos[t]}, {t, 0, 2 Pi},
PlotStyle ‐ {kawaZMlekiem, Thickness[0.05]}
];
param3 : ParametricPlot[{0.5 Sin[t], 0.5 Cos[t]}, {t, 0, 2 Pi},
PlotStyle ‐ {szczypiorek, Thickness[0.05]}
];
Zauważmy, każda z deklaracji zakończona jest średnikiem aby nie wykreślać
niepotrzebnie każdej z krzywej z osobna. Teraz wszystkie zadeklarowane krzywe
wykreślamy razem. Zauważmy jak kolejność wymieniania poszczególnych krzywych
w poleceniu Show wpływa na ostateczny wynik.
Show[param1, param2, param3]
1.0
0.5
0.0
0.5
1.0
1.0 0.5 0.0 0.5 1.0
38
Show[param2, param3, param1]

1.0
0.5
1.0 0.5 0.5 1.0
0.5
1.0
Wnioski wypływające z ostatnich dwu wykresów są następujące. Obiekty, które maja

stanowić tło umieszczamy jako pierwsze w poleceniu Show, natomiast te
najważniejsze na samym końcu. Deklaracje elementów globalnych wykresu, np.
ramka, kolor tła itp., możemy umieścić jako parametr w poleceniu Show, np. tak jak
poniżej
Show[param2, param3, param1,
Frame ‐ True,
AspectRatio ‐ 1,
Background ‐ LightBlue
]
Na zakończenie rozważań o wykresach krzywych zadanych za pomocą równań
parametrycznych pokażemy jeszcze jeden wykres. Tym razem oprócz interesującej
krzywej pokażemy jak można inaczej zadeklarować kolor krzywej. W tym celu
przyjrzyjmy się najpierw osobliwej procedurze Blend. Pozwala ona na mieszanie
kolorów wymienionych w postaci listy. Dla przykładu parametr w postaci
PlotStyle ‐ Blend[{Red, Blue, Yellow}, {1/4, 1/2, 1/4}]]
wymiesza kolory czerwony, niebieski, i żółty w proporcjach 0.25:0.5:0.25.
Oto zapowiedziana krzywa z mieszanym kolorem,
ParametricPlot[{t^Sin[3 t], t^Cos[5 t]}, {t, 0.1, 50},
PlotRange ‐ {0, 50},
PlotStyle ‐ Blend[{Red, Blue, Yellow},{1/4, 1/2, 1/4}]
]
39
Mirosław Majewski
50
40
30
20
10
0
0 10 20 30 40 50
Natomiast jeszcze ciekawsze efekty uzyskamy stosując funkcję koloru

(ColorFunction) z mieszanymi kolorami. Konstrukcja postaci
ColorFunction ‐ (Blend[{Red, Green, Blue}, #3] &)
spowoduje wymieszanie kolorów w postaci gradientu od koloru czerwonego poczynając,
przez wszystkie pośrednie do zielonego, i dalej przez kolejne kolory pośrednie do
niebieskiego. Przy czym zmiany będą następowały zgodnie z przebiegiem parametru t. Za
ten ostatni fakt odpowiedzialny jest #3. Natomiast #1 lub #2 będą powodowały zmiany
koloru odpowiednio wzdłuż osi OX lub OY. Oto nasz przykład w nowej postaci. Zmieniliśmy
również zakres przebiegu zmiennej t ( od 0.1 do 250), mamy większą wartość
PlotRange‐{0,250}, dokładniejszy wykres (PlotPoints ‐ 500), oraz szare tło.
ParametricPlot[{t^Sin[3*t], t^Cos[5 t]}, {t, 0.1, 250},
ColorFunction ‐ (Blend[{Red, Green, Blue}, #3] &),
PlotStyle ‐ Thickness[0.003],
Background ‐ Gray,
PlotPoints ‐ 500
]
40
250
200
150
100
50
0
0 50 100 150 200 250
Więcej na temat funkcji koloru powiemy w rozdziale poświęconym wykresom w 3D.

Tam kolor będzie miał istotne znaczenie.
Ćwiczenia
1. Równia parametryczne x  cos at i y  sin bt, gdzie a i b są stałymi, opisują
rodzinę krzywych znanych jako krzywe Lissajou. Wykonaj wykresy kilku
krzywych Lissajou.
2. Spróbuj odgadnąć kształt wykresu krzywej zadanej równaniami
2
parametrycznymi x  1−t
1t 2
2t
i y  1t 2 , gdzie −  t  . Wykonaj wykres
krzywej i porównaj go z twoim wyobrażeniem o tej krzywej. W jaki sposób

można sprawdzić jak parametr t przebiega po naszej krzywej?
3. Wykonaj wykres cykloidy x  at − sin t, y  a1 − cos t, gdzie 0  t  4.
4. Krzywa znana jako asteroida ma równanie x 2/3  y 2/3  a 2/3 . Równanie to może
być z łatwością przekształcone do postaci parametrycznej x  a cos 3 t,
y  a sin 3 t. Wykonaj wykres asteroidy dla 0  t  2.
5. Rozpatrzmy równania parametryczne x  a cos t − b cos qt i y  c sin t − d sin pt.
Wykonaj wykres krzywej reprezentującej te równania dla a  16, b  5,
c  12, d  3, q  473
, p  44
3
oraz t  0. . 10. Co należy zrobić aby otrzymać
bardzo dokładny wykres?
2.4 Wykresy we współrzędnych biegunowych

W zasadzie równania zadane we współrzędnych biegunowych można szybko
doprowadzić do postaci parametrycznej używając przekształceń x  r cos t oraz
y  r sin t. Jednakże procedura PolarPlot upraszcza znacznie zapis polecenia i
41
Mirosław Majewski
pozwala na wygodniejsze operowanie równaniami krzywych. Dzięki tej procedurze

możemy również zaobserwować jak wykresy znanych nam funkcji jednej zmiennej
zawijają się w różnego rodzaju krzywe skoncentrowane wokół środka układu
współrzędnych.
Przypuśćmy zatem, że mamy dane równanie krzywej zadane w postaci biegunowej
r  rt, gdzie r jest odległością punktu od początku układu współrzędnych, natomiast
t jest kątem w pewnej dziedzinie rzeczywistej. Jako przykład takiego równania weźmy
rt  t  sin 21t/20. Załóżmy ponadto, że interesuje nas wykres w zakresie t ∈ 0, 10.
Polecenie wykreślające taką krzywą ma postać,
PolarPlot[t*Sin[t 21/20], {t, 0, 80 Pi}]
200
100
200 150 100 50 50 100 150
100
Wykresy znanych funkcji wykreślone we współrzędnych biegunowych często

przybierają kształty rozmaitych spirali. Oto jak wygląda wykres znanej nam z
wcześniejszych stron funkcji oscylator.
42
oscylator[x_] : 2^(‐x*Cos[10 Pi x]);

PolarPlot[oscylator[t], {t, 0, 2 Pi}, PlotRange ‐ 10]
10
10 5 5 10
10
Na zakończenie warto wspomnieć, że tak jak poprzednio, procedura Show może

przydać się do tego, aby połączyć kilka wykresów we współrzędnych biegunowych,
jak również dowolnych innych, w jeden. Każdy z poszczególnych wykresów może
mieć swoje własne parametry, oraz cały wykres osobno swoje. Wszystkie te
parametry w połączeniu mogą tworzyć scenę graficzną dowolnego stopnia
komplikacji. Oto jeden z takich przykładów, w którym łączymy kilka różnych
krzywych, z odpowiednimi parametrami, w jeden wykres.
kawaZMlekiem  RGBColor[0.8789, 0.7578, 0.6289];
szczypiorek  RGBColor[0.5742, 0.6992, 0.2851];
storczyk  RGBColor[0.7539, 0.1914, 2187];
polar1 : PolarPlot[t*Sin[3 t], {t, ‐100, 100}];
polar2 : PolarPlot[t*Sin[2 t], {t, ‐100, 100},

PlotStyle ‐ {
storczyk,
Thickness[0.001]
}
];
polar3 : PolarPlot[t*(Sin[2 t] ‐ Cos[2 t]), {t, ‐100, 100},

PlotStyle ‐ {
szczypiorek,
Thickness[0.002]
},
PlotRange ‐ 160
];
43
Mirosław Majewski
param1 : ParametricPlot[{100 Sin[t], 100 Cos[t]}, {t, 0, 2 Pi},

PlotStyle ‐ {kawaZMlekiem, Thickness[0.05]}
];
Show[param1, polar1, polar2, polar3,

Background ‐ LightPink,
Axes ‐ False
]
Proponuję czytelnikowi aby rozejrzał się wśród znanych funkcji i sprawdził co

otrzyma wykreślając je w układzie współrzędnych biegunowych. Tymczasem mamy
przed sobą trochę ćwiczeń do samodzielnego wykonania.
Ćwiczenia
1. Wykreśl funkcje r  2 sin  i r  2 cos  dla 0 ≤  ≤ 2 w układzie
współrzędnych biegunowych. Czy umiesz udowodnić, że obie krzywe
przedstawiają okrąg?
2. Rozpatrzmy rodzinę krzywych zadanych we współrzędnych biegunowych
r  sin n, gdzie n  3. . 10 oraz 0 ≤  ≤ 2. Ich kształt często określa się jako
róże n‐płatkowe. Wykonaj wykres kilku krzywych z tej rodziny i sprawdź czy
zawsze ta nazwa jest odpowiednia.
3. Spiralę Archimedesa opisujemy równaniem r  3 for 0 ≤  ≤ 6. Wykonaj
wykres spirali Archimedesa.
4. Równanie r  A  B cos nC  D sin p, gdzie A, B, C i D są liczbami
naturalnymi,opisuje rodzinę krzywych. Wykonaj wykresy kilku krzywych z tej
rodziny.
44
2.5 Wykresy równań w postaci uwikłanej

Wprawdzie niezmiernie rzadko, ale zdarza się, że musimy wykreślić krzywą zadaną
równaniem w postaci uwikłanej. Aby otrzymać taki wykres posiłkujemy się funkcjami
dwu zmiennych i interesującą procedurą ContourPlot. Jest to procedura, którą
powinniśmy omawiać przy okazji grafiki funkcji dwu zmiennych, ale tu też jest nam
blisko do tego tematu.
Wyobraźmy sobie równanie uwikłane, np. sin 3x  cos 5y  0. Wykres krzywej zadanej
tym równaniem otrzymamy w następujący sposób,
ContourPlot[Sin[3 x]  Cos[5 y]  0, {x, ‐2, 2}, {y, ‐2, 2}]
2
2
2 1 0 1 2
Zauważmy, podajemy równanie zapisując je z użyciem podwójnego znaku równości, a

następnie zakres każdej ze zmiennych, tu x ∈ −2, 2 oraz y ∈ −2, 2. To wszystko
stanie się jeszcze bardziej interesujące jeśli zapomnimy podać znaku równości i
wartości po prawej stronie równości. W takim przypadku Mathematica potraktuje
lewą stronę naszego równania jako funkcje dwu zmiennych, a następnie wykreśli
poziome przekroje tej funkcji. Oto jeszcze raz ten sam przykład, ale tym razem
zapisany za pomocą funkcji dwu zmiennych.
45
Mirosław Majewski
ContourPlot[Sin[3 x]  Cos[5 y], {x, ‐2, 2}, {y, ‐2, 2}]
Zauważmy, że najciemniejsze miejsca odpowiadają najniżej położonym warstwom

funkcji, jaśniejsze natomiast warstwom górnym. No ale to zagadnienie zostawmy
sobie do omówienia przy innej okazji.
Ćwiczenia
1. Zastosuj ContourPlot w celu otrzymania wykresów krzywych zadanych
równaniami,
a. x cos x  y cos y  0
b. x sin x  y cos y  0
c. x cos x  y sin y  0
d. x cos y  y cos x  0
e. x cos y  y sin x  0
46
3
Grafika 3D w programie Mathematica
Po zapoznaniu się z grafiką na płaszczyźnie, możemy przejść do omawiania grafiki w
3D. Wiele z poznanych dotychczas koncepcji będziemy mogli wykorzystać bez
większych zmian. Pewne z nich będą wymagały nowego podejścia i modyfikacji.
Wreszcie dojdzie parę nowych procedur i parametrów specyficznych dla wykresów w
3D. Na początek zaczniemy od wykresów funkcji dwu zmiennych i przeanalizowania
specyficznych dla nich parametrów.
3.1 Wykresy funkcji dwu zmiennych

Funkcje dwu zmiennych deklarujemy podobnie jak funkcje jednej zmiennej, np.
goraDolina[x_, y_] : 15*x*Exp[‐(x^2  y^2)]
Teraz, możemy zrobić nasz pierwszy wykres takiej funkcji. Do tego celu wystarczy
proste polecenie,
Plot3D[goraDolina[x, y], {x, ‐4, 4}, {y, ‐4, 4}]
Otrzymany wykres jest w pełni interaktywny. Możemy obracać powierzchnię w każdą

stronę, zaglądać pod spód lub patrzeć na nią z góry. Tu widzimy skąd się wzięła nazwa
naszej funkcji goraDolina.
Teraz musimy trochę popracować aby otrzymany wykres spełniał nasze wymagania.
Na początek zauważmy, że wykres został obcięty z góry i dołu na pewnym poziomie.
Miroslaw Majewski
Aby sprawdzić czy te płaskie obszary nie są fragmentem naszej powierzchni

wystarczy dodatkowy parametr ClippingStyle ‐ None, aby zobaczyć dwa otwory
w miejscu płaskich fragmentów. Możemy również spowodować, żeby Mathematica
dorysowała brakujące fragmenty wykresu. To osiągniemy za pomocą znanego już nam
parametru PlotRange. Tu wartość 6. 5 lub 7 wystarczy na to aby wykres był widziany
w całości. Dodanie odpowiedniego AspectRatio spowoduje zmianę proporcji
jednostek na osiach na wygodniejsze do oglądania wykresu, tu np. AspectRatio ‐
2/3 daje pożądany efekt.
Plot3D[goraDolina[x, y], {x, ‐4, 4}, {y, ‐4, 4},
PlotRange ‐ 6.5,
AspectRatio ‐ 2/3
]
Od tego miejsca możemy kontynuować nasze eksploracje w kilku kierunkach, np.

badając wpływy różnych parametrów na wykres, odpowiednie kolorowanie wykresu,
itp. My przez moment zatrzymamy się na pozornie mało ważnym problemie
kolorowania wykresu. Dobrze dobrany kolor powierzchni może uwydatnić
odpowiednie jej fragmenty, natomiast źle dobrany kolor może uczynić ją płaską lub
trudną do analizy.
Koncepcja koloru w programie Mathematica jest bardzo rozbudowana. My skupimy
się tylko na kolorach nazwanych. Są to w gruncie rzeczy gradienty czyli ciągłe zestawy
kolorów ułożonych w sposób liniowy. To jest dokładnie ta sama koncepcja jak w
przypadku gradientu w programach graficznych typu Adobe Photoshop czy PainShop
Pro. Dla przykładu, wykonajmy polecenie,
48
ColorData["PlumColors"]
ColorDataFunction[{0, 1}, ]
Tu słowo PlumColors jest nazwą jednego z nazwanych gradientów. Diagram

otrzymany w wyniku wykonania polecenia pokazuje kolejność ułożenia kolorów. Te
na początku zostaną użyte w dolnej części wykresu, te na końcu w górnej części
wykresu. Nazwa gradientu powinna być wymieniona w cudzysłowie, jest to bowiem
tylko łańcuch znaków identyfikujący gradient, coś w rodzaju etykiety.
Zanim poznamy inne nazwane gradienty, zobaczmy jak tak zdefiniowany kolor może
być użyty do pokolorowania wykresu. Tym razem użyjemy gradientu nazwanego
DarkRainbow.
f  ColorData["DarkRainbow"];
Plot3D[goraDolina[x, y], {x, ‐4, 4}, {y, ‐4, 4},
ColorFunction ‐ f
]
Przyjrzyjmy się dokładniej, co tu się stało. Na początek zdefiniowaliśmy sobie obiekt o

ColorData i przyporządkowaliśmy mu nazwę f. A następnie użyliśmy tego obiektu
jako funkcji kolorującej wykres.
Teraz możemy przejrzeć listę gradientów zadeklarowanych w programie
Mathematica. Do tego celu wystarczy nam polecenie,
ColorData["Gradients"]
{AlpineColors, Aquamarine, ArmyColors, AtlanticColors, AuroraColors, AvocadoColors,
BeachColors, BlueGreenYellow, BrassTones, BrightBands, BrownCyanTones, CandyColors,
CherryTones, CMYKColors, CoffeeTones, DarkBands, DarkRainbow, DarkTerrain,
49
Miroslaw Majewski
DeepSeaColors, FallColors, FruitPunchColors, FuchsiaTones, GrayTones, GrayYellowTones,

GreenBrownTerrain, GreenPinkTones, IslandColors, LakeColors, LightTemperatureMap,
LightTerrain, MintColors, NeonColors, Pastel, PearlColors, PigeonTones, PlumColors,
Rainbow, RedBlueTones, RedGreenSplit, RoseColors, RustTones, SandyTerrain,
SiennaTones, SolarColors, SouthwestColors, StarryNightColors, SunsetColors,
TemperatureMap, ThermometerColors, ValentineTones, WatermelonColors}
Każdy z wymienionych tu gradientów może być użyty w identyczny sposób, w jaki
użyliśmy gradientu DarkRainbow. Na pewną uwagę zasługują DarkBands and
BrightBands. Są one wygodne do tego aby pokazać wysokości poszczególnych
fragmentów wykresu. W poniżej pokazanym przykładzie deklarujemy ColorData
bezpośrednio w procedurze Plot3D. Ponadto używamy PlotPoints‐90 aby
uzyskać lepszą dokładność poszczególnych warstw.
Plot3D[10*x*Exp[‐1/2*(x^2  y^2)], {x, ‐4, 4}, {y, ‐4, 4},
PlotPoints ‐ 90,
AspectRatio ‐ 1,
ColorFunction ‐ ColorData["DarkBands"],
Boxed ‐ False,
Axes ‐ False
]
Teraz kiedy już znamy podstawy wykresów w 3D, możemy zająć się wybranymi
rodzajami obiektów i ich wykresami, ale zanim to nastąpi warto wykonać trochę
samodzielnych wykresów.
50
Ćwiczenia
Wykonaj wykresy wymienionych tu funkcji dwu zmiennych.
1. fx, y  sin x cos y
2. fx, y  sinx 3 − y 3 
3. fx, y  cos 7y 2 sin 3x 2
xyx 2 − y 2 
4. fx, y 
x2  y2
5. z  4 − x 2 − y 2
6. z  x 2  y 2 − 3x  4y  2
7. z  2x 2  10x  3y 3 − 6y 2  1
8. z  1
1  cos x  sin y
2 2
9. z  x 2 − y 2 e −x −y
2 2
10. z  e 2x−4y−x −y 
2 2
11. z  xye −x y
12. z  xyx 2 − y 2 
xyx 2 − y 2 
13. z 
x2  y2
3.2 Wykresy równań parametrycznych

Równanie parametryczne obiektu w przestrzeni, w istocie rzeczy, oznacza trzy osobne
równania, jednej lub dwu zmiennych zwanych parametrami, opisujące współrzędne
punktów. Tak więc równanie krzywej w 3D będzie trójką równań x  xt, y  yt
oraz z  zt. Zazwyczaj zapisujemy je w zwartej postaci x, y, z  xt, yt, zt.
Nasza znajoma krzywa parametryczna z rozdziału o grafice na płaszczyźnie może
przybrać w przestrzeni równanie
x, y, z  t sin 3t , t cos 5t , t sin 2t 
a jej wykres otrzymamy używając kodu,
ParametricPlot3D[{t^Sin[3*t], t^Cos[5 t], t^Sin[2*t]}, {t, 0.1, 100},
ColorFunction ‐ (Blend[{Red, Green, Blue}, #3] &),
PlotStyle ‐ Thickness[0.002],
PlotPoints ‐ 500
]
51
Miroslaw Majewski
Zauważmy, że użyliśmy tu niemalże dokładnie tych samych parametrów jak w

przypadku wykresu parametrycznego na płaszczyźnie. Zmieniliśmy zakres parametru
t oraz PlotRange na [0,100], dzięki czemu uzyskaliśmy mniej zagęszczony wykres.
Parametr #3 w funkcji koloru został ten sam, ale tym razem zmienia on kolor
względem trzeciej osi, czyli osi pionowej. Oczywiście dodaliśmy funkcję dotyczącą
współrzędnej z  zx naszej krzywej.
Oto następny przykład. Tym razem zrobimy wykres powierzchni zadanej równaniami
parametrycznymi. Mamy zatem dwa parametry, tu są nimi t i u. Ponieważ kod służący
do wykreślenia takiej powierzchni jest bardzo prosty, skorzystamy z okazji aby
dowiedzieć się paru nowych rzeczy związanych z opisem wykresu i siatką wokół
wykresu.
Na początek zajmiemy się parametrem Mesh ‐ 25. Służy on do tego aby nałożyć
odpowiednio gęstą siatkę na rysowaną powierzchnię. Wyższa wartość parametru
powoduje gęstszą siatkę, niższa natomiast siatkę o mniejszej liczbie linii lub ich braku.
Zauważmy, że siatka taka daje nam lepsze wyobrażenie o kształcie powierzchni.
Dlatego siatka z parametrem 20 do 30 jest w wielu przypadkach w miarę optymalna.
Zbyt gęsta siatka zaczerni wykres i uniemożliwi dostrzeżenie jego szczegółów. Brak
siatki spowoduje, że wykres będzie ładny i kolorowy, ale za to często kompletnie
nieczytelny.
Tzw. FaceGrids pozwalają na stworzenie otoczenia wokół wykresu i umożliwiają
oszacowanie współrzędnych jego poszczególnych fragmentów. Jest wiele sposobów
na zadanie tych siatek. Tu podajemy współrzędne ich położenia, np. {0,0,‐1} daje
52
nam siatkę na poziomie z  −1.

Wreszcie ostatnie dwa nowe elementy w tym wykresie, są to nazwy osi (AxesLabel),
oraz nazwa całego wykresu (PlotLabel). Każda z tych etykiet może zawierać
dowolny tekst zamknięty w cudzysłowie, tak jak poniżej, lub wyrażenie
matematyczne, tym razem bez cudzysłowu. No a teraz zajmijmy się już naszym
wykresem.
ParametricPlot3D[{Sin[t]*Sin[u],
Sin[t]*Cos[u], Cos[t]*Sin[u]}, {t, 0, Pi}, {u, 0, Pi},
Mesh ‐ 25,
ColorFunction ‐ f,
FaceGrids ‐ {{0, 0, ‐1}, {0, ‐1, 0}, {1, 0, 0}},
FaceGridsStyle ‐ {Red, Green, Blue},
AxesLabel ‐ {"x", "y", "z"},
PlotLabel ‐ "Powierzchnia parametryczna"
]
Ćwiczenia
1. Wykreśl krzywe przestrzenne zadane równaniami,
a. x, y, z  3 sin t, t, 3 cos t, gdzie t  −3. . 4
b. x, y, z  4 cos t, 4 sin t, sin t cos t, gdzie t  0. . 2
c. Potrójny węzeł: x, y, z  2  cos 32 t cos t, 2  cos 3
2
t sin t, sin 3
2
t
d. x, y, z  t, sin 5t, cos 5t
53
Miroslaw Majewski
e. x, y, z  sin t, cos t, cos 8t

f. x, y, z  t sin 6t, t cos 6t, t
g. x, y, z  cos t sin 4t, sin t sin 4t, cos 4t
2. Wykonaj wykresy wymienionych tu funkcji zadanych równaniami
parametrycznymi.
a. x, y, z  u sin u cos v, u cos u cos v, −u sin v, gdzie u  0. . 2 i v  0. . .
b. x, y, z  sin u, sin v, sinu 2  2v 2 , dla u  −3. . 3, oraz v  −3. . . 3.
3 3
c. Powierzchni Ennepera x, y, z  u − u3  uv 2 , v − v3  vu 2 , u 2 − v 2 , gdzie
u  −2. . 2 oraz v  −2. . 2.
d. x, y, z  2 sin u sin 2v, 2 sin 2u cos 2 v, 2 cos 2u cos 2 v, gdzie u  −/2. . /2 oraz
v  −/2. . /2.
e. x, y, z  u cos v, u sin v, cosuv , gdzie 0 ≤ u ≤ 2 i 0 ≤ v ≤ 2.
f. Powierzchni Diniego
x, y, z  cos u sin v, t sin u sin v, cos v  logtan 2v   0. 2u, gdzie u  0. . 4
oraz v  0. 001. . 2.
g. Zmodyfikowanej powierzchni Ennepera
3 3
x, y, z  u − u3  uv 2 , v − v3  u 2 v, u 2  v 2 , gdzie u  −3. . 3 oraz
v  −3. . 3.
h. Wstęgi Moebiusa
x, y, z  cos u  v cos u2 cos u, sin u  v cos u2 sin u, v sin u2 , gdzie u  0. . 2
oraz v  −0. 5. . 0. 5.
i. x, y, z  0. 5 cos u, 1. 5 cos v  0. 5 sin u, sin v, gdzie u  0. . 2 oraz v  0. . 2.
j. x, y, z  cos 2u cosu  v, cos 2u sinu  v, sin 3v, gdzie u  −. . ,
v  −. . .
k. x, y, z  cos u cosu  v, cos u sinu  v, sin 3v, gdzie u  −. . ,
v  −. . .
l. x, y, z  u cos v, u sin v, u  v, gdzie u  −. .  oraz v  −2. . 2.
3.3 Wykresy równań uwikłanych i nierówności

Innym częstym przypadkiem w matematyce jest konieczność wizualizacji powierzchni
zadanych równaniem uwikłanym. Pewne z tych równań mogą być przekształcone do
postaci parametrycznej ale nie zawsze jest to możliwe. Dla przykładu równanie
hiperboloidy 2x 2  3y 2 − 5z 2  1 jest dość łatwe do przekształcenia do postaci
biegunowej. Natomiast równanie x 4  y 4  z 4 − x 2  y 2  z 2  2  3x 2  y 2  z 2   3
może stanowić już dość poważny problem. W takim przypadku musimy sięgnąć do
procedur umożliwiających wykresy równań uwikłanych. W programie Mathematica
54
jest to procedura ContourPlot3D. Oto prosty przykład pokazujący jak wykreślić

wspomnianą przed chwilą hiperboloidę.
ContourPlot3D[2*x^2  3*y^2 ‐ 5*z^2  1,
{x, ‐1, 1}, {y, ‐1, 1}, {z, ‐1, 1}
]
Skoro już wiemy jak wykreślać równania uwikłane, to możemy teraz zająć się czymś
trudniejszym.
Oto przykład pokazujący w jaki sposób możemy wykonać wykres powierzchni
Steinera, zwanej również powierzchnią rzymską. W naszym przykładzie używamy
uproszczonego równania uwikłanego powierzchni Steinera
y z  z x  x y  2xyz  0. Otrzymanie wykresu trwa dłużej niż zwykle ze względu
2 2 2 2 2 2
na dość skomplikowane algorytmy używane do wyliczenia punktów powierzchni.

Pokazana siatka na powierzchni jak i liczne niedokładności odzwierciedlają stopień
komplikacji obliczeń.
ContourPlot3D[ y^2*z^2  z^2*x^2  x^2*y^2  2*x*y*z  0,
{x, ‐1, 1},{y, ‐1, 1},{z, ‐1, 1}
]
55
Miroslaw Majewski
Wykresy otrzymane z równań uwikłanych mogą zawierać liczne niedokładności. Z

tego powodu, w miarę możliwości, powinniśmy unikać stosowania procedury
ContourPlot3D. W wielu przypadkach możemy znaleźć parametryczną lub sferyczną
reprezentację powierzchni zadanej równaniem uwikłanym. Dla przykładu,
przekształcając równanie Steinera do postaci parametrycznej otrzymamy równania
x  sin 2u  cos v 2
y  sin u  sin 2v
z  cos u  sin 2v
W takim przypadku możemy otrzymać znacznie dokładniejszy wykres powierzchni
Steinera. Jego czas wykonania będzie również o wiele krótszy niż w przypadku
równania uwikłanego.
Ponieważ my już wiemy jak wykreślać równania parametryczne, więc wykorzystamy
okazję do tego aby poeksperymentować z oświetleniem naszej powierzchni. W tym
celu "pomalujemy" powierzchnię na biało, a następnie użyjemy kilku świateł aby ją
oświetlić z kilku stron. Na początek zauważmy, że deklarując kolor powierzchni,
dodajemy parametr Specularity[White, 10], który sprawi, że krąg odbijanego
światła jest na powierzchni średniej wielkości. Dalej deklarujemy cztery światła –
jedno kierunkowe, coś w rodzaju bardzo oddalonego reflektora, oraz trzy punktowe
jak nasze żarówki. Za każdym razem podajemy punkt z jakiego światło świeci (światła
punktowe i kierunkowe), oraz punkt w kierunku którego światło świeci (światło
kierunkowe).
ParametricPlot3D[{Sin[2*u]*Cos[t]^2, Sin[u]*Sin[2*t], Cos[u]*Sin[2*t]},
56
{u, ‐Pi/2, Pi/2}, {t, ‐Pi/2, Pi/2},

Mesh ‐ 25,
AxesLabel ‐ {"x", "y", "z"},
PlotStyle ‐ {White, Specularity[White, 10]},
Lighting ‐ {
{"Directional", RGBColor[0.3, 0.3, 0.3], {{5, ‐5, 10}, {0, 0, ‐10}}},
{"Point", Red, {0, 0, 5}},
{"Point", Blue, {0, ‐5, ‐5}},
{"Point", Green, {5, 0, 0}}
}
]
Po tych eksperymentach ze światłem możemy na chwilę zatrzymać się na wykresach

nierówności z trzema zmiennymi. Dla przykładu wyobraźmy sobie równanie
sin x  sin y − sin z  0. Jest dość skomplikowane, ale tym razem interesuje nas jak
wyglądają dwie części przestrzeni na jakie ta powierzchnia dzieli całą przestrzeń.
Odpowiedź na to pytanie dostaniemy używając procedury RegionPlot3D. Jej
składnia jak i parametry są dokładnie takie same jak w przypadku innych wykresów
w 3D, a w szczególności wykresów równań uwikłanych.
RegionPlot3D[
Sin[x]  Sin[y] ‐ Sin[z]  0, {x, ‐10, 10}, {y, ‐10, 10}, {z, ‐10,10},
Mesh ‐ 10,
PlotLabel ‐ (Sin[x]  Sin[y] ‐ Sin[z]  0)
]
57
Miroslaw Majewski
Nierówność odwrotna daje nam bardzo podobny wykres,
58
Ćwiczenia
Wykonaj wykresy równań uwikłanych i nierówności:
1. x sin x  y sin y  z sin z  0
2. x sin x  y sin y  z sin z ≤ 0
3. x cos y  y cos z  z cos x  0
4. x cos y  y cos z  z cos x ≤ 0
5. x  y  z cos x  0
6. x  y  z cos x ≥ 0
3.4 Wykresy we współrzędnych sferycznych

Wykresy we współrzędnych sferycznych należą do jednych z bardziej interesujących
obiektów matematycznych. W praktyce wykres we współrzędnych sferycznych polega
na odpowiednim zawinięciu wykresu funkcji dwu zmiennych wokół środka układu
współrzędnych. Z tego powodu wykresy takie są bardzo dokładne, a nawet proste
równania funkcji dwu zmiennych dają bardzo interesujące kształty.
Oto bardzo prosty przykład. Równanie z  cos 4 4x  cos 4 4y wykreślone za pomocą
procedury Plot3D przedstawia stosunkowo monotonny krajobraz równo od siebie
oddalonych wzgórz i dolin (patrz rysunek poniżej).
Tymczasem to samo równanie zapisane we współrzędnych sferycznych,

r  cos 4 4u  cos 4 4v, reprezentuje bardzo interesującą powierzchnię. Oto nasze
równanie wykreślone we współrzędnych sferycznych. Zwróćmy uwagę na rodzaj
oświetlenia, które ma bardziej artystyczną wartość, niż matematyczne znaczenie.
SphericalPlot3D[Cos[4*u]^4  Cos[4*v]^4, {u, 0, 2*Pi}, {v, 0, Pi},
59
Miroslaw Majewski
Mesh ‐ 0,
PlotStyle ‐ {White, Specularity[White, 70]},
Lighting ‐ {
{"Directional",
RGBColor[1,0.7,0.1],
{{5,‐5, 5},{5,5,0}}}
}
]
Ćwiczenia
Wykonaj wykresy podanych równań we współrzędnych sferycznych.
1. r  1. 2  sin A, gdzie A  1, 2, 3, . . . 7,   −1. . 2, oraz   0. . .
2. r  , gdzie   −0. . 2 oraz   0. . .
3. r   sin 2, gdzie   0. .  oraz   0. . 2.
4. r   cos 2 2  sin 2 2 , gdzie   0. . 2 oraz   0. . 
5. r   cos 2 2  sin 2 2 , gdzie   0. . 2 oraz   0. . 
6. r  1. 3  tan , gdzie   −1. . 5 oraz   − 4 . . 
4
7. r  1. 2  sin  2 , gdzie   −1. . 2, oraz   0. . 
8. r  1. 2  sin  3 , gdzie   −1. . 2, oraz   0. . 
9. r  sin2  3, gdzie   0. . 2,   0. . 
60
3.5 Bryły otrzymane z obrotu krzywych

W analizie matematycznej dość często musimy rozpatrywać bryły otrzymane z obrotu
pewnych krzywych. Głównie to dotyczy sytuacji kiedy wyliczamy objętości
fragmentów przestrzeni ograniczonych pewnymi powierzchniami. W takim
przypadku wizualizacja obiektu jest ważną podpowiedzią odnośnie granic
całkowania. W tym tekście zajmiemy się tylko paroma prostymi wykresami
otrzymanymi za pomocą procedury RevolutionPlot3D. Na początek wyjaśnimy
mechanizm działania tej procedury.
Wyobraźmy sobie, że mamy funkcję z  fx – to jest ważne – jest to funkcja zmiennej
x o wartościach w z. Wykres takiej funkcji leży w płaszczyźnie xz, co oznacza, że jak
będziemy go obracać względem osi OY to otrzymamy płaski wykres. Przez obracanie
względem pozostałych osi otrzymamy wykres bryły przestrzennej. Tak więc zwykła
funkcja z  sin x da nam wykresy,
RevolutionPlot3D[Sin[x], {x, ‐2 Pi, 2 Pi}, RevolutionAxis ‐ "X"]
oraz
RevolutionPlot3D[Sin[t], {t, ‐2 Pi, 2 Pi}, RevolutionAxis ‐ "Z"]
61
Miroslaw Majewski
Wreszcie zauważmy, że możemy obracać względem innej osi, a raczej wektora, tak jak
poniżej,
RevolutionPlot3D[Sin[t],{t,‐2 Pi,2 Pi},RevolutionAxis ‐ {1,0,1}]
W podobny sposób możemy obracać krzywe zadane wzorami parametrycznymi

zarówno te płaskie jak i te przestrzenne.
W przypadkach brył otrzymanych z obrotu krzywej, czasem wygodnie jest pokazać na
jednym wykresie zarówno obracaną krzywą jak i rezultat obrotu. Oto prosty przykład
pokazujący jak to można zrobić używając procedur Inset (po polsku możemy to
nazwać jako wstawka), oraz Graphics. Procedura Graphics służy głównie do
wykreślania punktów, odcinków, wielokątów, brył i wielu innych obiektów, takich jak
np. obiekt Inset. Omówienie tej klasy obiektów graficznych zostawimy sobie na
osobny rozdział, który znajdzie się w pełnym wydaniu tego tekstu. Tymczasem
proponuję aby czytelnik przeanalizował załączony przykład i zastanowił się nad
znaczeniem parametrów w deklaracji Inset.
krzywa  Plot[Sin[x], {x, ‐2 Pi, 2 Pi},
Frame ‐ True,
];
bryla  RevolutionPlot3D[Sin[x], {x, ‐2 Pi, 2 Pi},
RevolutionAxis ‐ "X"
];
Graphics[
{
Inset[bryla, {0.5, 1}, Center, {3, 1.7}],
62
Inset[krzywa, {0, 0}, Center, {2.2, 1.4}]

},
]
Ćwiczenia
Wykonaj wykresy brył powstających przez obracanie wykresów funkcji wokół osi OX,
OY oraz 1, 0, 1,
1. z  1  cos26x
1x
2. z  sin 3x cos 5x
3. z  sin x2
1−x
2
4. z   2x − x
1
sin x  1
3.6 Wykresy funkcji dwu zmiennych inaczej

Zanim zakończymy ten rozdział wróćmy na chwilę do zagadnienia rozpoczętego w
rozdziale o grafice na płaszczyźnie. Tam użyliśmy procedury ContourPlot do tego
aby pokazać wykres równania uwikłanego z dwoma zmiennymi. Teraz możemy zająć
się nieco bliżej tym rodzajem wykresu i ocenić jego użyteczność do wykresów funkcji
dwu zmiennych. W tym celu wrócimy do naszej funkcji goraDolina z początku tego
rozdziału. Deklarujemy kolejno: funkcję goraDolina, funkcję koloru, normalny
wykres funkcji goraDolina, wykres jej konturów, i wreszcie na koniec łączymy
wszystko razem w jeden wykres używając obiektu Inset. Oto kolejne części naszej
63
Miroslaw Majewski
deklaracji,
goraDolina[x_, y_] : 15*x*Exp[‐(x^2  y^2)];
gd  Plot3D[goraDolina[x, y], {x, ‐2, 2}, {y, ‐2, 2},
ColorFunction ‐ f
]
cgd  ContourPlot[goraDolina[x, y], {x, ‐2, 2}, {y, ‐2, 2},

ColorFunction ‐ f,
Contours ‐ 15
]
2
2 1 0 1 2
Graphics[
{
Inset[gd, {1, 1}, Center, {3, 2.2}],
Inset[cgd, {0, 0}, Center, {1.5, 1.5}]
},
64
]
Podobne wykresy można otrzymać używając procedury DensityPlot.

dgd  DensityPlot[goraDolina[x, y], {x, ‐2, 2}, {y, ‐2, 2},
ColorFunction ‐ f, Mesh ‐ 50
]
Zwróćmy uwagę na to, że tu rola parametru Mesh jest zupełnie inna niż rola
parametru Contours w przypadku procedury ContourPlot.
65
Miroslaw Majewski
Ćwiczenia
Wykonaj wykresy wymienionych tu funkcji dwu zmiennych, tym razem używając
procedur ContourPlot oraz DensityPlot.
1. fx, y  sin x cos y
2. fx, y  sinx 3 − y 3 
3. fx, y  cos 7y 2 sin 3x 2
xyx 2 − y 2 
4. fx, y 
x2  y2
5. z  4 − x 2 − y 2
6. z  x 2  y 2 − 3x  4y  2
7. z  2x 2  10x  3y 3 − 6y 2  1
8. z  1
1  cos x  sin y
2 2
9. z  x 2 − y 2 e −x −y
2 2
10. z  e 2x−4y−x −y 
2 2
11. z  xye −x y
12. z  xyx 2 − y 2 
xyx 2 − y 2 
13. z 
x2  y2
66
4
Animacja i manipulacja
Możliwość animacji obiektów matematycznych znacznie rozszerza nasze możliwości
poznawcze. Pozwala ona nie tylko obserwować zmiany obiektów zależne od
występujących w nich parametrach, ale również symulować eksperymenty
zmieniające się w miarę upływu czasu. W tym rozdziale przyjrzymy się metodom
animacji i manipulacji obiektów matematycznych w programie Mathematica.
4.1 Podstawy procedury Manipulate

W programie Mathematica mamy procedurę Manipulate, dzięki której każdy z
dotychczasowych przykładów może być zamieniony w interaktywne laboratorium do
eksperymentów matematycznych. Na początek przyjrzyjmy się prostemu
przykładowi, w którym użyliśmy procedury Manipulate do generowania wyrazów
ciągu e n  1  1/n n dla n  1, 2, . . . , 10000.
Manipulate[
(1.0  1/n)^n,
{n, 1, 1000, 1}
]
Otrzymany wynik jest tym razem czymś w rodzaju okna dialogowego, tak
popularnego w wielu programach komputerowych. Mamy tu suwak, którym możemy
zmieniać wartości n aby otrzymać odpowiednie wartości e n . Zanim przejdziemy do
dalszych przykładów zastanówmy się przez chwilę nad strukturą polecenia
Manipulate oraz nad tym co otrzymaliśmy.
Jak łatwo można zauważyć składnia polecenia Manipulate jest następująca,
Manipulate[
{obiekt1,obiekt2,..,obiektN}(*obiekty do_manipulacji*)
parametry do manipulacji
]
Mirosław Majewski
W poleceniu tym możemy użyć jednego obiektu, lub wielu związanych nawiasem
klamrowym. Obiekty te mogą być dosłownie wszystkim – funkcjami, ciągami,
wykresami, itp. W drugiej części polecenia mamy parametry, które mogą być
manipulowane. Każdy z tych parametrów musi być zadeklarowany osobno. w
deklaracji podajemy nazwę parametru, jego początkową wartość, końcową wartość,
oraz parę innych rzeczy, które są opcjonalne. W naszym przykładzie liczba 1 oznacza
skok parametru. Mówimy bowiem o wyrazach ciągu, w związku z czym zakładamy, że
argumenty wyrażenia definiującego ciąg są liczbami naturalnymi. Jeśli opuścimy skok
parametru to otrzymamy parametr ciągły.
Teraz zajmijmy się panelem manipulacji. Tu mamy suwak z nazwą zmiennej
natomiast poniżej okienko z wartościami wyrazów ciągu. Panel manipulacji możemy
uczynić bardziej użytecznym wciskając mały znak "" znajdujący się z prawej strony
suwaka. Otrzymamy wówczas panel, w którym mamy okienko z aktualną wartością
parametru n, i dodatkowe guziki (krok do tyłu, uruchom animację, krok do przodu,
szybciej, wolniej, kierunek animacji).
Omówiony tu przykład jest bardzo prosty, ale pokazuje istotę działania procedury
Manipulate. W bardzo podobny sposób możemy konstruować wiele pomocy
dydaktycznych ilustrujących własności obiektów matematycznych.
Jednym z częstych pytań w dydaktyce szkolnej jest pytanie jak zmienia się funkcja w
zależności od występujących w niej parametrów. Oto jeden z takich przykładów.
Załóżmy, że mamy funkcję fx  sin ax  cos bx. Jak będzie się zmieniał wykres funkcji
w zależności od wartości parametrów a and b? Odpowiedź na to pytanie da nam
prosta konstrukcja,
Manipulate[
Plot[Sin[a x]  Cos[b x], {x, ‐Pi, Pi}],
{a, 0, 10, 1},
{b, 0, 10, 1}
]
68
Otrzymany panel w zasadzie wystarcza na potrzeby szkolne, ale warto poświęcić

trochę czasu aby go udoskonalić. Zauważmy, że mamy tu dwie rzeczy powodujące
trochę zamieszania. Pozioma oś układu współrzędnych zmienia swoje położenie w
zależności od wykresu funkcji. Możemy ją ustalić podając zakres wykresu, np.
PlotRange ‐ 2. W innych sytuacjach korzystne może być podanie wielkości
okienka wykresu, np. ImageSize ‐{400,300}.
Od tego momentu możliwe są dalsze usprawnienia, które wprawdzie nie mają już
większej wartości dydaktycznej, ale czynią otrzymany wynik przyjemniejszym dla
oka. Oto jedna z takich modyfikacji,
Manipulate[
Plot[Sin[a x]  Cos[b x], {x, ‐2 Pi, 2 Pi},
PlotRange ‐ 2,
ImageSize ‐ {400, 250},
],
{{a, 1, "Parametr dla Sin"}, 0, 25, 1},
{{b, 1, "Parametr dla Cos"}, 0, 25, 1}
]
69
Mirosław Majewski
Co istotnie nowego jest w powyższym kodzie? Zmieniła się deklaracja parametrów.

Mamy dodatkowo {a, 1, "Parametr dla Sin"}, gdzie 1 oznacza początkową
wartość parametru, czyli wykres zostanie pokazany z wartością a  1, oraz opis dla
każdego suwaka. Pozostałe elementy kodu znamy bądź z tego rozdziału, bądź z
wcześniejszych.
Aby lepiej zaznajomić się z podstawami procedury Manipulate pokażemy jeszcze
jeden przykład z nieco większą liczbą parametrów. Tym razem wrócimy do naszej
znajomej krzywej z wykresów parametrycznych x, y  t sin 3t, t cos 5t. Liczby 3 i 5
zastąpimy parametrami, dołożymy również parametry zmieniające zawartość
składników koloru krzywej ‐ r,g,b, oraz dołożymy parametr decydujący o grubości
linii. Kolor tła będzie generowany wtórnie jako negacja koloru krzywej, czyli
1‐r,1‐g,1‐b. Oto nasz przykład,
Manipulate[
ParametricPlot[{t^Sin[A*t], t^Cos[B t]}, {t, 0.1, 150},
PlotStyle ‐ {RGBColor[r, g, b], Thickness[t]},
Background ‐ RGBColor[1 ‐ r, 1 ‐ g, 1 ‐ b]
],
{A, 1, 15, 1}, {B, 1, 15, 1},
{{r, 0.2, "Czerwony"}, 0, 1},
{{g, 0.1, "Zielony"}, 0, 1},
{{b, 0.1, "Niebieski"}, 0, 1},
{{t, 0.004, "Grubosc"}, 0.002, 0.008}
70
Pokazany tu przykład może być adoptowany do licznych sytuacji spotykanych w

matematyce szkolnej czy nawet uniwersyteckiej. Zanim zatem przejdziemy do
dalszych przykładów warto poeksperymentować z paroma znanymi nam funkcjami
czy rodzinami funkcji.
Ćwiczenia
1. Jednym z ciekawszych przykładów funkcji w układzie biegunowym są tzw. róże
(rodonea curve), r  sin kt, gdzie parametr k może przyjmować dowolne
wartości całkowite. Użyj procedury Manipulate w celu wykonania panelu do
wizualizacji tych krzywych.
2. Inną ciekawą rodziną krzywych są krzywe Lissajous. Możemy je zdefiniować na
kilka sposobów. Jednym z nich są równania parametryczne x  A sinat  d,
y  B sin bt. Użyj procedury Manipulate w celu wykonania panelu do
71
Mirosław Majewski
wizualizacji tych krzywych.

3. Jeszcze inną ciekawą rodziną krzywych są epicykloidy. Najprostsze równanie
parametryczne ma postać: x  R  r cos t − r cos Rrr t oraz
Rr
y  R  r sin t − r sin r t. W zależności od stosunku R/r otrzymujemy krzywe
o różnych kształtach. Użyj procedury Manipulate w celu wizualizacji różnych
epicykloid. Szczególnie interesujące są krzywe, dla których R/r jest liczbą
niewymierną.
4.2 Różne twarze procedury Manipulate

Panele z licznymi suwakami nie zawsze są wygodne do operowania. Dla przykładu
panel z 15 suwakami może przyprawić o zawrót głowy. W wielu przypadkach pojawia
się konieczność innego podejścia do problemu, np. czasami konieczna jest możliwość
wyboru pewnych obiektów z listy, nawigacji po wykresie, lub zbliżenia do
określonych fragmentów wykresu. Dlatego powinniśmy poznać inne elementy
interfejsu możliwe do zadeklarowania w procedurze Manipulate. Na początek
przyjrzymy się czym można zastąpić suwak, jeśli wybieramy ze skończonego zbioru
wartości.
Oto przykład, w którym budujemy panel do modelowania cykloid.
x  A  B cos t − B cos AB

B
t
y  A  B sin t − B sin AB
B
t
Zakładamy przy tym, że A oraz B są wyrażone liczbami całkowitymi, np. 1,2,3,4,5.

Drugą interesującą rzeczą w tym przykładzie jest użycie Manipulate do manipulacji
kilku obiektów graficznych jednocześnie. Mamy tu dysk o zmiennym promieniu i
samą krzywą. Obiekty graficzne są różnego typu dlatego łączymy je procedurą Show,
która jak już wcześniej zauważyliśmy może służyć do łączenia różnych obiektów
graficznych i wyświetlania ich na jednym wykresie. Oto nasz przykład. Sugeruję aby
Czytelnik zapoznał się z nim linia po linii i zastanowił się za co każda linia jest
odpowiedzialna. Sugeruję również, aby Czytelnik zastanowił się co można zmienić w
tym kodzie aby uczynić efekt końcowy doskonalszym lub ciekawszym.
Manipulate[
Show[
Graphics[{Orange, Disk[{0, 0}, 1.6 (A  B)]}],
ParametricPlot[
{(A  B)*Cos[t]  B*Cos[(A  B)/B*t],
(A  B)*Sin[t]  B*Sin[(A  B)/B*t]},
{t, 0, 10 Pi},
PlotStyle ‐ RGBColor[r, g, b]
72
],
Background ‐ RGBColor[1 ‐ r, 1 ‐ g, 1 ‐ b],
PlotRange ‐ 15,
Axes ‐ True
],
{{A, 4}, {1, 2, 3, 4, 5}},
{{B, 2}, {1, 2, 3, 4, 5}},
{{r, 0.2, "Czerwony"}, 0, 1},
{{g, 0.1, "Zielony"}, 0, 1},
{{b, 0.1, "Niebieski"}, 0, 1}
]
Zauważmy, że zamiast suwaków dla A i B mamy teraz przyciski z liczbami, gdzie

możemy wybrać odpowiednie wartości dla tych parametrów. W przypadku, gdy
wybieramy z większej liczby elementów to zamiast przycisków otrzymamy jeszcze
inne rozwiązanie. Powyższy przykład może sprawić nam trochę kłopotów dla
większych wartości A i B. W takim przypadku zmienia się wielkość wykresu i stała
wartość PlotRange nie pozwala zobaczyć skrajnych partii krzywej. Dlatego zamiast
PlotRange użyjemy ImageSize‐{300,300}. To pozwoli nam ustalić wielkość
wykresu bez ograniczania zakresu wykreślanej krzywej. Oto nasz przykład po
modyfikacjach.
73
Mirosław Majewski
Manipulate[
Show[
Graphics[{Orange, Disk[{0, 0}, 1.6 (A  B)]}],
ParametricPlot[
{(A  B)*Cos[t]  B*Cos[(A  B)/B*t],
(A  B)*Sin[t]  B*Sin[(A  B)/B*t]},
{t, 0, 1.5 (A  B) Pi},
PlotStyle ‐ RGBColor[r, g, b]
],
Background ‐ RGBColor[1 ‐ r, 1 ‐ g, 1 ‐ b],
Axes ‐ True,
ImageSize ‐ {300, 300}
],
{{A, 4}, {1, 2, 3, 4, 5, 6, 7, 8, 9}},
{{B, 2}, {1, 2, 3, 4, 5, 6, 7, 8, 9}},
{{r, 0.2, "Czerwony"}, 0, 1},
{{g, 0.1, "Zielony"}, 0, 1},
{{b, 0.1, "Niebieski"}, 0, 1}
]
Warto zauważyć, że wartości parametrów mogą być nie tylko liczbowe ale również
innego rodzaju. Możemy np. wykonać panel demonstrujący wykresy różnych funkcji.
Konstrukcja takiego panelu jest bardzo prosta. Oto jeden z możliwych przykładów.
74
Manipulate[
Plot[f[x], {x, ‐3*Pi, 3*Pi},
ImageSize ‐ {400, 200}
],
{
{f, Sin, "Wykres funkcji"},
{Sin,Cos,Tan,Cot,Sec,Csc,Log,Exp,Sinh,Cosh,Tanh,Coth},
ControlType ‐ SetterBar
}
]
W pokazanym tu przykładzie mamy dwie nowe rzeczy. Pierwszą z nich jest

ControlType‐SetterBar. Ten parametr pozwala na zdefiniowanie tasiemki z
nazwami obiektów do wybierania, tu są nimi nazwy funkcji. Druga nowa rzecz to
zastosowanie zmiennej f, która przybiera wartości będące nazwami funkcji.
Zauważmy – deklarujemy dla f jej wartość początkową i etykietę jaka będzie
wyświetlana na panelu, następnie w nawiasie wypisujmy listę funkcji, bez znaku
cudzysłowu, inaczej mówiąc mamy Sin zamiast "Sin". Podany tu przykład może
posłużyć do wykonania wielu interesujących pomocy na lekcję matematyki.
4.3 Panele z suwakami 2D i kolorem

Suwaki używane w dotychczasowych przykładach są wygodne przy małej liczbie
parametrów lub w sytuacjach gdy mamy do czynienia z funkcjami jednej zmiennej.
Czasem jednak wygodniej, jak również ciekawiej, może być zastosowanie innej postaci
suwaka. W poniżej podanym przykładzie zastosujemy suwak dwuwymiarowy, a więc
taki w którym da się zmieniać dwa parametry jednocześnie.
Na początek opowiedzmy co zamierzamy zrobić. Wyobraźmy sobie, że chcemy
75
Mirosław Majewski
wygenerować pewną liczbę odcinków i je narysować. Aby było ciekawiej załóżmy, że

nasze odcinki łączą punkty postaci sin t, cos t oraz sinat  b, cosct  d. Mamy tu
zmienną t i jej rolą będzie generowanie odpowiedniej liczby odcinków, np. dla t
zmieniającego się od 0 do 10 ze skokiem 0. 1 otrzymamy 10/0. 1  314. 16 odcinków
do narysowania, czyli wystarczająco dużo aby otrzymać interesujący wzór.
Dodatkowo mamy dwie pary parametrów: a i c o podobnej roli, oraz b i d o podobnej
roli. Możemy zatem założyć że w zasadzie generujemy dwie pary wartości
parametrów: A o składowych {A[[1]],A[[2]]} i B o składowych
{B[[1]],B[[2]]}. W takim przypadku nasze odcinki będą miały współrzędne:
{{Sin[t], Cos[t]}, (* pierwszy punkt *)
{Sin[A[[1]]*t  B[[1]]],Cos[A[[2]]*t  B[[2]]]} (*drugi punkt*)
Skoro już mamy punkty określające odcinki, to możemy użyć tablicy do
wygenerowania odpowiednio dużej liczby odcinków.
Table[{
{Sin[t], Cos[t]},
{Sin[A [[1]] t  B[[1]]], Cos[A[[2]] t  B[[2]]]}},
{t, 0, 10 Pi, 0.1}
]
Teraz wystarczy użyć procedury Graphics[Line[{Table itd. aby utworzyć ciąg
odcinków rozumianych już jako obiekty graficzne i wykreślić je na ekranie.
Następnym krokiem będzie wygenerowanie suwaków dwuwymiarowych. Tu
konstrukcja jest prosta. Wystarczy zasygnalizować, że mamy dwa parametry
jednocześnie i Mathematica dostosuje suwak do naszych potrzeb. Taka konstrukcja
wystarczy do tego,
{{A, {0, 0}}, 0, 5, Slider2D},
{{B, {0, 0}}, 0, 10, Slider2D},
Tu A i B zaczynają swoje wartości jako punkty 0, 0 i każda współrzędna zmienia się
od 0 do 5 dla A, oraz od 0 do 10 dla B.
Aby nasz przykład uczynić jeszcze ciekawszym zastosujmy suwak do wybierania
kolorów. W tym celu użyjemy parametru Background ‐ Tlo i dalej w parametrach
dla Manipulate wstawmy polecenie {Tlo, Gray}. W podobny sposób deklarujemy
globalnie kolor naszych odcinków. No a teraz już cały kod i otrzymany w ten sposób
panel.
Manipulate[
Graphics[{
Circle[{0, 0}, 1],
Wzor, (* tu deklaracja koloru odcinkow *)
Line[
Table[
{
76
{Sin[t], Cos[t]},
{Sin[A [[1]] t  B[[1]]], Cos[A[[2]] t  B[[2]]]}
},
{t, 0, 10 Pi, 0.1}
] (* koniec polecenia Table *)
]}, (* koniec polecenia Line *)
Background ‐ Tlo
], (* koniec polecenia Graphics *)
{{A, {0, 0}}, 0, 5, Slider2D}, (* suwak 2D dla A *)
{{B, {0, 0}}, 0, 10, Slider2D},(* suwak 2D dla B *)
{Tlo, Gray}, (* suwak koloru dla tla *)
{Wzor, LightGray}, (* suwak koloru dla odcinkow *)
(* wstawiamy suwaki z lewej strony *)
ControlPlacement ‐ Left
]
Omówiony tu przykład może służyć jako wzór do wykonania prostych pomocy

dydaktycznych w matematyce szkolnej. Czytelnikowi pozostawiam wyszukanie
odpowiednich przykładów z matematyki szkolnej, gdzie omówione tu elementy dadzą
się zastosować.
4.4 Organizacja informacji na panelach Manipulate

Jak dotychczas, panele utworzone z Manipulate są kompletnie pozbawione opisu i
dekoracji. Nie wspominaliśmy również jak można zorganizować wszystkie elementy
kontrolne tak aby tworzyły logiczną całość. Jedynym elementem jaki się dotychczas
pojawił był parametr ControlPlacement ‐ Left, dzięki któremu panel z
poprzedniego przykładu rozciągnął się na szerokość zamiast na wysokość jak to
bywało w poprzednich przykładach. Zajmijmy się zatem elementami, które umożliwią
dodanie napisów do panelu, linii dzielących poszczególne sekcje oraz wyboru krojów
77
Mirosław Majewski
pisma, ich grubości czy koloru. Tak jak w wielu innych elementów Mathematica ma
bardzo rozbudowane możliwości w tym zakresie. I tym razem ograniczymy się
wyłącznie do najprostszych elementów.
Wróćmy zatem do ostatniego przykładu. Łatwo można zauważyć, że poszczególne
elementy kontrolne pojawiały się na panelu dokładnie w tej samej kolejności w jakiej
je deklarowaliśmy. Mieliśmy tam blok deklaracji,
{{A, {0, 0}}, 0, 5, Slider2D}, (* suwak 2D dla A *)
{{B, {0, 0}}, 0, 10, Slider2D}, (* suwak 2D dla B *)
{Tlo, Gray}, (* suwak koloru dla tla *)
{Wzor, LightGray}, (* suwak koloru dla odcinkow *)
(* wstawiamy suwaki z lewej strony *)
Zacznijmy teraz uzupełniać te deklaracje o nowe elementy. Na początek tytuł panelu.
Do wstawienia tytułu wystarczy dodać na początku powyższego bloku polecenie
Style["Pajeczyny", FontFamily ‐ "Verdana", 28, Orange, Bold],
Mamy tu kompleksową deklarację tytułu oraz stylu w jakim zostanie on wypisany na
ekranie. Będzie więc to tytuł "Pajęczyny", wypisany krojem pisma Verdana, wielkości
28pt, koloru pomarańczowego, z literami pogrubionymi.
Bezpośrednio po linii z deklaracją tytułu wstawmy słowo Delimiter. Będzie to linia
pozioma oddzielająca tytuł od elementów występujących poniżej.
Teraz możemy dodać w identyczny sposób tytuły dwu sekcji panelu. Będą to
Style["Parametry", 18, Bold, Orange],
oraz
Style["Kolory", 18, Bold, Orange],
z odpowiednimi liniami oddzielającymi sekcję parametrów od sekcji koloru.
Tak może wyglądać uzupełniony kod poprzedniego przykładu z uzupełnieniami i
poprawkami.
Manipulate[
Graphics[{
Circle[{0, 0}, 1],
Wzor,
Line[
Table[
{
{Sin[t], Cos[t]},
{Sin[A[[1]]*t  B[[1]]],Cos[A[[2]]*t  B[[2]]]}
},
{t, 0, Zakres*Pi, 0.1}
]
]},
78
Background ‐ Tlo
],
Style["Pajeczyny", FontFamily ‐"Verdana",28,Orange,Bold],
Delimiter,
Style["Parametry", 18, Bold, Orange],
{{A, {0, 0}}, 0, 5, Slider2D},
{{B, {0, 0}}, 0, 10, Slider2D},
{Zakres, 2, 15, 1},
Delimiter,
Style["Kolory", 18, Bold, Orange],
{Tlo, Gray},
{Wzor, LightGray},
]
4.5 Panele z zakładkami

Innym sposobem na budowanie paneli może być procedura TabView. Pozwala ona na
budowanie kilku warstw paneli, każdy z innym obiektem. Dla przykładu, chcemy
wykonać panel z kilkoma zakładkami, tak aby każda zakładka wyświetlała inny obiekt
matematyczny. Oto prosty przykład, w którym każda zakładka pokazuje inną bryłę.
TabView[
{"Kula" ‐ Graphics3D[Sphere[]],
"Stozek" ‐ Graphics3D[Cone[]],
"Szescian" ‐ Graphics3D[Cuboid[]],
"Walec" ‐ Graphics3D[Cylinder[]],
"Octahedron" ‐ PolyhedronData["Octahedron"]
},
ImageSize ‐ {450, 400}
]
79
Mirosław Majewski
4.6 Hybrydy Manipulate i TabView

Jeśli lubimy komplikować sobie życie, to możemy połączyć teraz kilka paneli z
użyciem Manipulate w jedną aplikację związaną procedurą TabView. Ponieważ takie
przykłady mogą osiągać znaczny stopień komplikacji, to wskazane jest wykonanie
każdego panelu z użyciem Manipulate osobno, a następnie sklejenie ich wszystkich
w jedną aplikację. Oto najprostszy z możliwych przykładów.
Na początek deklarujemy panel każdej z przyszłych zakładek osobno.
fsin  Manipulate[
Plot[Sin[a x], {x, 0, Pi}],
{a, 1, 10}
];
fcos  Manipulate[
Plot[Cos[a x], {x, 0, Pi}],
{a, 1, 10}
];
ftan  Manipulate[
Plot[Tan[a x], {x, 0, Pi}],
{a, 1, 10}
];
fcot  Manipulate[
Plot[Cot[a x], {x, 0, Pi}],
{a, 1, 10}
];
TabView[{
"Sinus" ‐ fsin,
"Cosinus" ‐ fcos,
80
"Tangens" ‐ ftan,
"Cotangens" ‐ fcot
},
ImageSize ‐ {600, 400}
]
Ćwiczenia
1. Mathematica posiada zdefiniowaną liczną kolekcję wielościanów. Dla
przykładu wielościany Archimedesowe są tu zdefiniowane jako
"Cuboctahedron",
"GreatRhombicosidodecahedron",
"GreatRhombicuboctahedron",
"Icosidodecahedron",
"SmallRhombicosidodecahedron",
"SmallRhombicuboctahedron",
"SnubCube",
"SnubDodecahedron",
"TruncatedCube",
"TruncatedDodecahedron",
"TruncatedIcosahedron",
"TruncatedOctahedron",
"TruncatedTetrahedron".
Każdy z nich może być wykreślony za pomocą polecenia podobnego do tego
PolyhedronData["Octahedron"]. Wykonaj panel demonstrujący wybrane
wielościany Archimedesowe.
81
Mirosław Majewski
2. W programie Mathematica mamy kilka innych grup wielościanów. Są nimi dla

przykładu:
"Archimedean",
"ArchimedeanDual",
"Johnson",
"KeplerPoinsot",
"Platonic",
"Uniform".
Zawartość każdej z tych grup może być wypisana poleceniem podobnym do
tego PolyhedronData["Johnson"]. Tu otwierają się szeroko możliwości do
ciekawych projektów pokazujących różne grupy lub kolekcje wielościanów.
Literatura
[1] Core Language, Wolfram Mathematica© Tutorial Collection, 2008
[2] Visualization and Graphics, Wolfram Mathematica© Tutorial Collection, 2008
[3] Majewski M., MuPAD Pro Computing Essentials, Springer Verlag, 2002
[4] Majewski M., MuPAD dla niecierpliwych, Omega Art, 2006
[5] Torrence B., Torrence E., The Student’s Introduction to Mathematica©,
Cambridge University Press, 2009
82

Mathematica Dla Niecierpliwych (Całość)

Uploaded by

Copyright:

Available Formats

You might also like

Mathematica Dla Niecierpliwych (Całość)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Mathematica Dla Niecierpliwych (Całość)

Uploaded by

Copyright:

Available Formats

Mathematica dla ©

Fragment tekstu Konferencja MathPAD 2010

2 Grafika 2D w programie Mathematica ...............................25

3 Grafika 3D w programie Mathematica ...............................47

4 Animacja i manipulacja ................................................ 67

4.3 Panele z suwakami 2D i kolorem .......................................................................................75

Wiele rzeczy można znaleźć w bogatej pomocy programu Mathematica.

Teraz jesteśmy gotowi do wykonania naszego pierwszego polecenia. Ustawmy

Uwaga techniczna Polecenia w programie Mathematica często używają pewnych, z góry

1.1 Mathematica jako podręczny kalkulator

(1  2  2^2  2^3  2^4  2^5)^(1/3)

234 − 456 752  345

1.1.2 Funkcje trygonometryczne, logarytmiczne

Funkcja Zapis w programie Mathematica i przykład użycia

Niezmiernie ważne jest zauważenie, że funkcje trygonometryczne używają

Mamy zatem dla przykładu:

Funkcja Zapis w programie Mathematica i przykład użycia

Oto kilka przykładów pokazujących jak te funkcje mogą być stosowane.

W podobny sposób zachowują się inne operacje i funkcje w programie Mathematica

1.2 Rozwiązujemy równania

A oto nieco bardziej skomplikowany przykład z algebry liniowej:

Solve[{x  2 y ‐ z  2, x ‐ y  z  4, 2 x  y ‐ z  5},{x, y, z}]

Na zakończenie tego bardzo krótkiego wstępu do rozwiązywania równań z

A następnie odrzucamy zbędne nawiasy klamrowe,

Polecenia z podwójnym nawiasem kwadratowym mogą się wydawać dziwne, ale w

Załóżmy, że chcemy jednocześnie wydobyć z niej wszystkie rozwiązania. W tym celu

Zwróćmy uwagę na kilka istotnych rzeczy w tych deklaracjach. W naszych

1.4.1 Problemy z deklaracjami

1.5 Operacje na wyrażeniach matematycznych

To samo polecenie, ale z dodatkowym założeniem x  0 daje zupełnie inny wynik.

1.6 Elementy analizy matematycznej

W podobny sposób możemy wyliczyć drugą pochodną i kolejne,

a następnie granica tej samej funkcji z prawej strony

1.7 Szukamy pomocy

1.7.1 Duże i małe litery

1.7.3 Równość nie jest równa równości

1.7.4 Kolor ma też jakieś znaczenie

1.7.5 Pomoc w programie

Rys 1.1 Nawigator funkcji w programie Mathematica

Plot[{Cot[x],Cot[x^2],Cot[x^3],Cot[x^4]}, {x,‐Pi,Pi},Filling ‐ Axis]

No i w ten sposób doszliśmy do wykresów w programie Mathematica, a to już jest

2.1 Wykresy funkcji jednej zmiennej

oscylator[x_] : 2^(‐x*Cos[10 Pi x])

0.5 1.0 1.5 2.0 2.5 3.0

0.5 1.0 1.5 2.0 2.5 3.0

Tu Mathematica wykonała za nas parę czynności, których zakodowanie wymagałoby

Rys. 2.1 Drawing Tools i Graphics Inspector

0.5 1.0 1.5 2.0 2.5 3.0

Rys. 2.2 Wykres po poprawkach z użyciem narzędzi

2.2 Wybrane parametry użyteczne w wykresach 2D

2.2.1 Proporcje i zakres wykresu

0.0 0.5 1.0 1.5 2.0 2.5 3.0

Wielokrotnie wykresy otrzymane w CAS mają zniekształcone proporcje jednostek

0.0 0.5 1.0 1.5 2.0 2.5 3.0

Parametr AspectRatio proporcje wykresu

2.2.2 Osie układu współrzędnych, siatka i ramka

0.0 0.5 1.0 1.5 2.0 2.5 3.0

2.2.3 Styl wykresów w 2D