Wykorzystanie poprzednio uzyskanych wyników:
- % lub Out[-1] – poprzedni wygenerowany rezultat;
- %% lub Out[-2] – przedostatni wygenerowany rezultat;
- %n lub Out[n] – rezultat z linii Out[n],
- In[n] – ponowne obliczenie n-tej formuły,
- InString[n] – wypisanie tekstu n-tej formuły;
Sekwencje operacji:
- wyr1;wyr2;wyr3 – wykonuje szereg operacji podając rezultat ostatniej,
- wyr1;wyr2; – wykonuje szereg operacji nie wysyłając rezultatu na ekran,
- wyr1; – wykonuje operację nie wyświetlając wyniku.
Wprowadzanie wyrażeń
Data i czas:
- Date[ ] – podaje aktualną datę rok, miesiąc, dzień, godzina, minuta, se-kunda,
- Date[h] podaje aktualną datę w strefie czasowej przesuniętej o h godzin wzgl. Greenwich,
- TimeZone[ ] podaje strefę czasową ustawioną w systemie,
- AbsoluteTime[ ] – liczba sekund od 1.01.1900,
- SessionTime[ ] – liczbą sekund od rozpoczęcia aktualnej sesji programu,
- Timing[wyr] – oblicza wyr i zwraca listę zawierającą czas obliczeń i wynik,
- Pause[n] – przerwa w pracy progeamu na n sekund;
- FromDate[data] dokonuje konwersji daty na czas bezwzględny,
- ToDate[czas] – dokonuje konwersji czasu bezwzględnego na datę.
Przykład 1. p={2006,11,20,0,0,0}; k=p+{1,0,0,0,0,0}; FromDate[k]-FromDate[p]
s=FromDate[ { 2007 , 11 , 20 , 12 , 0 , 0 }]; ToDate[Random[Integer, { 0 , s}]] – wy-generowanie losowej daty
Timing[N[Pi,100];] – sprawdzenie, jak długo Mathematica liczny π.
1
Zapis wyrażeń w innych formatach:
- InputForm[wyr] – zapisuje wyr w formie ”wprowadzenia”,
- OutputForm[wyr] – wypisuje wyr w formie podawania wyników,
- TextForm[wyr] – zapisuje wyr w formacie tekstowym,
- TeXForm[wyr] – zapisuje wyr w formacie TEX-a,
- FortranForm[wyr] – zapisuje wyr w formacie języka Fortran,
- CForm[wyr] – zapisuje wyr w formacie języka C.
Informacje o obiektach:
- ?Nazwa – ogólne informacje o obiekcie ”Nazwa”,
- ??Nazwa – rozszerzone informacje o obiekcie ”Nazwa”,
- ?A* – informacja o obiektach zaczynających się od A.
Wczytanie pakietu:
- << nazwa – wczytanie pakietu nazwa.
Przykład 2. In[1]:= RSolve[{a[1]==1,a[2]==1,a[n+2]==a[n+1]-a[n]} , {a[n]},n]
1
Liczby i zmienne
Typy liczb
W programie można wykorzystać nast. typy liczb:
- Integer,
- Rational,
- Real,
- Complex.
Użyteczne komendy:
- Head[liczba] – sprawdzanie typu ”liczba”,
- Numerator[w] – sprawdzenie licznika ułamka określającego liczbę w,
- Denominator[w] – sprawdzenie mianownika ułamka określającego liczbę w,
- IntegerQ[x] – sprawdza, czy x jest liczbą wymierną,
- EvenQ[x], OddQ[x] – sprawdzanie, czy x jest liczbą parzystą/nieparzystą, 2
- PrimeQ[x] – sprawdzanie, czy x jest liczbą pierwszą,
- Positive[x], Negative[x] – sprawdzanie, czy x jest liczbą dodatnią/ujemną,
- NonNegative[x] – sprawdzanie, czy x jest liczbą nieujemną,
- NumberQ[zmienna] – sprawdzanie, czy podana zmienna jest liczbą (do-wolnego typu).
Typy liczb
Przykład 3. In[1]:= x=Random[Integer,0,20]; {PrimeQ[x],EvenQ[x]}
Out[1]:= ???
In[2]:={Positive[-1],Positive[0],Positive[1]}
Out[2]:= ???
Konwersja między typami liczb
Użyteczne funkcje:
- N[wyr] lub wyr//N – przybliżona wartość numeryczna wyr,
- N[wyr,n] – jak wyżej, ale z dokładnością do n-cyfr,
- Rationalize[x] – podaje liczbę wymierną przybliżającą x,
- Rationalize[x,dx] – jak wyżej, ale z dokładnością dx.
Przykład 4. In[1]:= N[E,12]
Out[1]:= ???
In[2]:=N[9/8]
Out[2]:= ???
In[3]:= Rationalize[%]
Out[3]:= ???
In[4]:= Rationalize[N[E],10 ∧( − 5)]
Out[4]:= ???
In[5]:= Rationalize[N[E],0]
Out[5]:= ???
Systemy liczbowe
Użyteczne funkcje:
- IntegerDigits[n] – podaje listę zawierającą cyfry dziesiętne n,
- IntegerDigits[n,b] – jak wyżej, ale w systemie o podstawie b,
- RealDigits[x] – podaje złożoną z listy cyfr zapisu x w syst. dziesiętnym oraz liczbę cyfr przed kropką dziesiętną,
- Rationalize[x,dx] – jak wyżej, ale w systemie o podstawie b, 3
- BaseForm[x,b] – zapisuje x w systemie o podstawie b,
- b∧∧( liczba) – zapis liczba w syst. dzies.
Przykład 5. In[1]:= IntegerDigits[2007,16]
Out[1]:= ???
In[2]:=RealDigits[1987.351]
Out[2]:= ???
In[3]:= Rationalize[%]
Out[3]:= ???
In[4]:= BaseForm[2007,12]
Out[4]:= ???
In[5]:= 2 ∧∧(100010011)
Out[5]:= ???
Operacje arytmetyczne
Użyteczne funkcje:
- x∧y lub Power[x,y] – xy, x/y lub Divide[x,y] – x , x*y lub Times[x,y] –
y
x · y, x+y lub Plus[x,y] – x + y, -x – −x,
- x+=y lub AddTo[x,y] – dodaje do zmiennej x wartość y – x = x + y, x-=y lub SubstractFrom[x,y] – odejmuje od zmiennej x wartość y – x = x − y, x*=y lub TimesBy[x,y] – mnoży zmienną x przez wartość y – x = x · y, x/=y lub DivideBy[x,y] – dzieli zmienną x przez wartość y – x = x , y
- x++ lub Increment[x], ++x lub PreIncrement[x] – zwiększenie zmiennej x o 1,
- x– – lub Decrement[x], – –x lub PreDecrement[x] – zmniejszenie zmiennej x o 1,
Przykład 6. In[1]:= 460/68
Out[1]:= ???
In[2]:=460./68
Out[2]:= ???
In[3]:= 460/68 //N
Out[3]:= ???
In[4]:= x=0; P rint[ T able[ x+ = 2 , {i, 1 , 3 }]]
Out[4]:= ???
In[5]:= x=2; y=x++; {x,y}
Out[5]:= ???
In[6]:= x=2; y=++x; {x,y}
Out[6]:= ???
Definiowanie zmiennych
Użyteczne funkcje:
- x=wart – przypisanie wart zmiennej x, x=y=wart – przypisanie wart za-równo x jak i y, x=. lub Clear[x] – anulowanie jakiejkolwiek wart. przypi-sanej x,
- x y – oznacza x · y, xy – oznacza zmienną xy, 2x – oznacza 2 · x, x∧ 2 y oznacza x 2 y, ale nie x 2 y,
4
- wyr/. x− > wart – podstawienie w wyr w miejsce x wart, wyr/. {x− > xwar, y− > ywar} – wykonanie dwu podstawień jednocześnie, Przykład 7. In[1]:= x=5;y=6;x,y
Out[1]:= ???
In[2]:= Clear[x]; x,y
Out[2]:= ???
In[3]:= v = x∧ 3 − x + 1
Out[3]:= ???
In[4]:= v/. x− > 2
Out[4]:= ???
In[5]:= v/. x− > 1 − y
Out[5]:= ???
In[6]:= x=4; v
Out[6]:= ???
In[7]:= x=.; v
Out[7]:= ???
In[8]:= 1 + x + x∧ 2 /.x− > 1 + a Out[8]:=???
In[9]:= {f[1],f[2],f[3]}/. f [2] − > a
Out[9]:=???
In[10]:= {f[1],f[2],f[3]}/. f [ x−] − > x∧ 2 − 1
Out[10]:=
Precyzja obliczeń
Użyteczne funkcje:
- Precision[x] – podaje liczbę cyfr znaczących w x,
- Accuracy[x] – podaje liczbę cyfr po kropce dzies. w x,
- $MachinePrecision – podaje dokładność komputera,
- MachinePrecisionQ[x] – sprawdza, czy x jest podane z dokładnością komputera.
Przykład 8. In[1]:= s=Random[Real,{0,100},Random[Integer,{10,30}]]
Out[1]:=
???
In[2]:= {Precision[s],Accuracy[s]}
Out[2]:= ???
In[3]:= $MachinePrecision
Out[3]:= ???
In[4]:= MachinePrecisionQ[s]
Out[4]:= ???
Kontrola długości wyników
Użyteczne funkcje:
- wyr; – obliczenie wyr bez wyświetlenia wyników,
- wyr//Short lub Short[wyr] – oblicza wyr podając wynik w 1 linii,
- Short[wyr,n] – jak wyżej, ale wynik n liniach,
- Length[wyr] – podaje długość wyr.
Przykład 9. In[1]:= a=Expand[( x∧ 2 + y∧ 2 + 5) ∧(10)]; Out[1]:=
In[2]:= Length[a]
Out[2]:= ???
In[3]:= a//Short
Out[3]:= ???
5
Użyteczne funkcje:
- x=y lub Set[x,y] – przypisanie zmiennej x wartości y,
- x==y lub Equal[x,y] – sprawdzenie, czy x i y są równe,
- x===y lub SameQ[x,y] – sprawdzenie, czy x i y są identyczne,
Przykład 10. In[1]:= x=7
Out[1]:= ???
In[2]:= x
Out[2]:= ???
In[3]:= x==6
Out[3]:= ???
In[4]:= 9x-8==9x-8
Out[4]:= ???
In[5]:= z==3
Out[5]:= ???
In[6]:= z===3
Out[6]:= ???
Uwaga 1. Różnica między == oraz ===: Pierwsze daje w wyniku ”true”
lub ”false” tylko wtedy, gdy wyrażenia mają konkretną wartość liczbową lub identyczną postać. Drugie (===) sprawdza, czy wyrażenia są identyczne bez względu na wartości liczbowe, które się do nich podstawi. Stąd też == używane jest do zapisu równań.
Operatory logiczne i relacje
Użyteczne funkcje:
- x==y lub Equal[x,y] – równość,
- x!=y lub Unequal[x,y] – ”różność”,
- x > = y lub GreaterEqual[x,y] – większe lub równe,
- x < = y lub LessEqual[x,y] – większe lub równe,
- x===y lub SameQ[x,y] – identyczne,
- x=!=y lub UnsameQ[x,y] – nieidentyczne,
- x==y==z – wszystkie zmienne równe,
- x!=y!=z – wszystkie zmienne różne,
- !p lub Not[p] – negacja p,
- p && q && ... lub And[p,q,...] – koniunkcja,
- p||q||... lub Or[p,q,...] – alternatywa,
- Implies[p,q] – p = ⇒ q,
- Xor[p,q,...] – wykluczenie,
- If[p,prawda,fałsz] – wykonuje: prawda, jeśli p==True, fałsz, jeśli p==False;
- LogicalExpand[wyr] – rozwinięcia wyrażenia logicznego.
6
Przykład 11. In[1]:= x∧ 2!=0!=0
Out[1]:= ???
In[2]:= 28 > 19 < 20 > = 20 > 0 < = 1
Out[2]:= ???
In[3]:= x > = 6
Out[3]:= ???
In[4]:= 2 < = 3 || 5 < 0
Out[4]:= ???
In[5]:= ( p||q)&&( r||p)
Out[5]:= ???
In[6]:= LogicalExpand[%]
Out[6]:= ???
2
Analiza
Wielomiany
- PolynomialQ[wyr,x] – sprawdzenie, czy wyr jest wielomianem zmiennej x,
- PolynomialQ[wyr,{x,y,. . . }] - sprawdzenie, czy wyr jest wielomianem zmiennych x,y,. . . ,
- Variables[viel] – podaje listę zmiennych wielomianu viel,
- Length[viel] – podaje liczbę składników wielomianu viel,
- Exponent[viel,x] – podaje najwyższy wykładnik zmiennej x w wielomianie viel,
- Coefficient[viel,wyr] – podaje współczynnik przy wyr w wielomianie viel,
- Coefficient[viel,x,n] – podaje współczynnik przy xn,
- Coefficient[viel,x,0] – podaje wyraz wolny wielomianu viel,
- CoefficientList[viel,x] – podaje listę współczynników (od x 0) stojących w wielomianie viel przy kolejnych potęgach zmiennej x,
- PolynomialQuotient[p(x),q(x),x] – część całkowita z dzielenia wielomianu p przez wielomian q,
- PolynomialRemainder[p(x),q(x),x] – reszta z dzielenia wielomianu p przez wielomian q,
- PolynomialGCD[viel1,viel2] – nwd wielomianów viel1,viel2,
- PolynomialGCD[viel1,viel2] – nww wielomianów viel1,viel2,
- PolynomialMod[viel,c] – redukcja viel modulo c,
- Factor[viel] – rozkład wielomianu viel na czynniki,
- FactorList[viel] – j.w. w postaci listy,
- Decompose[viel] – rozkład wielomianu jako złożenie dwóch wielomianów.
7
Przykład 12. In[1]:= wiel=Expand[( x − 1)( y + 2)( z + 1) ∧ 2]
Out[1]:=
???
In[2]:= Length[wiel]
Out[2]:= ???
In[3]:= CoefficientList[wiel,z]
Out[3]:= ???
In[4]:= {PolynimialQuotient[ x∧ 3 − 2 , x − 1 , x],PolynimialRemainder[ x∧ 3 −
2 , x − 1 , x]}
Out[4]:= ???
In[5]:= PolynomialGCD[ x∧ 3+2 x∧ 2 −x− 2 , ( x− 1) ∧ 2( x+3)( x− 5)]
Out[5]:=
???
In[6]:= PolynomialMod[ x∧ 2 + 1 , x − 1]
Out[6]:= ???
In[7]:= Factor[wiel]
Out[7]:=???
In[8]:= Decompose[ x∧ 6 + x∧ 3 + 1 , x],
Out[8]:=???
Przekształcanie wyrażeń
- Expand[wyr] – wykonuje działania (wymnaża, podnosi do potęgi), (w przypadku ułamka jedynie licznik,
- ExpandAll[wyr] – jak wyżej, ale do całości,
- ExpandNumerator[wyr], ExpandDenominator[wyr] – rozwija licznik/mianownik funkcji wymiernej,
- PowerExpand[wyr] – zamienia ( xy) n na xnyn oraz ( xa) b na xab,
- Factor[wyr] – rozkłada wyr na iloczyn czynników,
- Together[wyr] – sprowadzenie do wspólnego mianownika,
- Apart[wyr] – rozkład wyr na ułamki proste„
- Cancel[ulamek] – skraca ułamek ulamek,
- Collect[wyr,x] – grupuje współczynniki wg potęg x,
- Simplify[wyr] – uproszczenie, sprowadzenie wyr do najprostszej postaci,
- Expand[wyr,Trig − > True] – wyraża potęgi funkcji trygonometrycznych przez funkcje wielokrotności kąta,
- Factor[wyr,Trig − > True] – instrukcja odwrotna do poprzedniej,
- TrigFactor[wyr] – zamienia sumę funkcji trygonometrycznych na iloczyn funkcji trygonometrycznych, (pakiet Algebra’Trigonometry’)
- TrigReduce[wyr] zamienia funkcję trygonometryczną wielokrotności kąta na iloczyn funkcji trygonometrycznych tego kąta, (pakiet Algebra’Trigonometry’) 8
Przykład 13. In[1]:= v = ( x + 1) ∧ 2(2 − x) /(( x + 3)( x + 2) ∧ 2) Out[1]:=
???
In[2]:= Expand[v]
Out[2]:= ???
In[3]:= ExpandAll[v]
Out[3]:= ???
In[4]:= Together[%]
Out[4]:= ???
In[5]:= Apart[%]
Out[5]:= ???
In[6]:= Factor[%]
Out[6]:= ???
In[7]:= w=Expand[( x + 2)( x + y) ∧ 2]
Out[7]:=???
In[8]:= Collect[w,x]
Out[8]:=???
In[9]:= p=Expand[( Cos[ x]) ∧ 2,Trig − > True]
Out[9]=???
In[10]:= Factor[p,Trig − > True]
Out[10]=???
In[11]:= TrigFactor[Sin[2*x]+Sin[4*x]]
Out[11]=???
In[12]:= TrigReduce[Sin[4*x]]
Out[12]=???
Wybrane funkcje i stałe
√
- Sqrt[x] –
x,
- Exp[x] – ex,
- Log[x] – ln x,
- Log[x,b] – log x,
b
- Sin[x], Cos[x], Tan[x], Cot[x] – funkcje trygonometryczne,
- ArcSin[x], ArcCos[x], ArcTan[x], ArcCot[x] – funkcje cyklometryczne,
- n! lub Factorial[n] – n!,
- Abs[x] – |x|,
- Max[x,y,. . . ], Min[x,y,. . . ] – maksimum i minimum zbioru {x,y,’ldots},
- Pi – π,
- E – e ,
- Degree – π/ 180,
√
- I – i =
− 1,
- Infinity – ∞,
√
- GoldenRatio – złoty podział φ = 1+ 5 ,
2
- EulerGamma – stała Eulera γ ' 0 . 5772156.
9
- Solve[row,x] – podaje rozwiązanie równania row względem niewiadomej x,
- Solve[{row1,row2,. . . },{x,y,. . . }] – rozwiązanie układu równań względem podanych niewiadomych,
- x/.rozw – utworzenie listy wszystkich rozwiązań,
- wyr/.rozw – podstawienie rozwiązań do wyr,
- Solve[ukl] – rozwiązuje ukl względem wszystkich występujących w nim niewiadomych,
- Eliminate[{l1==r1,l2==r2,. . . },{x,. . . }] – eleminacja podanych zmiennych z układu,
- Reduce[{l1==r1,l2==r2,. . . },{x,. . . }] – uproszczenie układu,
- SolveAlways[rownania,zmienne] – podaje wartości parametrów występu-jących w równaniach, dla których równania są spełnione dla dowolnych wartości zmiennych,
- NSolve[row,x] – numeryczne rozwiązanie równania,
- NSolve[{row1,row2,. . . },{x,y,. . . }] – numeryczne rozwiązanie układu rów-nań względem podanych niewiadomych,
- FindRoot[row,{x,x0}] – numeryczne rozwiązanie równania startujące z x0,
- FindRoot[funk==0,{x,{x0,x1}}] – numeryczne poszukiwanie pierwiastka funkcji.
Rozwiązywanie równań
Przykład 14. In[1]:= x∧ 2 − 2 x − a == 0
Out[1]:= ???
In[2]:= Solve[%,x]
Out[2]:= ???
In[3]:= Solve[2 x∧ 2 + 3 x − 5 == 0 , x]
Out[3]:= ???
In[4]:= x∧ 2 − 2 /. %
Out[4]:= ???
In[5]:= Solve[{x+y==1,x+3y==2},{x,y}]
Out[5]:= ???
In[6]:= Solve[ {x∧ 2 + y∧ 2 == 9 , 2 x − y == 5 }, {x, y}]
Out[6]:= ???
In[7]:= w[ x−] := x∧ 3+ x+1;Solve[{w[x]==0,Modulus==5},x]
Out[7]:=???
In[8]:= Eliminate[{2x+y+z==5,x+3y-2z==0},y]
Out[8]:=???
In[9]:= Solve[{2x==a,x==b},x]
Out[9]=???
In[10]:= Reduce[{2x==a,x==b},x]
Out[10]=???
In[11]:= NSolve[ x∧ 4 + x∧ 2 + x == 0 , x]
Out[11]=???
In[12]:= FindRoot[Sin[x]==Exp[x],{x,1}]
Out[12]=???
In[13]:= FindRoot[Sin[x]==Exp[x],{x,-1}]
Out[13]=???
10
- Limit[funk, x− > x 0] – granica funkcji funk w x0,
- Limit[funk, x− > x 0, Direction − > 1] – prawostronna granica funkcji funk w x0,
- Limit[funk, x− > x 0, Direction − > − 1] – lewostronna granica funkcji funk w x0,
Przykład 15. In[1]:= f [ x−] := Sin[ x] /x; Limit[f[x], x− > 0]
Out[1]:=
???
In[2]:= Limit[Exp[-x], x− > Inf inity]
Out[2]:= ???
In[3]:= Limit[Sin[1/x], x− > 0]
Out[3]:= ???
In[4]:= Limit[Exp[1/(1 − x∧ 2)], x− > 1,Direction − > − 1]
Out[4]:=
???
In[5]:= Limit[Exp[1/(1 − x∧ 2)], x− > 1,Direction − > 1]
Out[5]:= ???
Różniczkowanie
- D[f,x] – pochodna (cząstkowa) funkcji f względem x,
- D[f,x1,x2,...] – mieszana pochodna cząstkowa funkcji f względem x1,x2,...,
- D[f,{x,n}] – n-ta pochodna (cząstkowa) funkcji f względem x,
- D[f,x,NonConstants − > {y1,y2,...}] – pochodna funkcji f względem x uwzględ-niając, że y1,y2,... zależą od x,
- Dt[f] – różniczka zupełna funkcji f,
- Dt[f,x] – ”pochodna zupełna” funkcji f (zakłada, że wszystkie symbole poza liczbami zależą od zmiennej x,
- Dt[f,x,Constants − > {c1,c2,...}] – pochodna zupełna funkcji f z uwzględ-nieniem, że c1,c2,... są stałymi.
Przykład 16. In[1]:= Dt[ x∧n,x]
Out[1]:= ???
In[2]:= D[ArcTan[x],x]
Out[2]:= ???
In[3]:= D[ x∧x,x]
Out[3]:= ???
In[4]:= D[2*x*y+ x∧ 2,x,NonConstants − > {y}]
Out[4]:= ???
In[5]:= SetAttributes[c,Constant]; Dt[c+2*a*c*x,x]
Out[5]:= ???
In[6]:= D[f[ x∧ 3,Log[y]],x]
Out[6]:= ???
11
- Integrate[f,x] – całka nieoznaczona funkcji f względem x,
- Integrate[f,{x,x0,x1}] – całka oznaczona funkcji f względem x,
- Integrate[f,{x,x0,x1},{y,y0,y1}] – całka iterowana R x 1 R y 1 f dy dx, x 0
y 0
- NIntegrate[f,{x,x0,x1}] – wartość numeryczna całki,
- NIntegrate[f,{x,x0,xp1,xp2,...,xpn,x1}] – wartość numeryczna całki liczona jako suma po przedziałach (x0,xp1),...,(xpn,x1),
- NIntegrate[f,{x,x0,x1},{y,y0,y1}] – wartość numeryczna całki iterowanej.
Przykład 17. In[1]:= Integrate[ x∧ 3,x]
Out[1]:= ???
In[2]:= Integrate[Exp[- x∧ 2],x]
Out[2]:= ???
In[3]:= Integrate[Sin[x], {x,0,Pi}]
Out[3]:= ???
In[4]:= Integrate[x*y+ y∧ 2,{x,0,1},{y,0,x}]
Out[4]:= ???
In[5]:= Integrate[Sin[Sin[x]],x]
Out[5]:= ???
In[6]:= NIntegrate[Exp[-x],{x,0,Infinity}]
Out[6]:= ???
In[7]:= NIntegrate[1/( Sin[ x] ∧ 2),{x,0,Pi/4}]
Out[7]:= ???
In[8]:= Integrate[1/( Sin[ x] ∧ 2),x]
Out[8]:= ???
In[9]:= NIntegrate[z+1/z,{z,-1-I,1-I,1+I,-1+I,-1-I}]
Out[9]:= ???
Poszukiwanie ekstremów
- ConstrainedMin[f,nier,{x,y,...}] – poszukiwanie minimum funkcji f w za-danym obszarze,
- ConstrainedMax[f,nier,{x,y,...}] – poszukiwanie maksimum funkcji f w za-danym obszarze,
- LinearProgramming[c,m,b] – poszukuje x minimalizującego iloczyn cx i spełniającego warunki mx > = b oraz x > = 0,
- FindMinimum[f,{x,x0}] – poszukuje minimum lokalnego startując z x0,
- FindMinimum[f,{x,x0,x1}] – poszukuje minimum lokalnego używając x0,x1
jako dwu pierwszych wartości,
- FindMinimum[f,{x,x0,x1,x2}] – poszukuje minimum lokalnego wychodząc od x0 i przerywając, jeśli x wyjdzie poza [x1,x2].
Przykład 18. In[1]:= f [ x−] := x∧ 3+ x∧ 2 − 12 x; Plot[f[x],{x,-5,5}]
Out[1]:=
???
In[2]:= FindMinimum[f[x],{x,2}]
Out[2]:= ???
In[3]:= g[ x−] := −f [ x]; FindMinimum[g[x],{x,-4}]
Out[3]:= ???
12
- x+I y – liczba zespolona x+yi,
- Re[z] – część rzeczywista liczby z,
- Im[z] –część urojona liczby z,
- Conjugate[z] – sprzężenie liczby z z,
- Abs[z] – moduł liczby z,
- Arg[z] – argument liczby z ∈ ( −π, π],
- ComplexExpand[wyr] – przekształca wyrażenie wyr,
- ComplexExpand[wyr,{x,y,. . . }] – przekształca wyrażenie wyr zakładając, że {x,y,. . . } są zespolone, pozostałe rzeczywiste,
- TargetFunctions – docelowa postać {Re,Im,Abs,Conjugate,Sign}.
Przykład 19. In[1]:= ComplexExpand[Cos[x+I*y]
Out[1]:= ???
In[2]:=ComplexExpand[z,{z},TargetFunctions − > {Conjugate}]
Out[2]:=
???
3
Algebra
Listy
- Table[f[i],{i,n}] – tworzy list e długości n o elementach f[i],
- Table[f[i],{i,n1,n2}] – tworzy listę o elementach f[i] dla i ∈ {n 1 , n 2 },
- Table[f[i],{i,n1,n2,di}] – jak wyżej, ale ze skokiem di,
- Array[a,n] – tworzy listę długości n postaci {a[1],. . . ,a[n]},
- Range[n] – tworzy listę {1,. . . ,n},
- Range[n1,n2] – tworzy listę postaci {n1,n1+1,. . . ,n2},
- Range[n1,n2,d] – jak wyżej, ale ze skokiem d,
- Map[instr,lista] – stosuje instrukcję instr do każdego elementu listy,
- MapAt[instr,lista,i] – jak wyżej, ale tylko dla i-tego elementu, Przykład 20. In[1]:= { 1 , 2 , 3 }∧ 3 − 1
Out[1]:= ???
In[2]:= b={0,3,2}; (b+1)/(b-4)
Out[2]:= ???
In[3]:= Range[0.2,3.1]
Out[3]:= ???
In[4]:= Table[i/10,{i,10,50,10}]
Out[4]:= ???
In[5]:= a[1] = 1; a[2] = 1; a[ n−] := a[ n] = a[ n− 1]+ a[ n− 2]; T able[ a[ i] , {i, 1 , 7 }]
In[6]:= licz={1,3,4};Apply[Times,licz]
Out[6]:= ???
In[7]:= f [ x−] := x∧ 3 − 1;MapAt[f,licz,2]
Out[7]:= ???
13
- Table[f[i,j],{i,m},{j,n}] – tworzy macierz m × n o elementach f[i,j],
- Array[a,{m,n}] – tworzy macierz m × n z elementami a[i,j],
- IdentityMatrix[n] – generuje macierz jednostkową stopnia n,
- DiagonalMatrix[lista] – tworzy macierz przekątniową o elementach z listy,
- A[[i]] Part[A,i] – i-ty wiersz macierzy A,
- A[[i,j]] Part[A,i,j] – element A[i,j],
- Det[a] – wyznacznik macierzy A,
- Inverse[A] – maceirz odwrotna,
- Transpose[A] – macierz transponowana,
- Minors[A,k] – podaje listę wszyskich minorów stopnia k macierzy A,
- CharacteristicPolynomial[A,x] – wielomian charakterystyczny macierzy A (ze zmienną x),
- Eigenvalues[A] – wyznacza wartości własne macierzy A,
- Eigenvectors[A] – wyznacza wektory własne macierzy A,
- Eigensystem[A] – podaje listę zawierającą wartości i wektory własne macierzy A.
Wektory, macierze
Przykład 21. In[1]:= u={x,y,z};u[[2]]
Out[1]:= ???
In[2]:= p*u+q;
Out[2]:= ???
In[3]:= {x,y}.{a,b}
Out[3]:= ???
In[4]:= m={{a,b},{c,d}};//MatrixForm[m]
Out[4]:= ???
In[5]:= m[[1,2]]
Out[5]:= ???
In[6]:= n={{2,3,4},{0,1,2}}; m.n
Out[6]:= ???
In[7]:= v={x,y};m.v
Out[7]:= ???
In[8]:= v={x,y};v.m
Out[8]:= ???
In[9]:= m=Table[1/(i+j+1),{i,3},{j,3}]
Out[9]:= ???
In[10]:= n=m+IdentityMatrix[3]
Out[10]:= ???
In[11]:= m1=Inverse[m]
Out[11]:= ???
In[12]:= Minors[m,2]
Out[12]:= ???
In[13]:= a={{1,0,-1},{0,1,2},{1,1,-1}};wiel=CharacteristicPolynomial[a]
Out[13]:=
???
In[14]:= Solve[wiel==0,x]
Out[14]:= ???
In[15]:= Eigenvalues[a]
Out[15]:= ???
In[16]:= Eigensystem[a]
Out[16]:= ???
14
Grafika
Wykresy – podstawy
- Plot[f,{x,x1,x2}] – wykres funkcji w [x1,x2],
- Plot[{f1,f2,...},{x,x1,x2}] – jak wyżej, ale dla listy funkcji {f1,f2,...},
- Plot[f,{x,x1,x2},opcja − > wart}] – jak wyżej, ale z opcjami:
– AspectRatio – stosunek wysokości do szerokości: domyślnie 1/Gol-denratio, Automiatic – ustawia według wielkości zakresów x i y,
– Axes – określa, czy rysunek zawiera osie, domyślnie True,
– AxesLabel opisuje osie, domyślnie None, yopis – opisuje oś OY, {xopis,yopis}
– obie osie,
– AxesOrigin określa punkt przecięcia osi, domyślnie Automatic
– Frame – rysuje ramkę wokół wykresu, domyślnie None,
– FrameLabel – umieszcza opis wokół ramki, domyślnie None,
– Ticks – oznaczenie współrzędnych na osiach, domyślnie Automatic,
– Gridlines – siatka współrzędnych,
– PlotRange – zakres wartości funkcji, domyślnie: Automatic, cały zakres: All.
- Show[wykres] – przerysowuje wykres,
- Show[wykr1,wykr2,...] – jak wyżej, ale listę wykresów,
- Show[GraphicsArray[{{w1,w2,...},...}]], – tworzy tablicę wykresów,
- ParametricPlot[{fx,fy},{t,t1,t2}] – tworzy wykres krzywej parametrycz-nej,
- ParametricPlot[{{fx,fy},{gx,gy},...},{t,t1,t2}] – jak wyżej, dla listy krzy-wych,
- ParametricPlot[{fx,fy},{t,t1,t2},AspectRatio − > Automatic] – z zach. kształ-
tów,
- ParametricPlot3D[{fx,fy,fz},{t,t1,t2}] – wykres krzywej przestrzennej.
Wykresy – podstawy
Przykład 22. In[1]:= Plot[{Cos[x],Cos[2x]},{x,0,2Pi}]
Out[1]:= ???
In[2]:= Plot[ x∧ 2,{x,0,1},AxesLabel − > {”x”,” x 2”}]
Out[2]:= ???
In[3]:= Schow[%,Gridlines − > Automatic,AspectRatio − > 1,PlotLabel − > ”Rysunek”]
Out[3]:= ???
In[4]:= r1=Plot[Gamma[1,x],{x,0.1,5}]; r2=Plot[Gamma[2,x],{x,0.1,5}]; r3=Plot[Gamma[3,x],{x,0.1,5}]; r4=Show[r1,r2,r3] ;
Out[4]:= ???
15
In[5]:= Show[GraphicsArray[{{r1,r2},{r3,r4},GraphicsSpacing − > {3mm,4mm}], Out[5]:= ???
In[6]:=ParametricPlot[{Sin[t],Cos[t]},{t,0,2Pi}]
Out[6]:= ???
In[7]:=ParametricPlot[{Sin[t],Cos[t]},{t,0,2Pi},AspectRatio − > Automatic]
Out[7]:= ???
Obiekty graficzne
Graphics[obiekt,opcje] – rysuje obiekty typu:
• Circle[{x,y},r] – oktąg,
• Circle[{x,y},r1,r2] – elepsa o osiach r1,42,
• Circle[{x,y},r,{theta1,theta2}] – okrąg między kątem theta1 a theta2, (podobnie dla elipsy),
• Disk[{x,y},r] – dysk, (wycinki koła i elipsy podobnie)
• Rectangle[{xmin,ymin},{xmax,ymax}] – zamalowany prostokąt,
• Polygon[{{x1,y2},{x2,y2},...{xn,yn}}] – zamalowany wielokąt,
• Point[{x,y}] – punkt,
• Line[{{x1,y1},{x2,y2},...}] – łamana,
• Text[tekst,{x,y}] – tekst wycentrowany względem (x,y),
Przykład 23. In[1]:= Show[Graphics[Point[{3,4}],Axes − > True]]
Out[1]:=
???
Wykresy powierzchni
Graphics[obiekt,opcje] – rysuje obiekty typu:
- Plot3D[f,{x,x1,x2},{y,y1,y2}] – wykres funkcji f,
- ParametricPlot3D[{fx,fy,fz},{t,t1,t2},{u,u1,u2}] – powierzchnia dana pa-rametrycznie,
- ParametricPlot3D[{fx,fy,fz,s},...] – cieniuje wykres w zależności od s.
Przykład 24. In[1]:= ParametricPlot3D[{Cos[t](3+Cos[u]),Sin[t](3+Cos[u]),Sin[u]},
{t,0,2Pi},{u,0,2Pi}, Boxed − > False]
Out[1]:= ???
16