Doporučený metodický postup pro studium systému Mathematica         (součást přednášky FAP007)

Úplný začátek

Podívejte se na Help ⟶ Tutorial, je ve formě slide show.

Pokročilejší přístup

Help ⟶ Záložka "Getting Started"´. Projít všechny varianty.
Užitečné a z matematického hlediska zajímavé informace jsou  v záložce "Demos".

Důkladný průvodce

Help ⟶  Záložka "Tour". Také zde je prospěšné projít všechny varianty.

Přednášející radí následující postup pro porozumění systému:

(Nečiní si nicméně nárok na to, že jeho doporučení jsou suboptimální, natož optimální. Veškeré konstruktivní připomínky, podněty a náměty k přednášce VPFPM sdělené přednášejícímu jsou vítány. Je možné je podávat ústně, písemně i anonymně a e-mailem. Na připomínky podané e-mailem bude přednášejícím reagováno.)

(i)

Projít celou The Mathematica Book (záložka Help), případně Tour.nb. Tím se získá přehled, co všechno je možné pomocí systému realizovat. V této fázi není rozumné se věnovat detailům, navíc jest v prvním čtení nemožné porozumět všemu. Cílem je učinit si mlhavou představu o více než 2000 zabudovaných (build-in) funkcí, případně funkcí z Add-On Packages. Pak pomocí "Help" je v případě potřeby syntakticky správně zabudovat do uživatelského projektu.

(ii)

Jako jeden z efektivních postupů se jeví tento: Help ⟶ přibližný název funkce ⟶ přesný název funkce ⟶ (vybrat příbuznou funkci) ⟶ Further Examples ⟶ příslušnou část označit a  Copy+Paste do vlastního notebooku. U některých funkcí je k dispozici "Advanced Documentation". Doporučuji její přečtení. Čtenář se zde srozumitelným způsobem seznámi se současnými metodami, které obvykle nejsou v syllabech přednášek konaných na MFF.

(iii)

Není možné se naučit, natož pochopit všechno ihned. K nejmocnějším funkcím systému Mathematica (Apply, Map, Thread, případně Fold, Nest a funkcím podobným) je nezbytné se neustále vracet a zkoušet je v konkrétních situacích.

(iv)

Jádro systému Mathematica bylo naprogramováno v jazyku C. Půjdeme-li zpátky, pak C byl naprogramován v Assembleru, a ten přímo ve strojovém kódu. Pro efektivní užití systému Mathematica však není vhodná zakořeněná znalost ideologie procedurálních jazyků jako jsou Pascal, FORTRAN, C++ a další. Znalosti objektově orientovaného programování jsou naopak vítány. V systému Mathematica je sice možné prakticky doslova přepsat program napsaný v některém z těchto procedurálních jazyků, ale tím by byla zcela negována hlavní zbraň systému Mathematica, tj. funkcionalita, přehlednost, rychlost, kontrolovatelná přesnost a verifikovatelnost při modelování. Zejména z hlediska přehlednosti konstrukce modelů (a ve vyšší fázi použití nadstavby WorkBench pro vytváření projektů) jsou funkce typu "cyklus" naprosto nevhodné. Výhodou pro porozumnění systému Mathematica  je znalost logiky jazyků Prolog, LISP (byť velmi starých, které v době svého vzniku neměly podporu v potřebné počítačové technice) .

(v)

Pro úspěšné zvládnutí přednášené látky stačí zhruba 100 až 200 hodin samostudia. Aktivní zvládnutí celého systému je prakticky nemožné.

Lekce 1

Motivace, odkazy

www.wolfram.com

"C:\Program Files\Wolfram Research\Mathematica\5.2\Documentation\English\Tour"

4 pilire

Numericke vypocty

Vypocet pomoci Shift + Enter

1 + 1

(2^1000)

N[π, 20]

Sdruzovani vice vypoctu do jedne bunky

1 + 1
2 + 2
2 + 
3
2
+3

Symbolicke vypocty

e1 = Expand[(((x + y))^7)]

e2 = Factor[e1]

TeXForm[e2/e1]

Grafika

Plot[Sin[x + x^2], {x, 0, π}]
Plot3D[Sin[x + y^2], {x, 0, π}, {y, 0, π}, 
      ViewPoint -> {-0.007,  -1.850,  2.833}]

Programovani

hu[x_] := x^2

"="je okamzite prirazeni, ":=" je odlozene prirazeni

{hu[2], hu[Log[2]], hu[Log[2. ]], hu[e1]}

(Sin^2)[1. ]

Poznamka k sazbe: (x^2) se vysazi jako x Ctrl ^ 2, (Subscript[x, 3]) jako xCtrl _  (Sqrt[x]) nebo z palety (Menu File ⟶ Palettes nebo pomoci Esc sekvenci

hu[x_, y_] := x^y

{hu[2. ], hu[2, 3], hu[2, 3, 4]}

?hu

?Global`*

Clear[hu]
?hu

?Global`*

Remove[hu]
?hu

?Global`*

hil1[n_] := Table[(1/(i + j - 1)), {i, n}, {j, n}]

hil1[3]

h3m = hil1[3] // MatrixForm

Poznamka: f[x] je totez, co x//f resp. f@x

Poznamka: h3m neni totez co hil1[3]!!!

FullForm[h3m]

FullForm[hil1[3]]

Inverse[hil1[3]] // MatrixForm
Inverse[h3m]

(hil15 = hil1[5]) // MatrixForm

N znamena numerickou hodnotu:

{π, π // N, Log[2. ], Log[2], N[Log[2]], 
      N[Log[2], 10]}

0.6931471805599453`
0.6931471805599453093744803656`10.

{Det[hil15], Det[hil15] // N, Det[hil15 // N]}

{Det[h40 = hil1[40]], N[Det[hil1[40]]], Det[hil1[40] // N]}

Det[hil1[40]] Det[Inverse[hil1[40]]]

Cas dole v rohu a beep: Edit⟶Preferences⟶Notebook Options⟶Evaluation Options⟶EvaluationCompletionAct⟶{"Beep", "ShowTiming"}

Inverse[h40][[30, 30]]

{x*y, x y, xy}

aa=(({{a, b}, {c, d}}))

\[EscapeKey][[\[EscapeKey] dava [[

aa[[2, 
      2]]
aa[[All, 2]]

Poznamka k exportu a importu:

$ImportFormats

$ImportFormats // Length

$ExportFormats // Length

Technicke zalezitosti, vstup a vystup

Zruseni vypoctu: Kernel⟶Abort Evaluation nebo Kernel⟶Quit Kernel

inv = Inverse[hil1[200]];

inv3 = Inverse[hil1[3]];

inv3

inv30 = Inverse[hil1[30]];

inv30

Doplneni vyrazu: Ctrl+K

hil

IdentityMatrix

Sign

Typy cisel: Integer, Rational (= (Integer/Integer)), Real, Complex

{2, 2/3, π, 1 + 2 I, 
      1 + 2 I, ((1 + I)/(((2 - I))^3))}

(E^(2  π I))

Zavorky: [ ] argumenty funkci, [[ ]] elementy listu, { } listy, ( ) priorita algebraickych operaci

aa[1, 1]

aa (1, 1)

{aa {1, 2}, aa*{1, 2}}

aa  . {1, 2}

Lekce 2

FAQ - zadne

Technicke zalezitosti, vstup a vystup - pokracovani

Alternativni definice Hilbertovy matice (Cviceni) a ryzi funkce

Clear[hil6];
hil6[n_] := 
      Array[(1/(#1 + #2 - 1)) &, {n, n}]
 (* # argument ryzi funkce (pure function) *)

#(1^2) &[3]

Sin[#1] Cos[#2] &[2, 3]
Sin[#1] Cos[#2] &[2. , 3]

hil6[3]

2D zapis z palety nebo Ctrl + ...

(a/b)

(∑_(i = 1)^n) (i^4)

Mathematica vhodne interpretuje vektory a matice

(aa=(({{a, b}, {c, d}})))(({{e}, {f}}))

Duvod

(({{e}, {f}}))//FullForm

(({{a, b}, {c, d}}))(({{e, f}, {g, h}}))//MatrixForm

Maticovy soucin: . (tecka, dot)

(({{a, b}, {c, d}})).(({{e}, {f}}))//MatrixForm

(({{a, b}, {c, d}})).(({{e, f}, {g, h}}))//MatrixForm

{e, f}.(({{a, b}, {c, d}}))

(({{a, b}, {c, d}})).{e, f}

Transponovat lze pouze matice a ne vektory!!

Transpose[{e, f}]

Transpose[{{e, f}}  ]

{{e, f}} // MatrixForm

xx = Table[(Subscript[x, i]), {i, 3}]

xx . xx

Transpose[{xx}]

Transpose[{xx}] . {xx} // TableForm

Zopakujme

xx*xx
xx . xx
Outer[Times, xx, yy = {(Subscript[y, 1]), (Subscript[y, 2]), (Subscript[y, 3])}] // 
      MatrixForm
Transpose[{yy}] . {xx}

Outer[Plus, xx, yy]

Dalsi operace s maticemi

Eigenvalues[aa]

Inverse[aa]

aa2 = aa /. {b -> a, d -> c}

Inverse[aa2]

PseudoInverse[aa2]

mm = {{1, 2}, {1, 2}};
mm . PseudoInverse[mm] . mm
mm . PseudoInverse[mm] . mm == mm

{2.  == 2, 2.  === 2}
{a == b, a === b}

protoze neni mozne rozhodnour, jakych hodnot a a b nabyvaji:

?a

?b

Baliky programu (Statistika)

<< Statistics`DiscreteDistributions`

ale vetsinou staci

<< Statistics`

?Poi*

PDF (Power Density Function) = hustota

λ = 2; k = 7;
λ =. ; k =. ;
PDF[distr = PoissonDistribution[λ], 
      k]
distrGauss = NormalDistribution[μ, σ]

CDF (Cumulative Distribution Function)

{CDF[distr, k], CDF[distrGauss, x], Quantile[distrGauss, q]}

Momenty

{Mean[distr], Variance[distr], Skewness[distr], 
      Kurtosis[distr]}

ExpectedValue[(x^4), distr, x]
\(ExpectedValue[#\^4 &, distr]\)

Table[
      ExpectedValue[(((x - λ))^k), distr, x], {k, 6}]

tabPois1 = Table[Random[PoissonDistribution[3]], {4}]

SeedRandom[13];
tabPois2 = 
      Table[Random[PoissonDistribution[3]], {10}]
SeedRandom[13];
tabPois3 = 
      Table[Random[PoissonDistribution[3]], {5}]
tabPois4 = Table[Random[PoissonDistribution[3]], {5}]

SeedRandom[1113];
tabPois3 = Table[Random[PoissonDistribution[3]], {5}]

MaxMemoryUsed[]

tabPois5 = 
        Table[Random[
            PoissonDistribution[3]], {10000}];
MaxMemoryUsed[]

LocationReport[tabPois5]

DispersionReport[tabPois5] // N

fr5 = Frequencies[tabPois5]

PDF[PoissonDistribution[3. ], 13]

Needs["Graphics`"]

BarChart[fr5]

Histogram[tabPois5]

Pouziti funkce ListPlot

Reverse[{a, b}]

Map[f, {a, b, c}]
Map[f, {{a, b}, {c, d}}]

fr5rev = Map[Reverse, fr5]

ListPlot[fr5rev, PlotJoined -> True]

Vyrovnani, regrese

x^(Range[6] - 1)

fit5 = Fit[fr5rev, x^(Range[6] - 1), x]

p1 = 
      ListPlot[fr5rev, 
        PlotStyle -> PointSize[0.02]]
p2 = Plot[fit5, {x, 0, 13}, PlotRange -> All]

Show[p1, p2]

FindMinimum[fit5, {x, 9}]

regr5 = Regress[fr5rev, x^(Range[6] - 1), x]

Regress[fr5rev, x^(Range[5] - 1), x]

Generovani pozitivne definitni matice

aa = Table[Random[], {100}, {100}];
Eigenvalues[posdefmat = Transpose[aa] . aa]

Lekce 2

Lekce 2

Lekce 3

FAQ

CDF je zkratka pro Cumulative Distribution Function, tj. ditribucni funkci: F(x) = P {X < x}.

Psani vzorcu: (∫_a^b) (x^2) dx je co?

(∫_a^b) (x^2) \[DifferentialD]x = 
      sin x

(∫_a^b) 
            (x^2) \[DifferentialD]x

Popisky k obrazkum

Plot[(fFresnel = Integrate[Sin[(x^2)], {x, 0, y}]), {y, 0, 
          2  π}, AxesLabel -> {"x", "y"}, 
        PlotLabel -> "Fresneluv integral", 
        Ticks -> {{0, (π/2), π, ((3 π)/2), 2 π}, {0, 
              0.5, 0.75, 1. }}, PlotRange -> All];

empirickyzjistenemaximum = {1.76164, 0.90208};

fFresnel

Clear[fF];
fF[y_] := 
      Integrate[Sin[(x^2)], {x, 0, y}]

fF[2.  π]

maxfF = FindMaximum[fF[x], {x, π/2}]

{maxfF[[2]], 
      Last[maxfF]}

x /. Last[maxfF]

?x

maxfFexact = Maximize[{fF[x], π > x > 0}, x]

Needs["Graphics`"]
Needs["Graphics`Legend`"]
Plot[{Sin[x], Cos[x]}, {x, 0, 2  π}, 
        TextStyle -> {FontFamily -> "Tahoma", 
            FontSize -> 14}, 
        PlotLabel -> "Graf funkce Cos(x) a Sin(x)", 
        PlotStyle -> {Hue[0.3], Hue[0.6]},  
        PlotLegend -> {"Sin(x)", "Cos(x)"}, 
        LegendPosition -> {1.2, -0.5}, 
        LegendShadow -> {0.03, -0.03}, 
        LegendLabel -> "Legenda grafu", 
        LegendOrientation -> Horizontal, 
        Epilog -> {Arrow[{3.5,  .8}, {2.5, Sin[2.5]}, 
              HeadCenter -> 0, HeadLength -> 0.03], 
            Text["Sin(x)", {3.5,  .8}, {0, -1}], 
            Arrow[{1, - .75}, {Pi/2, Cos[Pi/2]}], 
            Text["Cos(x)", {1, - .9}, {0, -1}]}];

PlotLegend // Context

Dalsi moznosti

Zabudovane algoritmy

i1 = Integrate[v1 = (Sqrt[x]) ArcTan[x], x] // FullSimplify

d1 = D[i1, x]

d1 == v1

d1 === v1

d1 // Simplify

x = 5;
sol3 = 
      Solve[eq3 = {a (x^2) + y == x, b x + c (y^2) == y}, {x, 
          y}]

x =. ;
sol3 = 
        Solve[eq3 = {a (x^2) + y == x, b x + c (y^2) == y}, {x, 
            y}];
sol3 // Length

Plus[a, b, c]
Attributes[Plus]

Zkouska, zda druhe reseni skutecne splnuje dany system rovnic

eq3 /.  sol3[[2]] // 
      Simplify

x =. ; y =. ;
(mm = Table[(2^i) + (x^j), {i, 3}, {j, 4}]) // 
      MatrixForm
Dimensions[mm]

NullSpace[mm] // MatrixForm

Diferencialni rovnice symbolicky

eqdif = y'[x] + x y[x] == 
        x Exp[-(x^2)]
DSolve[eqdif, y[x], x]

Zabudovani pocatecni podminky pridanim dalsi rovnice

dsol = DSolve[{eqdif, y[0] == 0}, y[x], x]

yx = 
      y[x] /. dsol[[1]]
(y[x] /. dsol) // First

?yx

y1[x_] := yx
y1[z]

yx /. x -> z

y2[x_] = 
      y[x] /. dsol[[1]]
y2[z]

Numericke reseni diferencialnich rovnic

ndsol = 
      NDSolve[{x''[t] + x[t]^3 == Sin[t], 
          x[0] == x'[0] == 0}, x, {t, 0, 50}]

FullForm[ndsol]

ParametricPlot[{x[t], x'[t]} /. ndsol, {t, 0, 50}];

Plot[ChebyshevT[5, x],{x, -1, 1}]

Plot[Table[ChebyshevT[j, x], {j, 7}], {x, -1, 1}];

Plot[
        Table[ChebyshevT[j, x], {j, 7}] // Evaluate, {x, -1, 
          1}];

Soucty a souciny

soucet = (∑_(k = 1)^n) (1/(k^6))
Limit[soucet, n -> ∞]
(∑_(k = 1)^∞) (1/(k^6))

soucin = (∏_(n = 1)^5) 
          Gamma[((2  n)/5)]
soucin // Simplify
soucin // FullSimplify

Cos[x]^4 // FullSimplify
TrigReduce[Cos[x]^4]

Miliardte prvocislo

Prime[(10^9)]

Mersennova prvocisla

prvocisla = Prime[Range[30]]

(2^prvocisla) - 1 // Last

pole = PrimeQ[(2^prvocisla) - 1]

Count[pole, True]

Select[(2^prvocisla) - 1, PrimeQ]

Lekce 4.1

FAQ

Odkazy, jine zdroje pouceni, típy

Obecne:

http://www.wolfram.com

Tam hledejme MathSource.

http://www.wolfram.cz

The Mathematica Journal
Vyvolejte 
http://www.wolfram.com/services/premiersupport/

a jako licencni cislo zadejte L4667-9660.  Tam najdete vyznaceny The Mathematica Journal. Je pravdepodobne, ze bude fungovat pouze ze site na fakulte.

Klavesove zkratky (vyhodna prevence neustaleho prehmatavani mezi mysi a klavesnici): http://media.wolfram.com/brochures/mathematicashortcuts.pdf

Velmi dukladna uvodni instruktaz, viz take dalsi zajimave soubory v adresari Demos, GettingStarted:

"C:\Program Files\Wolfram \
Research\Mathematica\5.2\Documentation\English\Tour\Tour.nb"

Dalsi zajimave zdroje pouceni

"C:\Program Files\Wolfram Research\Mathematica\5.2\AddOns\ExtraPackages"

Help⟶ Master Index ⟶ Built-in Functions ⟶ Advanced Documentation

Konecne je take vyhodne se podivat na nektere zdrojove programy ze Standard Add On Packages. Nektere jsou snadno srozumitelne, u nekterych je tomu naopak.

Mnoho programu (nejen matematickych, ale i ekonomickych a financnich) je mozne ziskat bezplatne z Wolram serveru, oddilu MathSource. Kazdorocne se konaji konference (napr. Wolram Technology Conference). Vetsina prispevku je dostupna na vyse uvedenem serveru.

John McLean principles

jonm@wolfram.co.uk

1 Function names should label tasks not algorithms.
2 Use a minimum of data structures: the underlying principle: everything is an expression
3 Automate as much as possible

A warying example on precision
Varující příklad týkající se přesnosti v systému Mathematica a v systému MS Excel.

4 Try in MS Excel: 0.2->C2. Then copy formula 11*C2-2 15 times. This results in:

0.20  .20  .20  .20  .20  .20  .20  .20  .20  .20  .20  .2000050  .2000510  .2005570  .2061320  .2674570  .9420288  .36231289  .98543987  .839710864  .24

5 The same in Mathematica is solved as follows:

fjo[x_] := 11*x - 2
NestList[fjo, 0.2, 30]

But (e.g.):

fjo30 = NestList[fjo, 0.2`30, 30]

Max[Precision, fjo30]

6 Needs["Optimization`UnconstrainedProblems`"]

Needs["Optimization`UnconstrainedProblems`"]

?*FindMinimumPlot

7 Another calculation of a factorial

facn[n_] := Apply[Times, Range[n]]
facn[5]

8 An open problem:  How is it possible to get the original matrix, i. e. Log, from MatrixExp?

Financni systemy pracujici pod systemem Mathematica

Financial Essentials

Velmi jednoduchy, ale poucny.

UnRisk

V soucasne dobe asi nejlepsi. MFF by k nemu mohla mit pristup zdarma, ale na fakulte neni nikdo, kdo by mel kapacitu tento system provozovat.

Derivatives Expert

Ukazka:

PresentValue[cashflow1, termstructure1, 
        Compounding -> {Exponential, 2}]  //  ToN

Zaver

Vetsinou jedna se o otevrene systemy, coz umoznuje uzivateli adaptovat procedury dle sve potreby. Nejsou soucasti dodavky systemu Mathematica a cenove jsou bohuzel srovnatelne s cenou vlastniho systemu.

Lekce 4.2 (Dalsi uzitecne obraty vymykajici se systematickemu vykladu, tedy jeste )

Options

U vetsiny, zvlaste grafickych funkci, je siroka moznost voleb. To, co je mozne volit se ziska uzitecnym prikazem (uvadime na konkretnim priklade):

Options[Plot]

Toto ocividne nedava kruznici:

Plot[{-(Sqrt[1 - (x^2)]), (Sqrt[1 - (x^2)])}, {x, -1, 
          1}];

Musime zmenit AspectRatio. Takova ponekud nasilna zmena vsak neni obvykla.

Plot[{-(Sqrt[1 - (x^2)]), (Sqrt[1 - (x^2)])}, {x, -1, 1}, 
        AspectRatio -> Automatic];

Map a Apply

Clear[f, g, a, b, c];
li = {a, b, c};
soucin = a b c;
{Head[li], Head[soucin]}
{FullForm[li], FullForm[soucin]}

Map preskoci hlavicku druheho argumentu a applikuje prvni argument na to, co je za hlavickou druheho argumentu

Head[g[a, b, c]]
Map[f, g[a, b, c]]
Map[Plus, g[a, b, c]]

Total[{a, b, c}]

Apply je funkce, ktera vymeni hlavicku druheho argumentu za prvni argument

Apply[f, g[a, b, c]]

Priklad vypoctu aritmetickeho prumeru s pojistkou na to, aby argument funkce byl vektor delky alespon jedna.

prumer[x_] := 
      Apply[Plus, x]/Length[x] /; 
        VectorQ[x] && Length[x] > 0
{prumer[{a, b, c}], prumer[{{a}, b, c}], prumer[a, b, c], 
      prumer[2]}

Apply[Times, li]
Apply[List, soucin]
Apply[Plus, soucin]

Find Instance

Je velmi uzitecna funkce. Neumime-li najit vsechna reseni, tato funkce nam poskytne aspon nektere. A nahodnym, nam neznamym mechanismem jich najde i vice, viz:

Poznamka: Vypreparovani prvnich slozek z matice

mat = Table[a[i, j], {i, 3}, {j, 2}]

Prvni sloupec

mat[[All, 1]]

Prvni a treti radek

mat[[{1, 3}]]

mattransp = Transpose[mat]
mattransp[[1]]
Map[First, mat]

Clear[x, y];
fi = 
        FindInstance[x^2 + y^2 ≤ 1, {x, y}, 
          1000];
fi // Short

{x, y} /. First[fi]

ca = Map[{x, y} /. # &, fi];
Short[ca]
xx = Map[First, ca] // N; 
    yy = Map[Last, ca] // N;
Length[xx]
{Mean[xx], Mean[yy]}
\(\(ϕϕ = 
        Map[If[#[[1]] == 
                0, \(π\/2\) 
                Sign[#[[2]]], 
              ArcTan[#[[2]]\/#[[1]]]] &, {xx, yy} // 
            Transpose];\)\)
rr = (Sqrt[(xx^2) + (yy^2)]);

First[ca]

Select[
      ca, (#[[1]]^2 + #[[2]]^2 == 1) &]

crit = (#[[1]]^2 + #[[2]]^2 == 
              1) &;
Count[ca, _?crit]

{Mean[rr], Mean[ϕϕ]}

ListPlot[ca, AspectRatio -> Automatic];

{Random[Real, {-1, 1}], Random[Real, {-1, 1}]}

Distribution of (r,ϕ)

Clear[x, y, xy, r, ϕ];

(X, Y) possesses the uniform distribution on the unit circle with the PDF f(x, y) = (π^(-1)) if (x^2) + (y^2) ≤ 1 an 0 otherwise. After the transform

xy = {r Cos[ϕ], r Sin[ϕ]}

jac = D[xy, {{r, ϕ}, 1}]
det = Det[jac] // Simplify

the density of (r, ϕ) becomes f(x, y) = r/π, 0 ≤ r ≤ 1, 0 ≤ ϕ ≤ 2  π.

Cviceni

Analyzujte a popiste vsechny pouzite kroky v prikladu Find Instance.

Diferencni rovnice

Pro reseni diferencnich rovnic (nebo jejich soustav) je zabudovana mohutna funkce RSolve. Syntaxe zadani je prakticky stejna jako u obycejnych rovnic, diferencialnich rovnic, &c. Jak jest obecne z kalkulu znamo, spojite pripady jsou vetsinou daleko snadneji zvladnutelne nez pripady diskretni. Mathematica poskytuje neuveritelne rozsahly aparat pro symbolicke i numericke reseni diferencnich rovnic. Ilustraci vsak zacneme na banalnim prikladu vypoctu Fibonacciovych cisel. Pomineme na chvili skutecnost, ze funkce pro vypocet Fibonacciovych cisel jest funkce zabudovana, a z metodickych duvodu uvedeme nekolik algoritmu jejich vypoctu. Take se pritom poucime, jak efektivne vyuzit prikazy pro rekursivni procedury.

Fibonacci A

Spatna definice

Remove[fibS];
fibS[1] = 
        1;
fibS[2] = 
        1;
fibS[n_] := 
      fibS[n - 1] + fibS[n - 2]

Table[fibS[j], {j, 6}]
Map[fibS, Range[6]]

fibS[3.5]

fibS[270]

$RecursionLimit = 5000;

fibS[270]

fibS[-3]

Trivialni definice:

Remove[fibA];
fibA[1] = 
        1;
fibA[2] = 
        1;
fibA[n_?IntegerQ] := 
      fibA[n - 1] + fibA[n - 2] /; Positive[n]

Tady uzivame test, zda n je cele cislo a navic, jestli je kladne.

{fibA[3], fibA[4], fibA[-6], fibA[3.4], fibA[10]}

Casova narocnost je velka (za cviceni zjistete řád a proč)

fibA[29] // Timing

ListPlot[
        Table[(fibA[j] // 
                  Timing)[[1]]/
            Second, {j, 24}], PlotJoined -> True, 
        PlotRange -> All];

EUR = 28.30 CZK
15 EUR

Fibonacci B

Vyhodou je, kdyz si jiz vypocitana cisla muzeme zapamatovat. To Mathematica umoznuje nasledujici konstrukci:

$RecursionLimit = 256;

Clear[fibB];
fibB[1] = fibB[2] = 
          1;
fibB[n_?IntegerQ] := fibB[n] = 
        fibB[n - 1] + fibB[n - 2]

?fibB

Vsimneme si, jak se po vyvolani definice funkci A a B lisi:

{fibA[6], fibB[6]}

?fibA

?fibB

Vsimneme si tez casu potrebneho pro vypocet:

fibB[270] // Timing

Ale i tato konstrukce selze pri vyvolani

fibB[300]

To lze odstranit zmenou hodnoty systemove promenne, uvidime, ze to bude nezbytne pri hodnoceni americkych opci:

$RecursionLimit

$RecursionLimit = 5000;
fibB[500] // Timing

Na tomto miste je take mozne demonstrovat "listovatelnost" funkci, ktera jiz byla demonstrovana pri vyvolavani BuiltIn funkci. Pro uzivatelem definovane funkce pouzijeme nasledujici postup:

Nejprve zkusme aplikovat funkci fibA na list:

fibA[Range[6]]
Attributes[fibA]

Map[fibA, Range[6]]

Po zmene vlastnosti vsak jiz dosahneme kyzeneho vysledku:

SetAttributes[fibA, Listable];
fibA[Range[6]]
Attributes[fibA]

Fibonacci M

fibM[n_]:=First[MatrixPower[(({{1, 1}, {1, 0}})),n - 2].{1, 1}]/;n > 2

Timing[fibM[1600];]

Fibonacci C (Reseni diferencnich rovnic)

Vcetne pocatecnich podminek se jedna o soustavu 3 rovnic.

reseniC = 
      RSolve[{fibC[n] == fibC[n - 1] + fibC[n - 2], 
          fibC[1] == fibC[2] == 1}, fibC[n], n]

To je obecne reseni. Neni vsak patrne, jak vypada v konkretnim pripade.

Pokusy o zjednoduseni

reseniC // Simplify

reseniC // FullSimplify

Lepe uz to ocividne nejde. Nicmene konkretni hodnoty dostaneme takto:

reseniC /. n -> 200

Je to sice spravne, ale neni to to, co bychom si prali videt. Pouzijeme tedy zjednoduseni:

reseniC /. n -> 200 // FullSimplify

-(((-5 + (Sqrt[5])) (-((((1/2) - ((Sqrt[5])/2)))^200) + ((((1/2) + ((Sqrt[5])/2)))^200)))/(5 (-1 + (Sqrt[5])))) // PowerExpand

&c.

Fibonacci D (zabudovana funkce)

Fibonacci[200] // Timing

Konec 13.3.2007

Muj domaci ukol z 13.3.2007

Pripomenme, ze ukolem je z vyrazu g[a, b, c] vytvorit g[a + b + c].

gg = 5;
Module[{gg = Head[g[a, b, c]]}, {gg[Apply[Plus, g[a, b, c]]], 
        gg}]
?gg

Module je funkce slouzici k vytvareni slozitejsich struktur. Umoznuje lokalizovat promenne a lokalnim promennym priradit pocatecni hodnoty.

gg = 6;
With[{gg = Head[g[a, b, c]]}, 
      gg[Apply[Plus, g[a, b, c]]]]
?gg

With umoznuje bezpecne lokalizovat promenne.

Konec meho domaciho ukolu.

FAQ

Diference vyssich radu

Muj novy domaci ukol z 20.3.2007-1.

Nejdrive cviceni (diference pro vektory dat, srovnej vypocet vynosu z cen)