Techniki komputerowe
     w robotyce

Wykład VII

Mathematica – praktyczne wprowadzenie

Robert Muszyński

Katedra Cybernetyki i Robotyki
Wydział Elektroniki, Fotoniki i Mikrosystemów
Politechnika Wrocławska

Copyright 2009-2026 RM

Podstawy systemu – składnia

Obliczenia numeryczne i arytmetyka

Obliczenia dokładne i przybliżone

2+3+4
2 3 4
(3+4)^2-2(3+1)
2.3+5.63
2.4/8.9^2
2.4^45

1/3+2/7
N[1/3+2/7]
2^100
2^100//N

2^100-(2^100-1)
2.^100-(2^100-1)

({{x+y-z
x y z lub x*y*z
x/y
x^y
-x
N[wyr] lub wyr//N, 
}}) 
({{dodawanie
mnożenie
dzielenie
potęgowanie
minus
przybliżona wartość numeryczna wyrażenia}})

Funkcje matematyczne i liczby zespolone

({{Sqrt[x]
Exp[x]
Log[x]
Log[b,x]
Sin[x],Cos[x],Tan[x]
ArcSin[x],ArcCos[x],ArcTan[x]
n!
Abs[x]
Round[x],Floor[x],Ceiling[x]
Mod[n,m]
Random[]
Max[x,y,…],Min[x,y,…]
FactorInteger[n], 
}}) 
({{pierwiastek kwadratowy ((Sqrt[x]))
funkcja wykladnicza ((e^x))
logarytm naturalny ((Subscript[log, e])x)
logarytm o podstawie b ((Subscript[log, b])x)
funkcje trygonometryczne (z argumentami w radianach)
odwrotne funkcje trygonometryczne
n silnia
wartosc bezwzgledna
liczba calkowita najbliższa, mniejsza, większa od x
n modulo m
liczba pseudolosowa pomiędzy 0 a 1
maksimum,minimum z x,y,…
rozkład na liczby pierwsze}})

• Argumenty wszystkich funkcji Mathematici są zawarte w nawiasach kwadratowych
 • Nazwy funkcji wbudowanych w Mathematice zaczynają się od dużych liter

Sqrt[16]
Sqrt[2]
Sqrt[2]//N
Sqrt[2.]
Log[8]
Log[8.]
Sin[Pi/7]
Sin[Pi/6]
Sin[Pi/5]

({{Pi, π
E
Degree
I
Infinity, ∞, 
}})({{

, π≃3.14159
e≃2.71828
π/180:stopnie na radiany
i=(Sqrt[-1])
nieskończoność}})

Pi^2
Sin[π/2]
Sin[30 Degree]
Log[E^5]
Log[2,256]

Sqrt[-4]
ArcSin[1.5]
ArcSin[Cosh[5]]
Sin[1/6+I /3]
Sin[1/6+I/3]//N

Tan[π/2]
Limit[Tan[x],x->Pi/2,Direction->"FromBelow"]
Sin[∞]
Tan[∞]
mf[x_]=1/x-4
mf[∞]

({{x+I y
Re[z]
Im[z]
Conjugate[z]
Abs[z]
Arg[z], 
}})({{

, liczba zespolona x+i y
część rzeczywista
część urojona
liczba sprzężona(SuperStar[z])lub(OverBar[z])
wartość bezwzględna |z|   
argument φ w |z|(e^(i φ))}})

Obliczenia o zadanej dokładności

({{Precision[wyr]
Accuracy[wyr], 
}}) 
({{dokładność wyrażenia – liczba cyfr znaczących
dokładność wyrażenia – liczba cyfr znaczących po przecinku}})

Precision[1.2]
%//N
Solve[Log[10,2^x]==MachinePrecision,x,Reals]//N  (* Ile to bitóww? *)
Precision[1.2`20]
Precision[12/10]
Precision[1.2 x^2+5 b x]
Precision[12/10 x^2+5 b x]

Precision[1.2]
Accuracy[1.2]
Precision[1.2`20]
Accuracy[1.2`20]
Precision[1323.2`20]
Accuracy[1323.2`20]
Precision[12/10]
Accuracy[12/10]

a1=1+10^-16;
b1=1.0;
a1-b1
a2=N[1+10^-16,20];
b2=N[1,20];
a2-b2

N[1/7,100]
N[0.142857,100]

pp=33  (* też np. 55 czy 21 π/2  *)
Sin[pp]//N
Series[Sin[x],{x,0,18}]  (* Dzielenie bardzo dużych liczb *)
 (* Błędny wynik przy małej precyzji *)
Normal[Series[Sin[x],{x,0,100}]]/.x->N[pp]
(* Poprawny wynik przy zadanej precyzji ale nie za daleko *)
Normal[Series[Sin[x],{x,0,100}]]/.x->N[pp,100]

Animate[Plot[Evaluate[{Sin[x],Normal[Series[Sin[x],{x,0,n}]]}],{x,-20,20},PlotRange->3],{n,1,50,2},AnimationRunning->False]

Obliczenia algebraiczne

Wyrażenia symboliczne

({{wyrażenie numeryczne
wyrażenie symboliczne, 
}}) 
({{3+62-1   ⟶   64                                        (obiegowo) 
3x-x+2  ⟶   2+2 x}})

({{wyrażenie numeryczne
wyrażenie symboliczne

, 
}}) 
({{0.333333+0.166667   ⟶   0.5      (w Mathematice)
3x-x+2  ⟶   2+2 x
1/3+1/6  ⟶   1/2
3+62-1   ⟶   64                 ⟵ to też jest symbol!}})

-1+2x+x^3
x^2+x-4 x^2
x y+2 x^2 y+y^2 x^2-2 y x
(x+2y+1)(x-2)^2
Sin[x]^2+Cos[x]^2
π

a x^2+b x+c==0
D[x^3+a x+Cos[x]+b,x]
Integrate[a+3 (x^2)-Sin[x],x]
Integrate[1/x,{x,1,t}]

Przekształcanie i upraszczanie wyrażeń

Podstawowa zasada Mathematici – weź wyrażenie i zastosuj do niego reguły przekształcania tak długo, aż przestanie się zmieniać, uporządkuj je

{x-x,x/x,x*0,x^1,x^0}
{Sin[Pi],Log[E],Sqrt[-1],Exp[0],Sqrt[50]}
{Sqrt[x]^2,Sqrt[x^2]}
Sin[x]^2+Cos[x]^2

y+x+5+a+x
Sqrt[1+x]^4
Sqrt[2]/9801 (4n)! (1103+26390 n)/(n!^4 396^(4n))
Log[1+Cos[x]]

({{Expand[wyr]

ExpandAll[wyr]
Factor[wyr]
FactorInteger[x], 
}}) 
({{wylicz iloczyny i potęgi 
i zwróć wynik w postaci sumy składników 
także w argumentach funkcji (na wszystkich "poziomach")
zapisz wyrażenie wyr jako iloczyn jak najprostszych czynników
rozłóż x na czynniki pierwsze}})

Expand[(x+2y+1)(x-2)^2]
Factor[%]
wyr=(x+1)^2+Sin[(x+1)^2];
Expand[wyr]
ExpandAll[wyr]

Factor[x^6-1]
Factor[x^2+1]
Factor[x^2+1,GaussianIntegers->True]
FactorInteger[123456789]

({{Simplify[wyr]

FullSimplify[wyr]
, 
}}) 
({{znajdź jak najprostszą postać wyrażenia wyr
stosując standardowe przekształcenia algebraiczne 
znajdź jak najprostszą postać wyrażenia wyr
stosujac możliwe znane przeksztalcenia algebraiczne}})

Simplify[x^2+2x+1]
Simplify[x^10-1]
Simplify[x/(x^2-1)-1/(x+1)]
Simplify[Cos[x]^2+Sin[x]^2]

Simplify[Sqrt[x^2]]
Simplify[Sqrt[x^2],x>0]
Simplify[Sqrt[x^2],x<0]
Simplify[Abs[x],x>0]
Simplify[Abs[x],x<0]

Integrate[1/(x^4-1),x]
D[%,x]
Simplify[%]

wyr=Sqrt[7-4 Sqrt[3]];
Simplify[wyr]
FullSimplify[wyr]
Simplify[Gamma[x] Gamma[1-x]]
FullSimplify[Gamma[x] Gamma[1-x]]

({{TrigReduce[wyr]

TrigExpand[wyr]
, 
}}) 
({{przekształć iloczyny i potęgi funkcji trygonometrycznych
na postać funkcji trygonometrycznych o argumentach złożonych 
rozwiń funkcje trygonometryczne w wyrażeniu do postaci
sum i iloczynów funkcji o prostych argumentach}})

TrigReduce[Sin[x]^2]
TrigReduce[Cos[x]^3]
TrigReduce[Sin[x]Cos[y]]
TrigReduce[Sin[x]^2Cos[x]^2]
TrigExpand[Sin[2 x]]

({{a -> b (Rule)
wyr/.reg (ReplaceAll), 
}}) 
({{reguła: a przekształć w b 
zastosuj regułę reg do wyrażenia wyr}})

{a,b,c}/.b->x
{a,b,c}/.List->Plus
1+f[x]+f[y]/.f[t_]->t^2

moment=m*g*L*Sin[θ]
parametry={m->10,L->0.5,g->9.8}
moment/.parametry

Wyświetlanie wyników obliczeń

({{wyr
wyr;, 
}}) 
({{wylicz i wyświetl 
wylicz i nie wyświetlaj}})

Simplify[x/(x^2-1)-1/(x+1)]
Simplify[Cos[x]^2+Sin[x]^2];

({{StandardForm[ wyr]
TraditionalForm[wyr], 
}}) 
({{wyświetl w standardowym formacie Wolframa – domyślnie
wyświetl w tradycyjnym formacie matematycznym}})

x^2+x^(-1)+Pi//StandardForm
x^2+x^(-1)+Pi//TraditionalForm
Exp[I θ]==Cos[θ]+I Sin[θ]
Exp[I θ]==Cos[θ]+I Sin[θ]//TraditionalForm

D[f[x,y],{x,2},{y,3}]
%//TraditionalForm
Integrate[f[x^2]^2,x]
%//TraditionalForm

Nest[Sqrt[1+1/#]&,x,8]//TraditionalForm

({{FullForm[ wyr]
TreeForm[wyr], 
}}) 
({{wyświetl w pełnej okazałości
wyświetl w postaci drzewa}})

FullForm[1/2]
FullForm[0.5]
FullForm[64]
FullForm[64.]
Head[64]
Head[64.]

FullForm[x-y]
FullForm[x/y]
FullForm[1/x^2]
FullForm[a+b^2+c^3+d]
TreeForm[a+b^2+c^3+d]

//FullForm
//TreeForm

({{Column[ lista]
MatrixForm[lista], 
}}) 
({{wyświetl w kolumnie
wyświetl w postaci macierzy}})

{x^2,1/(x+1),Sin[x]}//Column
Column[{x^2,1/(x+1),Sin[x]},Center]
Column[{x^2,1/(x+1),Sin[x]},Center,Dividers->All]

{{1,2,3},{11,12,13},{111,112,113}}//MatrixForm
MatrixForm[{{1,2,3},{11,12,13},{111,112,113}},TableAlignments->Right]

Table[RotationMatrix[θ,UnitVector[3,i]],{i,3}]
%//MatrixForm
MatrixForm/@%%

({{Grid[lista]
Panel[wyr], 
}}) 
({{wyświetl na dwuwymiarowej siatce (tabele, zestawienia)
wyświetl w postaci panelu}})

dane={{"Parametr","Wartość"},{"Masa",1.5},{"Długość",0.8},{"Moment",0.12}};
Grid[dane,Frame->All,Background->{None,{GrayLevel[0.8],None}},ItemStyle->{"Text",12}]
Grid[Table[RandomChoice[{SpanFromLeft,SpanFromAbove,Item[RandomInteger[1000],Background->Hue[RandomReal[],.2,.9]]}],{8},{12}],Frame->All]

Panel[Style[2^100,Red,Bold],"Wynik obliczeń"]
status="READY";
temp=42.5;
battery=85;
Panel[Column[{Style["System Status Report",14,Bold,Darker[Blue]],Delimiter,Row[{"Current State: ",Style[status,Green,Bold]}],Row[{"CPU Temperature: ",NumberForm[temp,{3,1}]," °C"}],Row[{"Battery Level: ",ProgressIndicator[battery,{0,100},Appearance->"Step"]," ",battery,"%"}]},Spacings->1],"Robot Controller v1.0",Background->Lighter[Gray,0.9],FrameMargins->15]

({{TeXForm[ wyr]
CForm[wyr], 
}}) 
({{wyświetl w formacie TEX-a
wyświetl w formacie C}})

x/Sqrt[4 y] Cos[α]//TeXForm

x/Sqrt[4 y] Cos[α]//CForm

(* wymaga dołączenia nagłówka *)
FileNames["*",FileNameJoin[{$InstallationDirectory,"SystemFiles","IncludeFiles","C"}]][[1]]

Techniki obliczeniowe – nawiasologia

Wykorzystanie poprzednich wyników – definiowanie zmiennych

({{%
%%
%%...% (k razy)
%n, 
}}) 
({{ostatnio wygenerowany wynik                 (ostrożnie!)
przedostatnio wygenerowany wynik
k-ty od końca wynik
wynik z linii Out[n]             (bardzo ostrożnie!!!)}})

77^2
%+1
3 %+%^2+%%
%2+%3

({{x=war

x:=war


x=y=war
x=. lub Clear[x], 
}}) 
({{przypisz natychmiastowo wartość war zmiennej x
(przypisanie natychmiastowe, bezpośrednie, statyczne)
przypisz wartość war zmiennej x z opóźnieniem
(przypisanie opóźnione, odroczone, leniwe,
 dynamiczne, funkcyjne)
przypisz wartość war zmiennym x i y
usuń wartość przypisaną do x}})

x=5
x^2
x=7+4
pi=N[Pi,40]
pi
pi^2

a=4;
x=5+a;
y:=5+a;
x
y

?x
?y

a=7;
x
y
x=. 
x

rownanie=F==m*a
rownanie^2                             (* tylko po co 🙂 *)
%//TreeForm
wykres=Plot[Sin[x],{x,0,20}];
wykres^2

• Poprawny identyfikator zaczyna się od litery lub $ i składa z liter i cyfr i dolarów (także z innych alfabetów)
 • Wielkość liter ma znaczenie – vel, Vel, VEL to trzy różne zmienne
 • Nazwa może zawierać indeksy dolne ale należy uważać i jeśli już to użyć pakietu Notation ()
 • Należy pamiętać: Nazwy funkcji wbudowanych w Mathematicę zaczynają się od dużych liter
 • Dobra praktyka: Swoje zmienne i funkcje nazywaj zawsze od małej – kinWahadla 
 • Zasada: Od $ zaczynają się identyfikatory globalnych zmiennych konfiguracyjnych lub systemowych – $Version 
 • Zalecenie: Nie używaj nazw jednoliterowych – q ⟶ vq, Q ⟶ mQ
 • Uwaga: Szczególnie niebezpieczny jest znak podkreślenia _ – operator wzorca

vel=3
VEL
α=π/6
Sin[α]
(Subscript[a, 1])=12
((Subscript[a, 1])^2)
$Version

D[((Subscript[x, 1])^2),(Subscript[x, 1])]
D[((Subscript[x, 1])^2),(Subscript[x, 2])]
D[((Subscript[x, 1])^2),x]
x//FullForm
(Subscript[x, 1])//FullForm

zx=1;(Subscript[x, 1])=11;(Subscript[x, 2])=12;
{zx,(Subscript[x, 1]),(Subscript[x, 2])}
?zx
?(Subscript[x, 1])

((Subscript[x, 1])=11)//Hold//FullForm    (* Dlaczego to działa? *)
Subscript//DownValues

Addendum: Wewnętrzna struktura reguł – zrozumieć to, co na samym dnie

f[x_]=33;
f[x]=22;
?f
UpValues[f]
DownValues[f]

f[3]
f[x]
f[x_]

g[x_]=33            (* dla funkcji g zróbmy to inaczej *)
x/:g[x]=22;   (* /: – skojarz przypisanie z symbolem x (TagSet) *) 
?g
UpValues[g]
DownValues[g]

g[3]
g[x]
g[x_]

UpValues[x]      (* to x pamięta, że g[x] jest równe 22 *)
DownValues[x]

Zastosowanie: np. przeciążanie operatorów

zesp[1,2]+zesp[3,4]
Plus[zesp[re1_,im1_],zesp[re2_,im2_]]:=zesp[re1+re2,im1+im2]
Plus//Attributes

zesp/:Plus[zesp[re1_,im1_],zesp[re2_,im2_]]:=zesp[re1+re2,im1+im2]
?Plus
?zesp
UpValues[zesp]
DownValues[zesp]

zesp[1,2]+zesp[3,4]

Wracamy do identyfikatorów z indeksami dolnymi – przykład pochodnej wektorowej

vq={(Subscript[q, 1]),(Subscript[q, 2])}
kin[q_List]:={(Subscript[l, 1])Cos[q[[1]]]+(Subscript[l, 2])Cos[q[[1]]+q[[2]]],(Subscript[l, 1])Sin[q[[1]]]+(Subscript[l, 2])Sin[q[[1]]+q[[2]]]}                          (* kinematyka *)
kin[vq]//MatrixForm
D[kin[vq],{vq}]//MatrixForm                                    (* jakobian *)

Niebezpieczeństwo (niedopuszczalnego) znaku podkreślenia w nazwach

moj_robot=15   (* niby nie można a „zadziałało” *)
moj_robot             (* tylko gdzie jest moje 15? *)
moj
moj_
robot

moj//FullForm
moj_robot//FullForm

?moj_robot
?moj
?robot

UpValues[robot]
DownValues[robot]
robot
robot[14]
robot[cokolwiek]

• także zamiast używać stylu wężowego do nazywania identyfikatorów – snake_case
 • używamy stylu wielbłądziego – camelCase (a Mathematica używa stylu pascalowego – PascalCase)
 • jest jeszcze styl kebabowy (kebab-case), ale w Mathematice nie działa ☺

Clear[robot]
robot[14]
robot[cokolwiek]

• identyfikator (niebieski) – symbol pusty (brak wartości)
 • identyfikator (czarny) – symbol globalny z przypisaną wartością
 • identyfikator (zielony) – symbol lokalny/tymczasowy
  • wyrażenie (czerwony / różowe tło) – błąd składniowy / konflikt

({{ClearAll[x]
, 
}}) 
({{usuń wartość przypisaną do x, atrybuty, komunikaty, 
wartości domyślne}})

ClearAll["Global`*"]      (* usuń wszystko w kontekście Global *)

Wyrażenia złożone – techniki pracy z jądrem

({{(Subscript[wyr, 1]);(Subscript[wyr, 2;])(Subscript[wyr, 3])
(Subscript[wyr, 1]);(Subscript[wyr, 2;])(Subscript[wyr, 3]);
((Subscript[wyr, 1]);(Subscript[wyr, 2;])(Subscript[wyr, 3]))
((Subscript[wyr, 1]);(Subscript[wyr, 2;])(Subscript[wyr, 3]);), 
}}) 
({{sekwencja wyrażeń  zwracająca wartość ostatniego ((Subscript[wyr, 3]))
sekwencja wyrażeń  nie zwracająca wartości
wyrażenie złożone o wartości (Subscript[wyr, 3])
wyrażenie złożone o wartości Null}})

x=4;y=6;z=y+8
g=4;h=6;i=h+8;
{x,y,z}
{g,h,i}

wyn1
wyn2
wyn1=(a=2;b=5;a+b);
wyn2=(a=2;b=5;a+b;);
wyn1
wyn2

?wyn1
?wyn2

gcd[m0_,n0_]:=(m=m0;n=n0;While[n≠0,{m,n}={n,Mod[m,n]}];m)
gcd[18,21]
{m,n}

({{Module[{x,y,…},wyr]
Module[{x=(Subscript[x, 0]),y=(Subscript[y, 0]),…},wyr]
Block[{x,y,…},wyr]
Block[{x=(Subscript[x, 0])y=(Subscript[y, 0])…},wyr], 
}}) 
({{wylicz wyr traktując zmienne  x, y,...jako lokalne
zainicjuj zmienne  lokalne
wylicz wyr z lokalnymi wartościami zmiennych globalnych x, y,... 
zainicjuj zmienne globalne  lokalnymi wartościami}})

Clear[gcd,m,n]
gcd[m0_,n0_]:=Module[{m=m0,n=n0},While[n≠0,{m,n}={n,Mod[m,n]}];m]
gcd[18,21]
{m,n}

fib[n_]:=
Module[{f},
f[1]=f[2]=1;
f[i_]:=f[i]=f[i-1]+f[i-2];
f[n]
]
fib[7]

zm=i^2
Module[{i=a},i+zm]  (* zakres leksykalny *)
Block[{i=a},i+zm]    (* zakres dynamiczny *)

zx=7;
Block[{zx=14},Print[zx]]
Module[{zx=14},Print[zx]]
zx
Block[{zx},Print[zx]]
Module[{zx},Print[zx]]

({{Mathematica kernel
Mathematica front end, 
}}) 
({{jądro systemu wykonujące obliczenia
powłoka użytkownika}})

• Do pracy interaktywnej wykorzystuj interfejs graficzny (mathematica, wolframnb – pliki z rozszerzeniem .nb)
 • Do pracy wsadowej używaj interfejsu tekstowego (math, wolfram – pliki z rozszerzeniem .m)
 • W interfejsie graficznym nie umieszczaj zbyt wielu wyrażeń / poleceń / linii kodu w jednej komórce – traktuj komórkę jako jeszcze jeden element grupowania kodu, umieszczaj w niej „jeden logiczny krok” obliczeń
 • Komentuj kod :)
 • Nie wyświetlaj wyników, które Cię nie interesują, na przykład pośrednich
 • Gdy obliczasz coś ponownie użyj ponownie komórki, która to zawiera
 • Komórki można „zwijać”
 • Pamiętaj, że o kolejności obliczeń decyduje kolejność „uruchamiania” (Shift+Enter) komórek 
 • Jeśli chcesz wyliczyć „cały” notatnik użyj Evaluation -> Evaluate Notebook
 • I unikaj „procentów” ☺

• Jeśli widzisz „coś czerwonego” lub na „różowym tle” „poszukaj” komunikatu o błędzie i przeczytaj go
 • By „tymczasowo” wypisać wartość jakiegoś wyrażenia / jego części „otocz” je/ją funkcją Echo[]
 • W celu przerwania obliczeń użyj menu Evaluation -> Abort Evaluation
 • Jeśli „zabłądziłeś” użyj Clear[x] lub ClearAll[“Global*”]
 • W ostateczności możesz zakończyć działanie bieżącego jądra używając menu Evaluation -> Quit Kernel -> Local

Listy obiektów - operowanie ich elementami

• By utworzyć listę użyj nawiasów klamrowych {}
 • By wybrać elementy listy użyj podwójnych nawiasów kwadratowych [[]]

{3,5,1}
{3,5,1}^2+1
{6,7,8}-{3.5,3,2.5}
{6,7,8,9}-{3.5,3,2.5}

• Większość funkcji w Mathematice jest listowalna

Attributes[Exp]
Exp[%%%]
%//N

v={2,4,3.1}
v/(v-1)    (* element po elemencie *)

({{First[l]
Last[l]
Part[l,n] lub l[[n]]
Part[l,-n] lub l[[-n]]
Part[l,{(Subscript[n, 1]),(Subscript[n, 2]),…}] lub l[[{(Subscript[n, 1]),(Subscript[n, 2]),…}]], 
}}) 
({{pierwszy element listy l
element ostatni
n-ty element
n-ty element od końca
lista elementów z pozycji (Subscript[n, 1]),(Subscript[n, 2]),…}})

{5,8,6,9}//First
{5,8,6,9}//Last

{5,8,6,9}[[2]]
{5,8,6,9}[[{3,1,3,2,4}]]
%/.{el_->(el^2)}
(a+b+c+d)[[2]]
(a+b+c+d)[[{3,1,3,2,4}]]
%/.{el_->(el^2)}

v={2,4,7}
v[[2]]

v[[2]]=1
v

({{Take[l,n]
Take[l,-n]
Take[l,{m,n}]
Rest[l]
Drop[l,n]
Drop[l,-n]
Drop[l,{m,n}], 
}}) 
({{pierwszych n elementów z listy l
ostatnich n elementów
elementy od m do n (włącznie)
lista l z pominiętym pierwszym elementem
lista l z pominiętymi n pierwszymi elementami
lista l z pominiętymi n ostatnimi elementami
lista l z pominiętymi elementami od m do n}})

t={a,b,c,d,e,f,g}
Take[t,3]
Take[t,-3]
Take[t,{2,5}]
Rest[t]
Drop[t,3]
Drop[t,{3,3}]

Dwakroć po cztery w Mathematice

Cztery rodzaje nawiasów

({{f[x]
{a,b,c}
l[[i]]
(wyr), 
}}) 
({{kwadratowe dla argumentów funkcji
klamrowe dla list
podwójne kwadratowe do indeksowania
okrągłe do grupowania}})

Sin[x]
{a,b,c}
%[[3]]
(3+4)*5
3+4*5
(a=c)+b+c
a

Cztery sposoby zapisu funkcji

({{f[x,y]
f@x
x//f
x~f~y, 
}}) 
({{„standardowy”
prefiksowy
postfiksowy
infiksowy}})

Sin[x]
Sin@x
Sin@{x,2.1,Pi/3}
{x,2.1,Pi/3}//Sin
Sin[{x,2.1,Pi/3}[[2]]]  (* pobierz element i wylicz *)
Sin[{x,2.1,Pi/3}][[2]]  (* wylicz i pobierz element *)
{a,b,c}~Join~{d,e,f}

N[Pi,30]
Pi~N~30
Pi//N
N@ Pi

a=Sin@4+(b=7)
b
a=(4//Sin)+(b=7)

a=(b=1;c=2)+(d=3);
a
b
c

Ale ostrożnie! – nie komplikuj wyrażeń ponad miarę pamiętając o brzytwie
 Ockhama: 
 "Entia non sunt multiplicanda praeter necessitatem" 
 („Nie należy mnożyć bytów ponad potrzebę”)

Zrozumieć strukturę wyrażeń – manipulowanie ich fragmentami

fG=1/(s^2+2*s+5)
FullForm[fG]    (* dzielenie nie istnieje *)
mianownik=fG[[1]]
czlonZEs=fG[[1,2]]
wspolczynnik=fG[[1,2,1]]
TreeForm[fG]

fG=1/(s^2+2*s+ω)     (* zobaczmy więc *)
fG//FullForm                       (* ω jest na końcu *)
fG[[1,1]]
fG[[1,1]]=5;fG
fG//FullForm

fG[[1,1]]
fG[[1,1]]=ω;fG   
fG//FullForm

fG=1/(s^2+2*s+5)  (* ale przy liczbie w miejsce „omegi”... *)
fG//FullForm                    (* 5 jest na początku *)
fG[[1,1]]
fG[[1,1]]=ω;fG
fG//FullForm

fG[[1,1]]
fG[[1,1]]=5;fG                  (* Hmmm... *)
fG//FullForm

fG=1/(s^2+2*s+5);   (* porównajmy *)
fG[[1,1]]=ω;fG                  (* wyrażenie uzyskane przez podmianę elementu *)
fG//FullForm
fG1=1/(s^2+2*s+ω)   (* wyrażenie wpisane bezpośrednio *)
fG1//FullForm
fG[[1,1]]
fG1[[1,1]]

fG[[1,1]]=5;fG                  (* Hmmm... *)   (* Pamięta swoją „historię”? *)
fG1[[1,1]]=5;fG1      (* Hmmmmmmmm... *)  (* Więc „ale o co chodzi”? *)
fG//FullForm
fG1//FullForm

fG=1/(s^2+2*s+5);   (* porównajmy jeszcze raz te same zmienne *)
fG[[1,1]]=ω;fG               (* wyrażenie uzyskane przez podmianę elementu *)
fG//FullForm
fG1=1/(s^2+2*s+ω)   (* wyrażenie wpisane bezpośrednio *)
fG1//FullForm

(* zobaczmy definicje *)
?fG
?fG1
fG//OwnValues      (* „brudne wyrażenie” (dirty expression) *)
fG1//OwnValues    (* które FullForm wylicza, więc i sortuje „w locie” *)

fG//OwnValues//FullForm
fG1//OwnValues//FullForm

• Mathematica jest bardziej oszczędna niż się „wydaje” – przy definiowaniu zmiennych wylicza definiujące je wyrażenia, zapamiętuje w posortowanej wersji i oznacza bitem „ jestem posortowane” (funkcja HoldPattern)
 • Podstawienie „chirurgiczne” nie resetuje tego bitu, by „nie sortować co chwilę” – stąd różnica
 • W Mathematice zmienna to „żywy organizm”, który ciągle chce się upraszczać i sortować, a nie po prostu miejsce w pamięci do „przechowywania” wartości jak w C++ czy Pythonie

wx={1,2,3}//MatrixForm    (* inny rodzaj „zabrudzenia” *)
wy={4,5,6}//MatrixForm
wx+wy
%//FullForm

(wx={1,2,3})//MatrixForm
(wy={4,5,6})//MatrixForm
wx+wy//MatrixForm

Święta trójca – OwnValues, UpValues i DownValues

x1=10;
OwnValues[x1]
UpValues[x1]
DownValues[x1]

x2[x_]=10;
OwnValues[x2]
UpValues[x2]
DownValues[x2]

x3/:f[x3]=10;
OwnValues[x3]
UpValues[x3]
DownValues[x3]

Jak to w sumie działa? Jak „rozgryzany” jest zapis f[x]?
Krok 1 (OwnValues): System patrzy na sam symbol x i pyta: Czy x to zwykła zmienna? Czy ma jakieś OwnValues? Jeśli tak, to stosuje zapamiętaną tam regułę.
Krok 2 (UpValues): Jeśli x nie ma wartości własnej, system patrzy „w górę” i sprawdza UpValues. Pyta: Czy symbol x wie coś o tym, jak zachować się wewnątrz funkcji f? Jeśli tak, to stosuje zapamiętaną regułę.
Krok 3 (DownValues): Na koniec, jeśli x nic nie wie, system schodzi „w dół” i sprawdza DownValues dla f. Pyta główną funkcję: Szanowna f, czy masz ogólną regułę na to, co zrobić z tym, co dostałaś w nawiasie? Jeśli tak, to stosuje zapisaną tam regułę.
Są jeszcze SubValues i FormatValues

Wprowadzanie wyrażeń: stałe, operatory, litery greckie, wyrażenia wielowymiarowe

({{znak
π
∞
°, 
}}) ({{symbol
\[Pi]
\[Infinity]
\[Degree], 
}})({{skrót
p
inf
deg, 
}})({{wartość
Pi
Infinity
Degree, 
}})

– znak Escape

Sin[60 Degree]
Sin[60°]
Sin[π/3]

({{znak
x≤y
x≥y
x≠y
x->y, 
}})({{symbol
x\[LessEqual]y
x\[GreaterEqual]y
x\[NotEqual]y
x\[Rule]y, 
}}) ({{skrót
x <= y
x >= y
x != y
x -> y, 
}})({{wyrażenie
x<=y
x>=y
x!=y
x->y, 
}})

x/(x+1)/.x->3+y
x/(x+1)/.x -> 3+y

• Wiele takich „znaków” zamieniana jest automatycznie,
    np. -> pojawia się po wpisaniu „->coś”

({{\[Alpha]
a lub alpha
\alpha
&alpha;
\[Omega] w
\[CapitalOmega] W
\[Epsilon] e
\[CurlyEpsilon] ce, 
}}) 
({{({{„pełna nazwa” litery α
skrót „mathematicowy”
skrót „lateksowy”
skrót „HTLM-owy”
ω
Ω
ϵ
ε}})}})

– użyj palety 🙂

α=1
ω=100

({{znak
∑wyr
(∑_(□=□)^□)wyr
∏ wyr
∫ wyr
d zm
√ wyr
(Sqrt[wyr]), 
}}) ({{symbol
\[Sum]

\[Product]
\[Integral]
\[DiferentialD]
\[Sqrt]
SqrtBox[wyr], 
}})({{skrót
sum 
sumt
prod
int
dd
sqrt
 Ctrl+2, 
}})({{wyrażenie
znak sumy
znak sumy oznaczonej
znak iloczynu
znak całki
znak różniczki
znak pierwiastka
znak pierwiastka, 
}})

Sum[i,{i,1,10}]
(∑_(i=1)^10)i
Integrate[x^2,{x,0,10}]
(∫_0^10)(x^2)\[DifferentialD]x
Sqrt[x+y]
√(x+y)
(Sqrt[x+y])

• Klawisz Ctrl potrafi dużo więcej niż wprowadzanie „pierwiastka z daszkiem”, np. Ctrl+^ czy Ctrl+6 – więcej na Wprowadzanie dwuwymiarowych wyrażeń – Tutorial

(x^y)

({{zapis „dwuwymiarowy”, zapis „jednowymiarowy”, znaczenie}, {(x^y), x^y, potęga}, {(x/y), x/y, dzielenie}, {(Sqrt[x]), (RefLink[Sqrt, paclet:ref/Sqrt])[x], pierwiastek kwadratowy}, {(x^(1/n)), x^(1/n), pierwiastek n-tego stopni}, {(∑_(i=(Subscript[i, min]))^(Subscript[i, max]))f, (RefLink[Sum, paclet:ref/Sum])[f,{i,(Subscript[i, min]),(Subscript[i, max])}], suma}, {(∏_(i=(Subscript[i, min]))^(Subscript[i, max]))f, (RefLink[Product, paclet:ref/Product])[f,{i,(Subscript[i, min]),(Subscript[i, max])}], iloczyn}, {∫f dx, (RefLink[Integrate, paclet:ref/Integrate])[f,x], całka nieoznaczona}, {(∫_(Subscript[x, min])^(Subscript[x, max]))f dx, (RefLink[Integrate, paclet:ref/Integrate])[f,{x,(Subscript[x, min]),(Subscript[x, max])}], całka oznaczona}, {(∂_x)f, (RefLink[D, paclet:ref/D])[f,x], pochodna cząstkowa}, {(∂_(x,y))f, (RefLink[D, paclet:ref/D])[f,x,y], pochodna cząstkowa po wielu zmiennych}, {(z^*), (RefLink[Conjugate, paclet:ref/Conjugate])[x], liczba sprzężona}, {(m^ᵀ), (RefLink[Transpose, paclet:ref/Transpose])[m], transpozycja}, {(Subscript[expr, [[i,j,…]]]), (RefLink[Part, paclet:ref/Part])[expr,i,j,…], element}})

x/y
(x/y)
m={a,b,c}
m[[1]]
(Subscript[m, [[1]]])

• Ale nie „wszystko” co wygląda tak samo jest „tym samym”

a1=1+Power[x,y]
a2=1+Superscript[x,y]
a1/.{x->2,y->3}
a2/.{x->2,y->3}

• Można definiować własne skróty, np. dla „polskich cudzysłowów”

AppendTo[CurrentValue[EvaluationNotebook[],InputAliases],"lll"->"„"];
AppendTo[CurrentValue[EvaluationNotebook[],InputAliases],"rrr"->"”"];

CurrentValue[EvaluationNotebook[],InputAliases]~Take~-5

Wyrażenia w języku naturalnym

• Rozpocznij wpis w nowej komórce od znaku równości – pojawi się on na pomarańczowym tle „przed” komórką

Ostrzeżenia i komunikaty o błędach

• Mathematica generuje komunikaty i kontynuuje pracę!

wynik1=10/0;
wynik2=5+5;
{wynik1,wynik2}

Macierz={{1,2},{3,4}};
Wektor={1,2,3};
iloczyn=Macierz.Wektor;
suma=Macierz+Macierz;
iloczyn
suma

pomiary={0.5,1.2,3.4};
zlyOdczyt=pomiary[[10]];
dobryOdczyt=pomiary[[2]]*100;

Print["Zły odczyt to: ",zlyOdczyt];
Print["Dobry odczyt to: ",dobryOdczyt];

Table[pomiary[[i]],{i,1,10}]

Graphics[{Gray,Disk[{0,0},1],"To nie jest koło"}]

Manipulate[Plot[Sin[x],{x,0,a}],{a,{1,2,3,"BŁĄD"}}]

• Jeśli nie rozumiemy co się stało – klikamy pierwsze trzy kropeczki z lewej lub różowe tło czy plusik z prawej i czytamy!
 • Jeśli rozumiemy a komunikaty nas „denerwują” – wyłączamy je

({{Off[Funkcja::tag]
On[Funkcja::tag], 
}}) 
({{nie wyświetlaj komunikatów dla funkcji Funkcja
wyswietlaj komunikaty}})

Sqrt[4,5]
Off[Sqrt::argx]
Sqrt[4,5]
On[Sqrt::argx]

• Często niestety wyrażenie nie wylicza się jak chcieliśmy a komunikatu o błędzie nie ma (bo jest ono poprawnym wyrażeniem symbolicznym)

Manipulate[Plot[Sin[a*x+b],{x,0,10}],{a,1,5}]
Manipulate[Plot[Sin[a*x+b],{x,0,10}],{a,1,5},{b,0,pi}]

Graphics[{LightBlue,Disk[{0,0},1],Solve[x^2==4,x]}]

System pomocy, pakiety rozszerzające i konteksty

({{?Nazwa
??Nazwa
 ?Aaaa*
?*Aaaa*, 
}}) 
({{pokaż informacje o funkcji Nazwa
pokaż dodatkowa informacje o funkcji Nazwa
pokaż informacje o obiektach,których nazwy zaczynają sie od Aaaa
pokaż informacje o obiektach,których nazwy zawierają Aaaa}})

?Log
??Log

?Lo*

?*Plot*

?:=

• Większość pakietów Mathematici stanowi obecnie jej część

<<DiscreteMath`GraphPlot`
<<Combinatorica`

GraphPlot3D[{2->1,3->1,3->2,4->1,4->2,5->1,5->2}]
MinimumChangePermutations[{a,b,c}]

• Ale ciągle nie wszystkie ☺ – więcej na Wolfram System Standard Extra Packages

q=Conjugate[Quaternion[4,-3,1,-2]]

<<Quaternions`
q=Conjugate[Quaternion[4,-3,1,-2]]

q+1
q^2
(Subscript[q, 2])=Quaternion[1,3,-2,2]
q+(Subscript[q, 2])
q+(Subscript[q, 2])//FromQuaternion

q*(Subscript[q, 2])
q**(Subscript[q, 2])  (* ** – mnożenie nieprzemienne *)
(Subscript[q, 2])**q

a*b-b*a
a**b-b**a
a**(b+c)
3**4

Re[q]
Im[q]
Abs[q]
Norm[q]
Sin[q]

Listy i programowanie funkcyjne

Lista – uniwersalna struktura danych

Tworzenie i łączenie list obiektów

({{Table[f[i],{i,n}]
Array[f,n]
Range[n]
Range[(Subscript[n, 1]),(Subscript[n, 2])]
Range[(Subscript[n, 1]),(Subscript[n, 2]),(Subscript[Δ, n])]
Subdivide[n]
Subdivide[(Subscript[x, max]),n]
Subdivide[(Subscript[x, min]),(Subscript[x, max]),n]
, 
}}) 
({{lista  f[i],i=1,2,…,n
lista  f[i],i=1,2,…,n
lista {1,2,3,…,n}
lista {(Subscript[n, 1]),(Subscript[n, 1])+1,…,(Subscript[n, 2])}
lista {(Subscript[n, 1]),(Subscript[n, 1])+(Subscript[Δ, n]),…,(Subscript[n, 2])}
lista {0,1/n,2/n,…,1}
lista {0,(Subscript[x, max])/n,2(Subscript[x, max])/n,…,(Subscript[x, max])}
lista {(Subscript[x, min]),(Subscript[x, min])+(Subscript[Δ, x])/n,(Subscript[x, min])+2(Subscript[Δ, x])/n,…,(Subscript[x, max])}
z (Subscript[Δ, x])=(Subscript[x, max])-(Subscript[x, min]) }})

Table[i^2,{i,2,10,2}]
Array[(2#)^2&,5]
Array[#^2&,5,{2,10}]

Table[Sin[alpha °],{alpha,2,10,2}]
Table[Sin[alpha °],{alpha,2.,10,2}]
Array[Sin[# °]&,5,{2.,10}]

f[x_]:=x^2-3*x+1;
Table[f[i],{i,4}]
Array[f,4]

Range[0,2,0.4]
Subdivide[0,Pi,8]

({{Join[(Subscript[l, 1]),(Subscript[l, 2]),...], połącz listy (Subscript[l, i])}, {Append[wyr,elem], dołącz elem na końcu wyrażenia wyr}, {PreAppend[wyr,elem], dołącz elem na początku wyrażenia wyr}, {AppendTo[zm,elem], dołącz elem na końcu zmiennej zm}, {PreAppendTo[zm,elem], dołącz elem na początku zmiennej zm}, {Flatten[l], spłaszcz listę l na wszystkich poziomach}, {Flatten[l,n], spłaszcz listę l do n–tego poziomu}})

listaA={1,2,3};
listaB={4,5,6};
wynikJoin=Join[listaA,listaB]
wynikAppend=Append[listaA,listaB]
Flatten[wynikAppend]
AppendTo[listaA,listaB]
listaA

czas=Range[0,10,0.2];   (* Generujemy sztuczne dane pomiarowe *)
napiecie=Table[Exp[-0.3*t]*Sin[2*t],{t,czas}];
daneDoWykresu=Transpose[{czas,napiecie}];

Take[daneDoWykresu,3]
ListLinePlot[daneDoWykresu,Mesh->All,PlotStyle->Red]

n=25000;                               (* Czasy realizacji *)
czasTab=AbsoluteTiming[listaTab=Table[i,{i,n}];][[1]] (* deklaratywnie *)
czasArr=AbsoluteTiming[listaArr=Array[#&,n];][[1]]        (* funkcyjnie *)
czasApp=AbsoluteTiming[listaApp={};                                       (* iteracyjnie *)
Do[AppendTo[listaApp,i],{i,n}];][[1]]

czasArr/czasTab
czasApp/czasTab

tlo={GrayLevel[0.9],Rectangle[{0,0},{10,5}]};
losoweKola=Table[{RandomChoice[{Red,Blue,Orange,Yellow}],Disk[{RandomReal[{1,9}],RandomReal[{1,4}]},RandomReal[{.1,.4}]]},{i,50}];
calyRysunek=Join[tlo,losoweKola];
Graphics[calyRysunek]

Wektory i macierze: operacje liniowe

({{{a,b,c}, wektor (({{a}, {b}, {c}}))          (zazwyczaj ☺)}, {{{a,b},{c,d}}, macierz (({{a, b}, {c, d}}))}})

Są reprezentowane przez listy oczywiście – jak wszystko w Mathematice

v={x,y,z}
m={{a,b,c},{d,e,f},{g,h,i}}
v//MatrixForm
m//MatrixForm

m[[1,2]]
m[[1]]
m[[All,1]]
m[[1]]//MatrixForm
m[[All,1]]//MatrixForm

({{a b   lub   a*b, iloczyn „list” (element po elemencie)}, {a.b   lub   Dot[a,b], iloczyn wektorów (skalarny), macierzy, tensorów}, {a×b   lub   Cross[a,b], iloczyn wektorowy}, {a+b, suma wektorów, macierzy, tensorów }})

v+{(Subscript[x, p]),(Subscript[y, p]),(Subscript[z, p])}-{(Subscript[x, pp]),(Subscript[y, pp]),(Subscript[z, pp])}//MatrixForm
p v+q//MatrixForm
v v//MatrixForm
v.v //MatrixForm                              (* pierwszy v poziomy *)
v.{(Subscript[x, p]),(Subscript[y, p]),(Subscript[z, p])} //MatrixForm
v \[Cross] v //MatrixForm

m v //MatrixForm
m.v//MatrixForm
v.m//MatrixForm    (* tu v poziomy *)
m.m//MatrixForm

Funkcje do tworzenia / operowania na wektorach

({{Table[f[i],{i,n}], wektor {f[1],f[2],…,f[n]}}, {Array[f,n], wektor {f[1],f[2],…,f[n]}}, {Range[n], wektor {1,2,3,…,n}}, {Range[(Subscript[n, 1]),(Subscript[n, 2])], wektor {(Subscript[n, 1]),(Subscript[n, 1])+1,…,(Subscript[n, 2])}}, {Range[(Subscript[n, 1]),(Subscript[n, 2]),(Subscript[Δ, n])], wektor {(Subscript[n, 1]),(Subscript[n, 1])+(Subscript[Δ, n]),…,(Subscript[n, 2])}}, {c v , pomnóż wektor v przez skalar c}, {(Subscript[v, 1]).(Subscript[v, 2]), iloczyn skalarny dwóch wektorów}, {(Subscript[v, 1])×(Subscript[v, 2]) lub Cross[(Subscript[v, 1]),(Subscript[v, 2])], iloczyn wektorowy dwóch wektorów}, {Dimensions[v], wymiar wektora}})

Table[i,{i,3}]//MatrixForm
Array[#&,3]//MatrixForm
Range[3]//MatrixForm

v={a,b,c}
c v
v.v
v\[Cross]v
%//Dimensions

Funkcje do tworzenia / operowania na macierzach

({{Table[f[i,j],{i,m},{j,n}], macierz m×n złożona z wyrażeń f[i,j]}, {Array[f,{m,n}], macierz m×n złożona z wyrażeń f[i,j]}, {IdentityMatrix[n], macierz jednostkowa n×n }, {DiagonalMatrix[elem], macierz diagonalna z elementami elem 
na głównej przekątnej}, {c m , pomnóż macierz m przez skalar c}, {(Subscript[m, 1]).(Subscript[m, 2]), iloczyn macierzy}, {Inverse[m], macierz odwrotna}, {Transpose[m], transpozycja}, {Tr[m], ślad}, {MatrixPower[m,n], n–ta potega macierzy}, {Det[m], wyznacznik}, {Eigenvalues[m], wartości własne}, {Eigenvectors[m], wektory własne}, {Dimensions[m], wymiary macierzy}})

Table[a[i,j],{i,3},{j,3}]//MatrixForm
Array[a,{3,3}]//MatrixForm
IdentityMatrix[3]//MatrixForm
DiagonalMatrix[Range[3]]//MatrixForm

(m={{a,b},{c,d}})//MatrixForm
Inverse[m]//MatrixForm
%.m//MatrixForm
%//Simplify//MatrixForm

m//MatrixForm
Transpose[m]//MatrixForm
Det[m]
Tr[m]
Eigenvalues[m]//MatrixForm
Dimensions[m]

Zaawansowane operowanie elementami: testowanie, poszukiwanie, dodawanie i usuwanie

({{MemberQ[l,wz]
MatrixQ[wyr]
All/Any/NoneTrue[l,test]
Select[l,war]
Position[wyr,wz], 
}}) 
({{czy elementy listy l pasują do wzorca wz
czy wyrażenie wyr reprezentuje macierz
czy elementy listy l spełniają test
lista elementów  l, które spełniają warunek war
lista pozycji  wyr, które pasują do wzorca wz}})

w={10,-20,30,0,50};
M={{1,2,3},{4,-5,6},{7,8,9}};
MemberQ[w,0]
AllTrue[w,Positive]
AnyTrue[Flatten[M],Negative]
MatrixQ[M,NumericQ]

w
Select[w,#>15&]
Select[w,Negative]
Position[w,x_/;x>15]
Position[w,_?(#>15&)]
Position[w,_?Negative]

({{Insert[l,elem,n]
PreAppend/Append[l,elem]
Delete[l,test]
DeleteCases[l,wz]
Drop[l,n], 
}}) 
({{wstaw elem do listy l na pozycji n
dodaj na początek/koniec listy l element elem
usuń element z pozycji n listy l
usuń element listy l, które pasują do wzorca wz
usuń n pierwszyych elementów listy l}})

Insert[w,99,3]//MatrixForm
Insert[M,{100,200,300},2]//MatrixForm
Insert[M//Transpose,{100,200,300},2]//Transpose//MatrixForm
Append[M,{10,11,12}]//MatrixForm

w
Delete[w,4]//MatrixForm
Drop[w,2]//MatrixForm
Drop[M,{2,2}]//MatrixForm
Drop[M,None,{2,2}]//MatrixForm
DeleteCases[M,{___,_?Negative,___}]

Grupowanie i reorganizacja elementów

({{Partition[l,n]
Flatten[l]
GatherBy[l,war]
Reverse[wyr]
RotateLeft/Right[wyr,n], 
}}) 
({{podziel listę l na podlisty po n elementów
spłaszcz listę
zbierz elementy listy l wedlug kryterium war
odwróć kolejność elementów w wyr
przesuń cyklicznie o n pozycji w lewo/prawo}})

w={1,2,3,4,5,6,7,8,9,10};
M={{1,2},{3,4},{5,6}};
Partition[w,2]
Flatten[M]
GatherBy[w,EvenQ]

M//MatrixForm
Reverse[M]//MatrixForm
Reverse[M,2]//MatrixForm
RotateLeft[w,2]

Programowanie i mechanizmy funkcji

Definiowanie funkcji – różnice między = a :=

({{f[x_]:=wyr
_
x_
x_typ
f[x_,y_,...]:=wyr
?f
Clear[f], 
}}) 
({{zdefiniuj „opóźnioną” funkcję f z argumentem x
wzorzec reprezentuący dowolne wyrażenie
jak wyżej,nazwany lokalnie x
jak wyżej,zaakceptuj gdy ma głowę typ
funkcja wielu zmiennych
wyświetl definicję f
usuń definicję f}})

• f[x_]:=wyr – Wylicz argument, nazwij co otrzymałeś x i wylicz wyrażenie wyr

f[x_]:=x^2+3*x
?f
f[3]
f[x^2]

g[x_Integer]:=x^2+3*x
g[x_Real]:=ala
?g
g[3]
g[3.]
g[x^2]

Head[{1,2,3}]
Head[5]
Head[3.14]
Head[π]
Head["test"]

mag1[x_]:=x^2
mag2[x_Integer]:=x^2
mag2[x_List]:=Total[x]
mag1[5]
mag1[{3,5,7}]
mag2[5]
mag2[{3,5,7}]

rNat[]=RandomInteger[{1,100}];
rOp[]:=RandomInteger[{1,100}];
{rNat[],rNat[],rNat[]}
{rOp[],rOp[],rOp[]}

a=10;
gNat[x_]=x+a;
gOp[x_]:=x+a;
a=100;
gNat[5]
gOp[5]

• Jeśli nie potrzebujesz każdorazowego wyliczania definicji funkcji stosuj przypisanie natychmiastowe
 • Jeśli masz wątpliwości użyj przypisania opóźnionego
 • Jeśli nie działa, to może jednak natychmiastowe powinno być???

fOp[x_]:=x^2+3*x   (* funkcje działające identycznie *)
fNat[x_]=x^2+3*x
?fOp
?fNat

fOp[4]
fNat[4]
fOp[{a,x^2,Sin[x]}]
fNat[{a,x^2,Sin[x]}]

fOp[Print["H"];2]    (* wylicza argument i przekazuje wyliczoną wartość *)
fNat[Print["H"];2]

fNat[Hold[Print["H"];2]]   (* tu wyliczanie zostało wstrzymane *)
%//ReleaseHold
Attributes[fNat]={HoldAll};   (* przekaż argument nie wyliczając go *)
fNat[Print["H"];2]

hOp[x_]:=D[Sin[x^2],x];   (* tu opóźnione zazwyczaj nie działa *)
hNat[x_]=D[Sin[x^2],x];
?hOp
?hNat

hOp[y]
hNat[y]
hOp[3]
hNat[3]
hOp[x+y]
hNat[x+y]

(* Bardzo kosztowne obliczenia - zmienne leniwe (zapamiętuj wartości) *)
f[x_]:=f[x]=(Pause[2];Sin[x]^2+Cos[x]^2);
f[1] 
f[1]
f[π/4]
f[π/4]

Funkcje jako procedury – instrukcje warunkowe oraz pętle i iteracje

({{f[x_]:=((Subscript[wyr, 1]);(Subscript[wyr, 2]);(Subscript[wyr, 3]))
f[x_]:=Module[{zmLok},   
       (Subscript[wyr, 1]);(Subscript[wyr, 2]);(Subscript[wyr, 3]))], 
}}) 
({{zdefiniuj  funkcję wyliczającą sekwencją wyrażeń

jak wyżej, z listą zmiennych lokalnych}})

oblicz[x_]:=(Print["Rozpoczynam obliczenia dla x = ",x];
krok1=x+10;
Print["Wynik posredni: ",krok1];
krok1^2)
oblicz[5]

analizujDane[dane_List]:=Module[{n=1,srednia,wariancja,odchylenie},
n=Length[dane];
srednia=Total[dane]/n;
wariancja=Total[(dane-srednia)^2]/n;
odchylenie=Sqrt[wariancja];
{srednia,odchylenie}]
analizujDane[{10,20,30,40,50}]

({{If[w,t,f,u]
Which[(Subscript[w, 1]),(Subscript[v, 1]),(Subscript[w, 2]),(Subscript[v, 2]),...]
Switch[wyr,(Subscript[w, 1]),(Subscript[v, 1]),(Subscript[w, 2]),(Subscript[v, 2]),...]
Piecewise[{{(Subscript[v, 1]),(Subscript[w, 1])},{(Subscript[v, 2]),(Subscript[w, 2])},...}]
Do[wyr,n]
 Do[wyr,{i,(Subscript[i, min]),(Subscript[i, max]),(Subscript[Δ, i])}]
While[w,wyr]
For[in,war,ink,wyr], 
}}) 
({{wylicz warunek w i zwróć odpowiednio t,f lub u
zwróć pierwsze (Subscript[v, i]) dla którego warunek (Subscript[w, i])jest prawdziwy
wylicz wyr porównuj kolejno z (Subscript[w, i]),zwróć (Subscript[v, i]) gdy równe
zwracaj kolejne wartości (Subscript[v, i]) dla regionów zdefiniowanych przez (Subscript[w, i])
wylicz wyr n razy
jak wyżej,z iteratorem i
wyliczaj wyr dopóki warunek w jest prawdziwy
wylicz in,wyliczaj wyr i ink dopóki war}})

weryfikujWiek[wiek_]:=If[wiek≥18,"Dostęp przyznany","Brak dostępu"]
weryfikujWiek[20]

oceny[punkty_]:=Which[
punkty<50,"Ndst",
punkty<70,"Dst",
punkty<90,"Db",
True,"Bdb"]
oceny[75]

Do[Print["Kwadrat liczby ",i," to: ",i^2],{i,1,4}]

Do[Print["Kwadrat liczby ",i," to: ",i^2],{i,1,5}]

problemCollatza[start_]:=Module[{x=start,licznik=0},
While[x>1,If[EvenQ[x],x=x/2,x=3*x+1];
licznik++];
Print["Liczba krokow do osiagniecia 1: ",licznik]]
problemCollatza[12]

silnia[n_Integer]:=Module[{wyn=1},
For[i=1,i≤n,i++,wyn=wyn*i];
wyn]
silnia[5]

newtonDlaPier[start_]:=Module[{x=start,staryX=0.0,i},For[i=1,Abs[x-staryX]>10^-10,i++,staryX=x;x=(x+2/x)/2;Print["Krok ",i,": x = ",x]];
x]
newtonDlaPier[1.0]

• Pamiętaj jednakże o „deklaratywnym” i „funkcyjnym” sposobie tworzenia pętli

lista={};                                                                    (* źle - sposób procedurlny *)
Do[AppendTo[lista,i^2],{i,1,5}];

lista=Table[i^2,{i,1,5}]                            (* dobrze - sposób deklaratywny *)

FixedPoint[(#+2/#)/2&,1.]   (* algorytm Newtona na (Sqrt[2]) zaimplementowany funkcyjnie *)
Nest[k,x,3]  
NestList[(#+2/#)/2&,1.,4]

Wzorce i reguły przekształcania dla funkcji

({{_       lub Blank[]
x_     lub Patern[x,Blank[]]
_h     lub Blank[h]
x_h   lub Patern[x,Blank[h]]
__     lub BalnkSequence[]
__h   lub BalnkSequence[h]
___   lub BalnkNullSequence[], 
}}) 
({{wzorzec pasujący do dowolnego wyrażenia
jak wyżej nazwany x
wzorzec pasujący do wyrażenia z głową h
jak wyżej nazwany x
wzorzec pasujący do sekwencji wyrażeń
jak wyżej, każde z głową h
wzorzec pasujący do sekwencji wyrażeń w tym pustej}})

wyrazenia={f[2],f[a],f[x+y],g[2]};
wyrazenia/. f[_]->"Pasuje!"
wyrazenia/. f[x_]->x

kwadrat[liczba_]:=liczba^2;
kwadrat[5]
kwadrat[5.]
kwadrat[abc]
kwadrat[Plot[Sin[x],{x,0,10}]]

kwadratI[liczba_Integer]:=liczba^2;
kwadratI[5]
kwadratI[5.]
kwadratI[abc]
kwadratI[Plot[Sin[x],{x,0,10}]]

kwadratIR[liczba_Integer|liczba_Real]:=liczba^2; 
kwadratIR[liczba:(_Integer|_Real)]:=liczba^2; (* równoważne *)
kwadratIR[5]
kwadratIR[5.]
kwadratIR[1/3]
kwadratIR[3+4Ι]
kwadratIR[abc]

sum[elem_]:=Total[elem];
sum[{1,2,3,4,5}]
sum[1,2,3,4,5]

sum1[elem__]:=Total[{elem}];
sum1[{1,2,3,4,5}]
sum1[1,2,3,4,5]

({{p?test
wyr/;test
NumberQ
NumericQ, 
}}) 
({{obiekt pasujący do wzorca p, który spełnia test
wyrażenie, gdy test jest prawdziwy
prawda, gdy obiekt jest liczbą
prawda, gdy obiekt ma wartość numeryczną}})

kwadratNQ[liczba_?NumberQ]:=liczba^2;
kwadratNQ[5]
kwadratNQ[5.]
kwadratNQ[1/3]
kwadratNQ[3+4I]
kwadratNQ[abc]

aa=7;
lista={5,5.,1/3,3+4I,Sin[1.],Sin[1],π,aa,bb}
NumberQ/@lista
NumericQ/@lista

pochodnaNbQ[x_?NumberQ]:=D[Sin[t],t]/.t->x;
pochodnaNcQ[x_?NumericQ]:=D[Sin[t],t]/.t->x;
pochodnaNbQ[Pi]
pochodnaNcQ[Pi]
pochodnaNbQ[Sqrt[2]]
pochodnaNcQ[Sqrt[2]]
pochodnaNbQ[Sqrt[2.]]
pochodnaNcQ[Sqrt[2.]]

fnk[x_?EvenQ]:=x/2;
{fnk[10],fnk[7]}

wiek[wiek_Integer/;wiek>=18]:="Dorosły";  (* zastosuj, gdy warunek spełniony *)
wiek[wiek_Integer/;wiek<18]:="Dziecko"     (* ten warunek można pominąć *)
{wiek[25],wiek[10],wiek[x]}

wiekA[wiek_Integer]:="Dorosły"/;wiek>=18;  (* najpierw policz, potem zdecyduj czy zwrócić *)
wiekA[wiek_Integer]:="Dziecko"
{wiekA[25],wiekA[10],wiekA[x]}

{f[x],f[x+y],f[x,y],f[a],f[4]}/.f[a]->(a^2)
{f[x],f[x+y],f[x,y],f[a],f[4]}/.f[a_]->(a^2)
{f[x],f[x+y],f[x,y],f[a],f[4]}/.f[a__]->(a^2)
{f[x],f[x+y],f[x,y],f[a],f[4]}/.f[a_Integer]->(a^2)

(a^2)+(b^3)+(c^4)+(x^3)/.x->d
(a^2)+(b^3)+(c^4)+(x^3)/.x_->d
(a^2)+(b^3)+(c^4)+(x^3)/.((x_)^3)->d
(a^2)+(b^3)+(c^4)+(x^3)/.x_^3->Sin[x]
(a^2)+(b^3)+(c^4)+(x^3)/.x_^_->d
(a^2)+(b^3)+(c^4)+(x^3)/.x_^y_->(d^y)

{{a},{a,a},{b},{c},{x}}/.a->d
{{a},{a,a},{b},{c},{x}}/.a|b->d
{{a},{a,a},{b},{c},{x}}/.{a..}->{d}

{a,b,c,d,e,f,g}/.{x__,y__}->{{x},{y}}
{a,b,c,d,e,f,g}/.{Longest[x__],y__}->{{x},{y}}
{a,b,c,d,e,f,g}/.{x__,Longest[y__]}->{{x},{y}}
{a,b,c,d,e,f,g}/.{x__,Shortest[y__]}->{{x},{y}}

Znajdź najdłuższą sekwencje liczb całkowitych

{x,3,5,7,y,1,2,3,4,z}/.{a___,b__Integer,c___}->{b}
{x,3,5,7,y,1,2,3,4,z}/.{a___,Longest[b__Integer],c___}->{b}

Zachowanie argumentów: wartości domyślne, opcje, atrybuty funkcji

({{f[x_,y_:(Subscript[y, d]),z_:(Subscript[z, d])]:=wyr
:
wyr:dom

Default[f]
Options[sym]
Attributes[sym], 
}}) 
({{funkcja wielu zmiennych z wartościmi domyślnymi
opcjonalny (Optional)
wzorzec reprezentowany przez wyrażenie wyr, przy
 pominięciu zastępowany wartością dom 
podaj/zdefiniuj wartość domyślą argumentów funkcji f
podaj/zdefiniuj opcje symbolu sym
podaj/zdefiniuj atrybuty symbolu sym}})

mojLog[x_,podstawa_: 10]:=Log[podstawa,x];
{mojLog[100,100],mojLog[100]}

Default[mojaSuma]=10;
mojaSuma[x_.,y_.]:=x+y;
mojaSuma[2,3]
mojaSuma[2]
mojaSuma[]

Options[formatujTekst]={"Kolor"->Blue,"Pogrubienie"->False};
formatujTekst[tekst_String,OptionsPattern[]]:=Style[tekst,OptionValue["Kolor"],If[OptionValue["Pogrubienie"],Bold,Plain]];
formatujTekst["Oto jestem!"]
formatujTekst["Uwaga!","Kolor"->Red,"Pogrubienie"->True]
formatujTekst["Tylko kolor","Kolor"->Green]

plusDziesiec[x_]:=x+10;
plusDziesiec[4]
plusDziesiec[{1,2,3}]
Attributes[Plus]

progowanie[x_]:=If[x>0,1,0];
progowanie[4]
progowanie[{-1,0,2}]
Attributes[If]
SetAttributes[progowanie,Listable]
progowanie[{-1,0,2}]

Jeszcze jeden sposób robienia pętli (funkcyjnie)

gg[x_]:=cosik[x];
gg[4]
gg[{1,2,3,4}]
SetAttributes[cosik,Listable]
gg[{1,2,3,4}]

mojaRel[a,b]===mojaRel[b,a]      (* === – SameQ *)
SetAttributes[mojaRel,Orderless];
mojaRel[a,b]===mojaRel[b,a]

{2==2.0,2===2.0}
{x==y,x===y}
{x==x,x===x}
{x+y===y+x,{x,y}==={y,x}}

Funkcje anonimowe (pure functions) i ich zastosowanie w programowaniu funkcyjnym

({{def&    lub    Function[def]
#
#1,#2,#3,...
l/@f    lub    Map[f,l], 
}}) 
({{zdefiniuj funkcję anonimową
argument funkcji jednej zmiennej
argumenty funkcji wielu zminnych
zastosuj funkcję f do elementów listy l}})

f[x_]=x^2+4x
f[n]
Function[x,x^2+4x]
%[n]
#^2+4#&
%[n]

punkty={2,3,4,5,6};
f[x_]=x^2;    (* tradycyjnie *)
Map[f,punkty]
Map[#^2&,punkty]   (* anonimowo *)
#^2&/@punkty

tempCelsjusz={0,20,100,-40};
#+273.15&/@tempCelsjusz

punkty={{1,5},{3,2},{8,1},{4,4}};
SortBy[punkty,#[[2]]&]
Select[punkty,Norm[#]>5&]

Plot[Sin[x],{x,0,10},ColorFunction->(If[#2>0,Red,Blue]&),ColorFunctionScaling->False]

Plot[Sin[x],{x,0,10},ColorFunction->(Blend[{Blue,Red},#2]&)]

#1^2+4#2&
%[n,m]

Analiza matematyczna i modelowanie

Matematyka symboliczna i algebra

Przekształcanie, upraszczanie i podstawianie wartości pod symbole

({{Simplify[wyr]
FullSimplify[wyr]
LeafCount[wyr]
Expand[wyr]
Factor[wyr]
Collect[wyr]
HornerForm[wyr]
Together[wyr]
Apart[wyr]
Cancel[wyr]
TrigReduce[wyr]
TrigExpand[wyr]
TrigFactor[wyr]
TrigToExp[wyr]
ExpToTrig[wyr]
wyr/.reg
wyr//.reg , 
}}) 
({{uprość
uprość bardziej
policz liście
rozwiń
rozłóż na czynniki
pogrupuj
zwróć w postaci Hornera
zgrupuj
rozłóż na ułamki proste
uprość
uprość funkcje trygonometryczne
rozwiń funkcje trygonometryczne
faktoryzuj funkcje trygonometryczne
przedstaw jako funkcje wykładnicze
zamień wykładnicze na trygonometryczne
zastąp wszystko 
zastąp wielokrotnie}})

pier=Sqrt[x^2*(5+2*Sqrt[6])]
Simplify[pier]
Simplify[pier,x>0]
FullSimplify[pier,x>0]
LeafCount[%]
LeafCount[pier]

wiel=(x+2*a)*(x-3*b)*(x+1)
Expand[wiel]
Factor[%]
Collect[wiel,x]
HornerForm[wiel]

(ulam=(x^2-1)/(x^2+2*x+1)+2/(x+3))//TraditionalForm
Together[ulam]//TraditionalForm
Apart[ulam]//TraditionalForm
Cancel[ulam]//TraditionalForm

(wyr=Sin[2*x]+Cos[x]^2)//TraditionalForm
TrigReduce[wyr]//TraditionalForm
TrigExpand[wyr]//TraditionalForm
TrigFactor[wyr]//TraditionalForm
TrigToExp[wyr]//TraditionalForm
ExpToTrig[%]//TraditionalForm

wiel=x^2+3*x+1+4y
wiel/.x->2
wiel/.x->{1,2,3}
wiel/.{x->2,y->3}
wiel/.{x->{a,b,c},y->{d,e,f}}

{x,y}/.{x->y,y->z}
{x,y}/.(x->y)/.(y->z)
{x,y}//.{x->y,y->z}

(x+y)/.(x->y)/.(y->x)
(x+y)//.{x->y,y->x}

x/.(x->y)/.(y->x+z)
x//.{x->y,y->x+z}
$IterationLimit

Sumy, iloczyny, granice

({{Sum[f,{i,(Subscript[i, max])}]
NSum[f,{i,(Subscript[i, max])}]
Product[f,{i,(Subscript[i, max])}]
Limit[f,x->(SuperStar[x])], 
}}) 
({{wylicz sumę f dla i od 1 do (Subscript[i, max])
wylicz numerycznie sumę f dla i od 1 do (Subscript[i, max])
wylicz iloczyn f dla i od 1 do (Subscript[i, max])
wylicz granicę funkcji f przy x dążącym do (SuperStar[x])}})

Sum[i^2,{i,1,n}]
Sum[1/2^n,{n,1,Infinity}]
Sum[1/(n^3+Sin[n]),{n,1,Infinity}]
NSum[1/(n^3+Sin[n]),{n,1,Infinity}]
NSum[1/(n^3+Sin[n]),{n,1,Infinity},WorkingPrecision->30]

Product[i,{i,1,n}]
Product[i+1,{i,1,n}]
Product[i+n,{i,1,n}]
Product[(4*n^2)/(4*n^2-1),{n,1,Infinity}]

Limit[Sin[x]/x,x->0]
Limit[(1+1/n)^n,n->Infinity]
Limit[1/x,x->0]
Limit[1/x,x->0,Direction->-1]
Limit[1/x,x->0,Direction->1]

Rozwiązywanie równań i nierówności algebraicznych

({{Solve[rown,zm]
NSolve[rown,zm]
Reduce[wyr,zm]
FindInstance[wyr,zm]
FindRoot[rown,{x,(Subscript[x, 0])}], 
}}) 
({{rozwiąż równanie rown ze względu na zmienne zm
rozwiąż numerycznie
zredukuj wyrażenie wyr dla zmiennych zm
znajdź zmienne zm dla których wyrażenie wyr jest prawdziwe
znajdź pierwiastek równań rown w pobliżu (Subscript[x, 0]) (numerycznie)}})

Solve[a*x^2+b*x+c==0,x]
Solve[(x^2+2)(x^2-2)==0,x]
Solve[(x^2+2)(x^2-2)==0,x,Reals]
Solve[{(x^2+2)(x^2-2)==0,x>0},x,Reals]
Solve[{(x^2+2)(x^2-s)==0},x,Reals]

Solve[{x+y==4,x-y==2},{x,y}]
Solve[{x+y==0,x^2+y^2==4},{x,y}]
Solve[{x+y==4,x^2+y^2==4},{x,y}]

Solve[x^5-5*x+1==0,x]
NSolve[x^5-5*x+1==0,x]
Solve[x^2-a>0,x]
Reduce[x^2-a>0,x]

Solve[{x,y}∈InfiniteLine[{{0,0},{2,1}}]&&{x,y}∈Circle[],{x,y}]
Graphics[{{Blue,InfiniteLine[{{0,0},{2,1}}],Circle[]},{PointSize[Large],Red,Point[{x,y}]/.%}},ImageSize->Small]

Solve[Sin[x]==a,x]
Solve[Sin[x]+Cos[x]==0,x]
Solve[Sin[x]^2-3/2Sin[x]+1/2==0,x]

Solve[Cos[x]==x,x]
Reduce[Cos[x]==x,x]
FindInstance[Cos[x]==x,x]
FindRoot[Cos[x]==x,{x,0}]
FindRoot[{Exp[x-2]==y,y^2==x},{{x,1},{y,1}}]

Równania różniczkowe i dynamika

Notacja pochodnych – funkcje wielu zmiennych

({{D[f,x]
D[f,x,y,...]
f'
Derivative[(Subscript[n, 1]),(Subscript[n, 2])][f], 
}}) 
({{pochodna cząstkowa funkcji f po x
pochodna cząstkowa funkcji f kolejno po x,y,...
pochodna funkcji f jednej zmiennej
pochodna f po kolejnych zmiennych rzędu (Subscript[n, 1]), (Subscript[n, 2]),...}})

f[x_,y_]=x^3*y^2+Sin[x*y]
f[x_]=f[x,1]
D[f[x],x]
f'[x]
D[f[x,y],x]
D[f[x,y],y]

D[f[x,y],x,y]
D[f[x,y],y,x]
D[f[x,y],x,x,x,y]
Derivative[3,1][f][x,y]

g''[x]
D[g[x,y],{x,2},y]
%//FullForm
Derivative[n,m][g][x,y]

Różniczkowanie i całkowanie symboliczne

({{D[f,x]
D[f,{x,n}]
D[f,x,y,...]
D[f,{x,n},{y,m},...]
D[f,{{(Subscript[x, 1]),(Subscript[x, 2]),...}}]
Integrate[f,x]
Integrate[f,{x,(Subscript[x, min]),(Subscript[x, max])}]
Integrate[f,x,y,...], 
}}) 
({{pochodna cząstkowa funkcji f po x
pochodna cząstkowa rzędu n funkcji f po x
pochodna cząstkowa funkcji f kolejno po x,y,...
jak wyżej odpowiednio rzędów n,m,...
pochodna funkcji skalarnej po wektorze {(Subscript[x, 1]),(Subscript[x, 2]),...}
całka nieoznaczona funkcji f po x
całka oznaczona funkcji f po x dla x∈[(Subscript[x, min]),(Subscript[x, max])]
całka nieoznaczona po wielu zmiennych}})

f[x_]=x^5
f'[x]
f''[x]
f''''[x]

D[f[x,y],x,x]
D[f[x,y],{x,2}]
D[f[x,y],{x,2},{y,3}]

D[k[x1,x2,x3],{{x1,x2,x3}}]//MatrixForm   (* pochodne po wektorze *)
D[k[(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])],{{(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])}}]//MatrixForm
(vk={(Subscript[k, 1])[(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])],(Subscript[k, 2])[(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])],(Subscript[k, 3])[(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])]})//MatrixForm
D[vk,{{(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])}}]//MatrixForm   (* działa choć w dokumentacji ani mru mru *)

Integrate[f[x,y],x]
D[%,x]
Integrate[f[x,y],{x,1,5}]
Integrate[g[x,y],x]
%//FullForm

Integrate[Sin[Sin[x]],x]
Integrate[Sin[Sin[x]],{x,0,π}]
%//N
NIntegrate[Sin[Sin[x]],{x,0,π}]

f[x_,y_]:=x^2*y+Exp[x]
Integrate[f[x,y],x,y]
Integrate[f[x,y],{y,0,2},{x,0,3}]
Integrate[f[x,y],{x,0,2},{y,0,x}]
Integrate[f[x,y],{y,0,x},{x,0,2}]
Integrate[f[x,y],{x,y}∈ImplicitRegion[x^2+y^2<=1,{x,y}]]

Integrate[Exp[-(x^2+y^2+z^2+x*y*z)],{z,0,1},{y,0,1},{x,0,1}]
NIntegrate[Exp[-(x^2+y^2+z^2+x*y*z)],{z,0,1},{y,0,1},{x,0,1}]

Definiowanie i rozwiązywanie równań różniczkowych zwyczajnych (ODE), wykorzystanie wyników

({{DSolve[r,y[x],x]
DSolve[r,y[x],{x,(Subscript[x, min]),(Subscript[x, max])}]
DSolve[r,y,x]
DSolve[{(Subscript[r, 1]),(Subscript[r, 2]),...},{(Subscript[y, 1]),(Subscript[y, 2]),...},x], 
}}) 
({{rozwiąż równanie różniczkowe r dla y[x] ze zmienną niezależną x
jak wyżej,w przedziale [(Subscript[x, min]),(Subscript[x, max])]
jak wyżej,zwróć wynik w postaci funkcji anonimowej
jak wyżej,układ równań wielu zmiennych}})

(rown=y'[x]+2*y[x]==Exp[x])//TraditionalForm
rozw1=DSolve[rown,y[x],x]
rown/.rozw1
rown/.rozw1/.D[rozw1,x]
%//Simplify

rozw2=DSolve[rown,y,x]
rown/.rozw2
%//Simplify

init=y[0]==1;
rozw2=DSolve[{rown,init},y,x]
rown/.rozw2
Plot[y[x]/.rozw2,{x,-2,2}]

(rown=y''[x]+y'[x]+2*y[x]==0)//TraditionalForm
init={y[0]==2,y'[0]==0};
rozw=DSolve[{rown,init},y,x]
rown/.rozw//Simplify
Plot[y[x]/.rozw,{x,0,20}]
Plot[y[x]/.rozw,{x,0,20},PlotRange->All]

(rown=(y'[x])^2==y[x])//TraditionalForm
init={y[0]==2};
rozw=DSolve[{rown,init},y,x]
rown/.rozw//Simplify
Plot[y[x]/.rozw,{x,-5,5},PlotRange->All]
Plot[Evaluate[y[x]/.rozw],{x,-5,5},PlotRange->All]

Metody numeryczne i optymalizacja

Numeryczne rozwiązywanie równań różniczkowych

({{NDSolve[r,y[x],{x,(Subscript[x, min]),(Subscript[x, max])}]
NDSolve[r,y,{x,(Subscript[x, min]),(Subscript[x, max])}]
NDSolve[{(Subscript[r, 1]),...},{(Subscript[y, 1]),...},{x,(Subscript[x, min]),(Subscript[x, max])}], 
}}) 
({{rozwiąż równanie różniczkowe r dla y[x] dla x∈[(Subscript[x, min]),(Subscript[x, max])]
jak wyżej,zwróć wynik w postaci funkcji anonimowej
jak wyżej,układ równań wielu zmiennych}})

Wahadło matematyczne

(rown=y''[x]+Sin[y[x]]==0)//TraditionalForm
init={y[0]==2,y'[0]==0};
rozwS=DSolve[{rown,init},y,x]
rown/.rozwS//Simplify
Plot[y[x]/.rozwS,{x,0,15},PlotRange->All]

rozwN=NDSolve[{rown,init},y,{x,0,15}]
rown/.rozwN//Simplify
Plot[Evaluate[y[x]/.rozwN],{x,0,15}]
Plot[Evaluate[rown[[1]]/.rozwN],{x,0,15}] (* by sprawdzić*)
Plot[Evaluate[rown[[1]]/.rozwN],{x,0,15},PlotRange->All]

Plot[Evaluate[y[x]/.{rozwS,rozwN}],{x,0,15},PlotRange->All,PlotStyle->{{Thick,Blue},{Dashed,Red}}]
Plot[Evaluate[Sin[y[x]]/.{rozwS,rozwN}],{x,0,15},PlotRange->All,PlotStyle->{{Thick,Blue},{Dashed,Red}}]

(* porównanie z kosinusem *)
okres=4*EllipticK[Sin[2/2]^2]//N   (* okres = 4 całki eliptyczne z Sin[y[0]/2]^2 *)
Plot[Evaluate[{y[x]/.rozwN,2Cos[2 π/okres x]}],{x,0,3},PlotRange->All,PlotStyle->{{Thick,Blue},{Dashed,Red}}]

(* mniejsze wychylenie początkowe *)
init={y[0]==0.1,y'[0]==0};
rozwS=DSolve[{rown,init},y,x]
init={y[0]==1/10,y'[0]==0};
rozwS=DSolve[{rown,init},y,x]
rown/.rozwS//Simplify
Plot[y[x]/.rozwS,{x,0,15},PlotRange->All]

Rationalize[34.0396]

(* porównanie z kosinusem *)
amp=5π/180;
init={y[0]==amp,y'[0]==0};
rozwN=NDSolve[{rown,init},y,{x,0,15}]
okres=4*EllipticK[Sin[amp/2]^2]//N   (* okres = 4 całki eliptyczne z Sin[y[0]/2]^2 *)
Plot[Evaluate[{y[x]/.rozwN,amp Cos[2 π/okres x]}],{x,0,3},PlotRange->All,PlotStyle->{{Thick,Blue},{Dashed,Red}}]

(* większe wychylenie początkowe – porównanie z kosinusem *)
amp=179.5π/180;
okres=4*EllipticK[Sin[amp/2]^2]//N   (* okres = 4 całki eliptyczne z Sin[y[0]/2]^2 *)
init={y[0]==amp,y'[0]==0};
rozwN=NDSolve[{rown,init},y,{x,0,okres}]
Plot[Evaluate[{y[x]/.rozwN,amp Cos[2 π/okres x]}],{x,0,okres},PlotRange->All,PlotStyle->{{Thick,Blue},{Dashed,Red}}]

Model drapieżnik-ofiara (równanie Lotki-Volterry)

uklad={x'[t]==x[t]-1/2*x[t]*y[t],y'[t]==-3/4*y[t]+1/4*x[t]*y[t]};
init={x[0]==4,y[0]==2};
rozwS=DSolve[{uklad,init},{x,y},{t,0,20}]
symul=NDSolve[{uklad,init},{x,y},{t,0,20}]
Plot[Evaluate[{x[t],y[t]}/. symul],{t,0,20},PlotStyle->{Thick,Dashed},PlotLegends->{"Ofiary (x)","Drapieżniki (y)"},PlotRange->All]

FindMinimum[y[t]/.symul,{t,6}]

init={x[0]==8,y[0]==4};    (* inne populacje początkowe *)
symul=NDSolve[{uklad,init},{x,y},{t,0,100}];
Plot[Evaluate[{x[t],y[t]}/. symul],{t,0,100},PlotStyle->{Thick,Dashed},PlotLegends->{"Ofiary (x)","Drapieżniki (y)"},PlotRange->All]
Plot[Evaluate[{x[t],y[t]}/. symul],{t,0,5},PlotStyle->{Thick,Dashed},PlotLegends->{"Ofiary (x)","Drapieżniki (y)"},PlotRange->All]

init={x[0]==8,y[0]==4};
symul=NDSolve[{uklad,init,WhenEvent[x[t]<1,tend=t;"StopIntegration"]},
{x,y},{t,0,100}]
Plot[Evaluate[{x[t],y[t]}/. symul],{t,0,5},PlotStyle->{Thick,Dashed},PlotLegends->{"Ofiary (x)","Drapieżniki (y)"},PlotRange->All]
Plot[Evaluate[{x[t],y[t]}/. symul],{t,0,tend},PlotStyle->{Thick,Dashed},PlotLegends->{"Ofiary (x)","Drapieżniki (y)"},PlotRange->All]

Wykorzystywanie wyników: wiele rozwiązań i relacje logiczne

(rown=(y'[x])^2==y[x])//TraditionalForm
init={y[0]==2};
rozw=DSolve[{rown,init},y,x]

rozw[[1]]
y/.rozw[[1]]
y[x]/.rozw[[1]]
y'[x]/.rozw[[1]]

f[x_]=y[x]/.rozw[[1]]
f[0]
?f

(rown=y''[t]+Sin[y[t]]==0)//TraditionalForm
init={y[0]==2,y'[0]==0};
rozw=NDSolve[{rown,init},y,{t,0,15}]
Plot[Evaluate[y[t]/.rozw],{t,0,15}]
wyk=Plot[Evaluate[{y'[t],y''[t]}/.rozw],{t,0,15},PlotLegends->{y',y''},AxesLabel->{t,"y',y''"}]

FindRoot[y'[t]/. rozw,{t,6}]
punkt=Graphics[{PointSize[Medium],Red,Point[{t/.%,0}]}];
Show[wyk,punkt]
Plot[Evaluate[{y'[t],y''[t]}/.rozw],{t,0,15},PlotLegends->{y',y''},AxesLabel->{t,"y',y''"},Filling->{2->0}]
NIntegrate[Abs[y''[t]]/. rozw,{t,0,15}]

rozw={{y[x]->x^2},{y[x]->50-5*x}};
galaz1=y[x]/. rozw[[1]];
galaz2=y[x]/. rozw[[2]];
yHybryd[x_]:=Piecewise[{{galaz1,x<5},{galaz2,x>=5}}];
Plot[yHybryd[x],{x,0,10},GridLines->{{5},None},Method->{"GridLinesInFront"->True},PlotStyle->{Thick,Red},PlotLabel->"Układ przełączany w punkcie x = 5"]

Piłka skacząca w dół po schodach

c=0.75;
sol=NDSolve[{y''[t]==-9.8,y[0]==13.5,y'[0]==5,a[0]==13,WhenEvent[y[t]-a[t]==0,y'[t]->-c y'[t]],WhenEvent[Mod[t,1],a[t]->a[t]-1]},{y,a},{t,0,8},DiscreteVariables->{a}] ;
Plot[Evaluate[{y[t],a[t]}/.sol],{t,0,8},Filling->{2->0}]

Wykrywanie przecięć osi

rown={x'[t]==-y[t]-x[t]^2,y'[t]==2x[t]-y[t]^3};
init={x[0]==y[0]==1};
rozw=NDSolve[{rown,init},{x,y},{t,14}];
ParametricPlot[Evaluate[{x[t],y[t]}/.rozw],{t,0,14},AxesLabel->{x,y},ImageSize->Small]

{rozw, points}=Reap@NDSolve[{rown,init,WhenEvent[y[t]==0&&x[t]>0,Sow[{x[t],y[t]}]]},{x,y},{t,14}];
ParametricPlot[Evaluate[{x[t],y[t]}/.rozw],{t,0,14}, Epilog->{PointSize[Medium],Red,Point@@points},AxesLabel->{x,y}]