VPFPM ZS2021/22

NMFM308 Výpočetní prostředky finanční a pojistné matematiky

NMFM308 Computational Tools for Finance and Insurance

$LicenseExpirationDate

chttp://www.karlin.mff.cuni.cz/~hurt/

http://www.karlin.mff.cuni.cz/~hurt/

http://www.karlin.mff.cuni.cz/~hurt/VPFPM2021ZS.nb

E-maily

2022-01-08

1. Na přednášce 2022-01-07 byl vznesen dotaz, zda při zkoušce můžete používat vlastní notebooky. Konstatoval jsem, že je to nejtěžší otázka a měl jsem pravdu. A odpověděl jsem, že můžete používat vlastní notebooky, kterýžto souhlas jsem po čase vyhodnotil jako špatný. Uvedu důvody, které mě vedou ke změně rozhodnutí. Zaprvé, pro účely zkoušky již léta zřizuji na laboratorních počítačích zvláštní účet. To je v konečném čase na soukromém počítači nerealizovatelné. Zadruhé, někteří studenti by mohli podmínky pro absolvování zkoušky považovat za nerovné. Zatřetí, v případě potřeby externího souboru by také vznikly komplikace. Proto jsem rozhodl takto: Zkoušku je možné konat pouze na laboratorních počítačích.

2. Na mé webové stránce je upravený notes. Je ve verzi 13, ale asi jediná tam použitá funkce, která je v systému nová až ve verzi 12.3  je SolveValues (a její klony). Upozorňuji na změny:
2.1. Před sekcí Zabudované finanční funkce 2 je uveden příklad “Ukázka nesmyslnosti aritmetického průměru” týkající se úrokových měr.
2.2. V odstavci Black-Scholesův vzorec byl u rizikově neutrálního hodnocení je nepřesnost: “... čím vyšší averze k riziku ... tím vyšší výnos je požadován ... “. Nyní je zde uvedena přesnější formulace.

3. Vaše dotazy v rámci svých schopností rád zodpovím a pokud usoudím, že by informace mohla být zajímavá i pro ostatní, pošlu odpověď hromadným e-mailem s anonymizovaným tazatelem.

jh

2022-01-23 Poznámky ke zkušebním testům (vychází z poznatků již vykonaných zkoušek)

1. Všechny úlohy v testech jsou modifikované příklady z přednášek.

2. V některých testech postrádám řádné formátování, viz Menu ⟶ Style ⟶ ... 
Implicitně je nastaven vstup (Input = Alt+9). Další formátování buněk je nutné provést manuálně:
Text = Alt+7
Subsubsection = Alt+6 (to je tato buňka)
Subsection = Alt+5 (to je nadpis tohoto odstavce, tj. 2022-01-23 Poznámky ...)
atd.
Jsou minimálně 4 způsoby formátování: (i) označit (vybrat) buňku, Menu ⟶ Style ⟶ ..., (ii) totéž z klávesnice pomocí klávesových zkratek, (iii) z palety např. Writing Assistent, (iv) zkopírovat již řádně zformátovanou buňku.
Výhodou členění notesu je možnost uzavírání a otevírání buněk v dané hierarchii.

3. Všechny výpočty zkontrolujte opakovaným výpočtem. Často se stává, že při opravách nebo nedopatřením vymažete část kódu se symboly, které mají již přiřazené hodnoty. Kontrolní výpočet vyžaduje buď uzavření Mathematicy a opětovné otevření nebo jednodušeji opustit jádro (Menu ⟶ Evaluation ⟶ Quit Kernel ⟶ Local). V obou případech pak všechny buňky znovu inicializujte (⇧+⌤ nebo ⌤ na numerické klávesnici).

3. Úzce související výpočty nejsou v jedné buňce; to je obzvláště nebezpečné pro konstrukce typu

SeedRandom[13131];
Random[]

nebo

Inverse[HilbertMatrix[10]];
Det[%]

4. Uživatelem definované symboly nezačínat velkým písmenem! Tím začínají všechny zabudované funkce! I přes má četná varování došlo k použití N a C!!!
Viz:

?N
?C

Jak též v přednášce doporučeno, používat srozumitelné názvy proměnných. Místo “p1” použít “prumerPojistnychPlneni2020”. V krátkém kódu se ještě dokážete tentýž den zorientovat, ale pracujete-li na projektu 14 dnů, pak se ve stech takto označených proměnných nevyznáte, natož kolegové při sdílení projektu.

5. Buďte pozorní. Jsou-li např. v zadání všechny údaje v [%] nebo [((%)^2)], pak musíte důsledně počítat s procenty a ne smíšeně s procentním a desetinným vyjádřením. Nejčastěji se objevovala chyba tohoto typu:
Zadání: očekávaný výnos 5,%,..., předepsaný výnos 4,%.
Studentovo zpracování: r=5; μ=0.04; .
Vede samozřejmě k nesmyslnému výsledku. Není možné se na programu finanční matematika obhajovat tím, že se jedná jen o numerickou chybu. Když ve finanční instituci (do které pravděpodobně někteří z Vás nastoupí) poskytnete úvěr na 0.04,% místo na 4,%, tak se asi se zlou potážete. (Neuvažuji případ, že se Vám věřitel zavděčí v takové míře, že o další setrvání ve finanční instituci již nebudete usilovat.)

6. U probraných superfunkcí typu FinancialBond a FinancialDerivative si pečlivě prostudujte významy a interpretaci jednotlivých parametrů (viz tento notes, vysvětlivky  jsou zde v češtině a používají terminologii přednášky Finanční management).  Nejčastější chyby u “Expiration”, “ReferenceTime” (tento parametr je často ignorován), “CurrentPrice” (interpretován jako čas!).

7. Odložené (lhs: = rhs) a okamžité přiřazení (lhs = rhs) není žádná libůstka! Některé procedury nemohou při ignorování tohoto rozdílu fungovat.

8. Byl jsem velmi nemile překvapen následující konstrukcí, sice fungující, ale zato odporující základním principům programování (o modelování ani nemluvě). Jedná se o definici funkci a pak její použití. S ohledem na to v kolika případech se vyskytovala bych soudil, že nějaký guru ji rozšířil po sociálních sítích a mnozí z Vás ho následovali.

V ilustraci přidávám Clear. Někteří z Vás tuto funkci také zcela ignorují.

Clear[funkce]
funkce[s0_,delta_]:=s0+delta
(* Zmíněné nesmyslné vyhodnocení: *)
s0=100;delta=9;
funkce[s0,delta]
(* Správné vyhodnocení: *)
funkce[100,9]

9. Níže jsou uvedené pokyny, které jsem dosud poskytoval jen v papírové podobě, a i v budoucnu poskytovat budu.

Obecné pokyny pro zkoušku VPFPM

1. VÝSLEDKY průběžně ukládejte.

2. Není přípustné se logovat jinam.

3. Na internet se můžete připojit až při odesílání výsledků.

4. Formální úprava: postupujte odzdola: Text ⟶ Subsubsection ⟶ Subsection ...

5. Používejte pouze disk H.

6. Po skončení zkoušky nic nemažte, nezavírejte, nevypínejte. Výjimkou je Váš e-mail. Ten naopak zavřete. Na obrazovce by při Vašem odchodu měl být Váš notes. Všechny papíry nechte ležet u počítače. Setrvejte do okamžiku, kdy Vám potvrdím přijetí e-mailové zprávy.

Specifické pokyny

Otázky zpracujte a na konci zkoušky odešlete na adresu hurt@karlin.mff.cuni.cz  (nepoužívejte diakritiku) s těmito náležitostmi:
předmět: RRRRMMDD_Test_VPFPM_Prijmeni_Jmeno
(RRRR = rok, MM = měsíc, DD = den, např. 20140120_Test_VPFPM_Tygr_Leopold.nb) 
jako přílohu ve tvaru “RRRRMMDD_Test_VPFPM_Prijmeni_Jmeno.nb" v níže uvedené (závazné!) podobě (tzn. fonty, odstavce atd). Zvětšení 125 %. Ke všem otázkám je nutné se vyjádřit! Výpočty realizujte, nestačí napsat pouze vzorečky. Zadání neopisujte. Otázky stačí číslovat 1, 2, ... .

Závazná forma

Uveďte Vaše jméno! Pokud vím, nikdo z Vás se nejmenuje Leopold Tygr.

Jméno Příjmení

Leopold Tygr

Otázka 32

Odpověď 32

...

Otázka 132

Odpověď 132

...

2021-10-01 Lekce 1a

(konaná 2021-09-29)

Úvod

Odstavce označené hvězdičkami je třeba interpretovat takto:

Bez hvězdičky: Důležité informace

*    Slouží k procvičení, znalost ke zkoušce potřebná. Snadná studijní literatura.

**  Obsahuje důležité informace, ale jejich neznalost při zkoušce není fatální, zkouškou je možné “projít”. Poněkud těžší literatura.

*** Inspirativní náměty nebo zatím přednášejícím nezpracovaná témata. Leckdy užitečné pro řešení problémů v budoucnosti. Doplňková literatura. Označuje také zatím neaktuální informace.

Ve vstupních buňkách (Input cells) jsou hvězdičky v komentáři. Tak např.

(* ** *)1+1

representuje buňku s klasifikací ** ( = dvě hvězdičky)

Zkoušky a zápočty

Zápočet

Maximálně tři neomluvené absence, vypracování domácích úkolů a aktivní účast na cvičení. Zápočty udělené v minulosti se neuznávají. V případě distanční výuky vypracování domácích úkolů.

Zkoušky

Termíny budou vypsány v SIS. K zápisu na zkoušku je nutný zápočet.

2022-01-14 2022-01-21, 2022-02-11: 09:00 v posluchárně K4.

Odehrávají se v laboratoři K4 u počítače.  Jsou to problémově orientované otázky (obvykle v počtu 2 až 4) vycházející typicky z příkladů uvedených v přednášce. Posuzuje se i formální prezentace výsledků, tj. členění do sekcí, paragrafů, fonty atp. Jsou nutné znalosti z dříve absolvovaných předmětů bakalářského studia finanční matematiky.  Orientační doba trvání zkoušky je 75 minut. Řešení je v elektronické podobě odesíláno examinátorovi ve formátu *.nb v předepsaném formátu.  Výsledky zkoušky v SIS do 50 hodin od konce zkoušky.

***Seznam zabudovaných funkcí, jejichž znalost je vhodná pro úspěšné zvládnutí zkoušky

Ovládání nejdůležitějších funkcí základního Menu

File ⟶ Save Selection As

Insert ⟶ Hyperlink, &c.

Format ⟶ Style, Face, Size, Text Color, &c.

Evaluation ⟶ Dynamic Evaluation Enabled, Abort Evaluation, Quit Kernel

Palettes Writing Assistant

F1 Nápověda k označené funkci

Základní funkce (elementární funkce typu Log, Sin, Tan, ArcTan, Abs, ..., důležité konstanty Pi, E, i, (π,e,i)  se samozřejmě předpokládají)

(* zavorky *) Parentheses ( ), square brackets [ ], [[ ]], braces { }

FullForm,TreeForm,
Head (* Integer, Real, Rational, Complex, Symbol, String *)

; (* středník = potlačený výstup, výpočet se však provede *)

N, Binomial, Clear, Remove, ?identifikátor, (* dotazy typu *) ?*Function, ?Function*, ?*Function*

Symbolické funkce a jejich numerické ekvivalenty

Simplify, FullSimplify

Expand, ExpandAll, PowerExpand, FunctionExpand, Factor, Together, Apart

Total, Sum, Product

D, Integrate, NIntegrate

Solve, NSolve, Reduce, FindRoot, RSolve, DSolve, NDSolve

Limit, Series

FindSequenceFunction

Definice funkcí a pravidla (rules)

f[x_]=výraz (* globální pravidlo, okamžité přiřazení, provede se výpočet (vyhodnotí se výraz) a ten se uloží *)

f[x_]:=výraz (* globální pravidlo, odložené přiřazení, uloží se definice, výpočet se provede až v okamžiku vyvolání *)

x->y (* lokální pravidlo, substituce s okamžitým vyhodnocením *)
x:>y (* lokální pravidlo, substituce s odloženým vyhodnocením *)
(* aplikace: /. ReplaceAll, //. ReplaceRepeated *)

f[x_]:=Module[{lokální proměnné},složený příkaz]

f[x_]:=f[x]=výraz (* dynamické programování! *)

Which, Piecewise, Boole, While, Print

Grafika

včetně voleb probíraných na přednášce, viz Options[Plot] &c.

Plot, Plot3D, ParametricPlot, ParametricPlot3D, ListPlot,DateListPlot

Manipulate

Show[(Subscript[p, 1]),(Subscript[p, 2]),...] (* Sloučení více grafů do jednoho *)

Seznamy (lists), matice

Table, Array, Range

Take, Drop

First, Last, Rest, Most

Flatten

Prepend, Append, Insert, Delete, Position

Length,Dimensions

Reverse, RotateLeft

Join, Intersection, Complement

Součiny (maticový, obyčejný - po složkách, Hadamardův):

. ,*

IdentityMatrix, DiagonalMatrix,Diagonal, HilbertMatrix

Transpose,Inverse,Det,MatrixPower,Eigenvalues,Eigenvectors

Optimalizace (včetně omezení (constrained optimization) a různých oborů)

Minimize, NMinimize,FindMinimum

(* Příklad *) NMinimize[{(x-1/3)^2+(y-1/3)^2,x∈Integers},{x,y}]

Anonymní (ryzí) funkce, funkcionální programování

Function (* zkrácená konstrukce #& *)

Predikáty a vzory (předlohy, patterns), převod predikátu na vzor (_?)

Map, Apply, Thread, Through

Nest, NestList, Fold, FoldList, NestWhile

Řetězce, balíčky (Packages)

StringSplit,StringLength,StringJoin,StringTake,StringDrop,StringInsert,StringReplace,StringReverse

ToUpperCase,ToLowerCase,IgnoreCase->True

Characters,CharacterRange

ToExpression,ToString

Needs["HypothesisTesting`"] (* nebo v Unixovské syntaxi Get: *)

<<HypothesisTesting`
Names["HypothesisTesting`*"]

Pravděpodobnost a statistika

SeedRandom[13],Random,RandomVariate, RandomReal,RandomInteger

RandomChoice, RandomSample

NormalDistribution, UniformDistribution, DiscreteUniformDistribution, StudentTDistribution, ChiSquareDistribution, FRatioDistribution

Probability, ProbabilityDistribution, Expectation

Mean, Variance, StandardDeviation, Median, Quantile

FindFit, LinearModelFit, NonlinearModelFit

EstimatedDistribution, SmoothKernelDistribution

Databázové funkce, externí objekty

Count,Tally

Sort 
(* včetně třídících funkcí, ordering function a třídění podle jiné než první složky *)
Select Cases

FreeQ,MatchQ, MemberQ

FinancialData, CountryData

ExampleData[],ExampleData["Text"]

SetDirectory[NotebookDirectory[]] (* při exortu a importu se nemusí vypisovat kompletní cesta (Path), usnadňuje přenositelnost *)

Import, Export, $ImportFormats, $ExportFormats, Hyperlink, Button

Finanční funkce

FinancialDerivative[]

Annuity

AnnuityDue

Cashflow

TimeValue

EffectiveInterest

FinancialBond

FinancialDerivative

TradingChart

InteractiveTradingChart

FinancialIndicator
FinancialIndicator[All]//Length

FindRoot
FindMinimum
FindFit
Find

Solve
NSolve
FindRoot
Sort

Literatura

Pořadí zde uvedených odkazů nevypovídá nic o důležitosti. Rozhodující jsou hvězdičky.

[1]** Dupačová, J., Hurt, J., Štěpán, J.: Stochastic Modeling in Economics and Finance. Kluwer Academic Publishers. Dordrecht 2002.

[2]** Cipra, T.: Finanční ekonometrie. Ekopress, Praha 2008.

[3]* Cipra, T.: Matematika cenných papírů. Kamil Mařík Professional Publishing. Praha 2013.

[4]*** Hurt, J.: Yield curves with Mathematica 6.0. In: Wolfram Technology Conference 2007. http://library.wolfram.com/infocenter/Conferences/6956/ . Champaign (IL) 2007.

[5]*** Hurt, J.: Risk measures in finance. In: 2008 International Mathematica User Conference. http://library.wolfram.com/infocenter/Conferences/7230/.  Champaign (IL) 2008.

[6]*** Hurt, J.: Risk measures in finance revisited. In: Wolfram Technology Conference 2010. http://library.wolfram.com/infocenter/Conferences/7861/  . Champaign (IL) 2010.

[7]** Sciencedirect:  http://www.sciencedirect.com/

[8]***Mathematica Cookbook

[9]*** Luenberger, D.: Investment Science. Oxford University Press. New York 1998.

[10]*** Cipra, T.: Financial and Insurance Formulas. Springer-Verlag. Berlin Heidelberg 2010.

[11]** Vencálek, Ondřej: Základy analýzy dat v softwaru Mathematica. Univerzita Palackého v Olomouci. Olomouc, 2015. Text je dostupný v knihovně Karlín a Malá Strana. Rovněž je přístupný elektronicky na adrese http://mathscience.upol.cz/materialy.html a to jak ve formátu pdf, tak i ve formě spustitelného “sešitu” Mathematica (.nb).

[12]** An Elementary Introduction to the Wolfram Language by Stephen Wolfram: http://wolfr.am/eiwl

Obsahuje cvičení. Své odpovědi si můžete ověřit.

[13] ***Hands-on Start to Wolfram Mathematica and Programming with the Wolfram Language by Cliff Hastings, Kelvin Mischo, and Michael Morrison (Chapter 7 “Creating Interactive Models with a Single Command” available free online): http://www.handsonstart.com

[14]*** The Wolfram Language: Fast Introduction for Programmers
http://www.wolfram.com/language/fast-introduction-for-programmers/en
Zahrnuje též cvičení s odpověďmi.

[15]** What is new 
http://www.wolfram.com/mathematica/quick-revision-history.html

[16]*** Mathematica & Wolfram Language
Fast Introduction for Math Students

http://www.wolfram.com/language/fast-introduction-for-math-students/en/

http://www.wolfram.com/language/fast-introduction-for-math-students/en/probability/

http://www.wolfram.com/language/fast-introduction-for-math-students/en/statistics/

http://www.wolfram.com/language/fast-introduction-for-math-students/en/data-plots-and-best-fit-curves/

[17]** Podobné jako [12], ale je možné stáhnout:
http://www.wolfram.com/language/elementary-introduction/2nd-ed/?source=desktop

[18] NMFM301 Statistika pro finanční matematiku
http://www.karlin.mff.cuni.cz/~pesta/NMFM301/statistika_fm.pdf

[19]*** Asociativní pole:
https://reference.wolfram.com/language/guide/Associations.html

[20]** Virtual book (Mathematica book)
tutorial/VirtualBookOverview
(HyperlinkPaclet["paclet:tutorial/VirtualBookOverview", paclet:tutorial/VirtualBookOverview])

(* ** *)Hyperlink["paclet:tutorial/VirtualBookOverview"]

[21] NMFM201 Finanční management

Doporučený postup pro studium systému Mathematica (nyní Wolfram Language)

Kursy Antonína Slavíka

Připomenout si kurs Slavík A.: Mathematica pro začátečníky

http://www.karlin.mff.cuni.cz/~slavik/info.html

**Projít letmo kurs Slavík, A.: Mathematica pro pokročilé (tamtéž)

Help a dokumentace

Podívejte se na Help ⟶ Wolfram  Documentation ⟶ Wolfram Language and System. Prohlédněte si, co je v jednotlivých kapitolách a podívejte se  do Introductory Book (An Elementary Introduction to the Wolfram Language, odkaz viz Literatura výše).  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 některých málo z více než 8000 zabudovaných (built-in) funkcí.

Poznamenejme, že hodně zabudovaných funkcí jsou tzv. “superfunkce”. To znamená, že pod jedním názvem funkce se skrývá (pomocí voleb) programový balík. jsou to např. funkce pro finanční deriváty (FinancialDerivative) a  shlukovou analýzu (Cluster analysis, jedna z metod mnohorozměrné statistické analýzy):

Information["FinancialDerivative",LongForm->False]

Information["FindClusters",LongForm->False]

nebo funkce pro hodnocení finančních derivátů

?FinancialDerivative

Znáte-li alespoň přibližný název funkce nebo jeho části, můžete zkusit např. následující dotaz (Pozor na velká a malá písmena, Mathematica je “Case sensitive”, všechny zabudované funkce začínají velkým písmenem!!!). Máme např. tušení, že funkce pro časovou hodnotu peněz (Time value of money) bude asi mít ve svém názvu “value”. Zkusíme tedy:

?*value*

?*Value*

tam je “naše” funkce TimeValue, na tu poklepneme a dostaneme

poklepnutím na ≫ dostaneme kompletní popis funkce. Podobně:

?Association

Mathematica disponuje prediktivní nápovědou: Po napsání prvních dvou písmen existujícího symbolu se objeví seznam možných symbolů z nichž je pak možné vybrat ten požadovaný. U některých zabudovaných funkcí je k dispozici “Advanced Documentation”, někdy též “Tutorials”. (Doporučuji prostudovat zvláště při komplikovanější aplikaci odpovídající zabudované funkce.) Č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.

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.

Pět P (ve 3. ročníku sice trochu pozdě, nicméně připomenutí neškodí)

Viz Úvod k oranžové karolince str. 11 (12):

https://www.mff.cuni.cz/fakulta/tiskoviny/or_k1718.pdf

Z uvedených doporučení zvláště zdůrazňuji: Z přednášky si čiňte poznámky. Jak metodickými badateli zjištěno, samotným zapisováním se část poznatků v paměti fixuje lépe než při pouhém náslechu. Záznamy z přednášek na mé domovské stránce.

Proč Mathematica (Wolfram Language)?

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 porozumění systému Mathematica  je znalost logiky jazyků typu Prolog, LISP (byť velmi starých, které v době svého vzniku neměly podporu v potřebné počítačové technice) a v současnosti Python.

Klávesové zkratky

Klávesové zkratky 1

http://reference.wolfram.com/mathematica/guide/SelectingAndTypingInNotebooks.html

Velmi uzitečné: 
Enter (pouze odřádkování v rámci buňky), 
Shift+Enter nebo  Enter na numerické klávesnici (pro odstartování výpočtu), 
F1 (návod k dané funkci), 
Ctrl+Shift+K (make template, nejdříve napíšeme funkci), 
Ctrl+Shift+B (Balance, kontrola uzávorkováni), Otevírání resp. zavírání označených buněk Ctrl+⇧+{ resp. Ctrl+⇧+} nebo z Option Inspector instalovat “Show Group Opener”

*Klávesové zkratky 2

Templates

Integrate

Integrate[f,{x,(Subscript[x, min]),(Subscript[x, max])}]

Integrate[(x^2),{x,y}∈Disk[]]

Integrate[(x^2)+(y^2),{x,y}∈Disk[{0,0}]]

Enter

(* V jedné buňce je možné zadat více výpočtů současně *)
(* Vřele doporučuji pro elementární výpočty -  několikanásobný výpočet se provede jediným   *)
3 4
3/4

(* Pokud je jeden příkaz v jedné buňce na více řádcích, musí být operátor na konci řádku: *)
3/
4

(* Zde je "4" interpretována jako další příkaz: *)3                                                                                                               
 4

*Klávesové zkratky 3

vyhodna prevence neustaleho prehmatavani mezi mysi a klavesnici, da se vytisknout na dvou strankach podelne):
http://media.wolfram.com/brochures/mathematicashortcuts.pdf

Viz také:
tutorial/KeyboardShortcutListing
guide/NotebookShortcuts

Row[{Hyperlink[Button["Keyboard shortcuts"], 
    "paclet:tutorial/KeyboardShortcutListing"],"  ", 
   Hyperlink[Button["Notebook shortcuts"], 
    "paclet:guide/NotebookShortcuts"]}]

*Novinky v novějších verzích

Novinky verze 9, 10, 11, 12 (Např.: Built-in Integration with R)

Row[{Hyperlink[Button["            RLink            "], 
    "paclet:RLink/tutorial/Introduction"], "   ", 
   Hyperlink[Button["Summary Of New Features In 10"], 
    "paclet:guide/SummaryOfNewFeaturesIn100"], "   ", 
   Hyperlink[Button["Summary Of New Features In 11.2"], 
    "paclet:guide/SummaryOfNewFeaturesIn112"], "   ",
Hyperlink[Button["Summary Of New Features In 12"], 
    "paclet:guide/SummaryOfNewFeaturesIn12"],"   ",Hyperlink[Button["Summary Of New Features In 12.3"], 
    "paclet:guide/SummaryOfNewFeaturesIn123"]}]

Další prameny

***Printed Tutorial Collection

Manuály v PDF (volně ke stažení, trochu zastaralé):
http://www.wolfram.com/learningcenter/tutorialcollection/

*Wolfram U (Open courses for students and staff)

https://www.wolfram.com/wolfram-u/

*Wolfram Demonstrations Project

K dispozici 12000+ demonstrací (k 2021-09-29). Vyhledávání podle témat. Na dotaz “option pricing” 79 demonstrací. Zdrojový kód volně ke stažení (instruktivní!). Dosažitelné z Help nebo z:

http://demonstrations.wolfram.com/

Podivejte se na Latest, pak Search: Finance, Insurance, Economics, Probability, Statistics. Demonstrace je mozne stahnout a studovat. Zacnete studovat ty jednodussi. Cim hezci grafika, tim komplikovanejsi kod a pro zacatecnika hure srozumitelny.

Příklady

http://demonstrations.wolfram.com/PresentValueCalculator/

http://demonstrations.wolfram.com/BondPricing/

http://demonstrations.wolfram.com/FinancialEngineeringOfABond/

http://demonstrations.wolfram.com/DeterminantsOfTheNPVOfABond/

Jak získat zdrojový kód demonstrace?

V demonstraci pod obrázkem Download to Desktop.  Často se objeví zpráva, nejenom v tomto případě:

⚠ This file contains potentially unsafe dynamic content.

Nahoře stiskněte modré pole “Enable Dynamics”.

Menu Evaluation ⟶ Dynamic Upadating Enabled

Nefunguje-li Vám program v otevřeném oknu, vyberte vše  (Ctrl+A), a zkopírujte do Vašeho otevřeného notesu.

*The Mathematica Journal

Pro opravdové zájemce: http://www.mathematica-journal.com/

Specializovana cisla, statistika viz  Vol. 9 (4)

Odkazy

Základní stránky

http://www.wolfram.com

http://www.mathematica.cz/

http://community.wolfram.com/

http://mathematica.stackexchange.com/

http://blog.wolfram.com/

Výhradní distributor v ČR a SR: http://www.elkan.cz/

Videa a jak co udelat (“How tos”)

(Vhodne tez jako cviceni poslechu anglictiny)

http://www.wolfram.com/broadcast/

(Přejít na Channels)

http://www.wolfram.com/broadcast/video.php?channel=108&video=439

Integrated Data Sources

?*Data

2020929 fungují:

http://reference.wolfram.com/mathematica/guide/FinancialAndEconomicData.html

http://reference.wolfram.com/mathematica/guide/Finance.html

Aktuální kursy Google, Microsoft, Apple:

Date[]
FinancialData[{"GOOGL","MSFT","AAPL"}]
Row@{"Numericky:   ",%//QuantityMagnitude}

(* General Electric *)
FinancialData["GE"]

FinancialData["EUR/CZK",{2021,1,1}]
%//DateListPlot

**Příklad (zatím obtížná konstrukce)

FinancialData["EUR/CZK"]

rateEURCZK:=FinancialData["EUR/CZK"]
(* rateEURCZK:=FinancialData["EUR/USD"] *)
timedrateEURCZK:={DateString[],rateEURCZK}
Dynamic[timedrateEURCZK,UpdateInterval->2]

priceBMW:=FinancialData["F:BMW"]
timedpriceBMW:={DateString[],priceBMW}

Dynamic[timedpriceBMW,UpdateInterval->2]

fil9={};
Do[Pause[2];AppendTo[fil9,{DateString[],FinancialData["EUR/USD"]}],{10}]
fil9

DateListPlot[fil9]

Free-form Input and Wolfram|Alpha

Free-form input

Vstup “=” nebo “+“ vlevo

Wolfram|Alpha

Vstup "==" nebo "+" vlevo

Příklad

Integrate[(1+x^2)/(x+x^3+x^2),x]
(* % znamená odkaz na výstup posledního příkazu, v našem případě neurčitého integrálu uvedené funkce: *)
D[%,x]
Simplify[%]

Dobrá rada: % používejte z bezpečnosních důvodů jen v rámci jedné buňky.

??Integrate

WolframAlpha["world gdp",{{"History:GDP:WorldDevelopmentData",1},"ComputableData"}]

{{1960,1,1,0,0,0.`},(QuantityPrefixUnit[1.3665947482521`*^12, "$" , "per ""year", US dollars per year, (("USDollars")/("Years"))])}//FullForm

List[List[1960,1,1,0,0,0.`],Quantity[1.3665947482521`*^12,Times["USDollars",Power["Years",-1]]]]
%[[2,1]]

appleFormattedData=WolframAlpha["apple price history",{{"HistoryDaily:Close:FinancialData",1},"FormattedData"},PodStates->{"HistoryDaily:Close:FinancialData__Last 10 years"}];
DateListPlot[%]

WolframAlpha["apple price history",{{"HistoryDaily:Close:FinancialData",1},"QuantityData"},PodStates->{"HistoryDaily:Close:FinancialData__Last 10 years"}]

appleComputableData=WolframAlpha["apple price history",{{"HistoryDaily:Close:FinancialData",1},"ComputableData"},PodStates->{"HistoryDaily:Close:FinancialData__Last 10 years"}];

WolframAlpha["apple price history",{{"HistoryDaily:Close:FinancialData",1},"NumberData"},PodStates->{"HistoryDaily:Close:FinancialData__Last 10 years"}]

DateListPlot[appleComputableData]

Základní techniky  a doporučené návyky

Mathematica je interpret. Použitím zabudovaných funkcí (ty používají většinou nejlepší v současnosti známé algoritmy) a využitím logiky funkcionálního programování však dosáhnete vysoké efektivnosti. I tak je možné Vaše vlastní procedury přeložit pomocí zabudované funkce Compile.

Frontend (To, co vidíte na obrazovce) ⟷ Kernel (Tam se počítá)

Práce v prostředí Frontendu probíhá v souboru, který se v systému Mathematica nazývá notebook (přípona *.nb), česky “notes”.

Výpočet se aktivuje klávesami ⇧+⌤  nebo pouze ⌤ na numerické klávesnici.  Samotné Enter odřádkuje v rámci buňky. Pozor na lícovaní levého okraje!!!

Probíhající výpočet je indikován žlutě svítícím ohraničením buňky (cell). Při špatném zadání může výpočet probíhat neočekávaně dlouho. Pokud chceme výpočet přerušit, použijeme z Menu Evaluation nabídku Interupt Evaluation, v nejhorším případě nabídku Quit Kernel (Local).

Vaše práce se automaticky neukládá. (Jde to sice nastavit, ale vřele nedoporučuji.) Proto doporučuji čas od času rozdělanou práci uložit Ctrl+S, a zvláště tak učinit před každým “nejistým” výpočtem, lépe téměř před každým.

Palety: Menu ⟶ Palletes. Dost universální je Writing Assistent (u některých symbolů ukazuje také klávesovou zkratku). Je možné si vytvořit paletu vlastní.

Příklad symbolu s horním a dolním indexem: Palletes → Writing Assistent → Typesetting → 1. ikona ((■^□)) → 1. řádek, 3. sloupec (Subscript[■, □]^□) . Pohyb po šabloně tabelátorem.

(Subscript[a, c]^d)      (Subscript[a, c]^d)

(Subscript[a, c]^d)b

Pomocí klávesové zkratky napsat (Subscript[a, c]^d): a Ctrl-cCtrl5 d.

Závorky

kulaté

pro vyznačení priority aritmetických operací

{3+4 5,(3+4)5}

Mezera znamená násobení - pozor “a b” znamená součin, “ab” je identifikátor.

3 6
a=5; b=6;
ab
a b

hranaté

argumenty funkcí

Sin[(3/2)π]

ExampleData[]
ExampleData["Statistics"]

složené

k vytváření datových struktur (seznamů, “listů”) jako jsou  vektory, matice, stromy apod.

list1={a,{b,c,{d,e}},{f,g}}
%//TreeForm

dvojité hranaté

část seznamu (parts)

list1={a,{b,c,{d,e}},{f,g}}
{list1[[1]],(* pomocí \[EscapeKey][[\[EscapeKey] dostaneme přehlednější *)list1[[1]]}
(* dva ekvivalentní zápisy: *)
{list1[[2,3]],list1[[2]][[3]]}
{list1[[2,3,2]],list1[[2,3,3]]}

Interpreter["Time"]["17:30"]

Interpreter["University"]["Charles"]

Date[]

Výběr z guide/NotebookBasics

Implicitně je každá buňka nastavená jako vstupní pro vstup výrazu pro požadovaný výpočet.

F1 — get information or help

Apply[Sin,Cos[(π/23)]]
Clear[a,b,c]
{Apply[Times,{a,b,c}],Apply[Plus,{a,b,c}]}

Map[Sin,{a,b,c}]

Změna buňky na textovou Alt+7

π  se dostane jako EscpEsc, podobně α, EscaEsc  tzv. escape sekvence viz též Menu ⟶ Palettes ⟶ Writing Asistent ⟶ Typesetting ⟶ ...

Cell Groups and Outlining

double-click a group bracket — open or close a cell group
double-click cell brackets — close all other cells in a group
triple-click — select a function and its arguments
Subscript (Ctrl+ _): (Subscript[x, n])  ▪  Special Character  ▪  Convert to StandardForm  ▪  Why the Coloring?  ▪  
Superscript (Ctrl+ ^): (x^y)
Alt+7 — text cell (with default stylesheet) (Format ▶ Style ▶ ...)
Alt+4 — section-heading cell (with default stylesheet)

Všechny instrukce týkající se práce s notesy (notebooky)

Hyperlink[Button["Základy práce v notesu"],"paclet:guide/NotebookBasics"]

(* ** *)SystemOpen[Last[Hyperlink[Button["Základy práce v notesu"],"paclet:guide/NotebookBasics"]]]

4 pilíře systému Mathematica 1

1. Numerické výpočty 1

Výpočet pomocí Shift + Enter nebo Enter na numerické klávesnici. Samotné Enter odřádkuje v rámci buňky.

1+1 
2+3
3+5 4

Ekonomičtěji pro účely zobrazení ve tvaru seznamu:

{1+1,2+3, 3+4 5}

(* Ukázka téměř libovolné přesnosti *)Row[{"(2^1000)= ",(2^1000),"\nNumericky (2^1000) = ",N[(2^1000)],"\n((2^170)/(3^10)) přesně = ",number1=((2^170)/(3^10)),"\nTotéž numericky:  ",number2=N[((2^170)/(3^10))]}]

Chyba posledního výstupu:

number1-number2
{InputForm[number1]//N,InputForm[number2]}

{SetPrecision[number1,50],SetPrecision[number2,50]}
SetPrecision[number1,50]-SetPrecision[number2,50]

{Accuracy[number1],Accuracy[number2]}

(* π na 1000 des. míst *)N[π,1000]

Výpočet π:

http://mathworld.wolfram.com/PiFormulas.html

Konec 2021-09-29

2021-10-01 Lekce 1b

(konaná 2021-10-01)

FAQ

Wolfram|Alpha

Přesnost

NIntegrate

{NIntegrate[(1/(1+(Sqrt[x]))),{x,0,1}],
NIntegrate[(1/(1+(Sqrt[x]))),{x,0,1},PrecisionGoal->100,WorkingPrecision->200]}

4 pilíře systému Mathematica 2

1. Numerické výpočty 2

Středník: velmi důležitý!!!

⚠ Potlačení výstupu: ; (středník: výpočet se však provede!)

πnadesettisicmist=N[π,10000];
πnadvacettisicmist=N[π,20000];
πnadesettisicmist-πnadvacettisicmist

Ale na co už Mathematica nestačí:

dvena10000000000000000=(2^10000000000000000);
N[dvena10000000000000000]

Důvod (identifikátory začínající $ jsou některé systémové proměnné):

$MaxNumber

a=5;
(* Je zřejmé, jaká hodnota bude přiřazena, proto středník. *)

{π,Pi}

DMSList[N[(π/°)]]

npi=N[π,15]

π==Pi

Sdruzovani vice vypoctu do jedne bunky

1+1
2+2
2 +
3
(* ale *)
2
+3
(* radek musi koncit operatorem *)

Row@{π,"   ",N[π],"  log 2 numericky = ",Log[2.],"  log 2 presne = ",Log[2],"   ",N[Log[2]]}

Kopie predchoziho 3.14159 do Input bunky:

3.141592653589793`
Precision[%] (* % je odkaz na předchozí výstup, používat pouze v rámci jedné buňky!!! *)
$MachinePrecision

2. Symbolické výpočty 1

Různé funkce

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

e2=Factor[e1]
TeXForm[e2/e1]

**Převedení TEX výrazu do spočitatelného tvaru:

Clear[x];
e3TeX=TeXForm[e3=(((x-1))^2)]
e3New=ToExpression[ToString[e3TeX],TeXForm]
%//Expand

Clear[a];
(a^2)-1/Integrate[Sin[(x^2)],x]//TraditionalForm
TeXForm[%]

*Bez provedení výpočtu:

Clear[a];
(a^2)-1/HoldForm[Integrate[Sin[(x^2)],x]]
TeXForm[%]
%%//TraditionalForm

Ekvivalentní zápisy

{Expand[(((x-1))^5)],(((x-1))^5)//Expand (* postfix *),
Expand@((((x-1))^5)) (* prefix *)}

{Expand[(((x-1))^5)]//TraditionalForm,
TraditionalForm[Expand[(((x-1))^5)]],TraditionalForm@Expand[(((x-1))^5)]}

Postfixový zápis je vhodný pro funkce, které přímo nesouvisí s výpočtem. Zde je to např. TraditionalForm. Nejvhodnější je tedy:

Expand[(((x-1))^5)]//TraditionalForm

Pozor na zápis funkcí!

Běžný zápis (((sin x))^2) v matematickém textu je (sin^2)(x). Ale v Mathematice musí být zachován onen první způsob:

Clear[x]
{((Sin[x])^2),((Sin[(π/30.)])^2),(Sin^2)[(π/30.)],Sin Sin}
%//TraditionalForm

(Sin^2)[x_]:=Sin[x] Sin[x]

Text@Grid[Table[{j,Sin[(( π )/j)]},{j,1,10}],Frame->All]

Clear[a,b,c,x];
(* Rovnice se zapisují pomocí dvojitého rovná se: == . F1 *)
reseni=Solve[a (x^2)+b x +c==0,x]

Řešení je ve tvaru naznačených substitučních pravidel (lokálních pravidel). Je možné je vypreparovat provedením substituce:

koreny=x/. reseni

To je ještě ve tvaru seznamu. První kořen dosteneme jako první prvek tohoto seznamu:

koreny[[1]]

Ve verzi 12.3.1 jednodušší způsob:

reseniValues=SolveValues[a (x^2)+b x +c==0,x]

Podrobnější analýza pomocí funkce Reduce  (&& = And, || = Or)

Reduce[a (x^2)+b x +c==0,x]

Hodnota symbolu x:

x
?x

Znamená to, že x je v globálním kontextu (adresáři Global`) a nemá přiřazenou žádnou hodnotu.

(* Pozor! *)
x=4; (* To ale můžeme udělat někdy před dvěma hodinami a v tomto okamžiku si už na to nevzpomeneme. *)
Solve[a (x^2)+b x +c== 0,x]

Proč asi?

?x

Znamená to, že x je v globálním kontextu (adresáři Global`) a má přiřazenou hodnotu 4. Symboly, kterým není přiřazená hodnota svítí modře.
Bezpečná konstrukce je:

Clear[a,b,c,x]
Solve[a (x^2)+b x +c== 0,x]

Používejte srozumitelné názvy proměnných, prediktivní nápověda Vám umožní snadné doplnění. Vlastní identifikátory by měly začínat malým písmenem (všechny zabudované funkce začínají velkým písmenem.)
Ukázka tzv. velbloudího zápisu:

mesicniPredepsanePojistneMuzi=1000;
mesicniPredepsanePojistneZeny=2000;

me

Analýza výrazu:

Integrate

Určitý integrál z první palety

d se dostane jako EscddEsc

Clear[a,b,c,x];
i1=(∫_0^∞)(E^(-a (x^2)/2))\[DifferentialD]x

i1//FullForm

i1//TreeForm

i1[[1,2,1,2]]
{(* Hlavička výrazu má index 0 *)i1[[0]],i1[[1]],i1[[2]]}

Předpoklady:

Některé funkce (např. Refine, Integrate, Simplify, FullSimplify) připouštějí použití předpokladů (často se týkají parametrů):

{Assuming[a>0,(∫_0^∞)(E^(-a (x^2)/2))\[DifferentialD]x],(* ekvivalentně *)
Integrate[Exp[-a x^2/2],{x,0,Infinity},Assumptions->{a>0}],Integrate[(E^(-a (x^2)/2)),{x,0,∞},Assumptions-> a>0]}//Simplify

i1=(∫_0^∞)(E^(-a (x^2)/2))\[DifferentialD]x
{i1,
(* Zatím obtížné: Nutno číst: je-li reálná část a kladná, pak je výsledek to, co uvedeno jest *)
i1/.ConditionalExpression[a_,b_]->a,i1[[1]]}

(* Také je možné *)
Integrate[Exp[-a x^2/2],{x,0,Infinity},GenerateConditions->False]

Obory hodnot:

Funkce typu Solve, Reduce, Refine,  FindInstance, Minimize aj.  umožňují definování oborů hodnot (Complexes, Reals, Rationals, Integers, Booleans):

Clear[a,b,c,x]
(* Řešení kvadratické rovnice v oboru reálných čísel *)
(* Podmínky jsou na nezápornost diskriminantu, symbol || je logické Or, ∨ *)Solve[a (x^2)+b x +c== 0,x,Reals]

Diophantická rovnice ve dvou proměnných (řešení pouze v oboru celých čísel):

dioph=Solve[x^2+x y+y^2==109,{x,y},Integers];
diophPoints={x,y}/.dioph
ListPlot[diophPoints,PlotStyle->{Red,PointSize->Large},PlotLabel->"Solution to a Diophantic equation\n"]

Můžeme přidat i nerovnosti:

SolveValues[{x^2+x y+y^2==109,x>y},{x,y},Integers]

Celočíselné programování (Integer programming): Minimalizovat  účelovou funkci (objective function) 2x+3y-z za podmínek 1≤x+y+z≤2, x-y+z≤2, x-y-z==3, x,y,z celá čísla. Zde && je logické And, ∧.

minimal1=Minimize[{2x+3y-z,1≤x+y+z≤2&&1≤x-y+z≤2&&x-y-z==3 },{x,y,z},Integers]

(* ekvivalentně && je \[EscapeKey]&&\[EscapeKey]*)Minimize[{2x+3y-z,1≤x+y+z≤2∧1≤x-y+z≤2∧x-y-z==3 },{x,y,z},Integers]

Jak číst výstup: Minimální hodnota je 5 a účelová funkce ji nabývá v bodě {2,0,-1}. “Vypreparování” řešení:

reseni1={x,y,z}/.minimal1[[2]]

Přiřazení:

{x,y,z}={x,y,z}/.minimal1[[2]]
Clear[x,y,z]
{x,y,z}

***Zatím obtížné:

minimal1[[2]]//FullForm
minimal1[[2]][[1]][[2]][[2]]
Map[minimal1[[2]][[#]][[2]][[2]]&,{1,2,3}]

V oboru reálných čísel:

Minimize[{2x+3y-z,1≤x+y+z≤2&&1≤x-y+z≤2&&x-y-z==3 },{x,y,z}]

Seznam symbolů použitých v této seanci:

?Global`*

Konec 2021-10-01a

Pravděpodobnost 1

Probability
NProbability
ProbabilityDistribution
ProbabilityPlot

Modelování (simulace, metody Monte Carlo)

Náhodný výběr

X referenční náhodná veličina na prostoru (Ω,𝒜,P), náhodný výběr tvoří ((Subscript[X, 1]),...,(Subscript[X, n])) nezávislé stejně rozdělené náhodné veličiny (iid) s rozdělením jako má X. Příroda “vygeneruje” ω∈Ω a my pozorujeme konkrétní hodnoty (čísla) ((Subscript[X, 1])(ω),...,(Subscript[X, n])(ω)).

*Náhodný (stochastický) proces

Náhodný proces je množina náhodných veličin {(Subscript[X, t]),t∈T} indexovaných indexovou množinou T na stejném pravděpodobnostním prostoru (Ω,𝒜). V případě T={0,1,...} se často hovoří o časové řadě, v případě T={t≥0} o spojitém stochastickém procesu. Pro pevné ω∈Ω je (Subscript[X, t])(ω), jakožto funkce proměnné t reálná funkce proměnné t a nazývá se trajektorie. Pozor, náhodná veličina není reálná funkce přestože nabývá reálných hodnot.

Metody Monte Carlo (Simulační metody): Princip

MC metody: odvětví experimentální matematiky, které se zabývá experimenty s náhodnými čísly. Numerická technika provádění hromadných experimentů s modely pomocí počítače umožňující generovat velké množství náhodných výběrů (umělých náhodných výběrů). Většinou jsou efektivnější v situacích, kdy sama podstata problému je náhodná. Při řešení deterministických problémů tomu jsou většinou úspěšnější klasické metody numerické matematiky.

Probability

(RefLink[Probability, paclet:ref/Probability]) — compute probabilities of predicates

Esc dist Esc for the \[Distributed] symbol.
 Esc cond Esc for the \[Conditioned] symbol.
  Esc scD Esc for the 𝒟 symbol.

Hyperlink[Button["Probability And Statistics"], 
    "paclet:guide/ProbabilityAndStatistics"]

nebo také

https://reference.wolfram.com/language/guide/ProbabilityAndStatistics.html

Predikát je funkce jedné nebo více proměnných, která vrací True nebo False. U funkcí typu Probability je náhodný jev reprezentován predikátem. Je-li X  náhodná veličina, pak náhodný jev X>4 jest v tomto systému predikát.

Type Esc dist Esc for the \[Distributed] symbol.

Probability
NProbability
ProbabilityDistribution
ProbabilityPlot

?*Distribution

{Probability[iX≤3,iX\[Distributed]NormalDistribution[]],Probability[iX≤3,iX\[Distributed]NormalDistribution[]]//N,NProbability[iX≤3,iX\[Distributed]NormalDistribution[]],NProbability[iX≤3.,iX\[Distributed]NormalDistribution[]]}

Row@{"Přesně: ",Table[Probability[iX≤3,iX\[Distributed]NormalDistribution[]],{1000}];//Timing,"   Přibližně: ",Table[NProbability[iX≤3,iX\[Distributed]NormalDistribution[]],{1000}];//Timing}
Table[Probability[iX≤3.,iX\[Distributed]NormalDistribution[]],{1000}];//Timing

Momenty

Clear[μ,σ]
𝒟1=NormalDistribution[μ,σ];
momenty={Mean,Variance,StandardDeviation,Skewness,Kurtosis};
Through[momenty[𝒟1]]
{momenty,Through[momenty[𝒟1]]}//Transpose//TableForm
Grid[{momenty,Through[momenty[𝒟1]]}//Transpose,Frame->All]

Conditional Probability (Podmíněná pst)

A, B náhodné jevy, n. v. X\[Distributed]distribution. Pak P(X∈A|X∈B) je

Probability[X∈A\[Conditioned]X∈B,X\[Distributed]distribution]

Znak \[Conditioned]: EsccondEsc nebo z palety.

Exponential distribution

𝒟Míša=ExponentialDistribution[λ];
Row@{"Hustota (probability density function):  ",PDF[𝒟Míša,x],"\nDistribuční funkce (cumulative distribution function):  ",CDF[𝒟Míša,x]}

Exponenciální rozdělení nemá paměť:
Podmíněná pst:

Probability[x>t+h\[Conditioned]x>t,x\[Distributed]𝒟Míša,Assumptions->{t>0,h>0}]

Grid[{momenty,Through[momenty[𝒟Míša]]}//Transpose,Frame->All]

𝒟Pavel=CauchyDistribution[μ,σ];
Row@{"Hustota (probability density function):  ",PDF[𝒟Pavel,x],"\nDistribuční funkce (cumulative distribution function):",CDF[𝒟Pavel,x]}

Grid[{momenty,Through[momenty[𝒟Pavel]]}//Transpose,Frame->All]

Integrate[x PDF[𝒟Pavel,x],{x,0,∞}]

Quantiles of a Cauchy distribution

quantiles={Quantile[𝒟Pavel,1/10],Quantile[𝒟Pavel,1/4],Quantile[𝒟Pavel,1/2],Quantile[𝒟Pavel,3/4],Quantile[𝒟Pavel,9/10]}
%//N

Quantiles of a normal distribution

quantilesNormal={Quantile[𝒟Pavel,1/10],Quantile[𝒟Pavel,1/4],Quantile[𝒟Pavel,1/2],Quantile[𝒟Pavel,3/4],Quantile[𝒟Pavel,9/10]}/.𝒟Pavel->NormalDistribution[μ,σ]//N

Geometrické rozdělení

Spočtěte pst jevu x<X<x+h za podmínky X>x, kde h>0.

Clear[p]
𝒟MíšaGeom=GeometricDistribution[p];

Probability[x<X<x+h\[Conditioned]X>x,X\[Distributed]𝒟MíšaGeom]

To je sice správně, ale poněkud nepřehledné. Přidáme předpoklady:

Probability[x<X<x+h\[Conditioned]X>x,X\[Distributed]𝒟MíšaGeom,Assumptions->{h∈Integers&&x>0&&x∈Integers}]//Simplify//TraditionalForm

Geometrické rozdělení (diskrétní verze exponenciálního) také nemá paměť.

Konec 2021-10-01b

2021-10-08 Lekce 2

Jisté změny a doplňky viz v závěru předchozí lekce. Např. geometrické rozdělení.

FAQ

TraditionalForm

Clear[bi]
bi[n_,p_]=BinomialDistribution[n,p]
PDF[bi[n,p],k]//TraditionalForm
Simplify[PDF[bi[n,p],k],Assumptions->{k∈Integers,n∈Integers,0<p<1,0<=k<=n}]//TraditionalForm

NIntegrate - Methods

NIntegrate

Plot[(1/x)Cos[Log[x]/x],{x,0,1},PlotRange->15]

NIntegrate[(1/x)Cos[Log[x]/x],{x,0,1}]

NIntegrate[1/Sqrt[Sin[x]],{x,0,10}]

Specifying a larger value for (RefLink[MaxRecursion, paclet:ref/MaxRecursion]) gives a much better result:

NIntegrate[1/Sqrt[Sin[x]],{x,0,10},MaxRecursion->100]

Specifying the singularity locations is even more efficient:

NIntegrate[1/Sqrt[Sin[x]],{x,0,π,2 π,3 π,10}]

{Integrate[PDF[CauchyDistribution[0,(10^(-100))],x],{x,-∞,∞}],Integrate[PDF[CauchyDistribution[0.,(10^(-100))],x],{x,-∞,∞}],NIntegrate[PDF[CauchyDistribution[0.,(10^(-100))],x],{x,-∞,∞}]}

4 pilíře systému Mathematica 3

2. Symbolické výpočty 2

**Příklad složené funkce (různé zápisy)

{ArcTan[Tan[(π/4)]],(π/4)//Tan//ArcTan,ArcTan@Tan@(π/4)}

Částečné a nekonečné součty, integrály

Následující výpočet je instruktivní a dělá potíže i u státních zkoušek. Kolik je celých čísel mezi celými čísly a,b,a<b?

Clear[a,b];
(∑_(i=a)^b)1

Variace na dané téma: Všimněte si, že chybová zpráva týkající se druhého řádku se objeví ještě před výstupem.

{(∑_(i=1)^n)(∑_(j=1)^i)1,(∑_(i=1)^n)i,Total[Range[100]]}//TraditionalForm
{(∑_(i=1)^n)(i^6),(∑_(n=1)^∞)(1/n),(∑_(n=1)^∞)(1/(n^2)),(∑_(n=1)^∞)(1/(n^4))}

Meze vícenásobných součtů, integrálů odpovídají matematickému zápisu: interpretují se zleva doprava.

(Iterátor ve funkci Sum může mít dva elementy - v tom případě je dolní mez rovna 1, v případě tří elementů je {i,imin,imax}.

{Sum[1,{i,n},{j,i}],(∫_0^n)(∫_0^x)\[DifferentialD]y\[DifferentialD]x}

{(∑_(i=1)^n)(∑_(j=1)^i)i j//Expand,
Integrate[x y (* soucin x a y *),{x,0,n},{y,0,x}]}//TraditionalForm

Derivace a integrál

Row@{"1. derivace:  ",D[(x^n),x],"  3. derivace:   ",D[(x^n),{x,3}]//TraditionalForm}
Row@{"Parciální derivace \!\(\*Cell[TextData[{
"(∂/∂,x)(∂/∂y)",
Cell[BoxData[RowBox[{RowBox[{"Exp", "[", RowBox[{
SuperscriptBox["x", "m"], "+", 
SuperscriptBox["y", "n"]}], "]"}], ":"}]],CellChangeTimes->{{3.748066578237536*^9, 3.748066652748869*^9}, {3.7480666842080293`*^9, 3.7480667854185*^9}},ExpressionUUID->"e39e9b48-6645-4c3c-8881-37dddaca5f28"]
}],ExpressionUUID->"8473f861-4e7f-4261-bf6b-61cb93fc3249"]\)   ",D[Exp[(x^m)+(y^n)],x,y]}
Row@{"Parciální derivace vyšších řádů:  ",D[Exp[(x^m)+(y^n)],{x,2},{y,3}]}
Row@{"Poslední výraz zjednodušený v tradiční formě:\n  ",D[Exp[(x^m)+(y^n)],{x,2},{y,3}]//Simplify//TraditionalForm}

(* Neurčitý integrál, jeho derivace a zjednodušená derivace - *)(* ta teprve je ve tvaru integrované funkce *)
Integrate[1/(x^3+1),x]
D[%,x]
%//Simplify

(* Dvojný určitý integrál, vnější integrál podle x -*)
(* dva ekvivalentní zápisy a totéž v tradiční formě a numerická hodnota *)
(* CosIntegral je integrální kosinus. *)
{Integrate[Sin[x y],{x,0,1},{y,0,x}],(∫_0^1)(∫_0^x)Sin[x y]\[DifferentialD]y\[DifferentialD]x}
%//TraditionalForm
%%//N

{(1/2) (EulerGamma-CosIntegral[1]),(1/2) (EulerGamma-CosIntegral[1])}

Když nerozumíte symbolům ve výstupu (např. EulerGamma, CosIntegral), stačí umístit kursor na uvedený výraz a stisknout F1.

(* Povrch koule o poloměru r *)
{Assuming[r>0,Integrate[1,{x,y,z}∈Sphere[{0,0,0},r]]],
(* Ekvivalentně *)
(**)Area[Sphere[{0,0,0},r]]}

(* Numerická integrace *)
Row@{Integrate[Sin[Sin[x]],{x,0,2}],"   Numericky: ",integralSinSin=NIntegrate[Sin[Sin[x]],{x,0,2}],"\nPřesněji:  ",integralSinSin50=NIntegrate[Sin[Sin[x]],{x,0,2},WorkingPrecision->50],"\nRozdíl mezi těmito dvěma hodnotami:  ",integralSinSin-integralSinSin50}

3. Grafika

Některé z grafických funkcí (poklepem na vybranou funkci získáte informaci a návod k použití :

?*Plot*

Využití návrhu (Suggestion bar)

Po aktivaci následující buňky se pod výstupem objeví Suggestion bar a z něj můžeme postupně generovat příkazy které jsou dále uvedeny:

plotSinusxNaDruhou=Plot[Sin[(x^2)],{x,0,π}]

Show[plotSinusxNaDruhou,AxesLabel->{HoldForm[xxx],HoldForm[yyyy]},PlotLabel->HoldForm[poi],LabelStyle->{FontFamily->"Bahnschrift",14,GrayLevel[0],Bold}]

Toto jsou již příkazy generované z návrhové lišty:

Show[plotSinusxNaDruhou,AxesLabel->{HoldForm[x],HoldForm[Sin[(x^2)]]},PlotLabel->HoldForm[Sin[(x^2)]],LabelStyle->{FontFamily->"Arial",18,GrayLevel[0]}]

plotSinusxNaDruhouWithLables=Show[plotSinusxNaDruhou,AxesLabel->{HoldForm[x],HoldForm[Sin (x^2)]},PlotLabel->HoldForm[Sin (x^2)],LabelStyle->{18,GrayLevel[0]}]

Show[plotSinusxNaDruhouWithLables,Background->RGBColor[0.97`,0.93`,0.68`]]

Show[plotSinusxNaDruhou,Background->RGBColor[0.97`,0.93`,0.68`]]

Show[plotSinusxNaDruhou,Background->RGBColor[0.97`,0.93`,0.68`],AxesLabel->{HoldForm[x],HoldForm[y]},PlotLabel->HoldForm[Graf funkce sin (x^2)],LabelStyle->{FontFamily->"Aparajita",14,GrayLevel[0]}]

Plot[Sin[(x^2)],{x,0,π},PlotTheme->"Marketing" ]

Show[plotSinusxNaDruhou,Background->Directive[RGBColor[1.`,0.64`,0.28`],Opacity[0.254`]]]

Show[plotSinusxNaDruhou,AxesLabel->{HoldForm[osa x],HoldForm[osa y]},PlotLabel->HoldForm[Sin (x^2)],LabelStyle->{16,GrayLevel[0]}]

Show[plotSinusxNaDruhou,AxesLabel->{HoldForm[x],HoldForm[y]},PlotLabel->HoldForm[Sin[(x^2)]],LabelStyle->{FontFamily->"Arial",16,GrayLevel[0],Bold}]

Plot[Sin[x+x^2],{x,0,3π},PlotRange->{-5,5},Ticks->{{{0.5,"0.5"}},{Pi/2,Pi,2Pi}},FormatType->TraditionalForm,AxesLabel->{x,"Sin[x+(x^2)]\n"},TicksStyle->Directive[Orange,14]]
Plot[Sin[x+x^2],{x,0,π},PlotRange->{-5,5},Ticks->{{0,(Pi/2),Pi},{-Range[5],0,Range[5]}//Flatten},AxesLabel->{x,Style["\nSin[x+(x^2)]\n",Large]}]

3D grafy

SetDirectory[NotebookDirectory[]]

"3D grafy je možné otáčet, zvětšovat ..."
p1=Plot3D[Sin[x+y^2],{x,0,π},{y,0,π}]

p2=Show[p1,ViewPoint->Above]

Export ve zvoleném formátu:

$ExportFormats

Následující konstrukce je velmi užitečná a ulehčí práci s externími soubory a přenášení mezi různými médii. Do adresáře, kde máte uložen tento notes si uložte i všechny soubory, které potřebujete importovat. Zároveň do stejného adresáře exportujete soubory vytvořené v tomto notesu. Ušetříte si tím pracné nastavování cest (Path) v adresářích. Bohužel nutno zapamatovat:

Directory[]
SetDirectory[NotebookDirectory[]] (* Důležité!!!*)
Directory[]
Export["graffunkce1.pdf",p1]
Export["graffunkce2.pdf",p2]

Ještě jeden příklad (Srdcovka)

ContourPlot[((((x^2)+(y^2)-1))^3)-(x^2)(y^3)==0,{x,-1.3,1.3},{y,-1.1,1.3}]

ContourPlot[(x^2)+(y^2)==1,{x,-1,1},{y,-1,1}]

Ale:

{Plot[{(Sqrt[1-(x^2)]),-(Sqrt[1-(x^2)])},{x,-1,1},PlotStyle->Thick],Plot[{(Sqrt[1-(x^2)]),-(Sqrt[1-(x^2)])},{x,-1,1},PlotStyle->Thick,AspectRatio->1/GoldenRatio],
Plot[{(Sqrt[1-(x^2)]),-(Sqrt[1-(x^2)]),x,-x},{x,-1,1},PlotStyle->Thick,AspectRatio->Automatic]}

{GoldenRatio//FunctionExpand,(1/GoldenRatio)//FunctionExpand}
%//N

Manipulate[Plot[{(x^2),1-c (x^2)},{x,a,b}],{a,-1,1},{{b,1},-1,1},{{c,0},-1,1,Appearance->"Labeled"},SaveDefinitions->True]
(* Animace přes c!!! *)

**Cela a zlomkova cast (Floor, FractionalPart)

Plot[{Floor[x],FractionalPart[x]},{x,-2.5,4},PlotTheme->"Detailed"]

4. Programování 1

Definice funkcí 1

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

Příklad

Clear[hu]; 
(* odstraňuje hodnoty a definice symbolu hu. Symbol však zůstává známý v daném kontextu (= adresáři). Ekvivalentní zápis je hu=. *)
hu[x_]:=(x^2)

(“=” a “:=”  znamená  globální pravidlo)
"=" je okamžité přiřazení (pravá strana se vyhodnotí a uloží), ":=" je odložené přiřazení: uloží se pravidlo, pravá strana se vyhodnotí až při použití pravidla.

Levá strana libovolného pravidla může obsahovat vzory (patterns), v našem případě x_ zastupuje právě jeden argument. To může být libovolný objekt, číslo, matice, graf, ... .

🐺

hu[2]=🐺;
{hu[3],hu[2],hu[2.],hu[2.003],hu[(({{1, 2}, {3, 4}}))],hu[(({{1, 2}, {3, 4}}))]//MatrixForm}

(* Vysvětlení: 2≠2. *)
2===2.
{FullForm[2],FullForm[2.]}

(* Informace o symbolu *)
?hu

{hu[2],hu[Log[2]],hu[Log[2.]],hu[e1]}
%//Expand

Poznámka k sazbě: (x^2) se vysází jako x Ctrl ^ 2, (Subscript[x, 3]) jako x Ctrl _ 3, (Sqrt[x]) Ctrl2 x nebo z palety (Menu  Palettes Writing Assistant, Basic Math Assistant, Basic Math Input, Basic Typesetting  nebo pomoci Esc sekvenci)

Π ⟶ ⟶ ⟵  ↔  ↘  ↗  ⥮ Ctrl Esc ⌘

hu[x_,y_]:=x^y

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

{hu[🐺],hu[🐺,🐺],hu[🐺,🐺,🐺]}

?hu

FullForm: funkce, která ukazuje vnitřní zobrazení objektů systému. Pro elementární vážnější užití nezbytná. Zde jen pro informaci:

🐺//FullForm

Clear[hu]
?hu

Remove[hu]
(* Odstraní symbol z daného kontextu.  *)
?hu

Vsechny symboly v dane seanci v kontextu Global` (zpětná čárka má podobný význam jako “\” v DOS nebo “/” v Unixu].

?Global`*

Příklad (definice funkce definované po částech)

{I,I,E,E}

{I<1,2<1,0<1,a<1}

Clear[jh];
jh[x_]:=Which[
x<-1,-1,
-1≤x<1,x,
True (* tj., ve všech ostatních případech *),1]
{jh[-3],jh[a],jh[2,3],jh[I]}
Plot[jh[x],{x,-3,3},PlotStyle->Thick,PlotTheme->"Marketing",PlotLabel->"Funkce definovaná po částech" ]

Derivace a integrál funkce definované po částech

Row@{"Derivace: ",D[jh[z],z],"   Určitý intergál: ",(∫_1^10)jh[x]\[DifferentialD]x,"\nUrčitý intergál s proměnnou dolní mezí: ",Assuming[z>1/2,(∫_(1/2)^z)jh[x]\[DifferentialD]x]//TraditionalForm,"   Neurčitý intergál: ",∫jh[x]\[DifferentialD]x}

True ve třetím případě (tj. Assuming ...) znamená, že (1/2)<z≤1.

Plot[D[jh[x],x],{x,-3,3},PlotStyle->Thick,PlotTheme->"Marketing",PlotLabel->"Derivace funkce definované po částech" ]

D[jh[x],-2.9998774285714287`]

Plot[D[jh[x],x]//Evaluate,{x,-3,3},PlotStyle->Thick,PlotTheme->"Marketing",PlotLabel->"Derivace funkce definované po částech",PlotRange->All ]

⚠ Aplikace funkce Evaluate je v tomto případě nezbytná.

Příklad (Definice funkce pro argumenty přirozená a reálná čísla)

Clear[jh2];
jh2[x_]:=Which[
x∈Integers∧x>0,Factorial[x],
x∈Reals,x 🐺 (* tj. x krát Vlk *),
True,"Argument neni realne cislo."]
{jh2[10], jh2[1.5],"\n" jh2[I+1],"\n"jh2[1,2],jh2[{1,2}]}

Funkce jh2 aplikovana na list {1,2} zustava nevycislena, protoze Mathematica neumi vyhodnotit dotaz (neumi rozhodnout), zda

{1,2}>0 (* viz úplná forma: *)
{1,2}>0//FullForm

**Podivejte se do Help, s jakymi argumenty funkce Greater muze pracovat. Jiste vylepseni by bylo pri pouziti funkce Positive[x] misto x>0, ale jeste lepsi je omezit vypocet pouze na numericke hodnoty x.

Nasledujici funkce zahaji vypocet pouze v pripade, ze argument je numericka hodnota (muze byt i komplexni cislo). Symbol /; znamena “udelej pouze za podminky, ze ...”

Clear[jh3];
jh3[x_]:=Which[
x∈Integers&&x>0,Factorial[x],
x∈Reals,x 🐺,
True,"Argument neni realne cislo."]/;NumericQ[x]
{jh3[10], jh3[π],jh3[1.5],jh3[{1,2}],jh3[I+1]}

Jiná možnost:

(**)Clear[jh222];
jh222[x_Real]:=x 🐺
jh222[x_Integer]:=Factorial[x]/;x>0
{jh222[10], jh222[π],jh222[10.],jh222[7/10],"\n"jh222[1,2],jh222[{1,2}],"\n" jh222[I+1]}

jh222[x_Rational]:=Sin[x]
{jh222[7/10],jh222[7./10],jh222[-10]}

Definice Hilbertovy matice ({i,n} znamena totez co {i,1,n} - nazývá se iterátor - v Mathematice indexování zásadně od 1!!! )

HilbertMatrix 
(* je zabudovaná funkce, ale instruktivní je uvést i uživatelské možnosti *)

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

**Funkcionální definice:

Clear[hmarray];
hmarray[n_]:=Array[(1/(#1+#2-1))&,{n,n}]
hmarray[3]

hilbertovamatice[3]

h3matrixform=hilbertovamatice[3]//MatrixForm

Připomínka: f[x] je totez, co x//f resp. f@x

Poznamka: h3matrixform neni totez co hilbertovamatice[3]!!! Příkazy typu MatrixForm, TableForm, TreeForm slouží pouze pro přehlednější výstup jsou indikovány v názvu výstupní buňky! V našem případě Out[109]//MatrixForm= ... .

FullForm[h3matrixform]

FullForm[hilbertovamatice[3]]

S h3matrixform se neda pocitat:

{Det[h3matrixform],Det[hilbertovamatice[3]]}

Jak odstranit MatrixForm?
1. Nedefinovat symbol jako MatrixForm, ale MatrixForm pouzit pouze pro znazorneni:

{(h33m=hilbertovamatice[3])//MatrixForm,MatrixForm[h33m=hilbertovamatice[3]]}

S h33m pak mohu dale pocitat:

Det[h33m]

***(Nepovinné) 2. Aplikovat funkci Identity. Ta vymeni hlavicku vyrazu, tj. MatrixForm, za Identity. (Pro zacatecnika obtiznejsi.)

Apply[Identity,h3matrixform]//FullForm

Konec nepovinné části. ***

Inverse[hilbertovamatice[3]]//MatrixForm
Inverse[h3matrixform]

h20=hilbertovamatice[20];
Row@{"Prvni radek inverzni matice","\n",First[h20inv=Inverse[h20]]}
Row@{"Determinant presne  = " ,dh20=Det[h20],"\nDeterminant priblizne  = ",N[dh20]}
Det[h20inv]
Row@{"Soucin determinantu matice puvodni a matice inverzni  ",Det[h20]*Det[h20inv]}
First[h20.h20inv]
(* 2. radek matice*)
h20.h20inv[[2]] 
(**)First[Rest[h20.h20inv]]

h20.h20inv==IdentityMatrix[20]

Poznámka

(* nefunguje: *)
{Min[{4,6,7,8,9,4}],%+2}
(* funguje: *)
{min=Min[{4,6,7,8,9,4}],min+2}

Pravděpodobnost 2

(RefLink[Expectation, paclet:ref/Expectation]) — compute expectations of expressions

(OrangeLink[Random Variables », paclet:guide/RandomVariables])

Distributions

(RefLink[NormalDistribution, paclet:ref/NormalDistribution]) — parametric distributions ...

(RefLink[TransformedDistribution, paclet:ref/TransformedDistribution]) — derived distributions ...

ProbabilityDistribution
ProbabilityPlot

ProbabilityDistribution, TransformedDistribution, ProductDistribution

Definuje rozdělení s uživatelem zadanou hustotou (distr. fcí).

Příklad 1

(* Použitím volby Method->"Normalize" nemusíme zadávat normalizační konstantu. *)𝒟6=ProbabilityDistribution[1/(1+x^6),{x,-Infinity,Infinity},Method->"Normalize"]
pdf𝒟6[x_]=PDF[%,x]
Integrate[%,{x,-∞,∞}]

Clear[pdf𝒟6Apart]
pdf𝒟6Apart[x_]=pdf𝒟6[x]//Apart
Integrate[%,{x,-∞,∞}]
𝒟6Apart=ProbabilityDistribution[pdf𝒟6Apart[x],{x,-Infinity,Infinity}]
NExpectation[(x^6),x\[Distributed]𝒟6Apart]

Momenty 1. pokus přesně (Aborted po 2082 sec)

Grid[Table[{j,Expectation[(x^j),x\[Distributed]𝒟6]},{j,6}],Frame->All]

Když se však chvíli zamyslíme a užijeme znalosti z analýzy, tak ihned vidíme, že existují momenty řádu nižšího než 5.

Grid[Table[{j,Expectation[(x^j),x\[Distributed]𝒟6]},{j,4}],Frame->All]

Momenty 2. pokus numericky (0.22 sec, 5. a 6. moment špatně, ale se správnými chybovými hláškami)

Grid[Table[{j,NExpectation[(x^j),x\[Distributed]𝒟6]},{j,6}],Frame->All]

Momenty 3. pokus (Aborted po 994 sec)

Grid[Table[{j,Moment[𝒟6,j]},{j,6}],Frame->All]

Momenty 4. pokus (0.25 sec, správně)

Grid[Table[{j,Integrate[(x^j)pdf𝒟6[x],{x,-∞,∞}]},{j,6}],Frame->All]

Vidíme, že je asi chyba ve Wolfram Language (WL). Tento příklad je zároveň instruktivní. Ve WL máme řadu možností pro řešení jednoho problému.

Momenty 5. pokus (0.11 sec resp. 0.08 sec, až na 6. moment správně),

Clear[expectations𝒟6]
expectations𝒟6[j_]=Expectation[(x^j),x\[Distributed]𝒟6]

Csc je kosekans úhlu: csc(z)==1/sin(z), poměr přepona/protilehlá odvěsna.

(Grid[Table[{j,expectations𝒟6[j]},{j,6}],Frame->All])

Momenty 6. pokus (0.11 sec resp. 0.08 sec, perfektní),

Clear[moments𝒟6]
moments𝒟6[j_]=Moment[𝒟6,j]

(Grid[Table[{j,moments𝒟6[j]},{j,6}],Frame->All])

PDF, CDF, Plot, moments, quantiles, tail probabilities, comparison with other distributions

Momenty 7. pokus pomocí vytvořující funkce momentů

Teorie praví, že vytvořující funkce momentů (MGF) definujeme jenom v případě, že existují všechny momenty. Můžeme se nicméně pokusit o formální výpočet. Existuje sice zabudovaná funkce MomentGeneratingFunction, ale následující výpočet trvá (?) dlouho.

(mgf𝒟6[t_]=MomentGeneratingFunction[𝒟6,t])//Timing

Přímý výpočet:

(i61=Integrate[Exp[t x] (3/(2 π (1+(x^6)))),{x,-∞,∞}])//Timing

(i62=Integrate[((Exp[t x])/(1+(x^6))),{x,-∞,∞},Assumptions->t>0])//Timing

Plot[(i61/.t->x)//Evaluate,{x,0,4}]

(* Střední hodnota *)
SeriesCoefficient[i61[[1]],{t,0,1}]

{aux=(Sqrt[π])MeijerG[{{},{}},{{(1/2)},{0}},(x/2),(1/2)],Integrate[aux,x]}

Series[Factorial[x],{x,∞,5}]

Příklad 2

Obligace s nulovým kupónem s možným selháním, nominální hodnota F=1 splatná za jeden rok splatí X, kde X je n. v. s rozdělením 𝒟7. Jaká je spravedlivá cena obligace, je-li bezriziková ú. m. rovna r?

𝒟7=ProbabilityDistribution[Which[0<x<1/10,0,
							1/10<x<1,(200/81)x-(20/81)],{x,0,1}]
pdf𝒟7[x_]=PDF[𝒟7,x]
Integrate[%,{x,0,1}]
Plot[pdf𝒟7[x],{x,-1,2},PlotTheme->"Detailed",PlotStyle->Thick, PlotLabel->"Hustota skutečně splacené částky X"]

Spravedlivá cena P se spočte na základě principu ekvivalence: ve střední hodnotě musí obligace splatit částku odpovídající bezrizikovému výnosu, tj. P=E,X/(1+r).

iEX=Mean[𝒟7]

Jak se dojde k parametrům přímky? Pravděpodobnost, že bude splaceno méně než 1/10 je nula, od tohoto bodu lineární průběh. Integrál z hustoty musí být roven jedné:

Clear[k,q]
SolveValues[{Integrate[k x+q,{x,1/10,1}]==1,k/10+q==0},{k,q}][[1]]

Oprava. V původním textu je zde červeně označená pasáž špatně:

Jak se dojde k parametrům přímky? Pravděpodobnost, že nebude splaceno vůbec nic je 1/10, od tohoto bodu lineární průběh. Integrál z hustoty musí být roven jedné.

V takovém případě by se jednalo o rozdělení spojitě-diskrétního typu: P(X=0)=1/10 a na intervalu [1/10,1] hustota s parametry

Clear[k2,q2]
Solve(*Values*)[{Integrate[k2 x+q2,{x,1/10,1}]==9/10,k2/10+q2==0},{k2,q2}][[1]]

Střední hodnota tohoto rozdělení je tedy

0×(1/10)+(∫_(1/10)^1)x((20/9)x-(2/9))\[DifferentialD]x

Transformace

Spočtěte distribuční funkci (X^2)+(Y^2), kde X,Y iid N(0,1).

Clear[x]
Probability[(X^2)+(Y^2)<x,{X\[Distributed]NormalDistribution[],Y\[Distributed]NormalDistribution[]},Assumptions->x>0]

To nefunguje, ale:

TransformedDistribution[(X^2)+(Y^2),{X\[Distributed]NormalDistribution[],Y\[Distributed]NormalDistribution[]}]
CDF[%,x]

Clear[x,n]
CDF[ChiSquareDistribution[n],x]
Table[{n,%},{n,4}]//Simplify//TableForm

{PDF[GammaDistribution[(n/2),2],x],PDF[ChiSquareDistribution[n],x]}
{({{\[Piecewise], ({{(((2^(-n/2)) (E^(-x/2)) (x^(-1+(n/2))))/(Gamma[(n/2)])), x>0}, {0, True}})}}),({{\[Piecewise], ({{(((2^(-n/2)) (E^(-x/2)) (x^(-1+(n/2))))/(Gamma[(n/2)])), x>0}, {0, True}})}})}

Clear[x]
Probability[(X^2)+(Y^2)<x,{X,Y}\[Distributed]ProductDistribution[{NormalDistribution[],2}]]

Domácí cvičení : Zjistěte, k čemu je dobrá funkce ProbabilityPlot a QuantilePlot

Konec 2021-10-08

2021-10-15 Lekce 3

Důležitá doplnění k Lekci 2: Příklad 1 a Příklad 2

FAQ

Kvantilové funkce 1

viz následující Lekce 4

Clear[𝒟Poisson]
𝒟Poisson=PoissonDistribution[λ]
Quantile[𝒟Poisson,y]//FunctionExpand
InverseCDF[𝒟Poisson,y]//FunctionExpand

InverseCDF[NormalDistribution[],y]//FunctionExpand

Pravděpodobnost 3

(RefLink[RandomVariate, paclet:ref/RandomVariate]) — generate random variates from a distribution

(RefLink[EstimatedDistribution, paclet:ref/EstimatedDistribution]) — estimate parametric or derived distribution from data

(RefLink[DistributionFitTest, paclet:ref/DistributionFitTest]) — test how well data and a distribution fit

(RefLink[SmoothKernelDistribution, paclet:ref/SmoothKernelDistribution]) — nonparametric distributions ...

Modelování (simulace, metody Monte Carlo (MC))

Princip metod MC

MC metody: odvětví experimentální matematiky, které se zabývá experimenty s náhodnými čísly. Numerická technika provádění hromadných experimentů s modely pomocí počítače umožňující generovat velké množství náhodných výběrů (umělých náhodných výběrů). K tomu se používají generátory náhodných čísel. Většinou jsou efektivnější v situacích, kdy sama podstata problému je náhodná. Při řešení deterministických problémů tomu jsou většinou úspěšnější klasické metody numerické matematiky.

Náhodná čísla z rovnoměrného rozdělení

Náhodná čísla by měly mít vlastnosti náhodného výběru, nezávislé stejně rozdělené náhodné veličiny (iid, independent identically distributed r. v.))

Pro úspěšné použití metod MC je nutné mít kvalitní generátory náhodných čísel. V simulačních metodách je zapotřebí obvykle velké množství náhodných čísel (někdy řádově milióny) a proto je nutné je generovat rychle.

V současnosti nejúspěšnější jsou generátory posloupností náhodných čísel založeny na rafinovaných deterministických algoritmech, které produkují tzv. pseudonáhodná čísla. Při znalosti vstupních parametrů je možné příslušnou posloupnost přesně zrekonstruovat.  Ukazuje se, že generátory založené na deterministických algoritmech jsou podstatně lepší než ty, které jsou založené na “opravdové náhodě” (tahání očíslovaných lístků z urny, výběr očíslovaných pingpongových míčků, ruleta, házení kostkou, šum elektronek, házení mincí aj.)

Na generátorech náhodných resp. pseudonáhodných čísel se v zásadě požaduje: dlouhá perioda (nesmí se začít opakovat příliš brzy, vyžaduje se řádově (10^8) členů posloupnosti bez opakování), nezávislost nebo nekorelovanost, konečně to, aby se řídila požadovaným rozdělením, sdruženým rozdělením dvojic, trojic, atd. Teorie čísel (v poslední době teorie celulárních automatů aj.) poskytuje fundamentální podklad pro konstrukci generátorů, nicméně je stejně dobrá praxe podrobit nový generátor baterii statistických testů. Takové testy by měly být specielně zaměřeny na to, k jakému účelu mají být náhodná čísla použita.

⚠ V drtivé většině případů se primárně generují náhodná čísla z rovnoměrného rozdělení a ta se vhodnými postupy transformují na náhodná čísla z požadovaného rozdělení. Na počítači je přirozeně možné generovat náhodná čísla z diskrétního rovnoměrného rozdělení, řekněme U(0,...,M-1), kde M je “velké číslo”, např. (2^31). Po normování je možné takto generovaná náhodná čísla považovat za náhodná čísla ze spojitého rovnoměrného rozdělení U(0,1).

V principu je vždy možné generovat náhodná čísla z libovolného rozdělení pomocí náhodných čísel z U(0,1). Platí totiž věta:

Věta. (Metoda inverzní transformace) Nechť náhodná veličina X má rozdělení s distribuční funkcí F a kvantilovou funkcí (F^(-1))(y)=inf{x|F(x)≥y}, 0<y<1. Nechť U\[Distributed]U(0,1). Potom (F^(-1))(U) má rozdělení jako X.

Platí pro libovolné rozdělení, spojité, diskrétní a libovolné jiné!!!

Metoda generování náhodných čísel z jiných rozdělení založená na této větě je závislá na tom, jak efektivně jsme schopni numericky vyčíslit kvantilovou funkci. Proto pro řadu rozdělení existují algoritmy, které obcházejí nutnost numericky počítat kvantilovou funkci. Např. pro generování náhodných čísel z normálního rozdělení se používá Box-Mullerova transformace. Ve Wolfram Language jsou však zabudovány vysoce efektivní algoritmy pro numerické výpočty speciálních funkcí a proto je důsledně používána metoda inverzní transformace.

Podrobnosti mj. Hurt, J. (1982): Simulační metody. Skripta. SPN, Praha.

Hyperlink[Button["Random Number Generation"],"paclet:tutorial/RandomNumberGeneration"]

Kongruenční generátory

Kongruence zde i dále znamená zbytek po dělení. Generují se čísla 0,1,...,M-1. Generátor typu (Subscript[X, n+1])≡a (Subscript[X, n]) mod M se nazývá multiplikativní, 
(Subscript[X, n+1])≡a (Subscript[X, n])+b  mod M smíšená kongruenčni metoda. Při vhodně zvolených konstantách a,b,M mají dlouhou periodu (začnou se opakovat až za “dlouho”), někdy dokonce maximální možnou, tj. M.

Pro ilustraci uzijeme zabudovanou funkci Mod:

(illustrationModulo=Prepend[Flatten[Table[{x,y,Mod[x,y]},{x,2,5},{y,2,x}],1],{"x","M","Mod[x,M]"}])//TableForm

Následující výstup je mírně modifikovaný výstup s využitím příkladu z Help k funkci Grid:

Text@Grid[illustrationModulo,Background->{None,{Lighter[Yellow,.9],{White,Lighter[Blend[{Blue,Green}],.8]}}},Dividers->{{Darker[Gray,.6],{Lighter[Gray,.5]},Darker[Gray,.6]},{Darker[Gray,.6],Darker[Gray,.6],{False},Darker[Gray,.6]}},Alignment->{{Center,Center,Center}},ItemSize->{{2,2,5}},Frame->Darker[Gray,.6],ItemStyle->14,Spacings->{Automatic,.8}]

Příklad 1 (Perioda)

Generovani posloupnosti 17 nahodnych cisel     (Subscript[X, n+1])≡5(Subscript[X, n])+1 mod 16. Perioda je maximalni rovna 16. Počáteční (Subscript[X, 0])=0.

gen16=NestList[Mod[5 # +1,16]&,0,16]

Příklad 2  (Vetsi problem, rozdeleni dvojic. Stejny generator (Subscript[X, n+1])=5(Subscript[X, n])+1 mod 16.)

Hypoteticky má každá dvojice pst 1/(16^2)=1/256. Vzhledem k rekurenci však není možné generovat více než 16-1 dvojic. Generovaná čísla leží na dvou systémech přímek.

Zkoumáme rozdělení dvojic ((Subscript[X, n]),(Subscript[X, n+1])).

gen16shift=RotateLeft[gen16]

ListPlot[Transpose[{gen16,gen16shift}],PlotStyle-> PointSize[0.02]]

Příklad 3 (Generator kapesniho kalkulatoru TI-59)

Nasledujici funkce generuje nahodna cisla smisenou kongruencni metodou delky n+1. Perioda by mela byt 199016. Počáteční (Subscript[X, 0])=0.

Clear[gen59];
gen59[n_]:=NestList[Mod[24298 # +9991,199017]&,0,n]
gen59[10]

Počet různých generovaných náhodných čísel v posloupnosti délky 200000:

Length[Union[gen59[200000]]]

Po sobe jdouci dvojice

gen592[n_]:=Module[{shift,g},
shift=RotateLeft[g=gen59[n]];
Transpose[{g,shift}]
]
GraphicsRow@{gen592[50000]//ListPlot,
ListPlot[gen592[50000],PlotLabel->"Joint distribution of pairs",AspectRatio->Automatic]}

“V detailu:”

Correlation
{Mean,Variance}

{r1,r1,r1}
{r2,r2,r2}
SeedRandom[13];
{Random[],Random[],Random[]}
{r2,r2,r2}

SeedRandom[13]
Table[Random[],{6}]

?r1

?r2

SeedRandom[13]
(tabulkaNahodnychCisel=Table[Random[],{(10^7)}];)//Timing
Row@{"Min = ",Min[tabulkaNahodnychCisel],"  Max = ",Max[tabulkaNahodnychCisel]//InputForm,"\nMean = ",Mean[tabulkaNahodnychCisel]//InputForm,"  S.D. = ",StandardDeviation[tabulkaNahodnychCisel]}
{Mean[UniformDistribution[]],StandardDeviation[UniformDistribution[]]}//N

Histogram

Tyto dva odstavce  si přečtěte několikrát; a několikrát se k nim vraťte.

Nechť (Subscript[X, 1]),...,(Subscript[X, n]) je náhodný výběr z rozdělení referenční náhodné veličiny X. Nechť A je množina možných hodnot této náhodné veličiny, P(X∈A)=1. Nechť A = (Subscript[A, 1])⋃...⋃(Subscript[A, k]) je disjunktní rozklad (pro jednoduchost předpokládejme, že se jedná o ekvidistantní (stejně dlouhé) intervaly). Nechť (Subscript[n, j]) je počet hodnot z náhodného výběru, které padnou do intervalu (Subscript[A, j]). Přirozeně n=(∑_(j=1)^k)(Subscript[n, j]). Histogram je graf resp. funkce, kde nad intervalem (Subscript[A, j]) vztyčíme obdélník o výšce (Subscript[n, j]). Zabudovaná funkce je Histogram. Pokud nad zmíněnými intervaly vztyčíme obdélníky o výšce (Subscript[n, j])/n, je součet ploch pod všemi obdélníky roven jedné a odpovídající funkci můžeme tedy považovat za hustotu.

Třetí argument u funkce Histogram určuje výšku obdélníků. V případě, že specifikaci intervalů ponecháme na interním algoritmu, je nutné zadat druhý argument jako Automatic. Platí i pro další funkce, kde je nutné dodržet pořadí argumentů. V tomto ohledu jsou výhodnější volby (Options), kde na jejich pořadí nezáleží. Pro porovnání s hustotou (plocha pod hustotou je rovna jedné) je nutné, aby součet ploch všech obdélníků v histogramu byl také roven jedné. To zařídí "PDF" (Probability Density Function).

Příklad 5 (Metoda inverzní transformace)

Exponenciální rozdělení s parametrem 1

dE=ExponentialDistribution[1];
CDF[dE,x]
SeedRandom[1313];
iExponencialRandomNubers=Table[Quantile[dE,Random[]],{1000}];
%//Histogram
Probability[x>4.,x\[Distributed]dE]

Cvičení (Box-Mullerova transformace)

Navrhněte generátor N(0,1) založený na Box-Mullerově transformaci, viz např.

http://en.wikipedia.org/wiki/Box% E2 %80 %93 Muller_transform

Náhodná čísla z jiných rozdělení ve WL

?*Random*

Náhodné číslo z rozdělení distribution:

RandomVariate[distribution]

?*Distribution

Varování: NormalDistribution[ ] je N(0,1). NormalDistribution[μ, σ] je N(μ,(σ^2))!!! Ve Wolfram Language je druhým argumentem směrodatná odchylka!!!

Toto varování budiž poučné i v jiných situacích: parametrizace rozdělení není v literatuře jednotná. Proto je vhodné se nejdříve podívat na hustotu, např.:

PDF[ExponentialDistribution[λ],x]

Vidíme, že parametr λ má význam intenzity, střední hodnota je rovna 1/λ. Jiný příklad:

PDF[GammaDistribution[α,β],x]

Já jsem zvyklý na hustotu ve tvaru

PDF[GammaDistribution[n,θ],x]//TraditionalForm

což je hustota součtu n iid exponenciálně rozdělených n. v. se střední hodnotou θ.

SeedRandom[131]
(* Na svislé ose jsou četnosti v odpovídajích intervalech. Myší zjistíme četnosti. *)
Histogram[rv1000=RandomVariate[NormalDistribution[],1000]]

Očekávané (teoretické) četnosti krajních intervalů (vysvětlení funkce Count později) :

iN01=NormalDistribution[];
Row@{"Teoretická četnost = ",1000 Probability[Abs[x]>3.,x\[Distributed]iN01],"   Pozorovaná četnost = ",Count [rv1000,_?(Abs[#]>3&)]}
Row@{"Teoretická četnost = ",1000 Probability[Abs[x]>2.5,x\[Distributed]iN01],"   Pozorovaná četnost = ",Count [rv1000,_?(Abs[#]>2.5&)]}

SeedRandom[131]
(* Druhý argument u funkce Histogram určuje šířku intervalů případně jejich počet. *)
Histogram[RandomVariate[NormalDistribution[],1000],{0.3}]

Options[Histogram]

Důležitý příklad
Porovnání s hustotou normálního rozdělení N(0,1):

SeedRandom[13]
(* Třetí argument u funkce Histogram určuje výšku obdélníků. V případě, že specifikaci intervalů ponecháme na interním algoritmu, je nutné zadat druhý argument jako Automatic. Platí i pro další funkce, kde je nutné dodržet pořadí argumentů. V tomto ohledu jsou výhodnější volby (Options), kde na jejich pořadí nezáleží. Pro porovnání s hustotou (plocha pod hustotou je rovna jedné) je nutné, aby součet ploch všech obdélníků v histogramu byl také roven jedné. To zařídí "PDF" (Probability Density Function)   *)
Show[Histogram[RandomVariate[NormalDistribution[],10000],Automatic,"PDF"],Plot[PDF[NormalDistribution[0,1],x],{x,-4,4},PlotStyle->Red]]

(* Náhodná matice 2x10 *) RandomVariate[NormalDistribution[],{2,10}]

Histogramy šesti náhodných výběrů o rozsahu 10000 normované na hustotu spolu s hustotou N(0,1), (plocha pod grafem je rovna jedné):

SeedRandom[131]
Table[Show[Histogram[RandomVariate[NormalDistribution[],10000],Automatic,"PDF"],Plot[PDF[NormalDistribution[0,1],x],{x,-4,4},PlotStyle->Red]],{6}]

(* Elegantnější je konstrukce: Grafy ve třech řádcích a dvou sloupcích *)
SeedRandom[131]
GraphicsGrid[Table[Show[Histogram[RandomVariate[NormalDistribution[],10000],Automatic,"PDF"],Plot[PDF[NormalDistribution[0,1],x],{x,-4,4},PlotStyle->Red]],{3},{2}],Frame->True]

Nahodna cisla z diskretniho rovnomerneho rozdeleni

SeedRandom[131]
Histogram[Table[RandomVariate[DiscreteUniformDistribution[{100,999}]],{9000}]]

Vyhlazený histogram (SmoothHistogram, SmoothKernelDistribution)

Některá finanční data pochází ze spojitých rozdělení. Obyčejný histogram svým způsobem data diskretizuje a tím může zastřít některé podstatné rysy zvláště v oblasti chvostů rozdělení (tails). Vyhlazený histogram je graf hustoty spojitého rozdělení.

({{"MarketCap", market capitalization}})

Row@{"Starting {YY,MM,DD}: ",startDate=DateList[][[1;;3]]-{5,0,0},"   Ending {YY,MM.DD}: ",endDate=DateList[][[1;;3]]}
companies={"SP500","Coke","KO","F:VOW","AAPL"};
DateObject[]
Text@Grid[Prepend[ Map[{#,FinancialData[#,"Name"],FinancialData[#,"MarketCap"],FinancialData[#]}&,companies],{"Ticker","Name","MarketCap","Actual Price"}],Frame->All]

DateObject[]
returnsDailyWithDates=Map[FinancialData[#,"Return",{startDate,endDate},Method->"Legacy"]&,companies];
returnsDailyValues=Map[FinancialData[#,"Return",{startDate,endDate},"Value",Method->"Legacy"]&,companies];
pricesDailyWithDates=Map[FinancialData[#,{startDate,endDate},Method->"Legacy"]&,companies];

SetDirectory[NotebookDirectory[]]
Save["returnsDailyWithDates",returnsDailyWithDates]
Save["returnsDailyValues",returnsDailyValues]
Save["pricesDailyWithDates",pricesDailyWithDates]

(* Reading data from the files *) 
 (* SetDirectory[NotebookDirectory[]]
returnsDailyValues=Get["returnsDailyValues"];
returnsMonthlyWithDates=Get["returnsMonthlyWithDates"];
returnsMonthlyValues=Get["returnsMonthlyValues"];
*)

SetDirectory[NotebookDirectory[]];
returnsDailyValues=Get["returnsDailyValues"];

DateListPlot[pricesDailyWithDates[[1]],PlotLabel->"^SP500",PlotTheme->"Business"]

Grafy výnosů  jsou s výjimkou extrémů málo vypovídající:

DateListPlot[returnsDailyWithDates,PlotLegends->companies,PlotRange->All,PlotStyle->Thick]

DateListPlot[pricesDailyWithDates//Rest,PlotLegends->(companies//Rest),PlotRange->All,PlotStyle->Thick,PlotLabel->"Prices of 4 companies"]

Histogramy výnosů

GraphicsRow@Table[Histogram[returnsDailyValues[[j]],PlotLabel->companies[[j]]],{j,1,5}]

Grafy výnosů po rocích:

Table[GraphicsRow@Table[SmoothHistogram[Take[returnsDailyValues[[j]],249(i-1)+1;;249i],PlotRange->All,PlotLabel->companies[[j]]],{j,1,5}],{i,5}]

GraphicsRow@{Histogram[Take[returnsDailyValues[[5]],250;;500],PlotRange->All,PlotLabel->companies[[5]]],SmoothHistogram[Take[returnsDailyValues[[5]],250;;500],0.0025,PlotRange->All,PlotLabel->companies[[5]],PlotStyle->Thick]}

Explicitní nastavování šířky okénka (bandwidth, další parametr funkce  SmoothHistogram) společnosti Apple pro druhý rok:

Manipulate[SmoothHistogram[Take[returnsDailyValues[[5]],250;;500],bw,PlotRange->All,PlotLabel->companies[[5]],PlotStyle->Thick],{{bw,0.003},0.0008,0.015,Appearance->"Labeled"},SaveDefinitions->True]

Map[Length,returnsDailyValues]

249 5

Centrální limitní věta (CLV)

CLV:

Necht (Subscript[U, 1]),(Subscript[U, 2]),...  je posloupnost nezávislých stejně rozdělených náhodných veličin (iid, independent identically distributed) s konečným nenulovým rozptylem (σ^2) a střední hodnotou μ. Potom

(((∑_(n=1)^N)(Subscript[U, n])-N μ)/(σ(Sqrt[N])))

konverguje v distribuci k N(0,1).

Konvergence je poměrně rychlá.

Rovnoměrné rozdělení

\[Distributed] se dostane jako EscdistEsc

(* Sdružené rozdělení n iid rovnoměrných n. v. R(0,1) *)

Clear[productDistributionOfUniforms]
productDistributionOfUniforms[n_]:=ProductDistribution[{UniformDistribution[],n}]
sumOf2Uniforms=TransformedDistribution[X1+X2,{X1,X2}\[Distributed]productDistributionOfUniforms[2]]
sumOf3Uniforms=TransformedDistribution[X1+X2+X3,{X1,X2,X3}\[Distributed]productDistributionOfUniforms[3]]

Vidíme, že existuje zabudované rozdělení součtu iid rovnoměrných n. v.

UniformSumDistribution:

Plot[Table[PDF[UniformSumDistribution[n],x],{n,{1,2,4,12}}]//Evaluate,{x,0,12},PlotRange->All,Exclusions->None,Filling->Axis]

(* Hustota součtu 12 iid R(-1/2,1/2) *)PDF[u12=UniformSumDistribution[12,{-1/2,1/2}],x]

Poznamenejme, že průměr a rozptyl tohoto rozdělení jsou:

Row@{"Průměr = ",Mean[u12],"  Rozptyl = ",Variance[u12]}

Plot[{PDF[UniformSumDistribution[12,{-1/2,1/2}],x],PDF[NormalDistribution[],x]},{x,-4,4},PlotStyle->Thick,PlotLegends->{"Sum of 12 uniforms","Normal"}]

Nechť (Subscript[U, 1]),...,(Subscript[U, 12]) jsou iid R(-(1/2),(1/2)). Rozdíl mezi hustotami (Subscript[S, 12]):=(Subscript[U, 1])+...+(Subscript[U, 12]) a N(0,1):

Plot[PDF[UniformSumDistribution[12,{-1/2,1/2}],x]-PDF[NormalDistribution[],x],{x,-7,7},PlotStyle->Thick,PlotLabel->"The difference between the densities",PlotRange->All]

Plot[{Table[PDF[UniformSumDistribution[n,{-1/2,1/2}],x],{n,{1,2,4,12}}],PDF[NormalDistribution[],x]}//Flatten//Evaluate,{x,-5,5},PlotRange->All,Exclusions->None,Filling->Axis]

Porovnání pravděpodobností chvostů (tails)  (Subscript[S, 12]):=(Subscript[U, 1])+...+(Subscript[U, 12]) a N(0,1):

Grid[Prepend[Table[{k,Probability[Abs[X]>k,X\[Distributed]UniformSumDistribution[12,{-1./2,1/2}]],
Probability[Abs[X]>k,X\[Distributed]NormalDistribution[0,1.]]},{k,2,6,1}],{k,"P(|(Subscript[S, 12])|>k)","P(|N(0,1)|>k)"}],Frame->All,Background->{None,{LightPink}}]

Poznamenejme, že dříve se (Subscript[S, 12]) používalo pro generování náhodných čísel z N(0,1).

Pravidlo 2σ a 3σ

{Probability[Abs[X-μ]<2.σ,X\[Distributed]NormalDistribution[μ,σ]],Probability[Abs[X-μ]<3.σ,X\[Distributed]NormalDistribution[μ,σ]]}

Exponenciální rozdělení

?ExponentialDistribution

Parametrizace (dobré ověřit u každého zabudovaného rozdělení):

PDF[ExponentialDistribution[λ],x]
{Mean[ExponentialDistribution[λ]],Variance[ExponentialDistribution[λ]]}

(* Sdružené rozdělení *)productDistributionOfExponentials[n_]:=ProductDistribution[{ExponentialDistribution[1],n}]
sumOf2Exponentials=TransformedDistribution[(((X1+X2-2))/(Sqrt[2])),{X1,X2}\[Distributed]productDistributionOfExponentials[2]]
sumOf5Exponentials=TransformedDistribution[((X1+X2+X3+X4+X5-5)/(Sqrt[5])),{X1,X2,X3,X4,X5}\[Distributed]productDistributionOfExponentials[5]]

{Mean[sumOf5Exponentials],Variance[sumOf5Exponentials]}

Plot[{PDF[sumOf2Exponentials,x],PDF[sumOf5Exponentials,x],PDF[NormalDistribution[],x]}//Evaluate,{x,-3,3},PlotStyle->Thick,PlotLegends->{"Sum of 2 Exp","Sum of 5 Exp","Normal"}]

Dále využijeme faktu, že pro Exp[λ] iid (Subscript[X, 1]),...,(Subscript[X, n]) má (Subscript[X, 1])+...+(Subscript[X, n]) Erlangovo rozdělení ErlangDistribution[n,λ]=GammaDistribution[n,1/λ].

Clear[standardizedErlang]
Through[{Mean,Variance}[ErlangDistribution[n,λ]]]
standardizedErlang[n_]:=TransformedDistribution[((X-n)/(Sqrt[n])),X\[Distributed]ErlangDistribution[n,1]]

{Mean[standardizedErlang[n]],Variance[standardizedErlang[n]],Skewness[standardizedErlang[n]],Kurtosis[standardizedErlang[n]]}
(* V limitě stejné jako má N(μ,(σ^2)). *)
Limit[{0,1,(2/(Sqrt[n])),((3 (2+n))/n)},n->∞]

Konvergence hustoty k hustotě N(0,1) (nezaručuje však konvergenci v distribuci):

pdfErlang=PDF[standardizedErlang[n],x]//Simplify
Limit[pdfErlang,n->∞]

Plot[{Table[PDF[standardizedErlang[n],x],{n,{2,12,50}}],PDF[NormalDistribution[],x]}//Flatten//Evaluate,{x,-4,4},PlotStyle->Thick,PlotLegends->{"Erlang[2]","Erlang[12]","Erlang[50]","N(0,1)"}]

Další vymoženosti

**Translation, Binarize, TextRecognize, ImageIdentify, SocialMediaData

TextTranslation

SetDirectory[NotebookDirectory[]];
zkusebniText=Import["20181009_214132.jpg"]
Binarize[%]
TextRecognize[%]

Poštolka: Toto je podstatně lepší. Zkopírováno z fotografie *.jpg.

postolka1=Binarize[]

postolka1Text=TextRecognize[postolka1,Language->"Czech"]

Lepší použít Adobe Scan (iOS, Android)

ImageIdentify

SocialMediaData

**Použití Option Inspector (Menu Format)

Čas výpočtu

vlevo dole (ve Front End): Format ⟶ Option Inspector ⟶ Global Preferences ⟶  Notebook Options ⟶ Evaluation Options ⟶ EvaluationCompletionAction ⟶ Apply

SeedRandom[13]; (* Zaručuje reprodukovatelnost *)
tabmilion=Table[Random[],{10000000}]; (* Náhodná čísla z R(0,1) *)
Row@{"Sort timing: ",Sort[tabmilion];//Timing}
Row@{"Výběrový průměr:  ",prumer=Mean[tabmilion],"   Výběrový rozptyl:   ",rozptyl=Variance[tabmilion],"\nMinimum:   ",Min[tabmilion],"  Maximum:   ",Max[tabmilion]}
Row@{"Rozdíl mezi spočítanými a teoretickými hodnotami:   ",{prumer,rozptyl}-{(1/2),(1/12)}}

intJHpresne=Integrate[(1/(Sqrt[2π]))Exp[-(x^2)/2],{x,-3,3}]//Timing
intJHpriblizne=NIntegrate[(1/(Sqrt[2π]))Exp[-(x^2)/2],{x,-3,3}]//Timing

**Odstranění číslování buněk

Format ⟶ Global Preferences ⟶  Cell Options ⟶ Evaluation Options ⟶ Cell Labels ⟶ ShowCellLabel ⟶ Automatic ⟶ False

Konec 2021-10-15

2021-10-22 Lekce 4

Další doplnění k Lekci 2: Příklad 1 (7. pokus, momentová vytvořující funkce) a Příklad 2 (obligace s náhodným plněním)

FAQ

Q1

A1

Pravděpodobnost 4

Kvantilové funkce

Clear[𝒟Poisson]
𝒟Poisson=PoissonDistribution[λ]
Quantile[𝒟Poisson,y]//FunctionExpand
InverseCDF[𝒟Poisson,y]//FunctionExpand

InverseCDF[NormalDistribution[],y]//FunctionExpand

Random Poisson 2004

Výňatek z kódu balíku DiscreteDistributions.m z roku 2004:
Funkce Quantile vychází z diskrétní verze metody inverzní transformace, asi trochu vylepšené. Náhodná čísla se počítají pomocí kvantilové funkce.

**Quantile

PoissonDistribution/: Quantile[PoissonDistribution[mu_], q_] :=
    With[{result = iPoissonQuantile[mu, q]},
        result /; result =!= Fail
    ] /; ParameterQ[PoissonDistribution[mu]] && QuantileQ[q]
 
iPoissonQuantile[mu_, q_] := Module[{high, low, mid},
    If[q == 1, Return[Infinity]];
    If[N[Exp[-mu]] < q,
        high = 1;
        While[N[CDF[PoissonDistribution[mu], high]] < q, high *= 2];
        low = high/2;
        While[high - low > 1,
            mid = (high+low)/2;
            If[N[CDF[PoissonDistribution[mu], mid]] < q,
                low = mid,
                high = mid,
                low = high
            ]
        ]; high,
    (* else *)
        0,
    (* indeterminate *)
        Fail
    ]
]

**Random Poisson

(* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *)

internalRandomPoisson[mu_] :=
    Quantile[PoissonDistribution[mu],Random[]]

PoissonDistribution/: Random[PoissonDistribution[mu_?NumericQ]?ParameterQ] :=
       internalRandomPoisson[mu]

(* Next few routines written by Darren Glosemeyer and Daniel Lichtblau
for faster generation of arrays of Poisson randomly distributed variables.
2003-08 DANL *)
compiledPRAC = 
    Compile[{{mu, _Real}, {len, _Integer, 1}}, 
      Module[ {tabl, high, low, mid, res, q, tabllen, allrand}, 
        tabllen = 32; 
        While[GammaRegularized[1. + tabllen, mu] < .9999, tabllen *= 2]; 
        allrand = Apply[Times, len]; 
        If[mu == 0, Return[Table[0, {allrand}]]]; 
        tabl = Table[GammaRegularized[1. + j, mu], {j, tabllen}]; 
        res = Table[ q = Random[]; 
            If [Exp[-mu] < q, high = 1; 
              While[tabl[[high]] < q, high *= 2; 
                If[high > tabllen, tabllen *= 2; 
                  tabl = Join[tabl, 
                      Table[GammaRegularized[1. + j, mu], {j, tabllen/2 + 1, 
                          tabllen}]];]]; low = Round[high/2]; 
              While[high - low > 1, mid = Round[(high + low)/2]; 
                If[tabl[[mid]] < q, low = mid, high = mid ] ]; high, 
              0 ], {allrand}];
	res ]];
uncompiledPRAC[mu_, {len__Integer}] := 
  Module[ {tabl, high, low, mid, res, q, tabllen, allrand}, 
    tabllen = 32; 
    While[GammaRegularized[1. + tabllen, mu] < .9999,tabllen *= 2]; 
    allrand = Apply[Times, {len}]; 
    If[mu == 0, Return[Table[0, {allrand}]]]; 
    tabl = Table[GammaRegularized[1. + j, mu], {j, tabllen}];
    res = Table[ q = Random[]; 
    	If [Exp[-mu] < q, high = 1; 
    	  While[tabl[[high]] < q, high *= 2; 
    	    If[high > tabllen, tabllen *= 2; 
      	      tabl = Join[tabl, 
      		  Table[GammaRegularized[1. + j, mu], {j, tabllen/2 + 1, 
      		      tabllen}]];]]; low = Round[high/2]; 
	  While[high - low > 1, mid = Round[(high + low)/2]; 
	    If[tabl[[mid]] < q, low = mid, high = mid ] ]; high, 
	  0 ], {allrand}]; 
    res ]
PRAC[mu_?NumericQ, len_Integer] := 
  If[MachineNumberQ[Exp[N[mu]]], 
      compiledPRAC[mu, {len}], uncompiledPRAC[mu, {len}]] /; len > 0
PoissonDistribution /:
  RandomArray[PoissonDistribution[mu_?NumericQ]?ParameterQ, dim_] :=
	Module[{m, array},
    m = If [VectorQ[dim], Apply[Times, dim], dim];
	If [m<5,
		array = Table[internalRandomPoisson[mu], {m}]
		, (* else *)
		array = PRAC[mu, m]
		];
    If [VectorQ[dim] && Length[dim] > 1,
		Fold[Partition[#1, #2]&, array, Reverse[Drop[dim, 1]] ],
  		array
		]
  ] /; (IntegerQ[dim] && Developer`$MaxMachineInteger >= dim > 0) || 
  	(VectorQ[dim, (IntegerQ[#] && # > 0)&] && 
  		Developer`$MaxMachineInteger >= Apply[Times,dim])

(* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *)

PoissonDistribution/: ExpectedValue[f_Function,
		 PoissonDistribution[mu_], opts___?OptionQ] :=
  Module[{x, sum},
   (
    If[{opts} =!= {}, Message[ExpectedValue::sum]];
    sum
   ) /; (sum = Sum[ Evaluate[f[x] PDF[PoissonDistribution[mu], x]],
		        Evaluate[{x, 0, Infinity}]];
	 FreeQ[sum, Sum])
  ] /; ParameterQ[PoissonDistribution[mu]]

PoissonDistribution/: ExpectedValue[f_, PoissonDistribution[mu_],
	 x_Symbol, opts___?OptionQ] :=
 Module[{sum},
  (
   If[{opts} =!= {}, Message[ExpectedValue::sum]];
   sum
  ) /; (sum = Sum[ Evaluate[f PDF[PoissonDistribution[mu], x]],
       		Evaluate[{x, 0, Infinity}] ];
        FreeQ[sum, Sum])
 ] /; ParameterQ[PoissonDistribution[mu]]

Random Poisson JH 2021-10-15

Metoda, kterou zde uvádím vychází ze souvislosti Poissonova a exponenciálního rozdělení. Děj začíná se v okamžiku t=0. Uvažujme události, které nastávají postupně v okamžicích (Subscript[T, 1]),(Subscript[T, 2]),...,(Subscript[T, n]),...  přičemž doby mezi výskyty událostí jsou iid Exp[λ]. Doby mezi událostmi jsou tedy (Subscript[X, 1])=(Subscript[T, 1]), (Subscript[X, 2])=(Subscript[T, 2])-(Subscript[T, 1]),...,(Subscript[X, n])=(Subscript[T, n])-(Subscript[T, n-1]),... . Počet událostí K na intervalu [0,t] má Poisson[λt] (odvodťe, když to někdo nesvede, poskytnu návod). V našem případě položíme t:=1.

Princip: P(K=k)= P((∑_(j=1)^k)(Subscript[X, j])≤1∧(∑_(j=1)^(k+1))(Subscript[X, j])>1). Budeme generovat  (Subscript[X, j])∼Exp[λ] tak dlouho, dokud jejich součet poprvé překročí 1. Předposlední takové číslo prohlásíme za náhodné číslo z Poisson[λt].

***Auxiliary

p=Table[{Sin[t],0},{t,0,2π,2π/5}];

{Graphics[{PointSize[Small],Point[p]}],
Graphics[{PointSize[Small],Pink,Point[p]}],
Graphics[{PointSize[Medium],Point[p]}],
Graphics[{PointSize[Large],Red,Point[p]}]}

p={((Range[4])^2),ConstantArray[0,4]}//Transpose
Show[Graphics[Line[ {{1,0},{16,0}}]],Graphics[{PointSize[Large],Red,Point[p]}]]

NestWhile

NestWhile[#/2&,123456,EvenQ]
NestWhile[Log,100,#>0&]
NestWhile[#+1&,888,!PrimeQ[#]&]

SeedRandom[113]
tab=Table[Random[],{7}]
{1,0.44533684089423864`,0.44533684089423864` 0.7074749197312895`,0.44533684089423864` 0.7074749197312895` 0.9944534969398832`,0.44533684089423864` 0.7074749197312895` 0.9944534969398832` 0.629637537803105`,0.44533684089423864` 0.7074749197312895` 0.9944534969398832` 0.629637537803105` 0.4256433914842355`,0.44533684089423864` 0.7074749197312895` 0.9944534969398832` 0.629637537803105` 0.4256433914842355` 0.6176747992481962`,0.44533684089423864` 0.7074749197312895` 0.9944534969398832` 0.629637537803105` 0.4256433914842355` 0.6176747992481962` 0.018967606650981083`}
SeedRandom[113]
NestWhileList[# Random[]&,1,#>0.1&]
(%//Length)-1
{Log[0.1],Exp[-2.3]}

Generátor JH

randomPoissonJH[λ_,n_,seed_:113]:=Module[{aux=Exp[-λ],aux2},
SeedRandom[seed];
Table[aux2=NestWhileList[# Random[]&,1,#>aux&];
(aux2//Length)-2,{n}]]

Časové porovnání λ=1

SeedRandom[113]
(tabPoissonBuildIn=Table[RandomVariate[PoissonDistribution[1]],1000000];)//Timing
Row@{"Mean = ",Mean[tabPoissonBuildIn],"  Variance = ",Variance[tabPoissonBuildIn]}//N
tabPoissonJH=randomPoissonJH[1,1000000];//Timing
Row@{"Mean = ",Mean[tabPoissonJH],"  Variance = ",Variance[tabPoissonJH]}//N

Časové porovnání λ=4

SeedRandom[113]
(tabPoissonBuildIn=Table[RandomVariate[PoissonDistribution[4]],1000000];)//Timing
Row@{"Mean = ",Mean[tabPoissonBuildIn],"  Variance = ",Variance[tabPoissonBuildIn]}//N
tabPoissonJH=randomPoissonJH[4,1000000];//Timing
Row@{"Mean = ",Mean[tabPoissonJH],"  Variance = ",Variance[tabPoissonJH]}//N

Časové porovnání λ=10

SeedRandom[113]
(tabPoissonBuildIn=Table[RandomVariate[PoissonDistribution[10]],1000000];)//Timing
Row@{"Mean = ",Mean[tabPoissonBuildIn],"  Variance = ",Variance[tabPoissonBuildIn]}//N
tabPoissonJH=randomPoissonJH[10,1000000];//Timing
Row@{"Mean = ",Mean[tabPoissonJH],"  Variance = ",Variance[tabPoissonJH]}//N

DiscretePlot[Table[PDF[PoissonDistribution[λ],k],{λ,{1,4,10}}]//Evaluate,{k,0,20},PlotRange->All,PlotMarkers->Automatic,PlotLabel->"PDF of Poisson distribution"]

Testování

?*Test*

Clear[testData]
testData[λ_,n_(* rozsah výběru *),iN_(* počet výběrů *)]:=Table[randomPoissonJH[λ,n,j],{j,1,iN}]

pValuesrandomPoissonJH=Map[PearsonChiSquareTest[#,PoissonDistribution[4]]&,testData[4,10000,100]]

pValuesrandomPoissonJH//Sort

pValuesCorrelations=Map[AutocorrelationTest[#]&,testData[4,10000,100]];
%//Sort

SetDirectory[NotebookDirectory[]];
Save["pValuesrandomPoissonJHChiSquareTest",pValuesrandomPoissonJH]
Save["pValuesrandomPoissonJHAutocorrelationsTest",pValuesCorrelations]

4 pilíře systému Mathematica 4

4. Programování 2

Definice funkcí 2

Priklad (nasobeni vektoru a matic)

(* {...} je vektor *)
(* {{...},...{...}} je matice *) 
xx={x1,x2,x3};yy={y1,y2,y3};
xx.yy
{xx*yy,xx×yy,xx yy}
Transpose[xx] (* Transpose funguje pouze na matice. *)
{{xx},Transpose[{xx}]}
{xx}.{yy}

Dimensions[{xx}]
Transpose[{xx}].{yy}//MatrixForm
{xx}.Transpose[{yy}]
({xx}.Transpose[{yy}])[[1,1]] (* !!! *)

MatrixRank[Transpose[{xx}].{yy}]

(***)(* Nepovinne *)
Outer[Times,xx,yy]//MatrixForm

**Předefinování zabudované funkce

(0^0)

Dodefinujeme (0^0):=1

{(0^0)=1,(0^0)}

Clear[x,y]
{(x^y)//FullForm,Attributes[Power]}

Unprotect[Power];
(0^0)=1;
(0^0)
Protect[Power];
{(0^0),(2^3)}

Tato definice platí jen pro tuto seanci! Po opuštění jádra (Kernel, viz Evaluation → QuitKernel) je definice zrušena.

(0^0)

?Global`*

Definice funkce s jedním a více argumenty

x_	právě jeden argument (* _ Blank[ ] *)
x__	jeden a více argumentů
x___	žádný nebo více argumentů

Pri vyvolani procedury se nejdrive vyhodnoti argument. Nevyhovuje-li predepsanemu vzoru (v nasem pripade dvojite __ znamena jeden a vice argumentu), procedura se vubec nespusti. Viz priklad nize hj2[].

Clear[hj2];
hj2[x__]:=
Which[Length[{x}]==0,Print[x,"     No arguments"],
	  Length[{x}]==1,Print[x,"    Just one argument"],
          Length[{x}]>1,Print[{x},"   More than one argument so that ","\nThe sum of the elements = ",Total[{x}]]	]
{hj2[],hj2[{}],hj2[3],hj2[{1,2,3}],hj2[1,2,34,5,6],hj2[{1,2},{3,4,5}]}

Vysvetlivky

{Length[{}],Length[{{}}],Length[{1,2,3}],Length[{{1,2,3}}],Length[{{1,2},{3,4,5}}]}

Clear[hj3];
hj3[x___ (* žádný nebo více argumentů *)]:=
Which[Length[{x}]==0,Print[x,"     No arguments"],
	  Length[{x}]==1,Print[x,"    Just one argument"],
          Length[{x}]>1,Print[{x},"   More than one argument so that ","\nThe sum of the elements = ",Total[{x}]]		]
{hj3[],hj3[{}],hj3[3],hj3[{1,2,3}],hj3[1,2,34,5,6],hj3[{1,2},{3,4,5}]}(* ; *)

Místo Print je v následujícím příkladě výstupem seznam (List): { ... }, v posledním případě řetězec; podrobně prostudujte za cvičení. Aby fungovala funkce Total, je aplikována funkce Flatten.

StringJoin (* Ekvivalentně  <> *)

{(retezec1="abcd"<>"ABCD"<>"xyz")//FullForm,Head[retezec1]}
{retezec2=StringJoin["abcd","ABCD","xyz"],Head[retezec2]}
retezec1==retezec2

"\n"

(**)Hyperlink[Button["Strings and Characters"], 
    "paclet:tutorial/StringsAndCharactersOverview"]

Clear[hj1];
hj1[x___]:=
Which[Length[{x}]==0,Row@{x,"     No arguments"},
	  Length[{x}]==1,Row@{x,"    Just one argument"},
          Length[{x}]>1,"\n"<>ToString[{x}]<>":   More than one argument so that "<>"the sum of the elements = " <>ToString[Total[{x}//Flatten]]]
{hj1[],hj1[3],hj1[{1,2,3}],hj1[1,2,34,5,6],hj1[{1,2},{3,4,5}]}

hj1[{1,2}⋂{3,4}]

** Příklad: Povrch (a objem  koule později) v prostorech různé dimenze

Připomeňme příklad z ukázek o integraci:

(* Povrch koule o poloměru r *)
Clear[r]
{Assuming[r>0,Integrate[1,{x,y,z}∈Sphere[{0,0,0},r]]],
(* Ekvivalentně *)
Area[Sphere[{0,0,0},r]]}

*** BEGIN

Clear[x]
variables[n_]:=Array[x,n] (* Přehledněji Table[x[i],{i,n}] *)
stredKoule[n_]:=ConstantArray[0,n]
{variables[2],stredKoule[2]}
(* Povrch koule o poloměru r *)
Assuming[r>0,Integrate[1,variables[3]∈Sphere[stredKoule[3],r]]]

(* Objem koule o poloměru r *)
variables[3]
((variables[3])^2)
Total[((variables[3])^2)]

Boole[Total[((variables[3])^2)]<(r^2)]/.{r->1,x[1]->0,x[2]->1/2,x[3]->1/3}
Boole[Total[((variables[3])^2)]<(r^2)]/.{r->1,x[1]->1,x[2]->1/2,x[3]->1/3}

Integrate[x y,{{x,0,1},{y,0,1}}]

Integrate[x y,{{x,0,1},{y,0,1}}/.List[x__]->x]

Map[{#,-∞,∞}&,variables[3]]
Map[{#,-∞,∞}&,variables[3]]/.List[x__]->x

Clear[r]
Assuming[r>0,Integrate[Boole[Total[((variables[3])^2)]<(r^2)],Map[{#,-∞,∞}&,variables[3]]/.List[x__]->x]]

*** END

variables[n_]:=Array[x,n]
stredKoule[n_]:=ConstantArray[0,n]
{variables[2],stredKoule[2]}
Assuming[r>0,Integrate[1,variables[3]∈Sphere[stredKoule[3],r]]]

grafPovrch=Plot[4 π (r^2),{r,0,1.2`}]

Pomocí Suggestion Bar dostaneme odkaz na očíslovanou buňku!!!

Show[(* %57 *)grafPovrch,AxesLabel->{HoldForm[radius],HoldForm[Area]},PlotLabel->HoldForm[Area of a sphere],LabelStyle->{FontFamily->"Arial",16,RGBColor[1.`,0.5019607843137255`,0.25098039215686274`],Bold}]

Užijeme funkci Table. Výstupem je seznam (List).  Je to sice odklon od funkcionálního programování, ale je snadno pochopitelná a přehledná.

Table[(n^2),{n,5}]

tabulkaDruhychMocnin=Table[{n,(n^2)},{n,5}]
%//TableForm

Clear[n,i,j]
tabulkaSouctuMocnin=Table[{j,(∑_(i=1)^n)(i^j)},{j,6}]
%//TableForm(* //TraditionalForm *)

Tabulka povrchů koule v závislosti na poloměru r:

Text@Grid[(tabulkaPovrchuKoule=Table[{n,Assuming[r>0,Integrate[1,variables[n]∈Sphere[stredKoule[n],r]]]},{n,6}]),Frame->All]

Integrated Data Sources 1

ExampleData

?*Data

Vhodné k procvičování, testování i praktickému použití.

ExampleData[]
ExampleData["Text"]

Short[ExampleData[{"Text","OriginOfSpecies"}],20]

ExampleData[{"Text","UNHumanRightsChinese"}]

ExampleData["Statistics"]

Ukázka indexu Standard & Poor’s 500 (SP500)

Informace o SP500 je možné získat i jinak, ale postup zde uvedený je užitečný i pro použití jiných funkcí, zejména jde o to, jaké informace o použité funkci jsou dostupné. Zvláště potřebný (a v Helpu ne příliš zdůrazňovaný) je parametr “Properties”.

propertiesSP500=ExampleData[{"Statistics","SP500"},"Properties"]

Zde je přehled všech vlastností. Vidíme, že je dlouhý sloupec odpovídající vlastnosti “DataElements”, který obsahuje asi 2700 kótací výnosů SP500. Po prohlédnutí výstup vymažte nebo minimalizujte.

Map[{#,ExampleData[{"Statistics","SP500"},#]}&,propertiesSP500]//TableForm

Přehlednější je seznam vlastností bez konkrétních hodnot (ze seznamu propertiesSP500 vynecháme vlastnost DataElements) :

Map[{#,ExampleData[{"Statistics","SP500"},#]}&,DeleteCases[propertiesSP500,"DataElements"]]//TableForm

Můžeme jednoduše použít prosté hodnoty a graficky je znázornit:

ListLinePlot[ExampleData[{"Statistics","SP500"},"DataElements"],PlotRange->All]

Zatím ale nic nevíme, o jaké období se jedná, v jaké podobě jsou atd. Podrobnější je informace ve vlastnosti TimeSeries (po stisknutí křížku dostaneme detaily). Vidíme délku časové řady, inkriminované období, denní pozorování a také informaci, že data nejsou pozorována v ekvidistantních intervalech (pochopitelně - kótace jsou pouze v obchodních dnech), pro “chybějící data” je použita lineární interpolace (je možné použít i jiné metody, angl. resampling). Pro rychlou orientaci můžeme využít nabídky, která je pod výstupem. Užijeme DateListPlot.

timeSeriesSP500=ExampleData[{"Statistics","SP500"},"TimeSeries"]

Horní graf implicitně usekává extrémní hodnoty. K těm se dostaneme volbou

DateListPlot[timeSeriesSP500,PlotRange->All]

Rozdíl mezi PlotRange ⟶All a PloRange ⟶Full viz Help k PlotRange, příklad

FinancialData

Upozorňuji na to, že čas od času je funkce FinancialData nespolehlivá. JIž získaná data doporučuji ihned exportovat. Doporučuji se naučit importovat data z externích zdrojů.

Kurs Euro/Kč a grafické znázornění

Všechno je v jedné buňce, bez problémů tedy můžeme použít odkaz na předchozí výstup:

(* Aktuální kurs *)
Text@Row@{" Aktuální kurs EUR/CZK:  ", FinancialData["EUR/CZK"]}
(* Kursy v období 2020-01-01 až 2020-10-01 *)
fxEURCZK2020010120211014=FinancialData["EUR/CZK",{{2020,1,1},{2021,10,14}}]
DateListPlot[%,PlotLabel->"Kursy v období 2020-01-01 až 2021-10-14"]
(* Kursy v období 2017-04-01 až do dneška *)
(fxEURCZK2017=FinancialData["EUR/CZK",{2017,4,1}])//Short
(* Rozbalit + dostaneme detaily*)
DateListPlot[%,PlotLabel->"Kursy v období 2017-04-01 až do dneška"]

fxEURCZK2020010120211014klasicky=FinancialData["EUR/CZK",{{2020,1,1},{2021,10,14}},Method->"Legacy"]

Tickers (zkratky aktiv obchodovaných na burzách)

**WIKIPEDIA: Ticker symbol. A ticker symbol or stock symbol is an abbreviation used to uniquely identify publicly traded shares of a particular stock on a particular stock market. A stock symbol may consist of letters, numbers or a combination of both. “Ticker symbol” refers to the symbols that were printed on the ticker tape of a ticker tape machine.

Kursy Apple (stisknutím + ve výstupu TimeSeries další detaily)

aapl20170101=FinancialData["AAPL",{2017,01,01}]
%//DateListPlot

(* VolksWagen kótovaný ve Frankfurtu *)
FinancialData["F:VOW"]
iVW20170101=FinancialData["F:VOW",{2017,01,01}]
DateListPlot[%,PlotRange->All,PlotLabel->"Prices VW in EUR"]

FinancialData[]

{FinancialData["AAPL","Name"],FinancialData["AAPL","Company"]}
{FinancialData["KO","Name"],FinancialData["KO","Company"]}
{FinancialData["Coke","Name"],FinancialData["KO","Company"]}
(Entity["Apple", Entity["Company","Apple::5zkjq"], "Entity[\"Company\", \"Apple::5zkjq\"]", "company"])//FullForm

FinancialData["*AAPL*","Lookup"]

{Position[FinancialData[],"NASDAQ:AAPL"],FinancialData["L:AAPL"]}

Převod Tickers ⟷ Name

tickersAll=FinancialData[];

tickersAndName100=Map[{#,FinancialData[#,"Name"]}&,tickersAll[[1;;100]]];

tickersAll//Length

Company names in Python
https://stackoverflow.com/questions/32383585/turn-list-of-company-names-into-tickers

Alternativa k FinancialData

(* Dow Jones Industrial Index - *)(* prostý aritmetický průměr cen třiceti "nejlepších, blue chips" akcií *)
(* obchovaných na NYSE, New York Stock Exchange *) Row@{"Aktuální kurs DJI:  ",FinancialData["^DJI"]}
DateListPlot[FinancialData["^DJI",{2020,1,1}]]

Row@{"Aktuální kurs DJI:  ",FinancialData["^DJI"]}

Pokud nefunguje (Missing, Not available), můžeme zkusit Wolfram|Alpha - do vstupní buňky dvakrát rovnítko, objeví se hvězdička s rovnítkem uvnitř:

Po vykreslení grafu cen v sekci History stiskneme + a zaškrtneme Time Series Data. Je vygenerován příkaz, ze kterého data uložíme do námi určené proměnné.

pricesApple20211022=WolframAlpha["price Apple from January 1, 2017",{{"DateRangeSpecified:Last:FinancialData",1},"TimeSeriesData"}];

SetDirectory[NotebookDirectory[]]
Save["pricesApple20211022",pricesApple20211022]

SetDirectory[NotebookDirectory[]]
pricesApple20211022read=Get["pricesApple20211022"];

DateListPlot[pricesApple20211022read]

WolframAlpha["price Apple from January 1, 2017",{{"DateRangeSpecified:Last:FinancialData",1},"TimeSeriesData"}]

(* příkaz *)aapleFromWolframAlpha=WolframAlpha["price Apple from January 1, 2017",{{"DateRangeSpecified:Last:FinancialData",1},"TimeSeriesData"}];

DateListPlot[aapleFromWolframAlpha]

***Nepovinné

(***)
Export["aapleFromWolframAlphaNormal.XLSX",aapleFromWolframAlphaNormal];
Export["aapleFromWolframAlphaNormal.dat",aapleFromWolframAlphaNormal];

(***)
xlsJH=Import["aapleFromWolframAlphaNormal.XLSX"];
datJH=Import["aapleFromWolframAlphaNormal.dat"];

Konstrukce Save

***Begin Comment

(* Begin Help k funkci Save: *)
tempfile = FileNameJoin[{notebookDirectory,"saved.wl"}]
a={ "This must be saved",Today[]}
Save[tempfile,a]
Clear[a]
Get[tempfile];
a
DeleteFile[tempfile]
(* End Help k funkci Save: *)

Aplikace Save na data “aapleFromWolframAlpha” (formát TimeSeries) získaná pomocí Wolfram|Alpha:

DeleteFile[aapleFromWolframAlphaFileName]
aapleFromWolframAlphaFileName=FileNameJoin[{notebookDirectory,"aapleFromWolframAlpha.wl"}]
Save[aapleFromWolframAlphaFileName,aapleFromWolframAlpha]
aapleFromWolframAlphaTest=Get[aapleFromWolframAlphaFileName];
DateListPlot[aapleFromWolframAlphaTest]

***End Comment

**Případová studie: Data pro demografii a životní pojištění

Ilustrace se týká zabudované funkce MortalityData. Obsahují údaje potřebné pro analýzu a kalkulaci pojistných prémií (výše pojistek) v životním pojištění.  Jsou to údaje z tzv. úmrtnostních tabulek (něm. Die Sterbetafel, angl. kupodivu optimisticky Life tables). Podrobněji o úmrtnostních tabulkách a aplikacích v životním pojištění  viz např.

Cipra, T.: Praktický průvodce finanční a pojistnou matematikou. Ekopress. Praha, 2005.

V dalším nechť X označuje dobu dožití (dobu přežití do úmrtí), zde uvažovaná jako náhodná veličina. Údaje v úmrtnostních tabulkách jsou obvykle sofistikovaně upravované empirické údaje, v principu ale založené na matematicko-statistických metodách. Presentují se obvykle zvlášť pro muže a zvlášť pro ženy i když podle některých nesmyslných směrnic nadnárodních orgánů se nesmí rozlišovat mezi pohlavími. Uvádějí se v nich mimo jiné tyto charakteristiky:

x... uvažovaný věk, typicky x=0,...,110 [rok]

(Subscript[ℓ, 0])... kořen - počet jedinců, ze kterých se dále vychází. Standardně se volí (Subscript[ℓ, 0])=100000.

Ponaučení: Zprávy o počtu nakažených COVID19 z různých oblastí, krajů, zemí by měly být důsledně vztaženy na standardizovaný počet obyvatel. Absolutní počty jsou zajímavé pro konkrétní zemi, ale nelze je použít pro srovnávání!!! Víte kolik obyvatel má Portugalsko, California, Ukrajina, atd.? Mimochodem, Američané jsou považování za nevzdělance, uvádí se, že si většina z nich myslí, že Praha je v Jugoslávii. Jaká jsou hlavní města daleko větších států jako je New York, California, Alaska, Florida, Illionis, Pennsylvania?

(Subscript[ℓ, x])... počet dožívajících se věku x (jsou naživu ve věku x) z počtu (Subscript[ℓ, 0]) : z tohoto počtu se odhadují další charakteristiky

(Subscript[q, x])...  pravděpodobnost úmrtí ve věku x: nepřesné, ale obecně přijaté vyjadřování: (Subscript[q, x])=P(x≤ X<x+1|X≥ x)
odhaduje se jako

(Subscript[q, x])=(((Subscript[ℓ, x])-(Subscript[ℓ, x+1]))/(Subscript[ℓ, x]))

(Subscript[e, x])...  v pojišťovnictví zvaná střední délka života ve věku x, v Mathematice je to vlastnost  “RemainingLifeExpectancy”. Matematicky (Subscript[e, x])=E(X-x|X≥ x).

Information[MortalityData]

MortalityData["Properties"]

Země, pro která jsou data dostupná. Zde uvedená data je dobré brát s jistou rezervou, pro většinu uvedených zemí je asi lepší získat data z jejich vlastních zdrojů.

MortalityData["Countries"]

Střední zbytková doba života (USA)

iRemainingLifeExpectancy=MortalityData[\[LeftAssociation]"Age"->Quantity[Range[0,100],"Years"],"Gender"->"Male"\[RightAssociation],"RemainingLifeExpectancy"]
ListPlot[%,Filling->Axis]

Střední zbytková doba života (CZ)

iRemainingLifeExpectancyCzech=MortalityData[\[LeftAssociation]"Age"->Quantity[Range[0,100],"Years"],"Gender"->"Male","Country"-> (Entity["Czech Republic", Entity["Country","CzechRepublic"], "Entity[\"Country\", \"CzechRepublic\"]", "country"])\[RightAssociation],"RemainingLifeExpectancy"]
ListPlot[%,Filling->Axis]

(fff=({Range[0,100],iRemainingLifeExpectancyCzech//QuantityMagnitude}//Transpose));
Partition[fff,10]//TableForm

Partition[fff,10]//TableForm

Export a Import

$ExportFormats

$ImportFormats

Jednoduchý způsob užití funkce Save a Get

2021-10-29 Změna přípony u souborů *.dat na *save!!!!!

Efektivně použitelné pouze v rámci Wolfram language.

kursyEURCZK=FinancialData["EUR/CZK",{2020,7,1}]

Directory[]
SetDirectory[NotebookDirectory[]]
Save["20200701_Kursy.save",kursyEURCZK]

Zpětné načtení

SetDirectory[NotebookDirectory[]]
kursyGet=Get["20200701_Kursy.save"]

(* TimeSeries ⟶ F1 *)
properties=kursyGet["Properties"]

kursyGet["Times"];
(dataGet=Map[DateList[#][[1;;3]]&,%])//Short
kursyGet["Values"]//Short

DateList[3802636800][[1;;3]]

Běžné užití

DateListPlot[kursyGet]

Time je tzv. AbsoluteTime ve vteřinách od 1. 1. 1900 v tomto časovém pásmu.

?Date*

AbsoluteTime[]
%//DateList
%%//DateString
%%%//DateObject

(kursy2=kursyGet["Path"])[[1;;10]]
kursy2//DateListPlot
kursy2//ListLinePlot

Na vodorovné ose pouze pořadí:

GraphicsRow@{ListPlot[kursyGet["Values"],Joined->True],ListLinePlot[kursyGet["Values"]]}

**Wolfram|Alpha

WolframAlpha["price of gold",{{"PriceHistory:ElementData",1},"FormattedData"},PodStates->{"PriceHistory:ElementData__Log scale"}]

WolframAlpha["price of gold",{{"PriceHistory:ElementData",1},"ComputableData"},PodStates->{"PriceHistory:ElementData__Log scale"}]

priceofgold=WolframAlpha["price of gold",{{"PriceHistory:ElementData",1},"TimeSeriesData"},PodStates->{"PriceHistory:ElementData__Log scale"}];
%//DateListPlot

Příklad (Zlato, ceny v USD a CZK)

{Date[][[1;;3]],FinancialData["XAU"],FinancialData["XAU/USD"],FinancialData["XAU/CZK"]}

Cenu zlata za gram spočítáte jednoduše tak, že cenu jedné trojské unce (troy ounce), která je okolo 39473,61 Kč, vydělíte 31.103 (hmotnost trojské unce v gramech) a výsledek 1269,13 Kč je právě cena zlata za jeden gram.

(* Zlato  *)
(pricesGold2017= FinancialData[{"XAU","CZK"},{2017,4,1}])//DateListPlot[#,PlotLabel->"Cena troyské unce zlata v Kč"]&

Příklad (Zpracování nekonsistentních časových řad)

***BEGIN

(* *** BEGIN *)
(* Obtížné, ale užitečné; bude vysvětleno později. *)
fxDates=Map[First,fxEURCZK2017];
goldDates=Map[First,pricesGold2017];
commonDates=Intersection[fxDates,goldDates];
fxEURCZK2017commonDates=Map[Function[date,Select[fxEURCZK2017,#[[1]]==date&]],commonDates];
pricesGold2017commonDates=Map[Function[date,Select[pricesGold2017,#[[1]]==date&]],commonDates];
Text@Row@{"Correlation between FX EUR/CZK and price of gold = ",Correlation[fxPricesOnly=Map[FlattenAt[#,1]&,fxEURCZK2017commonDates][[All,2]],goldPricesOnly=Map[FlattenAt[#,1]&,pricesGold2017commonDates][[All,2]]]}
(* *** END *)

(* Dynamic[Refresh[FinancialData["USD/CZK","LatestTrade"],UpdateInterval->1]]
Dynamic[Refresh[FinancialData["EUR/CZK","LatestTrade"],UpdateInterval->1]] *)

***END

Další funkce FinancialData

Tickers

FinancialData[] (* //Length *)

(***)
tickers21=FinancialData[][[30380;;30400]]

namesAAP=FinancialData["AAP*","Lookup"]

Burzovní indexy

Všechny indexy (např. burzovní) začínají symbolem “^”. Ve WL to však není dodržováno důsledně, otázka je, proč ne. Např.

FinancialData[{"^SP500","SP500"}]
(* Zde je složení indexu SP500: *)FinancialData["SP500","Members"]
%//Length

ale

FinancialData[{"^DJI","DJI"}]
(* Pro DJI nefunguje: *)
FinancialData["DJI","Members"]

Složení DJIA (“Members”)

FinancialData["^DJI"]
membersDJI=FinancialData["^DJI","Members"]

FinancialData["^DJI","Members"]

Vlastnosti (“Properties”)

Uvedeme na příkladu Apple (platí pro všechny další finanční  entity, ale pro některé z nich mohou být nedostupné, tj. s typickou zprávou Missing[NotAvailable]:

FinancialData["AAPL","Properties"]

Údaje o posledních dostupných cenách na burze (denní ceny Open, High, Low, Close, Volume)

FinancialData["AAPL","OHLCV"]

Historie posledního měsíce:

Date[][[1;;3]]

Row@{"Today:  ",Date[][[1;;3]]}
iDataOHLCVLastMonth=FinancialData["AAPL","OHLC",{DatePlus[Date[],-30][[1;;3]],Date[][[1;;3]]}]

DateListPlot[iDataOHLCVLastMonth,PlotLegends->{"Open","High","Low","Close"},PlotStyle->Thick]

Vybrané vlastnosti (“Properties”)

({{"BookValuePerShare", book value per share}, {"FloatShares", number of shares available for trade in the open market}, {"MarketCap", market capitalization}, {"PERatio", price-to-earnings ratio}, {"PriceToBookRatio", price divided by book value}, {"PriceToSalesRatio", price divided by annual sales }})

({{"EarningsPerShare", earnings for the most recent four quarters}, {"EBITDA", standard cash flow measure}})

({{"DividendYield", ratio of annual dividend to current price }, {"DividendPerShare", annual dividend per share}, {"Dividend", dividend during a specified period }})

({{"AdjustedOpen", opening price during a period adjusted for dividends}, {"AdjustedHigh", highest price during a period adjusted for dividends}, {"AdjustedLow", lowest price during a period adjusted for dividends}, {"AdjustedClose", closing price adjusted for dividends}, {"AdjustedOHLC", list of open, high, low and close values for a period adjusted for dividends}, {"AdjustedOHLCV", list of open, high, low, close and volume values for a period adjusted for dividends}, {"AdjustedRange", lowest and highest prices for a period adjusted for dividends}})

For historical data, properties such as "AdjustedHigh", "AdjustedLow", "AdjustedClose" are adjusted for stock splits, spin-offs, share repurchases and other corporate actions, as well as ordinary dividends.

Cvičení (rozdíly v “AdjustedClose”,”Close”,”RawClose”,”Price”)

ipricesGEhistorical=Map[FinancialData["GE",#,{{2001,1,1},{2017,10,20}},Method->"Legacy"]&,pricesGE={"AdjustedClose","Close","RawClose","Price"}];
DateListPlot[%,PlotLegends->pricesGE]

ipricesGEnewer=Map[FinancialData["GE",#,{{2018,1,1},{2021,10,25}},Method->"Legacy"]&,pricesGE={"AdjustedClose","Close","RawClose","Price"}];
DateListPlot[%,PlotLegends->pricesGE]

DateListPlot[{FinancialData["GE","RawClose",{{2019,1,1},{2021,10,20}},Method->"Legacy"],FinancialData["GE","Close",{{2019,1,1},{2021,10,20}},Method->"Legacy"],FinancialData["GE","AdjustedClose",{{2019,1,1},{2021,10,20}},Method->"Legacy"],FinancialData["GE","Price",{{2019,1,1},{2021,10,20}},Method->"Legacy"]},PlotLegends->{"RawClose","Close","AdjustedClose","Price"}]

Příklad (Dividendy společností zastoupených v DJI)

Dividendy DJI

membersDJI=FinancialData["^DJI","Members"]

Grid[(dividendsDJItable=Table[FinancialData[ticker,{"Name","Dividend"}],{ticker,membersDJI}]),Frame->All]

U společnosti Salesforce.com údaj o dividendě chybí.

(* Tento příkaz vykoná totéž, co ten předchozí *) 
Grid[(dividendsDJI=Map[FinancialData[#,{"Name","Dividend"}]&,membersDJI]),Frame->All]
(* Všechny společnosti, u kterých je údaj Missing["NotAvailable"] vyloučíme tímto příkazem: *) 
(* (2. argument je poměrně obtížná konstrukce pomocí PatternTest - z predikátu vytvoří předlohu.) *) 
delCases=DeleteCases[dividendsDJI,_?(#[[2]]==Missing["NotAvailable"]&)]
Grid[Sort[delCases,#1[[2]]>#2[[2]]&],Frame->All]

Konec 2021-10-22

2021-10-29 Lekce 5

FAQ

Q1

A1

Integrated Data Sources 2

Ekonomická a jiná data

?*Data

CountryData[]

CountryData["Properties"]

(*{CountryData["CzechRepublic","GovernmentDebt"],CountryData["CzechRepublic","AdultPopulation"]}
Text@Row@{"Státní dluh v CZK = ",%[[1,1]] FinancialData["USD/CZK"]}
CountryData["CZ","Flag"]
*)

Údaje z roku 2020:

Aktuální údaje:

{dluh=CountryData["CzechRepublic","GovernmentDebt"],CountryData["CzechRepublic","AdultPopulation"]}
Text@Row@{"Státní dluh v CZK = ",dluh[[1]]×FinancialData["USD/CZK"]}
DateObject[]
dluh//FullForm

Ekonomická a jiná data

CountryData["CZ","Flag"]

Vnitřní struktura systému Mathematica a jeho jazyk

Výrazy (Expressions)

Všechno v systému Mathematica je výraz (i tento notes (notebook)). Každý výraz má hlavičku (Head): Hlavička je část výrazu s indexem nula.

{Head[7],Head[(1/7)],Head[1/7.],Head[2+I],Head[π],Head[Pi],Head["haf"]}
{7[[0]],(1/7)[[0]],(* Pozor, vrací hlavičku výrazu 7.0: *)1/7.0[[0]],(1/7.0)[[0]],(1./7.0)[[0]],π[[0]],"atd."[[0]]}

Unprotect[Plus];
Plus=Times;
Protect[Plus];
3+4+5
HoldForm[3+4+5][[1,0]]

a-b

aa=Array[a,3]
{FullForm[a-b],FullForm[a/b],Sum[a[i],{i,3}]//FullForm}

Někdy je užitečné vlastní pojmenování zabudované funkce.

Clear[hj5];
hj5[x_]:=(x^2)

h=Head;
seznam1={f,Integrate,π,EulerGamma,EulerGamma//N,hj5,"1/7","I","(I^2)","Toto je retezec."};
seznam2={h[f],h[Integrate],h[π],h[EulerGamma],h[EulerGamma//N],h[hj5],h[1/7],h[I],h[(I^2)],h["Toto je retezec."]};
Grid[Prepend[{seznam1,seznam2}//Transpose,{"Výraz","Hlavička"}],Frame->All,Background->{None,{LightPink}}]

(* Informace o objektu h *)
?h

(* Clear zajistí, že odpovídající proměnné nemají žádnou hodnotu. *)
(* Jakmile je ale proměnné přiřazena znovu nějaká hodnota, ta předchozí je zapomenuta. *)
Clear[a,b,c];
FullForm[a+b+c]

{Head[{a,b,c}],FullForm[{a,b,c}]}

Length[{a,b,c}]
{Transpose[{{a,b,c}}],Transpose[{{a,b,c}}]//MatrixForm}
Row@{"Delka {{a,b,c}} = ",Length[{{a,b,c}}],"   Delka {{a},{b},{c}} = ",Length[Transpose[{{a,b,c}}]]}
{Dimensions[{{a,b,c}}],Dimensions[Transpose[{{a,b,c}}].{{a,b,c}}]}
Length[a+b+c]
Length["Toto je retezec."]

**Záludnosti (Strings, numbers, and symbols are not subdividable - nejsou dále dělitelné, jsou to atomy ve Wolfram Language). Z výrazů, které nejsou atomy je možné extrahovat části.

{AtomQ["Retezec"],AtomQ[e=x+22/7],FullForm[e],AtomQ[e[[1]]],e[[1]],e[[0]]}
{AtomQ[22/7],(22/7)[[0]],(22/7)[[1]]}

a=1;
{Head[a],Dimensions[a],Length[a],AtomQ[a]}

aa={1,2};bb={{2},{1}};cc="String";dd={{1,2},{1,2,3}};
{Dimensions[aa],Dimensions[bb],Dimensions[cc],Dimensions[dd]}
{Length[aa],Length[bb],Length[cc],Length[dd]}

Clear[a,b,c,x];
expr=Sin[x](a (x^2)+b x +c)
Head[expr]
FullForm[expr]
TreeForm[FullForm[expr]]

aa

Part[f,n] je totéž jako f[[n]] :

f[[3]]//FullForm

soucet=aa+b
FullForm[soucet]
{Part[soucet,0],Part[soucet,1],Part[soucet,2],Part[soucet,3]}
(* V tomto případě je chybová hláška dříve než výstup *)
{soucet[[0]],soucet[[1]],soucet[[2]],soucet[[3]]}

Rozdil mezi [ ] a [[ ]] (argument funkce a část výrazu)

[[ dostaneme jako Esc[[Esc

Clear[aa,a];
aa=Table[a[i],{i,-4,4}]
{aa[[0]],aa[[1]],aa[[5]],aa[[9]]}
{a[0],a[5]}

{1,4,7}[[2]]

Pozor na stejně vypadající výstup symbolů a řetězců!!!

Všimněte si použití důležitého příkazu ToExpression. Pokud je to možné, převede řetězec na “spočitatelný” výraz. Inverzní příkaz je ToString.

Clear[a]
{"a",a,"3",3}
{"a",a,"3",3}//FullForm
Map[Head,{"a",a,"3",3}]
{"a"+a,FullForm["a"+a]}
{ToExpression["a"]+a,"3"+3,ToExpression["3"]+3}

Table["Hacek",{12}]
Speak[%]

TextRecognize[,Language->{"German","Russian","Spanish"}]

{"Co dostanu teď milé děti?"//Length,Length[π],Length[{π}],Dimensions[{{{π}}}]}
"Co dostanu teď milé děti?" (* Nejsou zobrazeny uvozovky *)
FullForm["Co dostanu teď milé děti?"]
Head["Co dostanu teď milé děti?"]
{"Co dostanu teď milé děti?"[[0]],"Co dostanu teď milé děti?"[[1]],π[[1]],{π}[[1]],{{{π}}}[[1,1,1]],{{{π}}}[[1]][[1]][[1]],{{{π}}}//First//First//First}

Characters["Co dostanu teď milé děti?"]
Length[%]
StringJoin[%%]

(* Připomenutí *)
Clear[a,b,c,x]
expr=Sin[x](a (x^2)+b x +c)
%//TraditionalForm
%%//FullForm

expr//Length

Table[{j,expr[[j]]},{j,0,3}]//TableForm

{expr[[0]],expr[[1]],expr[[2]],expr[[1,3]],expr[[1,3,2]],expr[[1,3,2,2]]}

Definice

Okamžité a odložené přiřazení (globální pravidlo, immediate and delayed assignment): “ = ” a “ := ”

viz též kurs kolegy Slavíka:

http://www2.karlin.mff.cuni.cz/~slavik/math_ls_ 2020_ 21/ulohy_5a.nb

Připomenutí: Příklad 1  (Generátory náhodných čísel)

Podrobnosti o generátorech náhodných čísel podrobně v sekci Metody Monte Carlo později.

SeedRandom[13] 
(* Startuje generátor náhodných čísel vždy ze stejné hodnoty. Velmi důležité pro reprodukovatelnost výsledků založených na simulacích. *)
(* Okamžité přiřazení, v r1 je až do příštího přepsání stále tatáž hodnota *)
r1=Random[]
SeedRandom[13]
(* Odložené přiřazení, po vyvolání r2 se teprve generuje náhodné číslo, které je "na řadě". *)r2:=Random[]

{r1,r1,r1}
{r2,r2,r2}
SeedRandom[13]
{Random[],Random[],Random[]}
{r2,r2,r2}

SeedRandom[13]
Table[Random[],{6}]

?r1

?r2

SeedRandom[13]
tabulkaNahodnychCisel=Table[Random[],{(10^7)}];//Timing
{Min[tabulkaNahodnychCisel],Max[tabulkaNahodnychCisel]//InputForm,Mean[tabulkaNahodnychCisel]//InputForm,StandardDeviation[tabulkaNahodnychCisel]}//Timing
Row@{"Mean = ",%[[2,3]]}

Příklad 2

Úvodní poznámka:

Clear[k]
k[x_?Positive]:=Log[x]
{k[2],k[2.],k[-2],Log[-2]}

Velmi důležité!!!

Clear[fdelayed,fimmediate,a]
(* V obou případech se počítá stejný integrál *)
(* V prvním případě se uloží pravidlo a při každém vyvolání se integrál počítá, *)
(* ve druhém případě se integrál spočítá a při vyvolání se do výsledku *)(* pouze dosadí hodnota parametru. *)
fdelayed[a_?Positive]:=(∫_0^∞)Log[a x] Exp[-(x^2)]\[DifferentialD]x
(fimmediate[a_?Positive]=(∫_0^∞)Log[a x] Exp[-(x^2)]\[DifferentialD]x)//Timing

?fdelayed
?fimmediate

{fdelayed[2]//Timing,fimmediate[2]//Timing,fimmediate[2]//Simplify//Timing}

Predikáty, vzory a booleovské operace 1

Predikáty (predicates)

Viz též (připomenutí)

Row[{Hyperlink[Button["Predikáty (predicates) a vzory (patterns) v PDF"],"http://www.karlin.mff.cuni.cz/~slavik/math_ls_2020_21/ulohy_7.pdf"],"   ", 
   Hyperlink[Button["Predikáty (predicates) a vzory (patterns) nb"],"http://www.karlin.mff.cuni.cz/~slavik/math_ls_2020_21/ulohy_7a.nb"]}]

Dává odpověď True nebo False. Zabudované predikáty:

?*Q

{PrimeQ[144],NextPrime[10000000],PrimeQ[NextPrime[10000000]]}

{OddQ[21],EvenQ[21]}

IntegerQ[5/9]

{NumberQ[π],NumberQ[∞],NumberQ[5/9],NumberQ[1+4.5I]}

{NumericQ[π],NumericQ[∞],NumericQ[5/9],NumericQ[1+4.5I]}

{AtomQ["asbhjo \\[Wolf]\\. n"],Length["asbhjo \\[Wolf]\\. n"]}
"asbhjo \\🐺\\. n"

"asbhjo \\🐺\\. n"

{ListQ[{a,{b,c}}],VectorQ[{a,{b,c}}],MatrixQ[{a,{b,c}}],MatrixQ[{{a,b},{b,c}}]}

!Příklad (Je Hilbertova matice positivně definitní?) 1

Sylvestrovo kritérium: Reálná symetrická matice je positivně definitní ⟺ všechny hlavní minory jsou kladné.

HilbertMatrix[3]//MatrixForm

(* V přesné aritmetice *)
PositiveDefiniteMatrixQ[HilbertMatrix[20]]
Text@Row@{"Determinant Hilbertovy matice řádu 20:   ",HilbertMatrix[20]//Det//N}
Text["Jsou Hilbertovy matice řádů 10 až 20 pozitivně definitní?"]
Text@Grid[Table[{j,PositiveDefiniteMatrixQ[HilbertMatrix[j]]},{j,10,20}]//Transpose,Frame->All]

ale

(* v reálné aritmetice, zde je matice funkcí //N převedena do formy, kdy všechna čísla jsou považována jako přibližná (Real) *)Text@Grid[Table[{j,PositiveDefiniteMatrixQ[HilbertMatrix[j]//N]},{j,10,20}]//Transpose,Frame->All]

Determinanty:

(* Hilbertova matice v numerické podobě, pak počítán determinant *)Text@Grid[Table[{j,HilbertMatrix[j]//N//Det},{j,10,20}],Frame->All]

I přibližná čísla je možné zobrazit prakticky s libovolnou přesností. Zde zvolíme 80 desetinných míst:

Text@Grid[Table[{j,N[HilbertMatrix[j],80]//Det},{j,10,20}],Frame->All]

Z numerického hlediska jsou to nuly, ale některé nuly jsou skutečné nule blíže.

Text@Grid[Table[{j,PositiveDefiniteMatrixQ[N[HilbertMatrix[j],80]]},{j,10,20}]//Transpose,Frame->All]

Následující funkce vyrobí posloupnost determinantů Hilbertovy matice řádu 1,2,...n:

detHilbert[n_]:=Table[Det[HilbertMatrix[j]],{j,n}]

(* Prvních deset determinantů *)
(d10=detHilbert[10])

Existuje obecné vyjádření takových determinantů? Zkusíme funkci FindSequenceFunction:

(* Jednoduché příklady *)
FindSequenceFunction[{1,3,5,7},n]
FindSequenceFunction[{1,1,2,3,5,8},n]
%//FunctionExpand
Plot[Fibonacci[x],{x,0,4},PlotStyle->Thick,PlotLabel->"Fibonacci"]

Nyní tedy posloupnost determinantů (zkuste se pomocí F1 podívat na konstantu Glaisher a funkci BarnesG):

f10=FindSequenceFunction[d10,n]
%//FunctionExpand

Konec 2021-10-29

2021-11-05 Lekce 6

FAQ

Q1 Pravidlo 2σ a 3σ pro Studentovo rozdělení se 4.1 stupni volnosti

Viz také novelizované FAQ Lekce 7 s rekapitulací.

A1

Clear[μ,σ,x]

distrStudent41=StudentTDistribution[μ,σ,41./10]
sd=StandardDeviation[distrStudent41]

Probability[Abs[x-μ]<2sd,x\[Distributed]distrStudent41]
1-Probability[Abs[x-μ]<2sd,x\[Distributed]distrStudent41]

Probability[Abs[x-μ]>2sd,x\[Distributed]distrStudent41]

Probability[Abs[x-μ]>2sd,x\[Distributed]distrStudent41,Method->"CDF"]

Probability[x-μ>2sd,x\[Distributed]distrStudent41,Method->"CDF"]

Probability[x-μ>2sd,x\[Distributed]distrStudent41,Method->"PDF"]

Attempt 1

{distrStudent41e=StudentTDistribution[μ,σ,41/10],sde=StandardDeviation[distrStudent41e]}
Probability[Abs[x-μ]<2sde,x\[Distributed]distrStudent41e]
%//N
1-%

Probability[Abs[x-μ]>2sde,x\[Distributed]distrStudent41e]

%//Simplify

Attempt 2

transformedStudent=TransformedDistribution[((x-μ)/σ),x\[Distributed]distrStudent41e]

Probability[Abs[y]<2(Sqrt[(41/21)]),y\[Distributed]transformedStudent]
%//N

Probability[Abs[y]>2(Sqrt[(41/21)]),y\[Distributed]transformedStudent]
%//N

Attempt 3

ruleStudent=Probability[Abs[x_]>u_,z_\[Distributed]d_]->1-Probability[Abs[x]<u,z\[Distributed]d]

Probability[Abs[y]>2(Sqrt[(41/21)]),y\[Distributed]transformedStudent]/.ruleStudent
%//N

Predikáty, vzory a booleovské operace 2

!Příklad (Je Hilbertova matice positivně definitní?) 2

detHilbert[n_]:=Table[Det[HilbertMatrix[j]],{j,n}]

(* Prvních deset determinantů *)
(d10=detHilbert[10])

f10=FindSequenceFunction[d10,n]
%//FunctionExpand//Simplify
GraphicsRow@{Plot[%,{n,1,10},PlotLabel->"Determinants of Hilbert matrices"],
LogPlot[%,{n,1,10},PlotLabel->"Logarithms of the Determinants of Hilbert matrices"]}

Prozkoumání funkce BarnesG (stačí pro n≥3/2), hledáme minimum:

Nejdříve zkusíme přesně (viz návod k fci Minimize) :

minBarnesG=Minimize[{BarnesG[x],x≥ 3/2},x]

Numericky:

minimumBarnesG=NMinimize[{BarnesG[x],x≥(3/2)},x,WorkingPrecision->30]
reseniMinimumBarnesG=x/.minimumBarnesG[[2]]

GraphicsRow@{Plot[BarnesG[x],{x,3/2,3},PlotLabel->"BarnesG"],LogPlot[BarnesG[x],{x,3/2,30},PlotLabel->"Logarithm of BarnesG"]}

Přes derivace:

derBarnesG=D[BarnesG[x],x]//Simplify
(* Pro zajímavost: *)
%//TraditionalForm

findBarnesG=FindRoot[derBarnesG==0,{x,2.5},WorkingPrecision->30]

Rozdíl mezi řešeními:

(x/.minimumBarnesG[[2]])-(x/.findBarnesG)

Další predikáty

MemberQ[{a,b,c},b]

(***)IntervalMemberQ[Interval[{3,4}],π]

(***)
?Interval*

(***)IntervalMemberQ[Interval[{1,1}],1]
Complement[Interval[{1,2}],Interval[{1,1}]]

Predikáty jsou také <, >, <=, >=, == ,!= ,≠.

Vzory, předlohy (patterns)

_  vzor jednoho libovolneho vyrazu v systemu Mathematica 
_h vzor  jednoho libovolneho vyrazu v systemu Mathematica s hlavickou h
__  vzor posloupnosti jednoho nebo vice libovolnych vyrazu v systemu Mathematica oddelenych carkami
__h vzor posloupnosti jednoho nebo vice libovolnych vyrazu v systemu Mathematica  s hlavickou h oddelenych carkami
___  vzor posloupnosti zadneho nebo vice libovolnych vyrazu v systemu Mathematica oddelenych carkami
___h vzor posloupnosti zadneho nebo vice libovolnych vyrazu v systemu Mathematica  s hlavickou h oddelenych carkami

Konstrukce vzor?predikát

Na místě této konstrukce může stát libovolný výraz, který vyhovuje zadanému vzoru, a pro nějž zadaný predikát nabývá hodnoty True.

Clear[f]
f[n_Integer?EvenQ]:=n/2
f[n_Integer?OddQ]:=0
Table[f[n],{n,1,10}]

Konstrukce vzor/;podmínka

Na místě této konstrukce může stát libovolný výraz, který vyhovuje zadanému vzoru a splňuje zadanou podmínku.

Definice faktoriálu odolná vůči chybnému zadání:

Clear[f]
f[1]:=1
f[n_Integer /; n>1]:=n f[n-1]
{f[-1],f[3.5],f[25]}
Clear[f]

Matching

Clear[x,y,z,a,b,c]

MatchQ[x,y]: Odpovídá x vzoru y? Vyhovuje x předloze y?

{MatchQ[12345,_],MatchQ[12345,__],MatchQ[12345,___]}

{MatchQ[12345,_Integer],MatchQ[12345.,_Integer],MatchQ[π,_Symbol],MatchQ[π,_Rational],MatchQ[π,_Real],MatchQ[π//N,_Real]}

Plus[a,]

FullForm[a+b]

{MatchQ[Plus[a,],Plus[_,___]],MatchQ[Plus[a],Plus[_,___]],MatchQ[Plus[a,b,c],Plus[_,_]],MatchQ[Plus[a,b,c],Plus[_,__]],MatchQ[Plus[a],Plus[___]],MatchQ[Plus[],Plus[___]]}

{MatchQ[,Times[___]],MatchQ[,___]}

BEGIN 2021-11-07 ?? ????????????????? Vysvětlení zdánlivých záhad

Ve WL se vnitřní výrazy vyhodnocují nejdříve. MatchQ má dva argumenty a např. při vyhodnocování výrazu

MatchQ[(x-1)(1 + 2 x + 3 x^2),Times[_,_]]

se nejprve vyhodnotí tyto dva argumenty (uvedeme raději také v úplné formě):

(x-1)(1 + 2 x + 3 x^2)//FullForm
{Times[_,_],Times[_,_]//FullForm}

Náš výraz však není druhá mocnina, ale součin dvou různých výrazů. Times[_, _] je zkratka pro Times[x_, x_], předpokládá tedy součin dvou stejných výrazů. Správný vzor v tomto případě tedy má být Times[x_, y_], součin dvou případně různýchvýrazů:

{Times[_,_],Times[x_,x_],Times[x_,y_]}

MatchQ[(x-1)(1 + 2 x + 3 x^2),Times[x_,y_]]

Také záhadně vypadající vyhodnocení

MatchQ[(x-1)(1 + 2 x + 3 x^2),Plus[___]]

má své vysvětlení (totéž pro Times, Power,... )

{Plus[___],Times[___],Power[___]}

takže ___ znamená nic a cokoli.

BEGIN 2021-11-19 ?? ????????????????? Vysvětlení zdánlivých záhad

Ale také
?????????????????

Stačí se podívat, jak se funkce pro binární operace vyhodnotí, pokud ji vyvoláme s jedním argumentem. Pro uvedené funkce je to  vždy _,__, ___.

{Plus[_],Power[__],And[_],Times[___]}
{Times[_]==_,And[___]==___}

Times resp. And se vyhodnotí a porovná sse vzorem.

MatchQ[(x-1)(1 + 2 x + 3 x^2),Plus[__]]

MatchQ[,Plus[_]]

{MatchQ[Plot[Sin[x^2],{x,0,1}],Plus[___]],MatchQ[Plot[Sin[x^2],{x,0,1}],Power[___]]}

END 2021-11-19 ?? ????????????????? Vysvětlení zdánlivých záhad

END 2021-11-07 ?? ????????????????? Vysvětlení zdánlivých záhad

{MatchQ[(x-1)(1 + 2 x + 3 x^2),Plus[_,__]],MatchQ[(x-1)(1 + 2 x + 3 x^2),Plus[___]],MatchQ[(x-1)(1 + 2 x + 3 x^2),Times[_,_]],MatchQ[(x-1)(1 + 2 x + 3 x^2),Times[_,__]]}
(x-1)(1 + 2 x + 3 x^2)//FullForm

MatchQ[Plus[1,Times[2,x],Times[3,Power[x,2]]],_]

MatchQ[Expand[(x-1)(1 + 2 x + 3 x^2)],Plus[_,__]]
Expand[(x-1)(1 + 2 x + 3 x^2)]//TraditionalForm
Expand[(x-1)(1 + 2 x + 3 x^2)]//FullForm

(* *** *){MatchQ[1+1,Plus[_,_]],
MatchQ[HoldForm[1+1],Plus[_,_]],MatchQ[HoldForm[1+1],HoldForm[Plus[_,_]]]}

(* GoldenRatio - česky "Zlatý řez" *)
FunctionExpand[GoldenRatio]
MatchQ[1+1/GoldenRatio-GoldenRatio,0]
1+1/GoldenRatio-GoldenRatio
%//Simplify
MatchQ[1+1/GoldenRatio-GoldenRatio//Simplify,0]

(* *** Instruktivní chyba *) Simplify[1+1/GoldenRatio-GoldenRatio]MatchQ[Simplify[1+1/GoldenRatio-GoldenRatio],0]

(* *** Instruktivní chyba - vysvětlení *) Simplify[1+1/GoldenRatio-GoldenRatio]MatchQ[Simplify[1+1/GoldenRatio-GoldenRatio],0]//HoldForm//FullForm

(* *** Instruktivní chyba *) Simplify[1+1/GoldenRatio-GoldenRatio]
(* Na tomto místě stiskneme Enter    ↗ *)MatchQ[Simplify[1+1/GoldenRatio-GoldenRatio],0]

Clear[a,b]
{MatchQ[(a^b),((x_)^(y_))],MatchQ[(2^3),((x_)^(y_))],MatchQ[HoldForm[(2^3)],((x_)^(y_))],MatchQ[HoldForm[(2^3)],HoldForm[((x_)^(y_))]]}

(* Důležité: *)
Clear[z,x,y]
Grid[Table[{(z^i),MatchQ[(z^i),((x_)^(y_))]},{i,0,3}],Frame->True]

FullForm[(x^y)]

(* Důvod *)
Grid[Table[{(z^i),FullForm[(z^i)]},{i,0,3}],Frame->True]

(* Odpomoc: Funkce _. Default *)  
MatchQ[z,((x_)^(y_.))]

Grid[Table[{(z^i),MatchQ[(z^i),((x_)^(y_.))]},{i,0,3}],Frame->True]

(* *** *){MatchQ[z,((x_)^(y___))],FullForm[((x_)^(y___))]}

(* *** *){MatchQ[(z^2),((_)^(_))],MatchQ[(z^2),((x_)^(x_))],MatchQ[(z^z),((x_)^(x_))],MatchQ[(z^z),((z_)^(z_))]}

x_, x__, x___, x_Head, ...

Clear[f];f[x_]:=(x^2)
{f[a],f[{a,b}],f[{b,a}],f[a,b]}
(* Mocnina je tzv. "listovatelná" (Listable) funkce. *)

Clear[f1];f1[x_List]:=(x^2)
hodnoty1={f1[a],f1[{a}],f1[{a,b}],f1[{b,a}]}

Clear[katerina];katerina[x__List]:=(x^2)
hodnotyKaterina={katerina[a],katerina[{a}],katerina[{a},{b}],katerina[{a,b}],katerina[{a,b},{c,d}],katerina[{b,a},{a,b,c}]}

katerina[{a},{b}]//Trace

Cvičení. Definujte funkci katerina2 tak, aby katerina2[{a,b},{c,d}]->{(a^2),(b^2)},{(c^2),(d^2)}.

Chceme vypreparovat výrazy s (a^2):

Důležité příklady!!!!

Cases[objekt, předloha neboli vzor neboli pattern]. Rozdíl:
Select[objekt, predikát)

(* Seznamy, které mají na prvním místě výraz (a^2); uvažují se pouze případy, kdy se (a^2) vyskytuje na první úrovni: *)
hodnoty1
(* Z objektu hodnoty1 vyber ty seznamy, které začínají elementem (a^2): *)
Cases[hodnoty1,{(a^2),___}]
(* Vybere ty seznamy, které mají výraz (a^2) kdekoli, ale na první úrovni *)Cases[hodnoty1,{___,(a^2),___}]

hodnotyKaterina
Cases[hodnotyKaterina,{___,(a^2),___}]
(* Vybere seznamy, které se vyskytují na libovolné úr+ovni: *)
Cases[hodnotyKaterina,{___,(a^2),___},Infinity]

(({b,a})^({(a^2),(b^2),(c^2)}))//TreeForm

Cases[hodnotyKaterina,{___,((_)^2),___},Infinity]

{FullForm[((_)^2)],FullForm[((__)^2)],FullForm[((___)^2)],FullForm[(a^(c^2))]}

{Power[Blank[],2],Power[BlankSequence[],2]}

**Třídění (Rule Based Programming)

Slouží jen jako ukázka použití “Rule Based Programming”. Pro praktické výpočty nepoužitelné, viz čas výpočtu!!!

SeedRandom[13]
xx=RandomInteger[{1,20},20]
(xx//.{a___,b_,c___,d_,e___}:>{a,d,c,b,e}/;d<b)

(xx//.{a___,b_,c___,d_,e___}:>{a,d,c,b,e}/;d<b)//Trace

Vysvětlení

Hyperlink["paclet:tutorial/VirtualBookOverview"]
Hyperlink["paclet:tutorial/PatternsAndTransformationRules"]

A pattern like f[x__,y__,z__] can match an expression like f[a,b,c,d,e] with several different choices of x, y, and z. The choices with x and y of minimum length are tried first. In general, when there are multiple __ or ___ in a single function, the case that is tried first takes all the __ and ___ to stand for sequences of minimum length, except the last one, which stands for “the rest” of the arguments.

Clear[sortRuleBased]
sortRuleBased[xx_List]:=(xx//.{a___,b_,c___,d_,e___}:>{a,d,c,b,e}/;d<b)
sortRuleBased[{4,3,2}]//Trace

Použití zabudované funkce Sort je (jak lze očekávat) rychlejší:

SeedRandom[13]
soubor=RandomReal[{0,1},50];
Text@Grid@{{"Třídění užitím zabudované funkce:   ",Timing[soubor//Sort;][[1]]," sec"},{"Třídění užitím funkce sortRuleBased:   ",Timing[soubor//sortRuleBased;][[1]]," sec"}}

Booleovské funkce a logické operace

(* Platí? *)
7<5

FullForm[HoldForm[abcdefg=a]]

{Equal[3,7-4,6/2],3==7-4==6/2}
HoldForm[3==7-4==6/2]//FullForm

Někdy je nutné použít funkci Simplify (ve druhém případě nedokáže Mathematica rozhodnout  - vrátí ve vstupní podobě):

{ (((x^4)-1)/((x^2)+1))//Simplify,equal=((x^2)-1== (((x^4)-1)/((x^2)+1))),equal//Simplify}//TraditionalForm

Tan[z]==((Sin[z])/(Cos[z]))

Korektněji :

Reduce[(x^2)-1== (((x^4)-1)/((x^2)+1)),x]

reseni2=Solve[(x^2)+1==0,x]

Cvičení: Prohlédněte Help k Reduce

{(x^2)-1,(((x^4)-1)/((x^2)+1))}/.{x->I}

6≠5 (* \[EscapeKey]!,=\[EscapeKey] *)

{6≠12/2,Unequal[6,12/2]}

Logické spojky

Clear[p,q,r]

Or ||, And &&, Not !,

EscorEsc, EscandEsc, EscnotEsc

{p||q,p&&q,!p}
(* ekvivalentne z palety nebo pomocí \[EscapeKey] sekvence, viz třeba Writing Assistant *)
{p∨q,p∧q,¬p}
(* ekvivalentne *)
{Or[p,q],And[p,q],Not[p]}
{p||q,p&&q,!p}//TraditionalForm

{3<5||5<3,3<5&&5<3,!(3<5)}
{3<5∨5<3,3<5∧5<3,¬(3<5)}

Zápisy Or, And, Not jsou velmi užitečné pro větší počet podmínek, kdy je nepraktické psát opakovaně && atd. (Pozor, argumenty těchto funkcí nejsou seznamy (listy)!) Např.:

And[3<4,66>-1,4>1]
And[{3<4,66>-1,4>1}]

**Pravdivostní tabulka (Truth Table (Example of Distribute and a Table) (Detailní prostudování je dosti obtížné cvičení)

TruthTable[vars_List,expr_]:=Distribute[Table[{True,False},{Length[vars]}],List,List,List,{##,Function[vars,expr][##]}&]
DisplayTruthTable[vars_List,expr_]:=With[{t=ReplaceAll[TruthTable[vars,expr],{True->"T",False->"F"}]},GridBox[Prepend[t,Append[vars,expr]],GridFrame->True,RowLines->Prepend[Table[0,{Length[t]-1}],2],ColumnLines->Append[Table[0,{Length[vars]-1}],2]]//DisplayForm]

Sestrojte pravdivostni tabulku vyrazu (A∨B)⟹C

Proč svítí C černě? Je to v této seanci známý symbol:

?C

DisplayTruthTable[{A,B,C},Implies[Or[A,B],C]]

Implies[Or[A,B],Or[C,D]]//TraditionalForm
DisplayTruthTable[{A,B,C,D},Implies[Or[A,B],Or[C,D]]]

DisplayTruthTable[{A,B,C,D},Implies[(A∨B),(C∨D)]]

DisplayTruthTable[{A,B},A∧B]

DisplayTruthTable[{A,B},Xor[A,B]]

*Atributy, zvláště atribut Listable

Attributes[Plus]

Plus[{a,b},{c,d}]
Plus[{a,b},{c,d,e}]

Plus[Plus[b,a]]//FullForm

Attributes[Sin]

Range[10]

Sin[{1,2,3}]
Sin[(π/6)(Range[10]-1)]

Attributes[Length]
Length[{1,2.,{3,4}}]

Remove[druhemocniny];
(* Zde nutné: Clear odstraní hodnoty, ale ne atributy!!! *)
(* Pro odstranění hodnot i atributů je možné použít ClearAll. *)
(* Symbol však zůstane v daném kontextu zachován. *)
(* Remove odstraní symbol z daného kontextu *)
druhemocniny[x_]:=(x^2)+Length[x]
Row@{"druhemocniny[{1,2,3}]:   ",druhemocniny[{1,2,3}]}
Row@{"Table[druhemocniny[i],{i,3}]:   ",Table[druhemocniny[i],{i,3}]}
Row@{"Attributes[druhemocniny]:   ",Attributes[druhemocniny]}
Row@{"SetAttributes[druhemocniny,Listable]   ",SetAttributes[druhemocniny,Listable]}
Row@{"Attributes[druhemocniny]:  ",Attributes[druhemocniny]}
Row@{"druhemocniny[{1,2,3}]:   ",druhemocniny[{1,2,3}]}

Změna atributů zabudované funkce IntegerQ

?IntegerQ

Attributes[IntegerQ]
{IntegerQ[x],IntegerQ[3],IntegerQ[3.],IntegerQ[{1,2}]}

(* Definice vlastní funkce integerQ (* malé i na začátku ! *), ale s funkcí Listable *)
ClearAll[integerQ]
SetAttributes[integerQ,Listable];
integerQ[x_]:=IntegerQ[x]
{integerQ[x],integerQ[3],integerQ[3.],integerQ[{1,2}]}

integerQ[3]=🐺;
{integerQ[x],integerQ[3],integerQ[3.],integerQ[{1,2}]}
SetAttributes[integerQ,Protected]
integerQ[5]=False;

{integerQ[x],integerQ[3],integerQ[3.],integerQ[{1,2}],integerQ[5]}
Unprotect[integerQ]
integerQ[5]=False;
{integerQ[x],integerQ[3],integerQ[3.],integerQ[{1,2}],integerQ[5]}

Attributes[integerQ]

{integerQ[x],integerQ[3],integerQ[3.],integerQ[{1,2}],integerQ[5]}
Unprotect[integerQ]
integerQ[5]=False;
{integerQ[x],integerQ[3],integerQ[3.],integerQ[{1,2}],integerQ[5]}

?integerQ

Clear[integerQ]
?integerQ

!!Ryzí, anonymní funkce,  (Pure functions) 1

Hyperlink[Button["Ryzí (anonymní) funkce (pure functions, λ-functions)"],"http://www.karlin.mff.cuni.cz/~slavik/math_ls_2020_21/ulohy_8.pdf"]

Prohlédněte si též odpovídající *.nb. Tam je více podrobností a vysvětlivek:

Hyperlink[Button["Ryzí (anonymní) funkce (pure functions, λ-functions)"],"http://www.karlin.mff.cuni.cz/~slavik/math_ls_2020_21/ulohy_8a.nb"]

Anonymní funkce nejsou svázány s identifikátorem. V symbolické logice též λ-funkce.

Ryzí funkce ma formu Function[proměnná, předpis]. Podivejte se též na Help. Druhá mocnina:

Function[x,(x^2)]

f=Function[x,(x^2)]
{f[x],f[3],f[I],f[y]}
{Function[x,(x^2)][x],Function[x,(x^2)][3],Function[x,(x^2)][I],Function[x,(x^2)][y]}

**Alternativní zápisy (šipka pomocí \[Function,] nebo EscfnEsc, pozor, ta šipka na paletě je jiná!!!)

x|->(x^2)

{(x|->(x^2)) [x],(x|->(x^2))[3],(x|->(x^2))[I],(x|->(x^2))[y]}

V úsporném zápise   #  značí proměnnou ryzí funkce a & značí ryzí funkci. Na symbol & se nesmí zapomenout!!! Ekvivalentní zápis druhé mocniny:

((#)^2)&

{((#)^2)&[x],((#)^2)&[3],((#)^2)&[I],((#)^2)&[y]}

Dvě proměnné v anonymní funkci se zadávají ve formě seznamu:

{Function[{x,y},x+y][cc,bbbb],Function[#1+#2][cc,bbbb],
(#1+#2)&[cc,bbbb],({x,y}|->x+y)[cc,bbbb]}

Konec 2021-11-05

2021-11-19 Lekce 7

FAQ

Q1 Vysvětlení zdánlivých záhad týkajících se MatchQ z předchozí lekce

A1

viz

Q2 Pravidlo 2σ a 3σ pro Studentovo rozdělení se 4.1 stupni volnosti

Problém spočívá v tom, že výpočet P(|X-μ|>2σ) končí složitým a dále nezjednodušitelným výrazem, ale výpočet P(|X-μ|<2σ) vede k explicitnímu výsledku.

A2

Rekapitulace mého řešení z minulé lekce

Clear[μ,σ,x]

distrStudent41=StudentTDistribution[μ,σ,41./10]
sd=StandardDeviation[distrStudent41]

První nápad řešení problému (počítáme pst doplňkovému jevu) - okamžitě fungující:

{Probability[Abs[x-μ]<2sd,x\[Distributed]distrStudent41],1-Probability[Abs[x-μ]<2sd,x\[Distributed]distrStudent41]}

Neúspěšné pokusy:

Probability[Abs[x-μ]>2sd,x\[Distributed]distrStudent41]

Probability[Abs[x-μ]>2sd,x\[Distributed]distrStudent41,Method->"CDF"]

Probability[x-μ>2sd,x\[Distributed]distrStudent41,Method->"CDF"]

Probability[x-μ>2sd,x\[Distributed]distrStudent41,Method->"PDF"]

Attempt 1 (Exact solution)

N[π,50]

{Rationalize[4.1],Rationalize[3.14159265358979323846264338,0]}

Výpočet pro přesnou hodnotu (přidáváme e k názvům funkcí předchozím) počtu stupňů volnosti (místo 4.1 vezmeme 41/10):

Row@{distrStudent41e=StudentTDistribution[μ,σ,41/10],"   SD = ",sde=StandardDeviation[distrStudent41e],
"\nPřesně: ",pb=Probability[Abs[x-μ]<2sde,x\[Distributed]distrStudent41e],"\nPřibližně: p = ",pb//N,"   1-p = ",1-pb//N}
%//N

Probability[Abs[x-μ]>2sde,x\[Distributed]distrStudent41e]

%//Simplify

Attempt 2 (standardization), successful

transformedStudent=TransformedDistribution[((x-μ)/σ),x\[Distributed]distrStudent41e]
StandardDeviation[transformedStudent]

Probability[Abs[y]<2(Sqrt[(41/21)]),y\[Distributed]transformedStudent]
%//N

Probability[Abs[y]>2(Sqrt[(41/21)]),y\[Distributed]transformedStudent]
%//N

!!Ryzí, anonymní funkce,  (Pure functions) 2

(* Z minulé lekce *)
f=Function[x,(x^2)]

Další příklady

Function[x,x.x][{aa,bb,cc}]

Function[x,x.x][q]
Function[x,x.x][{q}]
Function[x,x.x][(({{a, b, c}, {d, e, f}, {g, h, i}}))]//MatrixForm
Function[x,x.x][(({{a, b, c}, {d, e, f[k]}, {g, h, i}}))]//MatrixForm

!!Základy funkcionálního přístupu

Zásady

Elementární princip: není zapotřebí znát rozměry objektů, jejich charakter (všechno v systému Mathematica jsou výrazy (expressions)), seznamy se neprozkoumávají sekvenčně jako v procedurálním programování, ale hledí se na ně jako na objekty. Až na výjimky se typy proměnných určují z kontextu. Wolfram Language je interpret, ale zabudované funkce jsou samozřejmě zkompilované a užívají nejnovější a nejefektivnější algoritmy, takže běžný uživatel těžko naprogramuje něco lepšího. Nicméně zabudovaná funkce Compile umožňuje přeložit vlastní procedury.

Functional programming means programming by using functions as the arguments of the other functions.

Složené výrazy (Coumpound expressions)

Výrazy oddělené středníkem, výstupem je poslední výraz. Použití v případě, že kód není možné “přehledně” napsat na jeden řádek. Tato konstrukce se však více používá v dále uvedených složitějších konstrukcích (modulech).

x=3;y=6;x+y
Clear[x,y]
{x,y}

Module (lokalizace proměnných, přiřazení globálním proměnným)

Module je základní konstrukce pro uživatelem definované složitější funkce a procedury. Pokud nejsou v modulu požadovány mezivýstupy (např. příkazem Print), je výstupem modulu poslední příkaz složeného příkazu. Tím může být cokoli, jedno číslo, vektor řešení soustavy rovnic, graf, databáze, kombinace všeho předchozího.

Funkce Module (případně Block) má dva argumenty: první je  seznam lokálních (vnitřních) proměnných modulu s případně přiřazenými počátečními hodnotami a druhý je složený příkaz. Vnitřní proměnné jsou vně modulu neviditelné.

Clear[a]
x=6789;y=8888;
(* Oba následující moduly jsou ve svém důsledku ekvivalentní. *)
{Module[{x=5,y=a},x+y],Module[{x,y},x=5;y=a; x+y]}
{x,y}

Výpis objektů použitých v této seanci (poklepem zjistíme detaily):

?Global`*

Posledním výrazem v níže definovaném modulu je seznam o třech prvcích {Sin[x],Cos[y],graf obou funkcí} a ten je také výstupem:

Clear[f];
f[x_,y_]:=Module[(* lokální proměnné modulu *){xsin,ycos,plot},
(* Tělo modulu = složený příkaz *)
xsin=Sin[x];ycos=Cos[y];							    plot=Plot[{Sin[z],Cos[z]},{z,x,x+2π},PlotTheme->"Detailed",PlotLabel->"Graf funkce sinus a cosinus"];
		{xsin,ycos,plot}]
f[1.,2]

Chceme-li pouze graf:

(* Výstupem je seznam o třech prvcích *)
{xsin,ycos,plot}=f[2,3];
plot

nebo jednodušeji

f[2,3][[3]]

With (lokalizace proměnných, jednorázový výpočet)

With[{x=(Subscript[x, 0])},expr] specifies that all occurrences of the symbol x in expr should be replaced by (Subscript[x, 0]).

Clear[a,b]
x=5;y=π;
With[{x=7,y=a+1},x/y]
x

With je rychlejší než Module, viz (hledej “faster” v Help funkce With):

With

{Timing[Do[With[{x=5},x;],{(10^5)}]],Timing[Do[Module[{x=5},x;],{(10^5)}]]}

!!!Map, Apply, Thread (provlečení?, vlákno?), Through  (Obecný princip)

Map a Apply

Map přeskočí hlavičku druhého argumentu a aplikuje první argument na to, co je za hlavičkou.
Apply vymění hlavičku druhého výrazu za první.

Clear[f,g,a,b,c];
Map[f,g[a,b,c]]
Apply[f,g[a,b,c]]

{a,b,c}//Head
(* Hlavička je List. *)
Map[Sin,{a,b,c}]
Apply[Plus,{a,b,c}]
Map[Sin,Times[a,b,c]]
Apply[Plus,Times[a,b,c]]

Funkce Sin je “listovatelná” (viz Attributes[Sin]), takže tady stačí

Sin[{a,b,c}]

Ale

Attributes[NumberQ]
NumberQ[{1,2,3}]
Map[NumberQ,{1,2,3,b}]

** BEGIN
Odpomoc je snadná. Uvedeme dvě možnosti:

1. Zrušíme ochranu funkce NumberQ (Unprotect) a přidáme atribut Listable pomocí SetAttributes[NumberQ,Listable]. Vřele nedoporučuji. Wolfram dobře věděl, proč tam onen atribut nepřidal sám.

2. Definovat vlastní funkci numberQ (s malým n!):

ClearAll[numberQ];
numberQ[x_]:=NumberQ[x]
numberQ[{1,2,3,b}]
Map[numberQ,{1,2,3,b}]
SetAttributes[numberQ,Listable]
numberQ[{1,2,3,b}]
ClearAttributes[numberQ,Listable]
numberQ[{1,2,3,b}]

** END

Obecně však přesto obecně doporučuji použít funkci Map.

(**)
{3+4+5//Head,Unevaluated[3+4+5]//Head,HoldForm[3+4+5]//Head,a+b+c//Head}

Clear[a,b,c,d]
Apply[Times,a+b+c]
Apply[Times,3+4+5]
(* *** *)
{Apply[Times,Unevaluated[3+4+5]],Apply[Times,HoldForm[3+4+5]]}
a=3;b=4;Apply[Times,a+b+c]
Clear[a,b];

a+b+c-d//FullForm
Apply[Times,a+b+c-d]

Thread

Clear[f,a,b,c];
Thread[f[{a,b,c}]]

Clear[f,x,y,z];
Thread[f[{a,b,c},x]]

Thread[f[{a,b,c},{x,y,z}]]
Thread[f[{a,b,c},{x,y}]]

Vytvoří soustavu rovnic:

{a,b,c}=={x,y,z}
Thread[{a,b,c}=={x,y,z}]

{1,2,3}=={1,2,4}
Thread[Unevaluated[{1,2,3}=={1,2,4}]]

Příklad

Clear[x1,x2,x3];
xx={x1,x2,x3};
aa=HilbertMatrix[3];
bb={2,3,4};
(soustava=Thread[aa.xx==bb])//MatrixForm
(* V tomto pripade funguje i bez Thread *)
Solve[soustava,xx]
(xx/.Solve[soustava,xx])
(xx/.Solve[soustava,xx])[[1]]
(xx/.Solve[soustava,xx])[[1,2]]

Od verze 12.3:

SolveValues[soustava,xx]

V této verzi (od verze 11.3) již použití Thread není nutné:

Solve[aa.xx==bb,xx]

Aplikuje funkci na obe strany rovnice:

Thread[Sin[x==y],Equal]

Through

Aplikuje více funkcí na jeden argument:

Clear[f,g,h,x]
Through[{f,g,h}[x]]

Through[{Sin,Cos,Tan}[π/5]]

(* ** *)
Map[Through[{Identity,Sqrt}[#]]&,Range[4]//N]//Grid

***BEGIN
Součet prvních dvou derivací:

((D[#,x]&)+(D[#,{x,2}]&))[f[x]]
Through[%]
%/.f->Sin
%%/.f->Function[z,Exp[Sin[(z^2)]]]
%//Simplify

***END

!!!Důležitá poznámka k Apply, List ⟶ Sequence a jiné výměny hlavičky výrazu

Je důležité si uvědomit, že některé funkce více proměnných mají argumenty ve formě posloupnosti a jiné mají jeden argument, ale ve formě seznamu. Týká se jak zabudovaných funkcí, tak i uživatelem definovaných. U zabudovaných funkcí pozorně pročtěte Help (a nejlépe si z Helpu zkopírujte Vám nejbližší příklad).

Times je funkce funkce více argumentů, aplikovaná na seznam vrací původní seznam.

(Připomínám, že mezera mezi dvěma výrazy znamená násobení.)

{Times[{a,b,c}],Times[a,b,c],Apply[Times,{a,b,c}]}

Det (determinant) je funkce jednoho argumentu, argumentem je seznam reprezentující matici:

maticeABCDEFGHI=Partition[CharacterRange["a","i"],3]//ToExpression
Det[maticeABCDEFGHI]//TraditionalForm

!!!První příkaz vytvoří ze seznamu posloupnost, druhý z posloupnosti seznam (výměna hlavičky):

Clear[f,a,b,c];
{Apply[f,{a,b,c}],Apply[List,f[a,b,c]]}

!!!Výměnu hlavičky je možné provést také substitucí:

(* Předvod List ⟶ Sequence. *)
(seznamabc={a,b,c})/.List->Sequence
(* Předvod Sequence ⟶ List. Je to tak jednoduché, že je obtížné na to přijít. *)
{Sequence[a,b,c]}

Row@{"Součin seznamu: ",Times[{a,b,c}],"   Po substituci: ",Times[{a,b,c}/.List->Sequence]}
{Times[{a,b,c}],Times[{a,b,c}/.List->Sequence]}/.Times->Plus

{* ** *)
(* 2. příkaz nefunguje úplně podle představ: *)

Apply[Sequence,{a,b,c}]
{Apply[Sequence,{a,b,c}],Apply[List,Sequence[a,b,c]]}
Times[Apply[Sequence,{a,b,c}]]

Cvičení: Vysvětlete, v čem je problém.

Příklad (důležitý, nutnost použití Apply nebo Sequence)

Clear[f,a,b,c];
(* funkce tří proměnných: *)
f[x_,y_,z_]:=x+y+z
{f[{a,b,c}],f[a,b,c]}

Clear[f1]
f1[x__]:=Plus[x]
{f1[1],f1[2,3],f1[3,4,5],f1[]}

Clear[f2]
f2[x___]:=Plus[x]
{f2[1],f2[2,3],f2[3,4,5],f2[]}
Plus[]

Apply[f2,Range[5000]]

Apply[f,{a,b,c}]

a,b,c je posloupnost argumentů, takže alternativní řešení je nahradit hlavičku seznamu hlavičkou posloupnost:

f[{a,b,c}]/.List->Sequence

f[{a,b,c}]//FullForm

!Příklad (aritmetický průměr)

{VectorQ[{}],Length[{}]}

Clear[prumerFM,prumerFM2]
prumerFM[xx_?VectorQ]:=((Apply[Plus,xx])/(Length[xx]))
prumerFM2[xx_?VectorQ]:=((Total[xx])/(Length[xx]))
{prumerFM[Range[10]],prumerFM[{a,b,c}],prumerFM[],prumerFM[{}]}
{prumerFM2[Range[10]],prumerFM2[{a,b,c}],prumerFM2[],prumerFM2[{}]}

VectorQ[{}]

Příklad výpočtu aritmetického průměru s pojistkou na to, aby argument funkce byl vektor délky alespoň jedna. (Existuje ovšem zabudovaná funkce Mean.)

Clear[prumer];
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],prumer[{2}]}

Flatten[{{{a,d}},b,c}]

Použití zabudované funkce Total (Pozor na formu argumentu!) Pro Times podobná funkce není. Prostudujte za cvičení.

Clear[pr1];
pr1[data_]:=((Total[data])/(Length[data]))
pr1[{{{a,d}},b,c}] (* Výsledkem je matice 1x2. *)
pr1[{{{a,d}},b,c}//Flatten] (* Výsledkem je skalár. *)

Clear[pr2];
pr2[data_List]:=With[{dt=data//Flatten},((Total[dt])/(Length[dt]))]/;data≠{}
{pr2[{{{a,d}},b,c}],pr2[],pr2[{}]}

Pozor!!!

{{{a,d}},b,c}//TreeForm
Length[{{{a,d}},b,c}]
Dimensions[{{{a,d}},b,c}]

!!!Alternativně použitím tzv. PatternTest

S tím jsme se již jednou setkali,  viz

delCases=DeleteCases[dividendsDJI,_?(#[[2]]==Missing["NotAvailable"]&)]

💡Některé funkce používají pro testování predikát, jiné vzor (předlohu, pattern). Velmi často dokážeme zformulovat predikát, ale ne vzor. Pro převod predikát ⟶ vzor použijeme tzv.  PatternTest: Konstrukce je vzor=_?(predikát). (Není nutné ve všech případech uvádět predikát v závorkách, ale je to bezpečná konstrukce, zvláště při použití ryzích funkcí. K chybě při absenci závorek se přiznávají i někteří velmi zkušení vývojáři.) Připomínám také, že pokud argument funkce nevyhovuje vzoru, při vyvolání této funkce se nezačne nic počítat!

(* *** *)
x_?(VectorQ[#]∧Length[#]>0&)//FullForm

Clear[prumerJH]
prumerJH[x_?(VectorQ[#]∧Length[#]>0&)]:=((Apply[Plus,x])/(Length[x]))(* nebo Total[x]/Length[x] *)
{prumerJH[{a,b,c}],prumerJH[{{a},b,c}],prumerJH[a,b,c],prumerJH[2],prumerJH[{2}]}

!!Příklad (výpočet rozptylu)

Zabudovaná funkce Variance. (Nestranný odhad rozptylu (unbiased estimator of the variance), tj. (1/(n-1))∑... ).

Variance

?prumer

Clear[rozptyl]
rozptyl[x_?VectorQ]:=prumer[(((x-prumer[x]))^2)]
{rozptyl[Range[5]],rozptyl[{Range[5]}],rozptyl[{}]}

Clear[a,b,c,d,e]
ch5=CharacterRange["a","e"]
{prumer[ch5],prumer[{a,b,c,d,e}]}
%//TraditionalForm
%%//FullForm

{prumer[ch5]/.{"a"->1,"b"->2,c->3},prumer[{a,b,c,d,e}]/.{"a"->1,"b"->2,c->3}}

(* Analyzujte pomoci FullForm *)
{rozptyl[ch5],rozptyl[{a,b,c,d,e}]}//Simplify

(*(( ** )^( *** ))***){prumer[{3+I,2+5 I}],Mean[{3+I,2+5 I}]} 
{rozptyl[{3+I,2+5 I}],Variance[{3+I,2+5 I}]}

Seznamy (Lists) 1

Množinové operace

Clear[a,aa,b,c,e,f,g];
(* mnozinove sjednoceni: *)
Join[{b,c,a,aa},{d,e,f,e,a}]
(* Setřídí a odstraní duplicity: *)
Union[{b,c,a,aa},{d,e,f,e,a}]
(* Mnozinovy prunik (setřídí): *)
Intersection[{b,c,a,aa},{d,e,f,e,a,c}]

\\[Union]

{b,c,a,aa}⋃{d,e,f,e,a}
{b,c,a,aa}⋂{d,e,f,e,a}
(* Mnozinovy doplnek *)
Complement[{a,b,c,d,e},{a,c},{d}]

**Příklad (průnik bez setřídění, instruktivní)

Clear[a,b,c,d];
seznam1={a,a,c,c,b};
seznam2={d,d,c,c,b};
(* Prunik se setridenim *)
Intersection[seznam1,seznam2]

(* Průnik bez setřídění a bez odstranění duplicit *)
Position[seznam1,c]
(* Na kterych pozicich se v seznamu 1 vyskytuji prvky seznamu 2? *)
pozice=Map[Position[seznam1,#]&,seznam2]
(***)pozice=Map[Position[seznam1,#]&,seznam2]//Flatten
(***)Map[seznam1[[#]]&,pozice]
(***)Map[seznam1[[#]]&,pozice]//DeleteDuplicates

Třídění

SeedRandom[13];
r8=RandomInteger[{-4,4},15]
Sort[r8] (* viz Help *)
Union[r8]

(#1+2#2)&[a,b]

(* Třídění sestupné pomocí ryzí funkce - dva rovnocenné zápisy *)
{Sort[r8,#1>#2&],Sort[r8,Function[{x1,x2},x1>x2]]}
(* Ekvivalentne *)
Sort[r8,Greater]
(* Ekvivalentne *)
Reverse[Sort[r8]]

(* Trideni podle prvni slozky *)
Sort[r23={{a,2},{d,3},{c,1},{a,1}}]

(* Trideni podle druhe slozky, pozor, musí se uvést, že se jedná o druhou složku!!! *)
Sort[r23,#1[[2]]<#2[[2]]&]
(* !!!Ekvivalentne *)
Map[Reverse,r23]
Sort[Map[Reverse,r23]]
Map[Reverse,Sort[Map[Reverse,r23]]]

#,n je n-tý argument ryzí funkce. Pro n=1 je možné místo místo #1 psát pouze #. Třídící funkce je funkce dvou argumentů; ve formě ryzí funkce tedy obsahuje #1, #2.  Vektory se třídí podle první složky, pokud není uvedeno jinak. U druhé složky je nutné uvést jak argument ryzí funkce, tak složku podle které se má třídit, např. pro sestupné třídění podle druhé složky použít třídící funkci  #1[[2]]>#2[[2]]&.

!!!Cvičení. Všimněte si rozdílu mezi:

r23
Map[Reverse,r23]
Reverse[r23]

Výběry prvků ze seznamu

Již zmíněné funkce

Cases
Select

r8new={1,-4,-3,-3,-4,0,-1,3,2,2,0,-1,4,-1,-4};

Použití funkce Select (2. argument je kritérium, test )

(* Positive[x] nemá na konci Q, nejedná se tedy o predikát!!! *)
Clear[x]
Attributes[Positive]
(* Je listovatelná, takže je zbytečné užití Map[Positive,{0,1,x}] *)
Positive[{0,1,x}]

(* Ekvivalentní příkazy pro výběr prvků větších než  0 *)
{Select[r8new,Positive],Select[r8new,#>0&],Select[r8new,Function[x,x>0]]}

Všechny prvky větší než 1:

{Select[r8new,Function[x,x>1]],Select[r8new,#>1&],Select[r8new,Positive[#-1]&]}

Použití funkce Cases (2. argument musí být předloha, vzor, pattern )

Jak z predikátu pred dostanu předlohu: _?pred  (viz PatternTest). Lze použít i pro test, např. Positive.

Row@{Cases[r8new,_?Positive],", ",Cases[r8new,x_/;x>0],", ",Cases[r8new,_?(#>0&)],"\nnefunguje ale: ",Cases[r8new,(#>0&)]}

(* Nápověda: (#>0&) není vzor ale predikát: *)
{(#>0&)[3],(#>0&)[-3]}

Cases[r8new,-1]

Všechny prvky větší než 1:

{Cases[r8new,x_/;x>1],Cases[r8new,_?(#>1&)]}
{Select[r8new,#>1&],Select[r8new,Function[x,x>1]]}

Některé rozdíly mezi Select a Cases

Clear[b]
{Head[3],Head[b]}

?f

Clear[f]
Select[f[1,a,2,b,3],IntegerQ](* IntegerQ je predikát *)
Cases[f[1,a,2,b,3],_Integer](* vzor pro libovolný jeden výraz s hlavičkou Integer *)
Cases[f[1,a,2,b,3],_?IntegerQ](* vzor vytvořený z predikátu *)
(* ale pozor, níže nejsou vzory jako druhý argument!!! *)
{Cases[f[1,a,2,b,3],IntegerQ],Cases[{1,a,2,b,3},IntegerQ]}

Testování a hledání v seznamech

{Position[list1={a,b,c,d,e,f,c},c],Position[list1,cc]}
Map[Flatten,%]
%[[1]]

Používejte funkci Position jen v případě, že si nevíte rady. Výpočet je pomalý, výstupy nepřehledné.

(* cetnost vyskytu a *)
Count[list2={a,b,a,c,a,d,c,b,b,b,a,e,e},a]

(* Všechny různé prvky v seznamu list2 setříděné*)
Union[list2]

Zjišťování četností

Za cvičení zkuste pro zjištění četností v seznamu list2 použít funkci MemberQ:

list2={a,b,a,c,a,d,c,b,b,b,a,e,e};
unionlist2=Union[list2]
{MemberQ[list2,a],MemberQ[list2,f]}

Map[MemberQ[list2,#]&,unionlist2]

({True,False,False}//Total)
({True,False,False}//Total)/.{False->0,True->1}

Boole[{True,False,False,True,True}]
%//Total

Četnosti prvků v seznamu list2

Map[Count[list2,#]&,Union[list2]]
(* ekvivalentne *)
Map[Function[x,Count[list2,x]],Union[list2]]

{Union[list2],Map[Count[list2,#]&,Union[list2]]}//Transpose//TableForm

(* Jinak *)

Row@{Map[{#,2#}&,Union[list2]],"\n",Map[Function[x,x],Union[list2]]}

Row@{Map[{#,Count[list2,#]}&,Union[list2]]//TableForm,"       ",
Map[Function[x,{x,Count[list2,x]}],Union[list2]]//TableForm}

Avšak  existuje zabudovaná funkce Tally:

Tally[list2]

Konec 2021-11-19

2021-11-26 Lekce 8

FAQ

Q1 Vysvětlení dalších zdánlivých záhad týkajících se MatchQ z lekce 6

A1

Opět viz

Q2 Predikce v časových řadách (Time Series Forecast)

A2

Modely časových řad a jiných náhodných procesů

?*Process

Vybrané modely časových řad

Autoregressive integrated moving average ARIMA(p,d,q) process

(Integrovaný smíšený proces řádu p,d,q)

Time series (Subscript[X, 0]),(Subscript[X, 1]),...

(1-(∑_(i=1)^p) (Subscript[ϕ, i])(L^i))(((1-L))^d) (Subscript[X, t])= (1+(∑_(i=1)^q)(Subscript[θ, i]) (L^i) )(Subscript[ϵ, t])

Here L is the lag operator (operátor zpoždění): L,(Subscript[X, t])=(Subscript[X, t-1]), (L^2)(Subscript[X, t])=L(L,(Subscript[X, t]))=L,(Subscript[X, t-1])=(Subscript[X, t-2]), &c. The error terms (Subscript[ϵ, t]) are generally assumed to be uncorrelated or independent, identically distributed variables (iid), (Subscript[θ, i]), (Subscript[ϕ, i]) are parameters.

Speciální případy:

Clear[arima];arima[p_,d_,q_,drift_:0]:=Module[{iexpand},iexpand=Expand[(1-(∑_(i=1)^p)(Subscript[ϕ, i])(L^i))(((1-L))^d)(Subscript[X, t])==drift+(1+(∑_(i=1)^q)(Subscript[θ, i])(L^i))(Subscript[ϵ, t])];
iexpand/.{L (Subscript[X, t])->(Subscript[X, t-1]),L (Subscript[ϵ, t])->(Subscript[ϵ, t-1]),(L^(i_))(Subscript[X, t])->(Subscript[X, t-i]),(L^(i_))(Subscript[ϵ, t])->(Subscript[ϵ, t-i])}//Simplify//TraditionalForm]

Náhodná procházka (random walk):

arima[0,1,0]

Náhodná procházka s driftem:

arima[0,1,0,c]

Autoregresní posloupnost 1. řádu a 2. řádu:

{arima[1,0,0],arima[2,0,0]}

Klouzavé součty 1. řádu a 2. řádu :

{arima[0,0,1],arima[0,0,2]}

Něco složitějšího:

arima[0,2,0]

arima[2,2,2]//FullSimplify

Funkce pro práci s časovými řadami

Funkce pro práci s časovými řadami

?*TimeSeries*

Příklad (nalezení vhodného modelu a predikce)

{startDayTS=Today-Quantity[1,"Year"],endDateTS=Today-Quantity[1,"Month"]}
timeSeriesSP500=FinancialData["SP500",{startDayTS,endDateTS},Method->"Legacy"];
plotPricesSP500=DateListPlot[%,PlotStyle->Thick,PlotLabel->"Prices from "<>ToString[DateList[startDayTS][[1;;3]]]<>" to "<>ToString[DateList[endDateTS][[1;;3]]]];
(* Posledních 60 dnů: *)
GraphicsRow@{plotPricesSP500,plotPricesSP500minus60days=DateListPlot[Take[timeSeriesSP500,-60],PlotLabel->"Last 60 days",PlotStyle->Thick]}

timeSeriesSP500fit=TimeSeriesModelFit[timeSeriesSP500]
%//Normal
Row@{"Vzorec:   ",arima[Length[%[[2]]],%[[3]],Length[%[[4]]],%[[1]]]}

Vzorec:

arima[0,1,0,2.9667159806436567`]

timeSeriesSP500fitProperties=timeSeriesSP500fit["Properties"]

Map[{#,timeSeriesSP500fit[#]}&,timeSeriesSP500fitProperties]//TableForm

Ještě model pro diference:

timeSeriesSP500fitDifferences=TimeSeriesModelFit[Differences[timeSeriesSP500]]
%//Normal
Row@{"Vzorec:   ",arima[0,0,0,23.514081216054375`]}

Simulations of this for the next 30 days: 50 paths (trajectories) - possible development:

SeedRandom[131];
(simulationsSP500=RandomFunction[timeSeriesSP500fit,{1,30},50])//DateListPlot

RandomFunction[timeSeriesSP500fit,{1,30},50]
%//DateListPlot

SeedRandom[131];Show[plotPricesSP500,DateListPlot[RandomFunction[timeSeriesSP500fit,{1,30},50],Joined->True],PlotRange->All]

Shorther time horizon:

SeedRandom[131];Show[plotPricesSP500minus60days,DateListPlot[RandomFunction[timeSeriesSP500fit,{1,30},50],Joined->True],PlotRange->All]

95 per cent confidence interval for the end of September, the forecast, and the actual price:

Text@Row@{"Interval     ",timeSeriesSP500fit["PredictionLimits"][{2021,12,2}],"\nForecast    ",TimeSeriesForecast[timeSeriesSP500fit,{29}]//Normal//Last//Last,"\nActual price    ",FinancialData["SP500",{{2021,12,2},{2021,12,2}},Method->"Legacy"]//First}

Seznamy (Lists) 2

Aplikace funkcí na různých úrovních, grafická reprezentace seznamů

?*Chart

Labeled[{x,y,z},l,b,l] označí výraz {x,y,z} nálepkou trojice (funkce má 2 argumenty):

Labeled[{x,y,z},"trojice"]

Užití funkce Apply na vyšší úrovni (1. řádek na úrovni 0, implicitní, 2. řádek na úrovni 1:

(* level 0 *) Apply[f,{{a,b,c},{d,e}}]
(* level 1 *) Apply[f,{{a,b,c},{d,e}},{1}]

Reverse[{{a,4},{b,4},{c,2},{d,1},{e,2}}]

Reverse na 2. úrovni

Reverse[{{a,4},{b,4},{c,2},{d,1},{e,2}},2]

funguje jako

Map[Reverse,{{a,4},{b,4},{c,2},{d,1},{e,2}}]

Celkem

Reverse[{{a,4},{b,4},{c,2},{d,1},{e,2}},2]
Apply[Labeled,%,{1}]

BarChart[Apply[Labeled,Reverse[{{a,4},{b,4},{c,2},{d,1},{e,2}},2],{1}],PlotTheme->"Marketing"]
PieChart[Apply[Labeled,Reverse[{{a,4},{b,4},{c,2},{d,1},{e,2}},2],{1}]]

Nalezení zákonitosti v posloupnosti, FindInstance

Další příklad

{t1=Table[3k,{k,1,10,2}],Length[t1]}
FindSequenceFunction[t1,n]//TraditionalForm
(* Pomocí ryzí funkce (vynechána proměnná n) *) FindSequenceFunction[t1]
%[k]//TraditionalForm

Připomínka (viz též determinant Hilbertovy matice):

t2={1,1,2,3,5};
FindSequenceFunction[t2,n]
%//FunctionExpand
Simplify[FunctionExpand[Fibonacci[n]],Assumptions->Element[n,Integers]]

Funkce FindInstance (možná) najde řešení problému, na který jiné metody nestačí. V Helpu uvedených příkladech však najdeme případy, které jsou řešitelné funkcemi jako Solve, Reduce aj. Např.

FindInstance[x^2+x y+y^2==109,{x,y},Integers]
{x,y}/.FindInstance[x^2+x y+y^2==109,{x,y},Integers,30]
SolveValues[x^2+x y+y^2==109,{x,y},Integers]
%//Length

FindInstance[x^2-6 x y+9y^2-x+2y==1,{x,y},Integers]
FindInstance[x^2-6 x y+9y^2-x+2y==1,{x,y},Integers,3]
(* Obecné řešení: *)
SolveValues[x^2-6 x y+9y^2-x+2y==1,{x,y},Integers]

FindInstance[x^2-3y^2==22&&x>0&&y>0,{x,y},Integers]
FindInstance[x^2-3y^2==22&&x>0&&y>0,{x,y},Integers,4]
(* Obecné řešení: *)
SolveValues[x^2-3y^2==22&&x>0&&y>0,{x,y},Integers]

Na tuto úlohu již Solve ani Reduce nestačí:

FindInstance[x^2+y^2+z^2+t^2==123456789,{x,y,z,t},Integers]

Reduce[x^2+y^2+z^2+t^2==123456789,{x,y,z,t},Integers]

SolveValues[x^2+y^2+z^2+t^2==123456789,{x,y,z,t},Integers]

Vytváření seznamů

Table[(i^2),{i,1,5}] (* spatne z hlediska funkcionalniho programovani *)
Table[(i^2),{i,5}] (* spatne z hlediska funkcionalniho programovani *)
((Range[5])^2) (* spravne z hlediska funkcionalniho programovani *)

Range[4,8]
malaabeceda=CharacterRange["a","z"]
CharacterRange["a","z"]//FullForm

Alphabet["Czech"]
Alphabet["Slovak"]
Alphabet["Russian"]
%%%//Length
%%%//Length
%%%//Length

**Detaily

paclet:tutorial/CharacterCodes

(* Greek and other characters *)
CharacterRange[913,1009]

(* Chinese *)
CharacterRange[12288,35839]

(* Wolfram special characters *)
CharacterRange[61440,63487]
Position[%,\[WolframLanguageLogo]]
Position[%%,🐺]
\[WolframLanguageLogo]//FullForm
\[WolframLanguageLogo]🐺

\[WolframLanguageLogo]

\[WolframLanguageLogo]

\[WolframLanguageLogoCircle]

\[WolframLanguageLogoCircle]//FullForm

🐺//FullForm

\[WolframLanguageLogo]//FullForm

Tabulky

Clear[α]
Table[{i,Expand[(((1+α))^i)]},{i,3}]//TableForm

Text@Grid[{Range[3],Expand[(((1+α))^(Range[3]))]}//Transpose,Frame->{False,All},Frame->True]

Text@Grid[{Range[5],Expand[(((1+α))^(Range[5]))]}//Transpose,Background->{None,{{Pink,Yellow}}},Frame->{All,False},(* zde zbytečné *)Frame->True]

Nekdy je vsak prehlednejsi pouzit proceduralni pristup (s iteratorem):

Table[i+j,{i,5},{j,1,i}]//TableForm

Table[{i,j,i+j},{i,5},{j,1,i}]//TableForm

Porovnání dob výpočtů pri vytvareni stejneho seznamu

Vsimnete si pouziti potlaceneho vystupu ;          Vypocet spustte nekolikrat za sebou a pozorujte ruzne casy vypoctu.

Timing[Table[Sin[π k/4],{k,0,250000}];]
Timing[Sin[(Range[250001]-1)π/4];]
Timing[Map[Sin,(Range[250001]-1)π/4];]
Row@{Style["Úspora "<> ToString[(1-((%)/(%%%))//First)100]<>"%",18,Magenta]}

Ještě porovnáme dobu výpočtu vlastních čísel Hilbertovy matice při postupu 1. nejdříve H. matice přesně, pak numerickou hodnotu, 2. nejdříve převedeme Hilbertovu matici na realny tvar a pak vypočteme vlastní čísla.

Hilbertova matice, vlastní čísla

(HilbertMatrix[60]//Eigenvalues)//First//N
(HilbertMatrix[60]//Eigenvalues)//Last//N

{(* 1. *)Timing[hEigenNumeric=HilbertMatrix[60]//Eigenvalues//N;],
(* 2. *)Timing[hNumericEigen=HilbertMatrix[60]//N//Eigenvalues;]}

Nepřesnost, rozdíl mezi oběma postupy (odečteme vektory vlastních čísel, spočteme vektor absolutních hodnot odchylek a z nich maximum):

(* hEigenNumeric-hNumericEigen
Abs[hEigenNumeric-hNumericEigen] *)
Max[Abs[hEigenNumeric-hNumericEigen]]
$MachinePrecision

!!Vytvoření positivně definitní matice a příbuzné výpočty (důležité)

Vytvoříme náhodnou čtvercovou matici C. Ta je s. j. regulární. Potom C.(C^T) je s. j. positivně definitní.

Clear[nahodnactvercovamatice];
nahodnactvercovamatice[n_]:=RandomReal[{0,1},{n,n}]

SeedRandom[131];
nahodnactvercovamatice[3].Transpose[nahodnactvercovamatice[3]]//MatrixForm

Překvapení? Není symetrická!

Vyzkoušíme, všechna vlastní čísla positivně definitivní matice musí kladná:

SeedRandom[131];
Eigenvalues[nahodnactvercovamatice[3].Transpose[nahodnactvercovamatice[3]]]

To je ovšem konstrukce obsahujici hrubou chybu!!! Matice nahodnactvercovamatice[3] se volá dvakrát, pokaždé je jiná: při druhém volání procedury generátor náhodných čísel startuje z pozice zanechané po prvním volání.

SeedRandom[131];Row[Map[MatrixForm,{nahodnactvercovamatice[3],"  ",nahodnactvercovamatice[3]}]]

Pro správné konstrukci použijeme lokalizační funkci With:

SeedRandom[131];Eigenvalues[With[{cc=nahodnactvercovamatice[3]},cc.Transpose[cc]]]

Celá procedura:

Clear[vytvorenipositivnedefinitnimatice];
(* Druhý argument je případně uživatelem zadané semínko generátoru náhodných čísel. Výstup procedury je seznam, jehož 1. složka je positivně definitní matice, 2. resp. 3. složka je maximální resp. minimální vlastní číslo a 5. složka je graf vlastních čísel na logaritmické stupnici (Scree plot). 4. složka je "nový řádek"!!! *)
vytvorenipositivnedefinitnimatice[n_Integer,randomseed_:131]:=Module[{pom},SeedRandom[randomseed];pom=nahodnactvercovamatice[n];{pom=pom.Transpose[pom],Max[pom=Eigenvalues[pom]],Min[pom],"\n",ListLogPlot[pom,Joined->True,PlotRange->All,PlotLabel->"Eigenvalues",PlotTheme->"Scientific"]}]

Příklady:

(* Matice řádu 3 *)
vytvorenipositivnedefinitnimatice[3,27377]

(* Pouze graf - zvaný Scree plot *)
vytvorenipositivnedefinitnimatice[3][[5]]

{{{0.7955834063394303`,0.8982141962838699`,0.49476421916135227`},{0.8982141962838699`,1.5407832672178028`,1.1587449406901282`},{0.49476421916135227`,1.1587449406901282`,1.0770497122552403`}},2.9624998067609716`,0.02864041045229203`,"\n",}

(* Matice řádu 50 *)
vytvorenipositivnedefinitnimatice[50][[5]]
Text@Row@{"Determinant pos. def. matice P, 50×50:   ",Det[vytvorenipositivnedefinitnimatice[50][[1]]]}
Text@Row@{"Vlastní čísla matice P, 50×50:   ",Eigenvalues[vytvorenipositivnedefinitnimatice[50][[1]]]}
Text@Row@{"Její maximální vlastní číslo  = ",vytvorenipositivnedefinitnimatice[50][[2]]}
Text@Row@{"|(PP^(-1))| = ",Det[(p=vytvorenipositivnedefinitnimatice[50][[1]]).Inverse[p]]}

Vytvoříme 100 matic výše uvedenou procedurou dimenzi 1×1, 2×2, ..., 99×99, 100×100 a otestujeme je na positivní definitnost pomoci zabudované funkce PositiveDefiniteMatrixQ. Zajimá nás, zda tímto testem projdou všechny matice, takže stačí použít funkci Union.

Map[PositiveDefiniteMatrixQ[vytvorenipositivnedefinitnimatice[#][[1]]]&,Range[100]]//Union//Timing
(* Nebo procedurálně: *)
Union[Table[PositiveSemidefiniteMatrixQ[vytvorenipositivnedefinitnimatice[i][[1]]],{i,100}]]//Timing

Total[Range[100]]

**Spektrální rozklad reálné symetrické matice

I když to není v návodu přímo napsáno, ze zkušenosti se zdá, že Eigenvalues (Subscript[λ, 1])≥(Subscript[λ, 2])≥...≥(Subscript[λ, n])≥0 symetrické positivně semidefinitní matice A (n×n) jsou setříděné sestupně podle velikosti a jim odpovídající vlastní vektory (Eigenvectors) (Subscript[x, 1]),...,(Subscript[x, n]) jsou ortonormální. Pak je odpovídající spektrální rozklad

A=(∑_(i=1)^n)(Subscript[λ, i])(Subscript[x, i])(Subscript[x, i]^T)=X,Λ,(X^T),

kde X=((Subscript[x, 1]),...,(Subscript[x, n])) je n×n matice ortonormálních vlastních vektorů a Λ=diag((Subscript[λ, i])) je diagonální matice s vlastními čísly na diagonále.

**Otestujeme na matici (5×5). Přitom užijeme užitečnou funkci Tuples pro vytvoření všech dvojic Eigenvectors:

Clear[a,b,c];
Tuples[{a,b,c},2]
Tuples[{a,b,c},3]

p5=vytvorenipositivnedefinitnimatice[5][[1]];
cisla5=Eigenvalues[p5];
vektory5=Eigenvectors[p5];

Oveříme, zda vlastní čísla jsou seřazena podle velikosti:

Sort[cisla5,GreaterEqual]
(* ekvivalentně *)
Sort[cisla5,(#1≥#2)&]

cisla5==Sort[cisla5,GreaterEqual]

Vlastní čísla jsou tedy seřazena podle velikosti.

Související vsuvka — Poznámka (Test, zda n-tice čísel je permutace):

SeedRandom[13]
nahodnapermutace=RandomSample[Range[10],10]
(* Test *)
Sort[nahodnapermutace]==Range[Length[nahodnapermutace]]
Sort[{6,4,1,11,10,2,5,3,8,7}]==Range[Length[{6,4,1,11,10,2,5,3,8,7}]]

Konec vsuvky

***BEGIN

(* Vytvoříme všechny dvojice vlastních vektorů *)
tup5=Tuples[vektory5,2];Text@Row@{"Počet dvojic:  ",Length[tup5]}
Text@Row@{"První dvě dvojice {(Subscript[x, 1]),(Subscript[x, 1])} a {(Subscript[x, 1,])(Subscript[x, 2])}:    ",tup5[[{1,2}]]//MatrixForm}

(* Všech 25 skalárních součinů (funkce Dot), funkce Chop "usekne" bezvýznamné číslice za desetinnou tečkou, funkce Partition s druhým parametrem 5 vytvoří z vektoru těchto součinů matici (5×5) *) 
Partition[Map[#[[1]].#[[2]]&,tup5],5]//MatrixForm
%//Chop//MatrixForm

Vidíme tedy, že vlastní vektory jsou ortonormální.

Vytvoříme spektrální rozklad a odečteme původní matici:

Transpose[vektory5].DiagonalMatrix[cisla5].vektory5-p5
%//Chop//MatrixForm

Až na zaokrouhlovací chyby souhlasí s naší hypotézou.

***Pro positivně semidefintní matice:
Symetrická odmocninová matice (symetrická matice (A^(1/2)) s vlastností A = (A^(1/2))(A^(1/2)))

***Buď ze spektrálního rozkladu nebo jednodušeji použitím zabudované funkce MatrixPower. Ta se také používá při výpočtu matic přechodu přes několik období. Spektrální rozklad A:

(A^(1/2))=(∑_(i=1)^n)(Sqrt[(Subscript[λ, i])])(Subscript[x, i])(Subscript[x, i]^T).

(* *** *)(Transpose[vektory5].DiagonalMatrix[(Sqrt[cisla5])].vektory5-MatrixPower[p5,(1/2)]//Chop)//MatrixForm

***END

Části seznamů

r11=Range[7]
Text@Row@{"Vezmi prvni dva:  ",Take[r11,2],"   Vynech poslednich pet:   ",Drop[r11,-5]}
Text@Row@{"Vezmi posledni dva:  ",Take[r11,-2],"   Vynech prvnich pet:   ",Drop[r11,5]}
Text@Row@{"Vezmi treti az paty prvek:  ",Take[r11,{3,5}],"   ekvivalentně:  ",r11[[3;;5]],"   (Pozor na syntaxi!)"}
(* Take pracuje s libovolnou hlavickou, nejenom s hlavickou List, jako i mnoho jinych funkci *)
Take[a+b+c+d+e+f,3]

Cvičení:

Take[(({{11, 12, 13, 14, 15}, {21, 22, 23, 24, 25}, {31, 32, 33, 34, 35}, {41, 42, 43, 44, 45}, {51, 52, 53, 54, 55}})),{2,4}]//MatrixForm

Take[(({{11, 12, 13, 14, 15}, {21, 22, 23, 24, 25}, {31, 32, 33, 34, 35}, {41, 42, 43, 44, 45}, {51, 52, 53, 54, 55}})),{2,4},{3,5}]//MatrixForm

Take[(({{11, 12, 13, 14, 15}, {21, 22, 23, 24, 25}, {31, 32, 33, 34, 35}, {41, 42, 43, 44, 45}, {51, 52, 53, 54, 55}})),{1,-1,2},{1,-1,2}]//MatrixForm

Cviceni: Prozkoumejte funkce Most, Rest, First, Last, ;; (Span)

;;

Viz Help k Take.

Finanční indikátory 1

Používají se při technické analýze (srovnej Fundamentální analýza) finančních instrumentů. Viz též např.:

Víšková, H.: Technická analýza akcií. HZ systém. Praha, 1997.

Úvod

Používáme data:

(* Pouze ceny, 2. sloupec ze surových dat *)applePricesLastThreeYears=FinancialData["AAPL",{{2018,11,15},{2021,11,15}},Method->"Legacy"];
DateListPlot[%,PlotLabel->"Prices Apple",PlotStyle->Thick]
applePricesLastThreeYears=applePricesLastThreeYears[[All,2]];

FinancialIndicator
FinancialIndicator[All]//Length

guide/FinancialVisualization

Hlavní použití je pro funkce

CandlestickChart
InteractiveTradingChart
TradingChart

FinancialIndicator[]

ExponentialMovingAverage

K pochopení jsou potřebné pojmy klouzavý průměr (Moving average, MA , funkce MovingAverage) a exponeciálně vážený klouzavý průměr (EWMA, EMA, funkce ExponentialMovingAverage). Jsou to charakteristiky časových řad, které slouží k vyhlazení (smoothing). Odkazy:

Cipra, T.:  Analýza časových řad s aplikacemi v ekonomii. SNTL, Praha a ALFA, Bratislava 1986

https://en.wikipedia.org/wiki/Moving_average

Obecná Ilustrace klouzavých průměrů (MA)

Remove[x]
ts=Array[(Subscript[x, #])&,8]

Obyčejný klouzavý průměr řádu (délky) 3, dále MA(3). Délka má v našem případě rozměr [den].

MovingAverage[ts,3]

Vážený klouzavý průměr řádu 3 s vahami 3/6, 2/6, 1/6

MovingAverage[ts,{3/6,2/6,1/6}]

Konkrétní Ilustrace MA

appleMA=ListLinePlot[{applePricesLastThreeYears,MovingAverage[applePricesLastThreeYears,12],MovingAverage[applePricesLastThreeYears,26]},PlotLegends->{"Data původní","MA(12)","MA(26)"},PlotStyle->Thick]

appleMA700=ListLinePlot[{applePricesLastThreeYears[[700;;]],MovingAverage[applePricesLastThreeYears[[700;;]],12],MovingAverage[applePricesLastThreeYears[[700;;]],26]},PlotLegends->{"Data původní","MA(12)","MA(26)"},PlotStyle->Thick]

Obecná Ilustrace EMA s parametrem zapomínání (vyhlazovacím parametrem) α

ExponentialMovingAverage[ts,α][[1;;4]]//Expand//Simplify//TraditionalForm

V praxi se volí parametr α tak, aby byl takzvaně srovnatelný (ve smyslu stejného průměrného počtu dnů) s obyčejným klouzavým průměrem; je-li N počet dnů, ze kterých se počítá klouzavý průměr, pak se volí α=2/(N+1). Při presentaci se uvádí právě N: EMA(N), a ne EMA(α).

{(∑_(k=0)^∞)k α(((1-α))^k),(1/iN)(∑_(k=0)^(iN-1))k}
((%/.α->2/(iN+1))//Simplify//TraditionalForm)/.iN->"N"

appleEMA=ListLinePlot[{applePricesLastThreeYears,ExponentialMovingAverage[applePricesLastThreeYears,2/(12+1)],ExponentialMovingAverage[applePricesLastThreeYears,2/(26+1)]},PlotLegends->{"Data původní","EMA(12)","EMA(26)"},PlotStyle->Thick]

appleEMA700=ListLinePlot[{applePricesLastThreeYears[[700;;]],ExponentialMovingAverage[applePricesLastThreeYears[[700;;]],2/(12+1)(*2/(3+1)*)],ExponentialMovingAverage[applePricesLastThreeYears[[700;;]],2/(26+1)]},PlotLegends->{"Data původní","EMA(12)","EMA(26)"},PlotStyle->Thick]

Porovnání MA a EMA:

GraphicsRow@{appleMA,appleEMA}

CandlestickChart (Svíčkový graf)

Použitím FinancialData ceny a OHLC:

{endDate=Today,startDay=Today-Quantity[3,"Month"]}
(* Konstrukce s Quantity viz Today Help. Možné mj. použít fci DayPlus.   *)
Row@{"Struktura souboru:\n ",(applePricesLastThreeMonths=FinancialData["APPL","OHLC",{startDay,endDate},Method->"Legacy"])[[1;;3]]}

CandlestickChart[applePricesLastThreeMonths,PlotLabel->"Apple prices from "<>ToString[startDay[[1]]]<>" to "<>ToString[endDate[[1]]]]

Detail posledních 15 dnů:

startDayMinus15=Today-Quantity[15,"Day"]
applePricesLast15days=FinancialData["APPL","OHLC",{startDayMinus15,endDate},Method->"Legacy"];
CandlestickChart[applePricesLast15days,PlotLabel->"Apple prices from "<>ToString[startDayMinus15[[1]]]<>" to "<>ToString[endDate[[1]]]]

CandlestickChart[applePricesLastThreeMonths,PlotLabel->"Apple prices from "<>ToString[startDay[[1]]]<>" to "<>ToString[endDate[[1]]]]

Co se zobrazuje?

Poslední tři měsíce jsou také nastaveny implicitně:

CandlestickChart["SP500"]

(* Pozor na syntaxi, závorky!!! *)
CandlestickChart[{"IBM",{startDay,endDate}}]

CandlestickChart[{"IBM",{{2021,10,14},{2021,10,25}}}]

InteractiveTradingChart 1

{startDay,endDate}

InteractiveTradingChart[{"IBM",{startDay,endDate}}]

InteractiveTradingChart

InteractiveTradingChart[{"GOOGL",{{2009,1,1},{2009,12,31}}}]

Konec 2021-11-26

2021-12-03 Lekce 9

FAQ

Predikce v časových řadách zde

Q1

A1

Finanční indikátory 2

InteractiveTradingChart 2

Definice MACD a obchodní strategie

https://en.wikipedia.org/wiki/MACD

paclet:ref/indicator/MovingAverageConvergenceDivergence

V Helpu je chyba: místo “15-period” v tomto odstavci má být “9-period”:

“Returns two time series. The first is the difference between 12- and 26-period exponential moving averages, and the second is a signal line represented as a 15-period exponential moving average of the first.”

Uvažuje se původní časová řada cen TS(0). Indikátor MACD sestává ze tří grafů

MACD čára (line):	TS(1)=EMA(TS(0),12)-EMA(TS(0),26)			
Signální čára:		TS(2)=EMA(TS(1),9)
MACD histogram:	TS(3)=MACD line minus Signal Line =TS(1)-TS(2)

TS(3) je ve formě histogramu. Připomeňme, že pro počet dnů N je vyhlazovací parametr α=(2/(N+1)).

Jedna z možných obchodních strategií využívající MACD je založená na protnutí TS(1) a TS(2). Tento okamžik vysílá obchodní signál:

TS(1) protne TS(2) zdola ⟶ nakup, (BUY signal)
TS(1) protne TS(2) shora ⟶ prodej, (SELL signal)

TradingChart[{"MSFT",{{2021,9,1},{2021,11,30}}},{"MACD"}]

(pricesMSFT202109001to21211130=FinancialData["MSFT",{{2021,9,1},{2021,11,30}},Method->"Legacy"])//Length
DateListPlot[pricesMSFT202109001to21211130]

pricesMSFT202109001to21211130MA=MovingAverage[pricesMSFT202109001to21211130[[All,2]],3]
%//Length
%%//ListLinePlot

pricesMSFT202109001to21211130EWMA=ExponentialMovingAverage[pricesMSFT202109001to21211130[[All,2]],(2/(3+1))]
%//Length
%%//ListLinePlot

xx=Array[x,10]
MovingAverage[xx,5]
%//Length
ExponentialMovingAverage[xx,(2/(3+1))]//Simplify
%//Length

*Seznamy: Řetězce

Vybrané funkce (základní operace, převody řetězec ⟷ výraz)

Row@{Hyperlink[Button["Přehled zacházení se řetězci"],"paclet:tutorial/StringsAndCharactersOverview"],Spacer[10],Hyperlink[Button["Zacházení se řetězci"],"paclet:tutorial/OperationsOnStrings"],Spacer[10],Hyperlink[Button["Znaky v řetězcích"],"paclet:tutorial/CharactersInStrings"]}

Základní zabudované funkce pracující primárně se řetězci jsou analogické funkcím s ostatními objekty, mají však předponu String (např. Join ⟷ StringJoin). Po odklepnutí funkce v tabulce po provedení následujícího příkazu dostaneme stručnou nápovědu, po stisknutí “≫” na konci této nápovědy se dostaneme na Help

?String*

Jsou však také další funkce vztahující se k práci se řetězci a se znaky.

?*String*

?*Character*

Výběr často užívaných funkcí, jsou vyznačeny žlutým pozadím (Background v Menu Format)  (všímejte si též běžně užívaných zkratek: “<>”, “ “

s1=StringJoin["Toto" ," ","jsou" ," retezce","."]
StringJoin["Toto jsou"," retezce","."]
(* alternativne *)
"Toto"<>" "<>"jsou"<>" retezce"<>"."//FullForm

Jednotlive znaky a  znovu dohromady:

(ch1=Characters[s1])//FullForm
StringJoin[ch1]//FullForm
{StringLength[StringJoin[ch1]],Length[StringJoin[ch1]]}

Tally[ch1] (* Zjistí četnosti znaků v seznamu ch1, rozlišuje velká a malá písmena *)
(* _____________________*)
Tally[ToLowerCase[ch1]](* Tentokrát nerozlišuje velká a malá písmena *)

StringReverse[{"ALENA","ROMA"}]

Připomínka Reverse:

Reverse[{a,b,c}]
Reverse[Range[7]]
(Reverse[{{a,b},{c,d}}])//MatrixForm

Jak dostat {{b,a},{d,c}}?

{Map[Reverse,{{a,b},{c,d}}]//MatrixForm,
(* nebo *)
Reverse[{{a,b},{c,d}},2]//MatrixForm}

Téhož výsledku dosáhneme

Transpose[{{a,b},{c,d}}]//Reverse//Transpose//MatrixForm

Velmi důležité:
Převody: výrazy ⟷ řetězce, expressions ⟷ strings, ToString ⟷ ToExpression

Využívá se hlavně při importu externích souborů z jiných aplikací. Převést na řetězec je možné téměř cokoli, převést na výraz (expression) je možné jen něco. Do systému Mathematica převádíme obvykle objekty, které neumíme v původní aplikaci zpracovat. Výpočty se provedou v systému Mathematica a exportují se ve formátu původní aplikace.

{"4+2",ToExpression[{"Haf",2^3,"4+2","    4    + 2  "}]//FullForm}

*** Výraz z TeXu. Někdy vyžaduje manuální úpravy

ToExpression["\\sum_{t=0}^T \\frac{{CF}_t}{(1+i)^t}= 
        \\sum_{t=0}^T {CF}_t v^t =
        \\sum_{t=0}^T {CF}_te^{-\\delta t}",TeXForm]
%//TeXForm

Převést na výraz (expression) je možné jen něco.

{charrange4=CharacterRange["1","4"],Total[charrange4],Total[ToExpression[charrange4]]}

Konstrukce seznamů

!!!NestList, FoldList, Range, Table, Array

NestList[f,x,5]

Potřebujeme-li jen poslední:

Nest[f,x,5]

Podobně

FoldList[f,x,{a,b,c,d,e}]

Fold[f,x,{a,b,c,d,e}]

Příklad (částečné součty, funkce vhodná pro generovaní náhodné procházky)

(* Vysvětlení *)
Remove[xx,x]
xx[n_]:=Array[(Subscript[x, #])&,n]
{xx[5],(* ekvivalentně *)Table[(Subscript[x, i]),{i,5}]}

FoldList[Plus,0,xx[5]]
(* alternativně, pozor vynechává počáteční hodnotu, zde 0! *)
Accumulate[xx[5]]
FoldList[Times,1,xx[5]]

Příklad

Několik možností, jak vytvořit posloupnost prvních 6 mocnin čísla 2 (včetně nulté):

(* procedurálně *)
Table[(2^i),{i,0,5}]

NestList[Function[x,2x],1,5]
(* ekvivalentní s: *)
NestList[2*#&,1,5] 
(2^(Range[6]-1))
(* *** *)Array[(2^(#-1))&,6]
(* *** *)Normal[SparseArray[{i_->2^(i-1)},6]]

**Select a TakeWhile

Select[{1,3,7,4,10,2},#<5&]

TakeWhile[{1,3,7,4,10,2},#<5&]

!Příklad na postupná maxima (rekordy)

Clear[f,x,a,b,c,d];
FoldList[f,x,{a,b,c,d}]
FoldList[Plus,0,{a,b,c,d}]
FoldList[Times,1,{a,b,c,d}]

r6=FoldList[Max,{5,3,6,3,2,77,4,88}]

tj. Max[0], Max[Max[0],5], Max[Max[Max[0,5],3],...

(* rekordy *)
Union[r6]
ListLinePlot[{seznam,r6},AxesLabel->{"time","value"},PlotStyle->Thick,PlotTheme->"Business"]

Cviceni: Kdy rekordy nastaly? (Vystup: dvojice {cas, rekord})

Clear[rekordy];
rekordy[x_?VectorQ]:=Union[FoldList[Max,x]]
rekordy[{5,3,6,3,2,77,4,88}]
rekordy[-{5,3,6,3,2,77,4,88}]

Rozdíl mezi NestList a FoldList

NestList nemůže pracovat se souborem např. {a,b,c,d,e}. Přibližná charakteristika:

Nest, NestList: (Subscript[a, n+1])=f((Subscript[a, n])).

Fold, FoldList: (Subscript[a, n+1])=f((Subscript[a, n]),(Subscript[b, n])),  (Subscript[b, n]) vezme ze seznamu.

Modelování (simulace, metody Monte Carlo)

Náhodný výběr

X referenční náhodná veličina na prostoru (Ω,𝒜,P), náhodný výběr tvoří ((Subscript[X, 1]),...,(Subscript[X, n])) nezávislé stejně náhodné veličiny (iid) s rozdělením jako má X. Příroda “vygeneruje” ω∈Ω a my pozorujeme konkrétní hodnoty (čísla) ((Subscript[X, 1])(ω),...,(Subscript[X, n])(ω)).

Náhodný (stochastický) proces

Náhodný proces je množina náhodných veličin {(Subscript[X, t]),t∈T} indexovaných indexovou množinou T na stejném pravděpodobnostním prostoru (Ω,𝒜). V případě T={0,1,...} se často hovoří o časové řadě, v případě T={t≥0} o spojitém stochastickém procesu. Pro pevné ω∈Ω je (Subscript[X, t])(ω), jakožto funkce proměnné t reálná funkce proměnné t a nazývá se trajektorie. Pozor, náhodná veličina není reálná funkce přestože nabývá reálných hodnot.

Příklad: Modelování ceny akcie pomocí náhodné procházky

Simulace trajektorie ceny akcie v čase: Počáteční cena s0, maximální možná změna v následující periodě ±5% ( = 1/20 ) počáteční ceny. Následující definice jsou ekvivalentní:

Clear[cena,cenanest,cenanest2];
cena[s0_?NumericQ,delka_?IntegerQ]:=FoldList[Plus,s0,RandomReal[{-s0/20,s0/20},delka]]
cenanest[s0_,delka_]:=NestList[#+RandomReal[{-s0/20,s0/20}]&,s0,delka]
cenanest2[s0_,delka_]:=NestList[Function[x,x+RandomReal[{-s0/20,s0/20}]],s0,delka]

SeedRandom[131313];
cena[100,10]
SeedRandom[131313];
cenanest[100,10]
SeedRandom[131313];
cenanest2[100,10]
SeedRandom[131313];
ListPlot[cenanest[100,250],PlotTheme->"Scientific",Joined->True]

Cvičení. Pro stejný účel použijte funkci Accumulate.

Příklad (generováni 50 trajektorií vývoje ceny akcie délky 1000)

Jedna se vlastne o 50 scenaru, realizace nahodneho procesu pro 50 ruznych ω: (Subscript[ω, 1]),...,(Subscript[ω, 50]).  Vsimnete si, ze “Table” se vztahuje k poctu trajektorii!!!

SeedRandom[131313];
ListPlot[tab100=Table[cena[100,1000],{50}],Joined->True,PlotRange->All]
Dimensions[tab100]

Ceny v case 500 a jejich charakteristiky (řez v čase 500 v předchozím grafu):

ceny500=tab100[[All,500]];
Text@Row@{"Počet trajektorií = ",Length[ceny500],"  Min =  ",Min[ceny500],"  Max =  ",Max[ceny500],"  Prumer =  ",Mean[ceny500],"  Median =  ",Median[ceny500],"\nSmerodatna odchylka =  ",StandardDeviation[ceny500],"\nŠikmost = ",Skewness[ceny500],"  Špičatost = ",Kurtosis[ceny500]}
GraphicsRow@{Histogram[ceny500,8],SmoothHistogram[ceny500]}

{Mean[unidistr=UniformDistribution[{0,1}]],Variance[unidistr]}

{Mean[unif1=UniformDistribution[{-s0/20,s0/20}]],Variance[unif1],StandardDeviation[unif1]}
%/.s0->100.

3(Sqrt[500.])

Připomenutí
Ilustrace, jak funguje CLV (centralni limitni veta). Delka rady 100, pocet rad 1000, rozdeleni hodnoty (Subscript[S, 100])=(Subscript[S, 0])+(∑_(n=1)^100)(Subscript[U, n]), kde (Subscript[U, n]) jsou nezavisle stejne rozdelene nahodne veliciny s rozdelenim R(-(Subscript[S, 0])/20,(Subscript[S, 0])/20).

CLV:

Necht (Subscript[U, 1]),(Subscript[U, 2]),... je posloupnost nezavislych stejne rozdelenych nahodnych velicin (iid) s konecnym nenulovym rozptylem (σ^2) a stredni hodnotou μ. Potom pro N ⟶ ∞

(((∑_(n=1)^N)(Subscript[U, n])-N μ)/(σ(Sqrt[N])))

konverguje v distribuci k N(0,1).

Konvergence je pomerne rychla.

Příklad 1

\[Distributed] se dostane jako EscdistEsc

Clear[productDistributionOfUniforms]
productDistributionOfUniforms[n_]:=ProductDistribution[{UniformDistribution[],n}]
sumOf2Uniforms=TransformedDistribution[X1+X2,{X1,X2}\[Distributed]productDistributionOfUniforms[2]]
sumOf3Uniforms=TransformedDistribution[X1+X2+X3,{X1,X2,X3}\[Distributed]productDistributionOfUniforms[3]]

Plot[{Table[PDF[UniformSumDistribution[n,{-1/2,1/2}],x],{n,{1,2,4,12}}],PDF[NormalDistribution[],x]}//Flatten//Evaluate,{x,-5,5},PlotRange->All,Exclusions->None,Filling->Axis]

Rozdíl mezi hustotami (Subscript[U, 1])+...+(Subscript[U, 12]) a N(0,1):

Plot[PDF[UniformSumDistribution[12,{-1/2,1/2}],x]-PDF[NormalDistribution[],x],{x,-7,7},PlotRange->All]

{Probability[Abs[X]>6,X\[Distributed]UniformSumDistribution[12,{-1/2,1/2}]],
Probability[Abs[X]>6.,X\[Distributed]NormalDistribution[]]}

Konec Příklad 1

Cvičení. Příklad 3 (Erlangovo rozdělení, n∈ℕ)

(Subscript[X, n])\[Distributed]ErlangDistribution[n,1] ⇒ (Subscript[X, n ])is the sum of n iid ExponentialDostribution[1].

Clear[n]
{PDF[ErlangDistribution[n,1],x],PDF[GammaDistribution[n,1],x]}
PDF[ErlangDistribution[n,1],x]==PDF[GammaDistribution[n,1],x]

Clear[n]
{Mean[ErlangDistribution[n,1]],Variance[ErlangDistribution[n,1]]}

standardizedErlang[n_]:=TransformedDistribution[((X-n)/(Sqrt[n])),X\[Distributed]ErlangDistribution[n,1]]
{Mean[standardizedErlang[n]],Variance[standardizedErlang[n]],Skewness[standardizedErlang[n]],Kurtosis[standardizedErlang[n]]}

Clear[x]
PDF[standardizedErlang[n],x]
Limit[PDF[standardizedErlang[n],x],n->∞]

Plot[{Table[PDF[standardizedErlang[n],x],{n,{1,2,4,12}}],PDF[NormalDistribution[],x]}//Flatten//Evaluate,{x,-6,6},PlotLegends->Automatic]

Konec Příklad 3

SeedRandom[131313];tab1000=Table[cena[100,1000],{1000}];
poslednihodnoty=Map[Last,tab1000];
Through[{Mean,StandardDeviation}[UniformDistribution[{-1/20,1/20}]]]
Show[Histogram[poslednihodnoty,Automatic,"PDF"],Plot[PDF[NormalDistribution[100,(Sqrt[1000  (25/3)])],x],{x,-200,400},PlotStyle->{Thick,Red}]]

ListPlot[tab1000]

Test dobré shody s normálním rozdělením (DistributionFitTest)

ℋposlednihodnoty=DistributionFitTest[poslednihodnoty,Automatic,"HypothesisTestData"]

ℋposlednihodnoty["Properties"]

(* Odhadnuté rozdělení *)
ℋposlednihodnoty["FittedDistribution"]

Row@{"p - hodnota = ",ℋposlednihodnoty["KolmogorovSmirnov"]}

Tato hodnota není významná na hladině významnosti 5%, takže hypotézu o shodě s normálním rozdělením na této hladině nemůžeme zamítnout.

(* Všechny testy *)
ℋposlednihodnoty["TestDataTable",All]

Show[Histogram[poslednihodnoty,Automatic,"ProbabilityDensity"],Plot[PDF[ℋposlednihodnoty["FittedDistribution"],x],{x,-200,400},PlotStyle->{Thick,Red}]]

***Cviceni. Ve vyse uvedenem priklade jsme pouzili maximalni rust  resp. minimalni pokles o 5 %. Vytvorte proceduru, kde dalsim parametrem bude _procento znamenajici  maximalni rust  resp. minimalni pokles.

***Příklad (Pokračování): Růst nebo pokles z předchozí (a ne počáteční) ceny

Drive

cenanest[s0_,delka_]:=NestList[#+RandomReal[{-s0/20,s0/20}]&,s0,delka]

a nyni

Clear[cenanestdynamicky];
cenanestdynamicky[s0_,delka_]:=NestList[#+RandomReal[{-#/20,#/20}]&,s0,delka]

SeedRandom[131313];
ListPlot[Table[cenanestdynamicky[100,1000],{10}],Joined->True,PlotRange->{0,300},PlotLabel->"Nyní"]
(* Porovnani s puvodnim vyse uvedenym vyvojem *)
SeedRandom[131313];
ListPlot[Table[cena[100,1000],{10}],Joined->True,PlotRange->{0,300},PlotLabel->"Dříve"]

**Sparse arrays (Řídká pole)

**Sparse arrays (Řídká pole, matice)

Často se řesi problémy, ve kterých vystupují matice velkých rozměrů, ale s relativně málo nenulovými prvky (řídké matice). Zde jsou reprezentovány objektem SparseArray. Zabírají méně paměti a pro zacházení s nimi jsou vyvinuty speciální algoritmy.

sa1=SparseArray[{3->x,4->y},15]
%//Dimensions

“Zviditelnění”:

Normal[sa1]
ArrayPlot[{sa1//Normal}]

Počítat můžeme normálně:

sa1.sa1
sa1*sa1
%//Normal

{Head[sa1],Head[Normal[sa1]]}

SparseArray[{i_->(i^2)},5]//Normal

SparseArray[{2->a,5->b}]//Normal

SparseArray[{{1,2}->a,{3,2}->b,{3,3}->c}]//MatrixForm

(* *** *)
(tab1=Table[{i,j},{i,4},{j,i}])//Length
tab1
Flatten[tab1,1]
(sparseArray1=SparseArray[(indexy1=Flatten[tab1,1])->Range[Length[indexy1]]]//Normal)//MatrixForm
ArrayPlot[sparseArray1]

**Sparse arrays: pásy, bands

Band znamená pás. Z příkladů je zřejmé, jak se zabudovaná ffunkce Band používá. V maticích Band[{m,n}] znamená pozice s indexy (m,n),(m+1,n+1),....

SparseArray[{Band[{1,1}]->x,Band[{2,1}]->y,Band[{1,2}]->z},{5,5}]//MatrixForm

SparseArray[{i_,i_}->1,{4,4}]//MatrixForm
(* Totéž dostaneme IdentityMatrix[4] *)

***To, co už je zadáno se nepřepíše. Záleží tedy na pořadí zadávání lokálních pravidel (substitucí). Zde: na diagonále 1, ve 3. sloupci a, na 2. řádku b.

{SparseArray[{{i_,i_}->1,{_,3}->a,{2,_}->b},{4,4}]//MatrixForm,
SparseArray[{{_,3}->a,{2,_}->b,{i_,i_}->1},{4,4}]//MatrixForm}

Ukázka okamžité aplikace lokálního pravidla -> (substituce) a odložené :->

SeedRandom[13];SparseArray[{i_,i_}->RandomReal[],{4,4}]//MatrixForm
SeedRandom[13];
SparseArray[{i_,i_}:> RandomReal[],{4,4}]//MatrixForm

(* Vektor, ktery bude mit na sudych pozicich p a na ostatnich druhou mocninu *)
SparseArray[{_?EvenQ->p,i_-> (i^2)},{15}]//Normal
(* Alternativne *)
SparseArray[{i_/;EvenQ[i]->p,i_-> (i^2)},{15}]//Normal

(* V obracenem poradi se druhe pravidlo vubec neaplikuje, protoze vsechny pozice jsou obsazeny: *)
SparseArray[{i_-> (i^2),_?EvenQ->p},{15}]//Normal

(* Matice 4×4, pozor, zde je "nebo" vyjadreno jako jedna kolma cara "|", zatimco logicke nebo jsou dve kolme cary "||". *)
(* V prvnim nebo tretim radku a ve druhem nebo ctvrtem sloupci a *)
(* V 1. nebo 3. radku a 2. nebo 4. sloupci dosad a 
*)
SparseArray[{1|3,2|4}->a,{4,4}]//MatrixForm
SparseArray[{1|3,2|4}->a,{4,4}]//ArrayPlot

Map[(3<#<7)&,Range[10]]
Map[Function[x,3<x<7],Range[10]]

(* Ekvivalentni zapisy *)
Clear[p]
SparseArray[_?((3<#<7)&)->p,{10}]//Normal
SparseArray[i_/;3<i<7->p,{10}]//Normal

**Další příklady bez komentáře (za cvičení)

Clear[aasparse]
aasparse[n_]:=SparseArray[{i_,j_}/;Abs[i-j]==1->i+j,{n,n}]//MatrixForm
aasparse[5]

SparseArray[{i_,j_}/;Abs[i-j]<2->i+j,{5,5}]//MatrixForm

SparseArray[{Band[{1,1}]->2Range[5],Band[{1,2}]->2Range[4]+1,Band[{2,1}]->2Range[4]+1}]//MatrixForm

***Nepredvidatelny vysledek:

(sprec=SparseArray[{Band[{1,1}]->2Range[5],Band[{1,2}]->2Range[4]+1,Band[{2,1}]->2Range[10]+1}])//MatrixForm
Dimensions[sprec]

(sprec=SparseArray[{Band[{1,1}]->2Range[5],Band[{1,2}]->2Range[4]+1,Band[{2,1}]->2Range[10]+1},{10,10}])//MatrixForm
Dimensions[sprec]

Nespecifikovana pole jsou misto nul nahrazeny karetnimi symboly

SparseArray[{i_,j_}/;Abs[i-j]<2->i+j,{5,5},♡♢♣♠]//MatrixForm

***Sparse arrays (Priklad, porovnani se standardnim Array, Table, ...) Nepovinné,  ale jinak užitečné cvičení

Clear[aasparse];
aasparse[n_]:=SparseArray[{i_,j_}/;Abs[i-j]==1->i+j,{n,n}]

aasparse[5]//MatrixForm

aa=Array[0&,{5,5}];
(* dve ekvivalentni vyjadreni *)
{ReplacePart[aa,{i_,j_}:> i+j/;Abs[i-j]==1]//MatrixForm,
ReplacePart[aa,{i_,j_}/;Abs[i-j]==1->i+j]//MatrixForm}

Clear[aastandard]
aastandard[n_]:=Module[{aux},
aux=Array[0&,{n,n}];
ReplacePart[aux,{i_,j_}/;Abs[i-j]==1->i+j]
					  ]

aastandard[5]//MatrixForm

{ByteCount[0],ByteCount[0.],ByteCount[2.],ByteCount[2.`50]}

{Timing[aasparse1000=aasparse[1000];],Timing[aastandard1000=aastandard[1000];]}
{ByteCount[aasparse1000],ByteCount[aastandard1000]}

aasparse500=aasparse[500];
aastandard500=aastandard[500];{Timing[invsparse500=Inverse[aasparse500];],Timing[invstandard500=Inverse[aastandard500];]}

{ByteCount[invsparse500],ByteCount[invstandard500]}

Duvod: obe matice jsou identicke

Take[invsparse500,10,10]//MatrixForm

Take[invsparse500,10,10]-Take[invstandard500,10,10]//MatrixForm

Map[Abs,{{1,2},{I+1,-4}}//Flatten]

Max[Map[Abs,(invsparse500-invstandard500)//Flatten]]

Cviceni: Provedte tez srovnani pro numericke verze matic.

Seznamy: Různé

Přidávání, odstraňování a modifikování seznamu

Prepend[m={a,b,c},aa]
Append[m,aa]
AppendTo[m,aa]
m
AppendTo[m,aa]

**Následující Riffle je míchaní (karet). Neplést s Rifle.

Clear[a,b,c,x,y,z]
Riffle[m={a,b,c},x]
Riffle[m={a,b,c},{x,y,z}]

{ReplacePart[m,2->x],m,m[[2]]=xx;m}
mat🐺=ReplacePart[mat={{a,b,c},{d,e,f}},{1,2}->🐺]

mat🐺[[2]]=🐺🐺🐺
mat🐺

(mat={{a,b,c},{d,e,f}})//MatrixForm
mat[[All,1]]={x,y};
mat//MatrixForm

Kombinace seznamů

Argumentem Join musí být seznamy:

Join[{a,b,c},{x,y},{t,u},{b,a,c},{a}]
Join[{a,b,c},{x,y},{t,u},{{b,a},c},{a}]

Chyba:

Join[{a,b,c},{x,y},{t,u},{b,c},a]

Union, Duplicates

(* Pozor na rozdílné výstupy: Union třídí, DeleteDuplicates ne. *)
Union[{a,b,c},{x,y},{t,u},{b,c},{a}]
DeleteDuplicates[{{a,b,c},{x,y},{t,u},{b,c},{a}}//Flatten]
%//Sort

Dělení a vyplňování seznamů

Clear[a, b, c, d, e, f, g, h, x]; 
Partition[{a, b, c, d, e, f, g}, 3]
Partition[{a, b, c, d, e, f, g, h}, 3]

!!!Dělení s překrytím (offset)

MatrixForm[Partition[{a, b, c, d, e, 
    f, g}, 3, 1]]

*** BEGIN Nepovinné

Partition[{a, b, c, d, e, f, g}, 3, 3, 
  1]
Partition[{a, b, c, d, e, f, g}, 3, 3, 
  1, x]
Partition[{a, b, c, d, e, f, g}, 3, 3, 
  1, {x, y, z, v, w}]
Partition[{a, b, c, d, e, f, g}, 3, 1, 
  {1, 1}, x]

***Viz tez PadLeft a pribuzne funkce.

*** END Nepovinné

Konec 2021-12-03

2021-12-10 Lekce 10

FAQ

Q1

A1

Associations (Asociovaná též asociativní pole) 1

guide/Associations

Along with lists, associations are fundamental constructs in the Wolfram Language . They associate keys with values, allowing highly efficient lookup and updating, even with millions of elements . Associations provide generalizations of symbolically indexed lists, associative arrays, dictionaries, hashmaps, structs, and a variety of other powerful data structures .

https://reference.wolfram.com/language/guide/Associations.html

Úvod

Clear[a,b,c,v,w,x,xx,y,yy,z];

Asociativní pole je pole, jehož prvky nejsou indexovány pomocí posloupnosti celých čísel, ale pomocí klíčů. Klíčem může být číslo, textový řetězec (nejčastěji), symbol a jiné. Význam asociativního pole spočívá v jednodušším zápisu programu, při kterém odpadají konstrukce pro vyhledávání prvku v poli. Viz též hash.

Obrovskou výhodou je přehlednost. Vidíme, co z pole vytahujeme, na rozdíl od číselného indexu, který nám mnohdy nic neříká. Díky vnitřní reprezentaci (hashing) je také vyhledávání podstatně rychlejší. Každé číselně indexované pole lze zapsat jako pole asociativní.

V asociaci se klíči přiřazuje hodnota. Klíčem může být prakticky cokoli (je vhodné ale klíče volit uvážlivě), hodnotou může být cokoli.

Clear[a,b,c,x,y,z]
(* a je klíč, x je hodnota *)
asociace0=Association[{a->x,b->y,c->z}]
(* ekvivalentní zápis: *)
\[LeftAssociation]a->x,b->y,c->z\[RightAssociation]

Ukázky

(Zde pozor na rozdíl mezi symbolem a a řetězcem “a”. Pozdější asociace se stejným klíčem nahrazuje předchozí. To platí i pro většinu dalších operací s asociacemi.)

asociace1=\[LeftAssociation]a->x,"a"->{xx,yy},b->{y,v,33},c->z,a->w\[RightAssociation]
%//FullForm

{a+a,a+"a","a"+"a"}

Převod asociace na seznam lokálních pravidel:

rules1=asociace1//Normal

Převod seznamu lokálních pravidel na asociaci:

Association[{a->w,"a"->{xx,yy},b->{y,v,33},c->z}]

Keys[asociace1]
Keys[asociace1]//FullForm

Values[asociace1]

Výběr částí asociací (hodnoty pod klíčem b)

{asociace1[b] ,(* ekvivalentně (jenže to ztrácí význam asociací) *)asociace1[[3]]}

asociace1[b][[2]]

Není možné:

asociace1[[b,2]]

Ale pokud je klíčem řetězec (String), pak to možné je:

asociace1[["a",2]]

Ale většinou použijeme konstrukci

asociace1["a"][[2]]

Ve všech případech pozor na závorkování: [ ] a [[ ]] !!!
Funkcí aplikované na asociace jsou většinou transparentní, “průhledné”: funkce se aplikuje na hodnotu a ne na klíč!

asociace0
{Total[asociace0],Sin[asociace0]}

asociace1
{Total[asociace1],Sin[asociace1]}

Vybrané funkce s vybranými aplikacemi

AssociationMap

?*Assoc*

AssociationMap[f,{a,b,c,d,e}]
(am1=AssociationMap[ToString,{a,b,c,d,e,f,g,h}])//FullForm
am1//Values//FullForm

Následující příkaz provede výměnu klíče ⟷ hodnoty:

AssociationMap[Reverse,am1]
Keys[%]//FullForm
Values[%%]//FullForm

**AssociateTo

AssociateTo[a, klíč->hodnota] změní asociaci a přidáním dvojice klíč-hodnota. V případě, že klíč již existuje, pak změní hodnotu.

Poznamenejme, že všechny funkce končící na “To” jsou nebezpečné: mění první argument!!! Týká se funkcí jako PrependTo, AppendTo, .... Týká se to i jiných funkcí, např. později níže uvedené KeyDropFrom

asociace1

asociace2=asociace1
(* nový klíč *)AssociateTo[asociace2,novýKlíč->w]
asociace2

asociace2=asociace1
(* existující klíč b; hodnota je  nahrazena novou hodnotou *)
AssociateTo[asociace2,b->"NováHodnota"]
asociace2

AssociationThread

Mj. použití v případě, že máme zvlášť pole klíčů a pole hodnot.

klice=CharacterRange["h","z"];
hodnoty=Prime[Range[Length[klice]]]
asociace3= AssociationThread[klice->hodnoty]
asociace3["u"]

(* Alternativně *)
Thread[klice->hodnoty]//Association

*Merge (v obecnosti obtížné, pozornost věnovat následujícím příkladům)

Prosté spojení

Merge[{<|a->1,b->2|>,<|a->5,b->10,c->15|>},Identity]

***Totéž použitím Flatten:

(* *** *) 
Merge[{<|a->1,b->2|>,<|a->5,b->10,c->15|>},Flatten]

(* *** *) 
Merge[{asociace1,asociace2},Identity]
(* ale pozor *)
Merge[{asociace1,asociace2},Flatten]

(* *** *) 
Merge[{<|a->1,b->2|>,<|a->5,b->10|>,<|c->6,d->"puvodniHodnota"|>},Identity]

Ke stejným klíčům přidává případné nové hodnoty

Merge[{<|a->1,b->2|>,<|a->5,b->10|>,<|c->6,d->"puvodniHodnota"|>,<|d->"NováHodnota"|>},Identity]

(* *** *)
asociaceMerge1=Merge[{<|a->1,b->2|>,<|a->5,b->10|>},f]
(%/.f->Identity)//Simplify
%//Values

**Cvičení

Merge[{<|a->1,b->2|>,<|a->5,b->10|>},Total]
Merge[{<|a->1,b->2|>,<|a->5,b->10|>},Identity]
%//Total

Poznamenejme, že Total aplikováno na matice sčítá po řádcích:

Total[(({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}))]

KeyDropFrom

Clear[a,b,c,v,w,x,xx,y,yy,z];
asociace0=Association[{a->x,b->y,c->z}]
asociace1=\[LeftAssociation]a->x,"a"->{xx,yy},b->{y,v,33},c->z,a->w\[RightAssociation]

?*Drop*

Odstraňuje element z asociace podle klíče. Užitečná operace vyžadující jisté opatrnosti. Přepisuje!!!

asociace6=asociace1
Row@{"Odstraní položku s klíčem b:  ",KeyDropFrom[asociace6,b]}
Row@{"Vznikne asociace:  ",asociace6}
(* odstranění nějakého elementu v hodnotě asociace *)
Row@{"V položce s klíčem a odstraníme hodnotu yy:  ",asociace6["a"]=DeleteCases[asociace6["a"],yy]}
Row@{"Výsledná asociace je:  ",asociace6}

(* Jinak *)
DeleteCases[asociace1,yy,Infinity]
(* Ale pozor: to odstraní yy ze všech hodnot příslušné asociace!!! *)

Příklad

SeedRandom[131];
(* jména osob  *)cRan=CharacterRange["a","z"];
(* jména osob a jejich stáří *)asociace7=AssociationThread[cRan-> Table[RandomInteger[{20,90}],Length[cRan]]]
(* Vyřaď všechny starší 50 let *)
DeleteCases[asociace7,_?(#>50&),Infinity]

SeedRandom[131];
(* Nyní cRan je identifikátor dvojice manželů a hodnota je dvojice označující věky manželů *)
asociace8=AssociationThread[cRan-> Table[{RandomInteger[{20,90}],RandomInteger[{20,90}]},Length[cRan]]]
(* V dvoučlenných seznamech vyřadíme všechny položky větší než 50. U DeleteCases nutné zadat třetí argument, tj. úroveň do které se mají položky vymazat. Stačila by sice hodnota 2, ale Infinity nic nezkazí. *)
DeleteCases[asociace8,_?(#>50&),∞]
(* Ještě odstraníme prázdné seznam: *)
DeleteCases[%,{}]

KeyMap

KeyMap[f, <|a->1,b->2,c->3|>]

Užitečné např. v případě, že jsme “líní” neustále psát uvozovky. Ze symbolů vytvoříme řetězce a pak zpětně symboly:

KeyMap[ToString,<|a->1,b->2,c->3|>]
%//FullForm
KeyMap[ToExpression,%%]//FullForm

PositionIndex

PositionIndex[{c,a,b,b,a,a,b,c,a,c,b,a,a}]

?Position*

Příklad (hodnotou může být cokoli)

Clear[grafSin,grafSinxSquared,tableOfTheFirst50Primes]
(* dosud to jsou symboly *)
(* změna na řetězce *)
(klicePriklad=Map[ToString,{grafSin,grafSinxSquared,tableOfTheFirst50Primes}])//FullForm

hodnotyPriklad={Plot[Sin[x],{x,0,3π}],Plot[Sin[(x^2)],{x,0,3π},PlotTheme->"Detailed",PlotStyle->Thick],Table[{n,Prime[n]},{n,50}]//TableForm};

asociacePriklad=AssociationThread[klicePriklad,hodnotyPriklad];

asociacePriklad["grafSinxSquared"]

!!!Porovnání rychlostí (“výkonostní porovnání”)
Důležité, obsahuje užitečné obraty a konstrukce.

Podrobnosti viz

Zdeněk Buk
zdenek.buk@fit.cvut.cz
Katedra teoretické informatiky, FIT, ČVUT

http://www.mathematica.cz/download/doc/2014/setkani/Buk-2014-Mathematica10Novinky.zip

Úloha: Dány jedenáctirozměrné vektory (záznamy) ve tvaru {identifikátor, číslo1, ..., číslo10}, konkrétně třeba {“id-52”,8,9,5,1,4,7,2,6,3,10}. Z této množiny vektorů  vybrat podmnožinu s předem zadanými identifikátory.

Seznam (List)

Připomenutí

(* Permutace, využití funkce RandomSample *)
(* a,b,c,d mohou být libovolné objekty *)
Clear[a,b,c,d]
{SeedRandom[13];RandomSample[{a,b,c,d},4],(* ekvivalentně *)
SeedRandom[13];RandomSample[{a,b,c,d}]}

(* Vytvoření identifikátorů id-1, ..., id-100 *)
Table[id="id-"<>ToString[i],
{i,1,100}]//Short

Nejprve ukázka na 10 záznamech:

(i10Records=With[{n=10},SeedRandom[13];
Table[Join[{"id-"<>ToString[i]},RandomInteger[{1,10},{10}]],{i,n}]])//MatrixForm

Nyní náhodná permutace těchto 10 záznamů:

(*  náhodná permutace řádků výše uvedené matice, tj. řádků typu: *)
(* {"id-52",8,9,5,1,4,7,2,6,3,10} *)
SeedRandom[13];RandomSample[i10Records]

Clear[n]
n=10; 
SeedRandom[13];(*  náhodná permutace řádků výše uvedené matice, tj. řádků typu: *)
(* {"id-52",8,9,5,1,4,7,2,6,3,10} *)
(* Těch deset čísel již ale nemusí tvořit permutaci !!! *)
(lData=RandomSample[Table[Join[{"id-"<>ToString[i]},RandomInteger[{1,10},{10}]],{i,n}]])//MatrixForm

Nyní pro větší počet záznamů:

n=100000; 
SeedRandom[13];
(*  náhodná permutace řádků výše uvedené matice, tj. řádků typu: *)
(* {"id-52",8,9,5,1,4,7,2,6,3,10} *)
lData=RandomSample[Table[Join[{"id-"<>ToString[i]},RandomInteger[{1,10},{10}]],{i,n}]];
(* Výběr prvních sedmi ze 100000 *)Take[lData,7]

(* *** *)ByteCount[lData]/1024^2.

Výběr záznamů s danými identifikátory:

Nejprve najdeme na zkoušku záznam s identifikátorem “id-1000”:

Select[lData,#[[1]]=="id-1000"&]//AbsoluteTiming
(* nebo *)
Cases[lData,{"id-1000",__}]//AbsoluteTiming

Nyní naostro výběr 100 záznamů s identifikátory id-1, ..., id-100 ze 100000 záznamů ldata:

(* Výběr 100 záznamů s identifikátory id-1, ..., id-100 *)
AbsoluteTiming[Table[id="id-"<>ToString[i];
Select[lData,#[[1]]==id&],
{i,1,100}]//Short
]

V tomto případě je užití Cases podstatně rychlejší než Select:

AbsoluteTiming[Table[id="id-"<>ToString[i];
Cases[lData,{id,__}],
{i,1,100}]//Short
]

Dotaz: Je  možné se obejít bez ryzí funkce?

Clear[fEqualtoID]
fEqualtoID[x_?VectorQ,id_]:=x[[1]]==id
{fEqualtoID[lData[[1]],"id-2"],fEqualtoID[lData[[54825]],"id-2"]}

Vsuvka

fGreaterThanTwo[x_]:=x>2
{fGreaterThanTwo[1],fGreaterThanTwo[3]}
Select[{1,2,4,7,6,2},fGreaterThanTwo]

Pomocí anonymní funkce:

Select[{1,2,4,7,6,2},Function[x,x>2]]

Position[lData,"id-2"]
lData[[Position[lData,"id-2"][[1,1]]]]

Konec Dotazu

Rychlejší je použití Cases:

Cases[lData,{"id-1000",___}]

AbsoluteTiming[Table[id="id-"<>ToString@i;
Cases[lData,{id,___}],
{i,1,100}]//Short
]

Lokální pravidla (Rules)

lData[[2,1]]->lData[[2]]

(* Vytvoříme seznam 100000 lokálních pravidel: *)
(* Zde # znamená řádek v lData: *)rData=Map[#[[1]]->#&,lData];
firstThreeRules=Take[rData,3]

fourRules=Join[firstThreeRules,{"id-1000"->{"id-1000",6,1,1,1,1,10,6,8,1,6}}]

Vyhledání záznamu s “id-1000”:

(* Za id-1000 substitujeme odpovídající záznam: *) 
(* Ilustrace na 4 pravidlech *)
"id-1000"/.fourRules
(* Ilustrace na všech 100000 pravidlech *)
"id-1000"/.rData

(* Výběr 100 záznamů s identifikátory id-1, ..., id-100 *)
AbsoluteTiming[Table[id="id-"<>ToString[i];
id/.rData,
{i,1,100}]//Short
]

To je zhruba desetkrát rychlejší než Lists pomocí Select a více než dvakrát rychlejší pomocí Cases.

Asociace (Associations)

(* Z lokálních pravidel vytvoříme asociaci: *)
aData=Association[Map[#[[1]]->#&,lData]];
Take[aData,3]
Keys[%]
Values[%%]

aData["id-1000"]

(* Výběr 100 asociací s klíči id-1, ..., id-100 *)AbsoluteTiming[Table[id="id-"<>ToString[i];
aData[id],
{i,1,100}]//Short
]

Keys[aData]

(* Zde si všimněte uspořádání - "id-10" je v lexikografickém uspořádání před "id-2"*)aData//Sort

Porovnání rychlosti s předchozím případem:

((1.3324489`)/(0.0003761`))

**Beta Estimation from Monthly Returns (Market portfolio = SP500)

**Lineární regrese

Hyperlink[Button["Demonstrace lineární regrese"],"http://demonstrations.wolfram.com/MeanFittedValueErrorAndResidualInSimpleLinearRegression/"]

This Demonstration simulates the simple linear regression (Subscript[y, i])=a+b (Subscript[x, i])+(Subscript[ϵ, i]), i=1,…,10. The red line is the plot of y=a+b x, while the blue line is the plot of (OverHat[y])=(OverHat[a])+(OverHat[b])x, where (OverHat[a]) and (OverHat[b]) are the least-squares estimates. The x's are ordered from smallest to largest and for any particular observation number i that is selected, a double arrow is used to indicate (Subscript[μ, i])=a+b (Subscript[x, i]), (Subscript[(OverHat[y]), i])=(OverHat[a])+(OverHat[b])(Subscript[x, i]), (Subscript[ϵ, i])=(Subscript[y, i])-(Subscript[μ, i]), or (Subscript[e, i])=(Subscript[y, i])-(Subscript[(OverHat[y]), i]). In the thumbnail, μ has been selected with i=5, so the double arrow shows the value of (Subscript[μ, 5]). The numerical values of these quantities are displayed when you mouseover one of the data points. Select some other observation numbers. Can you give approximate values for the quantities shown by the arrows? Check your answer by mousing over the selected observation.

Manipulate[Module[{x,e,y,pts,mu,ϵ,yHat,ans,aH,bH,mrk,t1,t2,t3,t4,tt,pts2},
SeedRandom[sr];
x=Sort[RandomVariate[UniformDistribution[{0,10}],n]];
e=RandomVariate[NormalDistribution[0,1.5], n];
y=a+b*x+e;
pts=Transpose[{x,y}];
mu = a+b x;
ϵ=y-mu;
yHat=(ans=Fit[pts,{1,𝔵},{𝔵}])/.𝔵->x;
{aH,bH}=CoefficientList[ans,𝔵];
e=y-yHat;
mrk=Switch[ind,
"μ",{Arrowheads[{-Asz,Asz}],Arrow[{{x[[iObs]],0},{x[[iObs]],mu[[iObs]]}}]},
OverHat["y"],{Arrowheads[{-Asz,Asz}],Arrow[{{x[[iObs]],0},{x[[iObs]],yHat[[iObs]]}}]},
"ϵ",{Arrowheads[If[Abs[ϵ[[iObs]]]<1,{0.01,0.01},{-Asz,Asz}]],Arrow[{{x[[iObs]],mu[[iObs]]},{x[[iObs]],y[[iObs]]}}]},
"e",{Arrowheads[If[Abs[ϵ[[iObs]]]<1,{0.01,0.01},{-Asz,Asz}]],Arrow[{{x[[iObs]],yHat[[iObs]]},{x[[iObs]],y[[iObs]]}}]}
];
t1=Row[{"ϵ = ",#}]&/@ϵ;
t2=Row[{"μ = ",#}]&/@mu;
t3=Row[{Style["e",Italic]," = ",#}]&/@e;
t4=Row[{ OverHat[Style["y",Italic]]," = ",#}]&/@yHat;
tt=Transpose[{t1,t3,t2,t4}];
pts2=MapThread[Tooltip[#1,#2]&,{pts,tt}];
ListPlot[pts2,Axes->False,Frame->True,FrameLabel->{Style["x",Italic],Style["y",Italic]},PlotRange->{{mnx,mxx},{0,10}},PlotStyle->{Brown,PointSize[Large]},RotateLabel->False,Epilog->{mrk,
Thickness[Large],Red,Opacity[0.5],Line[{{mnx,a+b*mnx},{mxx,a+b*mxx}}],
Blue,Opacity[0.5],Line[{{mnx,aH+bH*mnx},{mxx,aH+bH*mxx}}]},
PlotLabel->Row[{Style["true line",Red]," and ",Style["estimated line",Blue]}],ImageSize->1.15{450,350}]
],
{{iObs,5,"observation number"},1,n,1,Appearance->"Labeled"},
{{ind,"μ","indicate: "},{"μ"->"μ",OverHat["y"],"ϵ"->"ϵ","e"->Style["e",Italic]}},
{{sr,5983,"random seed"},4971,72345,1,Appearance->"Labeled",ControlPlacement->Top,AnimationRate->1/2},
TrackedSymbols:>{sr,iObs,ind},
AutorunSequencing->{1,3},
Initialization:> (
n=10;a=1.0; b=0.7;mnx=0.0;mxx=10.0;Asz=0.025;
)
]

**Coke, Coca-Cola, VW, Apple

(Date[]//DateList)[[1;;2]]

{startDate=(Today//DateList)[[1;;2]]-{5,0},endDate=(Today//DateList)[[1;;2]]}
companies={"SP500","Coke","KO","F:VOW","AAPL"};
DateObject[]
Text@Grid[Prepend[ Map[{#,FinancialData[#,"Company"],FinancialData[#]}&,companies],{"Ticker","Name","Actual Price"}],Frame->All]

DateObject[]
returnsMonthlyWithDates=Map[FinancialData[#,"Return",{startDate,endDate,"Month"}]&,companies];
returnsMonthlyValues=Map[FinancialData[#,"Return",{startDate,endDate,"Month"},"Value",Method->"Legacy"]&,companies];

returnsAssociation=Association[Thread[companies->returnsMonthlyValues]];
Keys[returnsAssociation]
Map[Length,Values[returnsAssociation]]

DateListPlot[returnsMonthlyWithDates,PlotLegends->companies,PlotRange->All,PlotStyle->Thick]

linearModelsCompanies=Association[Thread[Rest[companies]->Map[LinearModelFit[Transpose[{returnsAssociation["SP500"],returnsAssociation[#]}],x,x]&,Rest[companies]]]]

Estimates of α, β, their standard errors, t-statistic, p-value, (R^2):

parameterTableCompanies=Map[{#["ParameterTable"],#["RSquared"]}&,linearModelsCompanies]

95 per cent confidence intervals for α, β:

(parameterConfidenceIntervalsCompanies=Map[#["ParameterConfidenceIntervals"]&,linearModelsCompanies])//Dataset

parametersCompanies=Map[#["BestFitParameters"]&,linearModelsCompanies]

Recall CAPM  for asset n: (Subscript[r, n])-(Subscript[r, 0])=(Subscript[β, n])((Subscript[μ, M])-(Subscript[r, 0])). From the estimated regression equation (Subscript[r, n])=(OverHat[(Subscript[α, n])])+(OverHat[(Subscript[β, n])])(Subscript[μ, M])  we may estimate the risk free rate as (OverHat[(Subscript[r, 0])])=(OverHat[(Subscript[α, n])])/(1-(OverHat[(Subscript[β, n])])):

Row@{"Risk free rate estimates (OverHat[(Subscript[r, 0])]):  ",(riskFreeRateEstimate=Map[((#[[1]])/(1-#[[2]]))&,parametersCompanies]),"\nAverage of the above:   " ,Mean[riskFreeRateEstimate] }

***DJI

membersDJI={"3M","American Express","Apple","Boeing","Caterpillar","Chevron","Cisco","Coca-Cola","Disney","DuPont","Exxon Mobil","General Electric","Goldman Sachs","Home Depot","Intel","IBM","Johnson & Johnson","JPMorgan Chase","McDonald's","Merck & Co.","Microsoft","Nike","Pfizer","Procter & Gamble","Travelers","UnitedHealth","United Technologies","Verizon Communications","Visa","Wal-Mart Stores"};
Clear[MMM,AXP,AAPL,BA,CAT,CVX,CSCO,KO,DIS,DD,XOM,GE,GS,HD,INTC,IBM,JNJ,JPM,MCD,MRK,MSFT,NKE,PFE,PG,TRV,UNH,UTX,VZ,V,WMT]
tickersDJI=Map[ToString,{MMM,AXP,AAPL,BA,CAT,CVX,CSCO,KO,DIS,DD,XOM,GE,GS,HD,INTC,IBM,JNJ,JPM,MCD,MRK,MSFT,NKE,PFE,PG,TRV,UNH,UTX,VZ,V,WMT}];
(* Add the returns of the market portfolio, i. e., SP500 *)tickersDJI=Join[{"SP500",tickersDJI}]//Flatten

{startDate=(Today//DateList)[[1;;2]]-{5,0},endDate=(Today//DateList)[[1;;2]]}

DateObject[]
returnsMonthlyWithDates=Map[FinancialData[#,"Return",{startDate,endDate,"Month"}]&,tickersDJI];
returnsMonthlyValues=Map[FinancialData[#,"Return",{startDate,endDate,"Month"},"Value"]&,tickersDJI];

2017-11-20 The above operaton timing 67 sec.
2015-12-12 The above operation timing 126 sec, 67 sec, 44 sec

returnsAssociation=Association[Thread[tickersDJI->returnsMonthlyValues]];
iKeys=Keys[returnsAssociation]
iLengths=Map[Length,Values[returnsAssociation]]

Sometimes it may happen that two or more companies have only one element. The above list looks like {59,59,59,1,59,...,59,1,59,59,...}. Obviously wrong. What are these companies? We use the following construction with a possible result:

Select[returnsAssociation,Length[#]==1&]
\[LeftAssociation]"HD"->Missing["NotAvailable"],"JNJ"->Missing["NotAvailable"]\[RightAssociation]

(* Select[returnsAssociation,Length[#]==1&] *)

It follows that at the moment of downloading the data of these two companies were not available.

DateListPlot[returnsMonthlyWithDates,PlotLegends->tickersDJI,PlotRange->All,PlotStyle->Thick]

Next we perform the linear regression of the company return on the return of SP500 (proxy for the market portfolio) for all 30 companies. Explanation: The first element In tickersDJI are the returns SP500. We simply use Rest to work with dependent variables returns DJI only. The result is the association.

linearModelstickersDJI=Association[Thread[Rest[tickersDJI]->Map[LinearModelFit[Transpose[{returnsAssociation["SP500"],returnsAssociation[#]}],x,x]&,Rest[tickersDJI]]]]

Estimates of α, β, their standard errors, t-statistic, p-value, (R^2):

parameterTabletickersDJI=Map[{#["ParameterTable"],#["RSquared"]}&,linearModelstickersDJI]

95 per cent confidence intervals for α, β:

(parameterConfidenceIntervalstickersDJI=Map[#["ParameterConfidenceIntervals"]&,linearModelstickersDJI[[1;;15]]])//Dataset
(parameterConfidenceIntervalstickersDJI=Map[#["ParameterConfidenceIntervals"]&,linearModelstickersDJI[[16;;30]]])//Dataset

(* Estimated {α,β} for every company *) parameterstickersDJI=Map[#["BestFitParameters"]&,linearModelstickersDJI]

Recall CAPM  for asset n: (Subscript[r, n])-(Subscript[r, 0])=(Subscript[β, n])((Subscript[μ, M])-(Subscript[r, 0])). From the estimated regression equation (Subscript[r, n])=(OverHat[(Subscript[α, n])])+(OverHat[(Subscript[β, n])])(Subscript[μ, M])  we may estimate the risk free rate as (OverHat[(Subscript[r, 0])])=(OverHat[(Subscript[α, n])])/(1-(OverHat[(Subscript[β, n])])):

Row@{"Risk free rate estimates (OverHat[(Subscript[r, 0])]):  ",(riskFreeRateEstimate=Map[((#[[1]])/(1-#[[2]]))&,parameterstickersDJI]),"\n\nAverage of the above:   " ,Mean[riskFreeRateEstimate] }

Histogram[riskFreeRateEstimate]

***Auxilliary calculations and actual prices

DateObject[]
Text@Grid[Prepend[ Map[{#,FinancialData[#,"Company"],FinancialData[#]}&,tickersDJI],{"Ticker","Name","Actual Price"}],Frame->All]

***Relationship between SP500 and DJI

{startDate=(Today//Normal)[[1;;2]]-{5,0},endDate=(Today//Normal)[[1;;2]]}
indicesSP500DJI={"SP500","^DJI"};
DateObject[]
Text@Grid[Prepend[ Map[{#,FinancialData[#,"Company"],FinancialData[#]}&,indicesSP500DJI],{"Ticker","Name","Actual Price"}],Frame->All]

DateObject[]
returnsMonthlyWithDates=Map[FinancialData[#,"Return",{startDate,endDate,"Month"}]&,indicesSP500DJI];
returnsMonthlyValues=Map[FinancialData[#,"Return",{startDate,endDate,"Month"},"Value"]&,indicesSP500DJI];

2015-11-06 The above operation timing 126 sec, 67 sec, ...

returnsAssociation=Association[Thread[indicesSP500DJI->returnsMonthlyValues]];
iKeys=Keys[returnsAssociation]
iLengths=Map[Length,Values[returnsAssociation]]

djiReturns=FinancialData["^DJI","Return",{startDate,endDate,"Month"},"Value"]

Sometimes it may happen that two or more companies have only one element. The above list looks like {59,59,59,1,59,...,59,1,59,59,...}. Obviously wrong. What are these companies? We use the following construction with a possible result:

Select[returnsAssociation,Length[#]==1&]
\[LeftAssociation]"HD"->Missing["NotAvailable"],"JNJ"->Missing["NotAvailable"]\[RightAssociation]

Select[returnsAssociation,Length[#]==1&]

(* Select[returnsAssociation,Length[#]==1&] *)

It follows that at the moment of downloading the data of these two companies were not available.

DateListPlot[returnsMonthlyWithDates,PlotLegends->indicesSP500DJI,PlotRange->All,PlotStyle->Thick]

Next we perform the linear regression of the company return on the return of SP500 (proxy for the market portfolio) for all 30 companies. Explanation: The first element In indicesSP500DJI are the returns SP500. We simply use Rest to work with dependent variables returns DJI only. The result is the association.

linearModelsindicesSP500DJI=Association[Thread[Rest[indicesSP500DJI]->Map[LinearModelFit[Transpose[{returnsAssociation["SP500"],returnsAssociation[#]}],x,x]&,Rest[indicesSP500DJI]]]]

Estimates of α, β, their standard errors, t-statistic, p-value, (R^2):

parameterTableindicesSP500DJI=Map[{#["ParameterTable"],#["RSquared"]}&,linearModelsindicesSP500DJI]

95 per cent confidence intervals for α, β:

(parameterConfidenceIntervalsindicesSP500DJI=Map[#["ParameterConfidenceIntervals"]&,linearModelsindicesSP500DJI[[1;;15]]])//Dataset
(parameterConfidenceIntervalsindicesSP500DJI=Map[#["ParameterConfidenceIntervals"]&,linearModelsindicesSP500DJI[[16;;30]]])//Dataset

(* Estimated {α,β} for every company *) parametersindicesSP500DJI=Map[#["BestFitParameters"]&,linearModelsindicesSP500DJI]

Recall CAPM  for asset n: (Subscript[r, n])-(Subscript[r, 0])=(Subscript[β, n])((Subscript[μ, M])-(Subscript[r, 0])). From the estimated regression equation (Subscript[r, n])=(OverHat[(Subscript[α, n])])+(OverHat[(Subscript[β, n])])(Subscript[μ, M])  we may estimate the risk free rate as (OverHat[(Subscript[r, 0])])=(OverHat[(Subscript[α, n])])/(1-(OverHat[(Subscript[β, n])])):

Row@{"Risk free rate estimates (OverHat[(Subscript[r, 0])]):  ",(riskFreeRateEstimate=Map[((#[[1]])/(1-#[[2]]))&,parametersindicesSP500DJI]),"\n\nAverage of the above:   " ,Mean[riskFreeRateEstimate] }

Histogram[riskFreeRateEstimate]

Principy programování 1

Příklady definicí funkcí

Definice (funkce logaritmus)

Hyperlink[Button["Vzory, předlohy, Patterns"],"paclet:tutorial/PatternsForSomeCommonTypesOfExpression"]

Definice je prepisovaci pravidlo, ktere je automaticky pouzito na libovolny vyraz. Priklad na definici logaritmu:

Clear[log];
log[x_*y_]:=log[x]+log[y]
{log[2x (y^2)],log[2x y y]}
{(y^2)//FullForm, (y y)//FullForm,HoldForm[y y]//FullForm}

Prestoze z matematickeho hlediska je (y^2) (Power) totez, co y*y (Times), potrebujeme dalsi prepisovaci pravidlo, protoze porovnani vzoru (pattern matching) je v zasade syntakticke, a ne semanticke!

log[((a_)^(n_))]:=n*log[a]
log[2x (y^2)]
?log

log[x*2*y^3*z]

Definice primitivní funkce

Hyperlink[Button["Defining Your Own Integration Function"],"paclet:tutorial/AnExampleDefiningYourOwnIntegrationFunction"]

Vlastni definice funkce integrate[f,x]=∫f[x]dx

_.

Principy

({{mathematical form, Mathematica definition}, {∫(y+z)dx==∫ydx+∫zdx, integrate[y_+z_,x_]:=integrate[y,x]+integrate[z,x]}, {∫cydx==c∫ydx (c independent of x), integrate[c_y_,x_]:=c integrate[y,x]/;FreeQ[c,x]}, {∫cdx==cx, integrate[c_,x_]:=cx/;FreeQ[c,x]}, {∫(x^n)dx==((x^((n+1)))/(n+1)), n≠-1, integrate[x_^n_.,x_]:=x^(n+1)/(n+1)/;FreeQ[n,x]&&n!=-1}, {∫(1/(ax+b))dx==((log(ax+b))/a), integrate[1/(a_.x_+b_.),x_]:=Log[ax+b]/a/;FreeQ[{a,b},x]}, {∫(e^(ax+b))dx==(1/a) (e^(ax+b)), integrate[Exp[a_.x_+b_.],x_]:=Exp[ax+b]/a/;FreeQ[{a,b},x]}})

tutorial/OptionalAndDefaultArguments

Hyperlink[Button["Default _."],"paclet:tutorial/OptionalAndDefaultArguments"]

Realizace:

Clear[integrate,a,b,c];

integrate[y_+z_,x_]:=integrate[y,x]+integrate[z,x]

integrate[a x+b x^2+3,x]

integrate[c_ y_,x_]:=c integrate[y,x]/;FreeQ[c,x]

integrate[a x+b x^2+3,x]

integrate[c_,x_]:=c x/;FreeQ[c,x]

integrate[a x+b x^2+3,x]

integrate[c_,x_]:=c x/;FreeQ[c,x]

integrate[a x+b x^2+3,x]

Chybí-li exponent, doplní se jednička:

integrate[x_^n_.,x_]:=x^(n+1)/(n+1)/;FreeQ[n,x]&&n≠-1

integrate[a x+b x^2+3,x]

(* Jestliže chybí a, dosadí se místo něj 1, chybí-li b, dosadí se 0: *)integrate[1/(a_. x_+b_.),x_]:=Log[a x+b]/a/;FreeQ[{a,b},x]

integrate[1/x,x]

integrate[1/(2 p x-1),x]//TraditionalForm

integrate[Exp[a_. x_+b_.],x_]:=Exp[a x+b]/a/;FreeQ[{a,b},x]

integrate[Exp[4x +y],x]

?integrate

Principy programování 2

Příklady definicí funkcí

Definice vytvořující funkce pravděpodobností

MomentGeneratingFunction

Příklad

Dobré i při počítání s vytvořujícími funkcemi pravděpodobností (Probability generating function, pgs). Vhodné pro diskrétní náhodné veličiny.

(Subscript[G, X])(s)=(∑_(k=0)^∞)P(X=k)(s^k).

Význam:

P(X=k)=(((Subscript[G, X]^((k)))(0))/(k!))

Platí: (Subscript[G, X])(s)=E,(s^X). Dále platí: X, Y nezávislé ⟹ (Subscript[G, X+Y])(s)=(Subscript[G, X])(s)(Subscript[G, Y])(s).

Viz také charakteristická funkce ψ(t)=E,(e^(i,t,X)) a vytvořující funkce momentů ((Subscript[μ, j]) je j-tý obecný moment):

(Subscript[M, X])(t)=((Ee)^(t,X))=(∑_(j=0)^∞)(((Subscript[μ, j])(t^k))/(j!)),.

Související zabudované funkce:

CharacteristicFunction
MomentGeneratingFunction

Clear[pgs]
pgs[s_,distribution_]:=Expectation[(s^x),x\[Distributed]distribution]//Simplify

distr6=DiscreteUniformDistribution[{1,6}];
Expectation[(s^x),x\[Distributed]distr6]//Simplify

Odpovídající pgs (zde je účelné použít okamžité přiřazení):

pgs6[s_]=pgs[s,DiscreteUniformDistribution[{1,6}]]

Rozdělení součtu ok padlých na hracích kostkách

Clear[pgsSouctun]
pgsSouctun[n_][s_]:=((pgs6[s])^n) (* //Factor//Expand *)
pgsSouctun[3][s]

ClearAll[pravdepodobnosti]
pravdepodobnosti[k_,pgs_]:=Module[{s},(D[pgs[s]//Apart,{s,k}]/k!)/.s->0]
Grid[Table[{k,pravdepodobnosti[k,pgs6]},{k,6}]//Transpose,Frame->All]

pgsSouctun[10][s]//Apart

Timing[ListPlot[Table[pravdepodobnosti[k, pgsSouctun[10]],{k,60}],PlotStyle->Thick]]

Proč Apart?

(1/((1+x)(1+2x)(1+(x^2))))//Apart

Clear[x]
iP=Product[(1/(((1+i x))^i)),{i,10}];
Timing[p5=D[iP,{x,15}]//Simplify;]
iPApart=iP//Apart;
Timing[p5Apart=D[iPApart,{x,15}]//Simplify;]

D[1/((((1+x))^10)(((1+2x))^5)),x]
%//Apart

***Různé programovací styly 1 (Četnosti)

Nasledujici funkce zjistuji cetnosti v posloupnosti prirozenych nahodnych cisel 1,...,10. (Diskretni rovnomerne rozdeleni R(1,...,10)

**Proceduralni styl

SeedRandom[130];
(* data=Table[Random[Integer,{1,10}],{100}]; *)
data=RandomInteger[{1,10},{100}]

proc[x_]:=Module[{bins=Table[0,{10}]},
Do[bins[[x[[i]]]]++,{i,1,Length[x]}];bins]
pr=proc[data]
Total[pr]

**Funkcionalni styl

(* Nejdříve každému elementu přiřadíme četnost 1 *)Clear[fun];
(* fun[x_?VectorQ]:=fun[Function[y,{y,1}],x] *)
fun[x_?VectorQ]:=fun[Map[{#,1}&,x]]
fun[{1,2,3,2,4,3,2}]

Poznamka: _ prave jeden argument, __ jeden a vice argumentu, ___ nula a vice argumentu, x___

fun[{a___,{b_,n_},c___,{b_,m_},d___}]:=fun[{a,{b,n+m},c,d}]
fun[{1,2,3,2,4,3,2}]

SeedRandom[131313];
rc1=RandomChoice[Range[5],20]
fun[rc1]
cetnosti=fun[rc1]/.fun->Identity
Text@Grid[%,Frame->All]

*** Alternativne

(* *** *)
fun[a_List]:=Map[Last,a]
fun[rc1]
fun[rc1//Sort]

My ale jeste chceme znat hodnoty, ke kterym se cetnosti vztahuji. Pozor, přepíše horní definici fun[a_List]:=Map[Last,a]!!!

fun[a_List]:=a//Sort;
Text@Grid[(cetnosti=fun[rc1]),Frame->True]

?fun

*** Konec Alternativne

Mathematica styl

Naivně:

SeedRandom[130];
(* data=Table[Random[Integer,{1,10}],{100}]; *)
data=RandomInteger[{1,10},{100}];

Table[{i,Count[data,i]},{i,10}]

Použitelné jenom v případě, že víme, která čísla se v souboru vyskytují. Dobrá realizace je (funguje pro libovolná data) :

Map[Count[data,#]&,Union[data]]
(* Ekvivalentně *)
Map[Function[x,Count[data,x]],Union[data]]
(* Přehledněji *)
Clear[cetnosti]
cetnosti[data_]:=Map[{#,Count[data//Flatten,#]}&,Union[data//Flatten]]//TableForm
(* Ekvivalentně *)
Map[Function[x,{x,Count[data,x]}],Union[data]]
cetnosti[data]
cetnosti[{,"Pes",1,2,4,4,"Pes",{4,8,{1,2}}}]

*Funkce Tally 1

Tally[{c,b,a,a,a,b,a,c,b,a}]
%//Sort

***Funkce Tally 2

Slozitejsi priklad: za identicke se povazuji elementy se stejnou hlavickou.

t1=Tally[{{a,b},{w,x,y,z},E,a,vvv,11111,{w,x,y,z},2,3,4,5,E},Head[#1]===Head[#2]&]
Map[{Head[#//First],#//Last}&,t1]

Tally[Map[Head,{{a,b},{w,x,y,z},E,a,vvv,11111,{w,x,y,z},2,3,4,5,E}]]

Vsimneme si, jake jsou hlavicky prvku v uvedenem listu:

Map[Head,{{a,b},{w,x,y,z},E,a,vvv,11111,{w,x,y,z},2,3,4,5,E}]

**Funkce Tally 3 (komplikovany, ale dulezity priklad, zahrnuje též úvod do práce s importovanymi soubory a jejich zpracování, zpracování textu Shakespeare Hamlet)

Nejdrive ukazka funkce FileNames[ ]:

$Path

Directory[]
FileNames[]

Klicova konstrukce pro export a import (usnadnuje prenositelnost). Nastavi adresar na stejny adresar, ve kterem je spusten tento notebook.

SetDirectory[NotebookDirectory[]]
FileNames[]

Sada datovych souboru, nekdy je nutne pripojeni k Internetu

ExampleData[]

ExampleData["Statistics"]//Length

ExampleData["Text"]

textHamlet=StringTake[ExampleData[{"Text","Hamlet"}],10000];

Cetnosti podle vyskytujicich se znaku v poradi, jak se v textu vyskytuji:

(tallyHamlet=Tally[Characters[textHamlet]])(* //Sort//FullForm *)
Dimensions[%]

Overime, kolik tech znaku je (tri zpusoby):

{Total[Map[Last,tallyHamlet]],Total[Transpose[tallyHamlet][[2]]],Total[tallyHamlet[[All,2]]]}

Total[tallyHamlet]
Total[tallyHamlet]//Last

Nejcetnejsi znaky

Sort[tallyHamlet,#1[[2]]>#2[[2]]&]
%//First//FullForm

Lze také užít (krkolomná konstrukce):

Map[Reverse,Sort[Map[Reverse,tallyHamlet]]]//Reverse

Cetnosti slov (Nejdrive pouzijeme funkci StringSplit)

StringSplit[kratkyretezec="StringSplit rozdeli retezec na podretezce, bez dalsi specifikace podle mezer. Je vsak mozne pouzit i jine oddelovace. Ukazeme v uplne forme."]//FullForm

Je vhodne ignorovat velka a mala pismena:

ToLowerCase[kratkyretezec]
ToLowerCase[StringSplit[kratkyretezec]]

Funguje i na cestinu:

ToLowerCase["Řeči, Šupiny"]

Aplikace na Hamleta:

{"",""}

vsechnyznaky=Union[Characters[textHamlet//ToLowerCase]]
Row@{"Vsechny znaky, ktere nejsou pismeny:\n",(vsechnyznakykterenejsoupismeny=Complement[vsechnyznaky,CharacterRange["a","z"]])//InputForm (* pouzito misto FullForm *)}
(* Doplnek doplnku *)Complement[vsechnyznaky,Complement[vsechnyznaky,CharacterRange["a","z"]]]

vsechnyznakykterenejsoupismeny

slovaslovaslova=StringSplit[textHamlet]//ToLowerCase;
cetnostislovaslovaslova=Tally[slovaslovaslova]

(* Setridene podle abecedy *)
Sort[cetnostislovaslovaslova]
%//Length

Vidime jistou nedokonalost naseho postupu - “bernardo,” a “bernardo?” jsou povazovana za dve ruzna slova. Spravne bychom museli pouzit i oddelovace “,”, “.”, “!”, “?” a mozna i jine. Takove znaky jsou vsak jiz v souboru

vsechnyznakykterenejsoupismeny//FullForm

Takze

ToCharacterCode[""]//FullForm

slovaslovaslovanew=StringSplit[textHamlet,vsechnyznakykterenejsoupismeny]//ToLowerCase;
slovaslovaslovanew[[1;;10]]//FullForm
(charH=Characters[textHamlet][[1;;50]])//FullForm
StringJoin[charH]//FullForm
cetnostislovaslovaslovanew=Tally[slovaslovaslovanew]

Sort[cetnostislovaslovaslovanew]
%//Length
%%//First//FullForm

Setridene podle cetnosti vzestupne, tedy podle druheho elementu

cetnostislovaslovaslovanewsort=Sort[cetnostislovaslovaslovanew,#1[[2]]<#2[[2]]&]

Setridene podle cetnosti sestupne  a v pripadech, kdy jsou cetnosti stejne, pak podle abecedy.

Realizace: Nejdrive se setridi podle slov (cetnostislovaslovaslovanew//Sort) a potom podle druhe slozky setridime sestupne. To prvni trideni zustane zachovano.

(* Setridene podle cetnosti sestupne *)
Sort[cetnostislovaslovaslovanew//Sort,#1[[2]]≥#2[[2]]&]

Ilustrace predchozich kroku na matici 5×3 (Prostudujte Help pro funkci Sort)

SeedRandom[130];
(souborN0153=RandomVariate[NormalDistribution[],{5,3}])//TableForm
(* Trideni podle 2. sloupce *)
Sort[souborN0153,#1[[2]]<#2[[2]]&]//TableForm
(* ekvivalentne *)
Sort[souborN0153,Function[{x,y},x[[2]]<y[[2]]]]//TableForm

(* Trideni podle 3. sloupce *)Sort[souborN0153,#1[[3]]<#2[[3]]&]//TableForm

Vybrat vsechna slova s cetnosti 5

Select[cetnostislovaslovaslovanewsort,#[[2]]==5&]
(* Za cvičení definujte pomocí Function. *)

Substitucni pravidla (lokalni pravidla, replacement rules, rule-based programming)

Lokalni pravidla se aplikuji zleva doprava, kazde jenom jednou. Četnost 3 = ?

{1,2,3,2,3,1,2,4}/. 3->🐺/.x_Integer->0

(* Pocet vyskytu cisla 3 v uvedenem seznamu *)v1={1,2,3,2,3,1,2,4}/. 3->🐺/.x_Integer->0/.🐺->1
Total[v1]

Clear[pravidla];
(* Četnost n v mnozine celych cisel *)
pravidla[data_List,n_]:=
Total[data/.n->🐺/.x_Integer->0/.🐺->1]
{pravidla[data={1,2,3,2,3,1,2,4},2],
pravidla[{1,2,3,2,3,1,2,4},3]}

Map[pravidla[data,#]&,Range[10]-1]
Map[{#,pravidla[data,#]}&,Union[data]]
(* ekvivalentně *)
Map[Function[x,{x,pravidla[data,x]}],Union[data]]

char2=Characters["Map[pravidla[data,#]&,Range[10]] Map[pravidla[data,#]&,Union[data]]'"]

Clear[pravidla2];
pravidla2[data_List,n_]:=Count[data,n]
pravidla2[{"a","p","[","p","r","a","v"},"p"]

(cetnosti2={u2=Union[char2],Map[pravidla2[char2,#]&,u2]}//Transpose )//TableForm
(* ekvivalentně *)
{u2=Union[char2],Map[Count[char2,#]&,u2]}//TableForm

Pozor, pri importu souboru (napr. z Excelu) mohou vzniknout zaludnosti tohoto typu (opticky se mezera v obou pripadech tvari stejne).

{" "//FullForm," "//FullForm}

Praktické doporučení: Import[soubor,”xlsx”] ⟶ Union ⟶ FullForm

" "(* //FullForm*)

**Příklad (za cviceni)

**Znaky se stejnymi cetnostmi jsou v jednom listu (ukazka vnorene ryzi (anonymni) funkce):

sdruzenecetnosti=Map[Function[x,Select[sort2,#[[2]]==x&]//Sort],vsechnycetnosti]//TableForm

Setrideni uvnitr seznamu se stejnou cetnosti sestupne

Map[Sort[#,Smaller]&,sdruzenecetnosti]

Sort[{{"i",3},{"n",3},{"t",3}},#1[[1]]>#2[[1]]&]

{CharacterRange["a","c"],{1,2,3}}//Transpose//Reverse

SeedRandom[13];
randomarray43=RandomReal[{0,1},{4,3}]
Sort[randomarray43] (* třídí podle 1. sloupce *)
Sort[randomarray43,#1[[2]]>#2[[2]]&] (* třídí podle 2. sloupce *)

Sort[{CharacterRange["a","c"],{1,2,3}}//Transpose,#1[[1]]>#2[[1]]&]

Prehledne usporadani

(tab2=Map[Function[x,Select[sort2,#[[2]]==x&]//Sort],vsechnycetnosti])//TableForm

Partition[Flatten[tab2],2]//TableForm

Map[Reverse,Partition[Flatten[tab2],2]]//TableForm

Poznamka (připomenutí: rozdil v pouziti Reverse, v prvnim pripade na radky, v druhem pomoci Map na sloupce)

mat123=(({{a, b}, {c, d}, {e, f}}));
Reverse[mat123]//MatrixForm
Map[Reverse,mat123]//MatrixForm

Různé programovací styly 2 (Ilustrace Fibonacci a řešení diferenčních rovnic)

Fibonacciova posloupnost je definovana rekurentne (Subscript[f, n])=(Subscript[f, n-1])+(Subscript[f, n-2]) , pocatecni hodnoty (Subscript[f, 1])=1, (Subscript[f, 2])=1.

Fibonacci A

Remove[fibS];
fibS[1]=1;
fibS[2]=1;
(* V těchto dvou případech není zapotřebí ukládat pravidlo, ale je možné okamžitě odpovídající hodnoty přiřadit. *)
fibS[n_]:=fibS[n-1]+fibS[n-2]

Toto je primocara, ale spatna definice,  (ma mnoho nedostatku, nektere jsou patrne ihned, nektere odhalime pozdeji)

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

Toto nefunguje:

fibS[3.5]

fibS[270]

$RecursionLimit

$RecursionLimit=5000;
fibS[3.5]

fibS[270]

fibS[-3]

Trivialni definice, s kosmetickymi vylepsenimi:

Remove[fibA];
fibA[1]=1;
fibA[2]=1;
fibA[n_]:=fibA[n-1]+fibA[n-2]/;Positive[n]&&IntegerQ[n]
{fibA[30],fibA[-2],fibA[3.5]}//Timing

(* ekvivalentne *)
Remove[fibA2];
fibA2[n_?(IntegerQ[#]&&Positive[#]&)]:=fibA2[n-1]+fibA2[n-2]
fibA2[1]=1;
fibA2[2]=1;
{fibA2[30],fibA2[-2],fibA2[3.5]}//Timing

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

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

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

fibA[39]//Timing

{(fibA[31]//Timing)[[1]],(* nebo *)Timing[fibA[31];]//First}

ListLogPlot[Table[(fibA[j]//Timing)[[1]]+0.000000000001,{j,24}],Joined->True,PlotRange->All,PlotStyle->{Orange,Thick}]

?fibA2

!!! Fibonacci B (tzv. Dynamické programování, velmi důležité z hlediska praxe !!!)

Poznamenejme, ze pojem "Dynamicke programovani" je pouzivan v jinych oblastech v odlisnem kontextu, např. dynamické programování v optimalizačních metodách. Podobně jako "normální".

Vyhodou je, kdyz si jiz vypocitane hodnoty muzeme zapamatovat. To Mathematica umoznuje nasledujici konstrukci (nutno si zapamatovat, v nápovědě se těžko hledá - funguje např. “remember values” ):

Hyperlink[Button["Dynamické programování (remember values\!) "],"paclet:tutorial/FunctionsThatRememberValuesTheyHaveFound"]

f[n,_]:=f[n]=f[n libovolna definice]

Clear[fibB];
fibB[1]=fibB[2]=1;
fibB[n_?(IntegerQ[#]&&Positive[#]&)]:=fibB[n]=fibB[n-1]+fibB[n-2]

?fibB

MaxMemoryUsed[]

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

{fibA[6],fibB[6]}

?fibA

?fibB

Vsimneme si casu potrebneho pro vypocet a spotreby pameti:

$RecursionLimit=1024;

fibB[1350];

fibB[1350]

MaxMemoryUsed[]
fibB[1350]//Timing
MaxMemoryUsed[]

?fibB

Konec 2021-12-10

2021-12-17 Lekce 11

FAQ

Q1

A1

Principy programování 3

Různé programovací styly 3 (Ilustrace Fibonacci a řešení diferenčních rovnic)

Fibonacci M

Vychází z lineární transformace:

(({{(Subscript[f, n+1])}, {(Subscript[f, n])}}))=(({{1, 1}, {1, 0}})).(({{(Subscript[f, n])}, {(Subscript[f, n-1])}}))

{(({{1, 1}, {1, 0}})).(({{(Subscript[f, n])}, {(Subscript[f, n-1])}}))//TraditionalForm//MatrixForm,((({{1, 1}, {1, 0}})).(({{1, 1}, {1, 0}})).(({{(Subscript[f, 2])}, {(Subscript[f, 1])}}))/.{(Subscript[f, 1])->1,(Subscript[f, 2])->1})//MatrixForm,((({{1, 1}, {1, 0}})).(({{1, 1}, {1, 0}})).(({{1, 1}, {1, 0}})).(({{(Subscript[f, 2])}, {(Subscript[f, 1])}}))/.{(Subscript[f, 1])->1,(Subscript[f, 2])->1})//MatrixForm,((({{1, 1}, {1, 0}})).(({{1, 1}, {1, 0}})).(({{1, 1}, {1, 0}})).(({{1, 1}, {1, 0}})).(({{(Subscript[f, 2])}, {(Subscript[f, 1])}})))//MatrixForm}

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

Map[fibM,Range[6]]

{Timing[fibM[160000];],Timing[fibM[10000000];]}

Fibonacci W (cyklus, ktery je zde podstatne efektivnejsi nez naivni rekurence)

Clear[fibW]
fibW[n_]:=Module[{f1=1,f2=1},Do[{f2,f1}={f1+f2,f2},{n-2}];f2]

Map[fibW,Range[6]]

Timing[fibW[160000];]
fibW[160000]//N

!Fibonacci C (Reseni diferencnich rovnic)

{(∫_1^∞)(1/(x^2))\[DifferentialD]x,(∑_(n=1)^∞)(1/(n^2))}
%//N

Pro reseni diferencnich rovnic (nebo jejich soustav, mj. důležitých v matematické ekonomii) 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.

V nasem pripade cetne pocatecnich podminek se jedna o soustavu 3 rovnic.

Clear[n,fibC]
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. Uzijeme funkci, kterou jsme již použili dříve, FunctionExpand:

reseniC2=reseniC//FunctionExpand
(fibC[n]/.reseniC2)//First

Plot[fibC[n]/.reseniC2,{n,0,5}]

Uvedomme si, ze cos(n π)=(((-1))^n) pro n cele. Kyzeny tvar dosahneme pouzitim predpokladu

Assuming[n∈Integers,Simplify[reseniC2]]
(* ekvivalentně *)
Simplify[reseniC2,Assumptions->{n∈Integers}]

Konkretni hodnoty dostaneme napr. takto:

(fibC[n]/.reseniC/.n->200)//First

Všimněme si, že symbolu fibC nebyla přiřazena žádná hodnota:

?fibC

Fibonacci D (zabudovana funkce)

AbsoluteTiming[Fibonacci[10000000];]

**Fibonacci F (zabudovana funkce, IPM, p. 218)

More efficient algorithm is based on the formula:

(Subscript[F, 2n])=2(Subscript[F, n-1])(Subscript[F, n])+(Subscript[F, n]^2),	 n≥1

(Subscript[F, 2n+1])=(Subscript[F, n+1]^2)+(Subscript[F, n]^2),                         n≥1

Clear[fibF];
fibF[n_?(IntegerQ[#]&&Positive[#]&)]:=fibF[n]=
	Which[n==1,1,
     	      n==2,1,
		EvenQ[n],2 fibF[n/2-1] fibF[n/2]+((fibF[n/2])^2),
		OddQ[n],((fibF[(n+1)/2])^2)+((fibF[(n-1)/2])^2)
		]
{fibF[2.5],fibF[3],fibF[-1]}

Grid@Map[{#,fibF[#]}&,10 Range[10]]

{Timing[fibF[160000];],Timing[fibF[10000000];]}

FindSequenceFunction a FindInstance

Clear[n]
FindSequenceFunction[{1,1,2,3,5,8},n]

**Poznámka. Podobná funkce FindInstance:

FindInstance[x^2+y^2+z^2≤1&&9z^3==2x-5 y-7,{x,y,z},Reals]

(*  Tři případy *)
FindInstance[x^2+y^2+z^2≤1&&9z^3==2x-5 y-7,{x,y,z},Reals,3]
%//N
({x,y,z}/.%%)//N

Finanční funkce 1

Zpracování externích dat

Poznámka k exportu do XLSX a importu

Při zpětném importu jednoho souboru je první index pořadové číslo odpovídajícího listu (sheet) v Excelu. Proto ta konstrukce např. ceny[[1,All,2]].

SetDirectory[NotebookDirectory[]];
ivwvynosy=Import["vwvynosy.xls"];
(* První tři kalendářní data *)
ivwvynosy[[1(* = index listu v Excelu *),1;;3,1]]
(* První čtyři výnosy *)
ivwvynosy[[1(* = index listu v Excelu *),1;;4,2]]

Problémy exportu (příklad časových řad ČNB)

Průměrné výnosy státních dluhopisů s průměrnými dobami do splatnosti 2, 5 a 10 let

https://www.cnb.cz/cnb/STAT.ARADY_PKG.PARAMETRY_SESTAVY?p_sestuid=22049&p_strid=AEBA&p_lang=CS

SetDirectory[NotebookDirectory[]];
import=Import["20211217_VYNOSY_cnb.xls"];
(i2=import[[1,6;;]])//FullForm
radek1=i2[[1]]
{Join[{radek1[[1]]},Map[ToExpression,Rest[radek1]]]}//FullForm

{i2[[1,1]],Table[ToExpression[i2[[1]][[j]]],{j,2,4}]}

Úvodní poznámky

Uložíme jako “20211216_Vynosy_CNB.xls” a  “20211216_Vynosy_CNB.txt”. Ilustrujeme uložení v Excelu.

{"<tr><td>30.11.2021</td><td>3.00</td><td>2.84</td><td>2.62</td></tr>"}//FullForm

DateList[{"30.11.2021",{"Day",".","Month",".","Year"}}]

{"3.00","2.84","2.62"}//ToExpression//FullForm

Excel

SetDirectory[NotebookDirectory[]];
vynosyDluhopisuCNBxls=Import["20211216_Vynosy_CNB.xls"]

Text a zpracování

SetDirectory[NotebookDirectory[]];
vynosyDluhopisuCNBtxt=Import["20211216_Vynosy_CNB.txt"];
s1=StringSplit[vynosyDluhopisuCNBtxt,"\n"];
s1Head=s1[[1]];
s1Data1=s1//Rest;
s1Data2=Map[StringSplit[#,"|"]&,s1Data1];
s1Data3=Map[{DateList[{#[[1]],{"Day",".","Month",".","Year"}}][[1;;3]],ToExpression[Rest[#]]}&,s1Data2]

s1Data4=Map[{#[[1]],#[[2]]/.List->Sequence}&,s1Data3]

DateListPlot[Table[s1Data4[[All,{1,i}]],{i,2,4}],PlotLabel->"Yields of Czech T-bonds",PlotLegends->{"2 years","5 years","10 years"}]

**Yahoo

https://finance.yahoo.com/quote/

https://finance.yahoo.com/lookup

WMT ⟶ Historical Data ⟶ HistoricalPrices, TimePeriod (Daily, Weekly, Monthly) ⟶ Download (*.csv)

https://finance.yahoo.com/quote/%5EDJI/history?period1=1167606000&period2=1574031600&interval=1d&filter=history&frequency=1d

Firmy (Companies)

Jejich zkratky (malými písmeny) převedeme na velká. Zjistíme, jaké firmy se pod nimi skrývají a z jakých odvětví pocházejí (Sector).

companiesTickers={"sap","xom","emr","glp","cvs","nvs","mdlz","blk","hd","crm","wfc","ba"}//ToUpperCase

(companiesNames=Map[{#,FinancialData[#,"Name"],FinancialData[#,"Company"],FinancialData[#,"Sector"]}&,companiesTickers])//TableForm

Načtení dat (výnosů a cen) a jejich uložení (Export)

(returnsAllCompaniesWithDates=Map[FinancialData[#,"Return",{{2013,11,25},{2018,11,23}}]&,companiesTickers];
pricesAllCompaniesWithDates=Map[FinancialData[#,{{2013,11,25},{2018,11,23}}]&,companiesTickers];)//Timing

Pro jistotu data exportujeme, nebudeme pak závislí na připojení k Internetu.

Export ve formátu *.XLSX:

SetDirectory[NotebookDirectory[]];
Export["returnsAllCompaniesWithDates.XLSX",returnsAllCompaniesWithDates];
Export["pricesAllCompaniesWithDates.XLSX",pricesAllCompaniesWithDates];

Případný import (je rychlejší než načtení z předchozí sekce)

SetDirectory[NotebookDirectory[]];returnsAllCompaniesWithDates=Import["returnsAllCompaniesWithDates.XLSX"]
pricesAllCompaniesWithDates=Import["pricesAllCompaniesWithDates.XLSX"]

{Dimensions@returnsAllCompaniesWithDates,Dimensions@pricesAllCompaniesWithDates}

Předběžné zpracování, eliminace kalendářních dat (dále datumů)

Zjistíme, kolik záznamů máme od jednotlivých firem:

Map[Length,returnsAllCompaniesWithDates]

Vidíme, že počty záznamů se liší. Nejpravděpodobnější vysvětlení je, že některé firmy nebyly v některých obchodních dnech obchodované nebo je chyba v záznamech.

Pomocí následující procedury zjistíme dny, ve kterých byly obchodovány všechny tituly (CommonDates). Záznamy z těchto dnů vybereme a budeme s nimi dále pracovat. Nazýváme je konsolidované záznamy. Stejnou délku časových řad potřebujeme např. pro výpočet korelační či rozptylové matice.

Myšlenka procedury  “konsolidace” je jednoduchá, pochopení jednotlivých kroků poněkud náročnější. 
1. krok (allDates): pro každou firmu se vyberou data (datumy), ve kterých byla obchodována.
2. krok (commonDates): Provede se průnik dat (datumů) z 1. kroku. Tím dostaneme soubor datumů, ve kterých byly obchodovány všechny tituly.
3. krok (selectedRecords): Podle commonDates se vyberou záznamy z původního souboru.

(* ** *)
Clear[recordsConsolidation]
recordsConsolidation[records_]:=Module[
{n=Length[records],allDates,commonDates,selectedRecords},
allDates=Map[Map[First,records[[#]]]&,Range[Length[records]]];
commonDates=Intersection[Apply[Sequence,allDates]];
selectedRecords=Map[Select[#,MemberQ[commonDates,First[#]]&]&,records]
]

returnsAllCompaniesWithCommonDates=recordsConsolidation[returnsAllCompaniesWithDates];
%//Dimensions

Map[Length,returnsAllCompaniesWithCommonDates]

Pro další potřeby si společné datumy “vytáhneme” z procedury. (Alternativně jsme mohli tyto datumy mít jako část výstupu z procedury - tím by se ale procedura stala ještě méně “průhledná”.

returnsAllCompaniesWithCommonDates//Dimensions
(* 12 firem, 1247 společných obchodních dní, 2 položky pro každý záznam {{datum},return} *)

(commonDates=returnsAllCompaniesWithCommonDates[[1,All,1]])//Short
Length[commonDates]

Podívejme se na strukturu:

returnsAllCompaniesWithCommonDates//Dimensions
returnsAllCompaniesWithCommonDates[[All,All,1;;2]]//Dimensions
(* Záznamy všech firem pro první tři datumy: *)
returnsAllCompaniesWithCommonDates[[All,1;;3,All]]

Dále se budeme zabývat pouze hodnotami, eliminujeme datumy:

returnsAllCompaniesWithoutDates=returnsAllCompaniesWithCommonDates[[All,All,2]];
%//Dimensions
SetDirectory[NotebookDirectory[]];
Save["returnsAllCompaniesWithoutDates",returnsAllCompaniesWithoutDates];

***Chceme pracovat pouze s nějakým časovým úsekem (window), zde vyjádřený indexy, např. období [t,t+y], 1≤t≤t+y≤1247. Zde 1247=Length[commonDates]. Odpovídající funkce:

(* *** *)ClearAll[windowOnReturnsAllCompanies]
windowOnReturnsAllCompanies[t_,y_]:=returnsAllCompaniesWithoutDates[[All,t;;t+y]]
(* Poslední tři záznamy pro všechny firmy *)windowOnReturnsAllCompanies[Length[commonDates]-2,2]

Vytvoření asociace

companiesTickers={"sap","xom","emr","glp","cvs","nvs","mdlz","blk","hd","crm","wfc","ba"}//ToUpperCase

(companiesNames=Map[{#,FinancialData[#,"Name"],FinancialData[#,"Company"],FinancialData[#,"Sector"]}&,companiesTickers])//TableForm

Klíče: Tickers (companiesTickers) {SAP,XOM,EMR,GLP,CVS,NVS,MDLZ,BLK,HD,CRM,WFC,BA})
Hodnoty: matice {datumy, výnosy} 1247×2 pro každou firmu (returnsAllCompaniesWithCommonDates)

companiesTickers={"sap","xom","emr","glp","cvs","nvs","mdlz","blk","hd","crm","wfc","ba"}//ToUpperCase

associationReturns12companies=AssociationThread[companiesTickers->returnsAllCompaniesWithCommonDates];

SetDirectory[NotebookDirectory[]];
Save["associationReturns12companies",associationReturns12companies];

(*Export["associationReturns12companies.csv",associationReturns12companies]; *)

associationReturns12companiesGet=Get["associationReturns12companies"];

AssociationQ[associationReturns12companiesGet]

(* assocCSV=Import["associationReturns12companies.csv"]; *)
(* AssociationQ[assocCSV] *)

Keys[associationReturns12companiesGet]
Values[associationReturns12companies]

Take[associationReturns12companies["BA"],3]

DateListPlot[associationReturns12companiesGet["BA"],PlotRange->All]

ListPlot[associationReturns12companiesGet["BA"][[All,2]],PlotStyle->PointSize[0.01],PlotRange->All]

Výnosy, korelační a kovarianční struktura

Všechny záznamy:

(* returnsAllCompaniesWithoutDates=Get["returnsAllCompaniesWithoutDates"]; *)
expectedReturnsAll=Mean[dataMatrix=returnsAllCompaniesWithoutDates//Transpose]

**Rozptylová i korelační matice jsou symetrické, navíc na diagonále korelační matice jsou jedničky. Celá matice tedy obsahuje redundantní informaci. ⟹ Úsporné zobrazení kovariancí a korelací v jedné matici: horní trojúhelník na diagonále rozptyly, nad diagonálou kovariance; dolní trojúhelník pod diagonálou korelace. Barevné rozlišení: rozptyly - červeně, kovariance modře, korelace zeleně.

(covupper=UpperTriangularize[Covariance[dataMatrix]])//MatrixForm;
(covlower=LowerTriangularize[Correlation[dataMatrix],-1])//MatrixForm;
(mix=covupper+covlower)//MatrixForm
ReplacePart[mix,{i_,i_}:>Style[mix[[i,i]],Red]];
ReplacePart[%,{i_,j_}:>Style[mix[[i,j]],Blue]/;i<j];
ReplacePart[%,{i_,j_}:>Style[mix[[i,j]],Green]/;i>j];
(%)//MatrixForm

(correlationMatrixReturnsAll=Correlation[returnsAllCompaniesWithoutDates//Transpose])//MatrixForm
covarianceMatrixReturnsAll=Covariance[returnsAllCompaniesWithoutDates//Transpose];
%//Dimensions

Determinant kovarianční matice a charakteristická čísla

Through[{Det,Eigenvalues}[ covarianceMatrixReturnsAll]]

Je vidět, že rozptylová matice je prakticky singulární (viz condition number of a matrix). To je zapotřebí mít na zřeteli při dalších výpočtech a při interpretaci výsledků.

Optimální portfolio (Markowitz) 1

Úloha: Minimalizovat riziko neboli rozptyl výnosu portfolia při předepsaném očekávaném výnosu a jednotkovém investovaném bohatství.

(* Váhy portfolia *)
Clear[xx,x]
 xx=Array[x,Length[expectedReturnsAll]]

Předpoklady eficientního trhu?

sdReturnsAll=(Sqrt[Diagonal[covarianceMatrixReturnsAll]]);
TableForm[{expectedReturnsAll,sdReturnsAll}//Transpose//Sort,TableHeadings->{None,{"Return","Risk"}}]

Racionální uvažování: Při záporných očekávaných výnosech a při zakázaných prodejích nakrátko nebude žádný investor kupovat tituly se záporným očekávaným výnosem.

Účelová funkce a omezení:

ClearAll[objectiveFunction,constraintsShortSalesAllowed,constraintsShortSalesNotAllowed]
objectiveFunction[xx_,cov_]:=xx.cov.xx
constraintsShortSalesAllowed[xx_,ee_(* expectedReturns *),μ_(* target return *)]:={Total[xx]==1,xx.ee==μ}
constraintsShortSalesNotAllowed[xx_,ee_(* expectedReturns *),μ_(* target return *)]:={Total[xx]==1,xx.ee==μ,Thread[xx≥0]}//Flatten

Odpovídající výnos a risiko (ShortSalesAllowed)

attempt1=NMinimize[{objectiveFunction[xx,covarianceMatrixReturnsAll],constraintsShortSalesAllowed[xx,expectedReturnsAll,0.00024]},xx]

Total[xx/.attempt1[[2]]]

Row@{"Return = ",(xx/.attempt1[[2]]).expectedReturnsAll,"   Risk =  ",
((xx/.attempt1[[2]]).covarianceMatrixReturnsAll.(xx/.attempt1[[2]]))//Sqrt}

Odpovídající výnos a risiko (ShortSalesNotAllowed)

constraintsShortSalesNotAllowed[xx,expectedReturnsAll,0.00024]

attempt2=NMinimize[{objectiveFunction[xx,covarianceMatrixReturnsAll],constraintsShortSalesNotAllowed[xx,expectedReturnsAll,0.00024]},xx]

Total[xx/.attempt2[[2]]]

Row@{"Return = ",(xx/.attempt2[[2]]).expectedReturnsAll,"   Risk =  ",
((xx/.attempt2[[2]]).covarianceMatrixReturnsAll.(xx/.attempt2[[2]]))//Sqrt}

***Optimální portfolio (Markowitz) 2

(* Nefunguje??? *)attempt2WorkingPrecision100=NMinimize[{objectiveFunction[xx,covarianceMatrixReturnsAll],constraintsShortSalesNotAllowed[xx,expectedReturnsAll,0.00024]},xx,WorkingPrecision->100]

Row@{"Return = ",(xx/.attempt2WorkingPrecision100[[2]]).expectedReturnsAll,"   Risk =  ",
((xx/.attempt2WorkingPrecision100[[2]]).covarianceMatrixReturnsAll.(xx/.attempt2WorkingPrecision100[[2]]))//Sqrt}

**Inequalities instead of equalities constraints:
Short sales allowed:

Clear[objectiveFunction,constraintsShortSalesAllowedInequalities,constraintsShortSalesNotAllowedInequalities]
objectiveFunction[xx_,cov_]:=xx.cov.xx
constraintsShortSalesAllowedInequalities[xx_,ee_(* expectedReturns *),μ_(* target return *)]:={Total[xx]≤1,xx.ee≥μ}
constraintsShortSalesNotAllowedInequalities[xx_,ee_(* expectedReturns *),μ_(* target return *)]:={Total[xx]≤1,xx.ee≥μ,Thread[xx≥0]}//Flatten

attempt3Inequalities=NMinimize[{objectiveFunction[xx,covarianceMatrixReturnsAll],constraintsShortSalesAllowedInequalities[xx,expectedReturnsAll,0.00024]},xx]

Total[xx/.attempt3Inequalities[[2]]]

Row@{"Return = ",(xx/.attempt3Inequalities[[2]]).expectedReturnsAll,"   Risk =  ",
((xx/.attempt3Inequalities[[2]]).covarianceMatrixReturnsAll.(xx/.attempt3Inequalities[[2]]))//Sqrt}

Inequalities instead of equalities constraints:
Short sales not allowed:

attempt4Inequalities=NMinimize[{objectiveFunction[xx,covarianceMatrixReturnsAll],constraintsShortSalesNotAllowedInequalities[xx,expectedReturnsAll,0.00024]},xx]

Total[xx/.attempt4Inequalities[[2]]]

Row@{"Return = ",(xx/.attempt4Inequalities[[2]]).expectedReturnsAll,"   Risk =  ",
((xx/.attempt4Inequalities[[2]]).covarianceMatrixReturnsAll.(xx/.attempt4Inequalities[[2]]))//Sqrt}

***Increase WorkingPrecision

attempt2WorkingPrecision100=NMinimize[{objectiveFunction[xx,covarianceMatrixReturnsAll],constraintsShortSalesNotAllowed[xx,expectedReturnsAll,0.00024]},xx,WorkingPrecision->100]

Row@{"Return = ",(xx/.attempt2[[2]]).expectedReturnsAll,"   Risk =  ",
((xx/.attempt2[[2]]).covarianceMatrixReturnsAll.(xx/.attempt2[[2]]))//Sqrt}

Finanční funkce 2

Zakladni financni funkce a definice funkce s volbami

Zabudované finanční funkce budeme probírat později.

Uvodni poznamky

Poznámka 1

Off[Clear::ssym];
Clear[x,r,(* ⟵ zbytecne, pouziva se pouze jako argument ryzi funkce *)
c,(Subscript[r, 1]),(Subscript[r, 2]),(Subscript[r, 3]),(Subscript[i, 1]),(Subscript[i, 2]),(Subscript[i, 3]),(Subscript[i, 4])]
NestList[Function[x,(x/(1+r))],c,4]
FoldList[Function[{x,i},(x/(1+i))],c,{(Subscript[i, 1]),(Subscript[i, 2]),(Subscript[i, 3]),(Subscript[i, 4])}]
c/FoldList[#1 * (1+#2)&,1,{(Subscript[i, 1]),(Subscript[i, 2]),(Subscript[i, 3]),(Subscript[i, 4])}]
(* ekvivalentne *)
c/FoldList[Function[{x1,x2},x1(1+x2)],1,{(Subscript[i, 1]),(Subscript[i, 2]),(Subscript[i, 3]),(Subscript[i, 4])}]
On[Clear::ssym];

rr={(Subscript[r, 1]),(Subscript[r, 2]),(Subscript[r, 3])};(1/(((1+rr))^(Range[Length[rr]])))

!!!Současná hodnota 1 (ekvidistantní časové intervaly mezi platbami) 
Důležitý příklad!

Predpoklada se, ze cf je penezni tok, cf={(Subscript[cf, 0]),(Subscript[cf, 1]),...,(Subscript[cf, T])}, i konstantni hodnotici urokova mira (“constant”), ii={(Subscript[i, 1]),...,(Subscript[i, T])} promenne urokove miry (“variable”) pro obdobi 1,...,T, rr={(Subscript[R, 1]),...,(Subscript[R, T])} okamzite rocni (spotove) urokove miry pro investice se splatnostmi 1,...,T, (vynosova krivka, ”yieldcurve”). Tyto tri pripady rozlisime pomoci volby “interestrates”. Implicitne bude nastavena volba interestrates -> ”constant”.

Následující konstrukce využívají faktu, že současná hodnota je skalární součin vektoru peněžního toku a vektoru diskontních faktorů. Musí se pouze dávat pozor na délky odpovídajících vektorů a jejich první složky.

x/.{x->3,x->5,y->5}

ClearAll[pv];
Options[pv]={interestrates->"constant"};
(* dalsi mozne volby "variable" a "yieldcurve" *)

?pv

pv[cf_?(VectorQ[#]&&Length[#]>0&),i_,opts___?OptionQ]:=Module[{n=Length[cf](*=T+1*),interests},
interests=interestrates/.Flatten[{opts,Options[pv]}];
Which[interests=="constant",cf.(1/(((1+i))^(Range[n]-1))),
	interests== "variable",cf.(1/(FoldList[#1 * (1+#2)&,1,i])),
	interests=="yieldcurve",First[cf]+Rest[cf].(1/(((1+i))^(Range[n-1])))]
	 ]

?pv

Clear[cf,ii,rr,i,i1,i2,i3,r1,r2,r3,cf0,cf1,cf2,cf3];
cf={cf0,cf1,cf2,cf3};
ii={i1,i2,i3};
rr={r1,r2,r3};
(* Priklady spatneho zadani *)
{pv[1,ii],pv[{},ii],pv[,ii]}

pv[cf,i]//TraditionalForm
pv[cf,ii,interestrates->"variable"]
pv[cf,rr,interestrates->"yieldcurve"]
pv[cf,i,interests-> "variable"] //TraditionalForm
(* zadna substituce za interests v tele procedury se neprovede *)

pv[{cf0,cf1,cf2,cf3},i,in]

pv[cf,ii]
(* ekvivalentne *)
pv[cf,ii,interestrates->"constant"]
(* Substituce za interests se provede a v prepinaci Which se prejde na variantu "constant"*)

pv[cf,ii,interestrates->"CCCconstant"]

IRR: ekvidistatni casove intervaly mezi platbami

Nejjednodussi pristup (vyhledani vsech korenu) spociva v pouziti funkce NSolve. Odpovidajici algebraicka rovnice je v sice v promenne v, ale Mathematica rozpozna, ze se jedna o algebraickou rovnici i kdyz je promennou urokova mira i.

Nejprve ukazka projektu, ktery asi zadny potencialni investor nebude povazovat za realny:

i=.
cfnerealny={-1000,3600,-4310,1716};
Plot[pv[cfnerealny,i],{i,0,0.4},PlotTheme->"Detailed"]

Vnitrni mira vynosnosti se ziska takto:

i=.
irrsolv=NSolve[pv[cfnerealny,i]==0,i]
i/.irrsolv

NSolveValues[pv[cfnerealny,i]==0,i]

?i

Zde je podstatne, ze se pouzije numericka varianta Solve, tj. NSolve. Vsimneme si, co udela obecna procedura pro vyhledani korenu FindRoot (zde je nutne zadat pocatecni reseni i0)

Clear[i] je totez, co i =.

i0=.;i=.;
Table[{i0,FindRoot[pv[cfnerealny,i],{i,i0}]},{i0,0,0.5,0.05}]//TableForm

Samozrejme, ze nas nezajimaji imaginarni, a z hlediska ekonomickeho a vetsinou ani zaporna vnitrni vynosova procenta. Separace v nasledujici obecne procedure:

Clear[irr];
(* Predpoklada vyse definovanou funkci pv *)
irr[cf_]:=Module[{solutions,i},
solutions=i/.NSolve[pv[cf,i]==0,i,Reals];
Select[solutions,#>0&]				]

SeedRandom[13];
cf13=RandomReal[{-25,33},{32}]
NSolve[pv[cf13,i]==0,i,Reals]
irr[cf13]

Ještě příklad s jiným náhodným tokem

SeedRandom[313131]; 
cf313131=RandomReal[{-25,33},{30}];
Plot[pv[cf313131,i],{i,0,0.5},PlotRange->All,PlotLabel->"Present Value of Another Random Cashflow"]

irr[cf313131]

Analyzujte za cvičení:

solutions=i/.NSolve[pv[cf313131,i]==0,i]
Cases[solutions,_?((Im[#]==0&&Re[#]≥0)&)]
Cases[solutions,i_Real]
Cases[solutions,i_Real/;i≥0]

Alternativně zkuste pomocí Select.

Priklad nahodneho penezniho toku (Poučné z technického hlediska.)

Nyni priklad nahodneho penezniho toku. Uvadime tez prislusne statisticke charakeristiky

Znovu upozorňuji:
SeedRandom musí byt buď ve stejné buňce nebo před každým spuštěním funkce generující náhodná čísla musí být znovu spuštěno. Jediná bezpečná konstrukce je: ve stejné buňce!!!

i=.;
SeedRandom[13];
Text@Row@{"Mean: ",Mean[cf13=RandomReal[{-25,33},{32}]],"   Variance:   ",Variance[cf13],"   Smerodatna odchylka = "<>ToString[StandardDeviation[cf13]],"  5% percentile:   ",Quantile[cf13,0.05],"    95% percentile:   ",Quantile[cf13,0.95]}
{Min[cf13],Max[cf13]}
ListPlot[cf13,Joined->True,PlotTheme->"Marketing",PlotLabel->"A Random Cashflow"]
Plot[pv[cf13,i],{i,-1.9,-1.85},PlotRange->All,PlotLabel->"Present Value of Random Cashflow"]

NSolve[pv[cf13,i]==0,i]
Solve[pv[cf13,i]==0,i]

(allIRRs=NSolve[pv[cf13,i],i])//Length
Select[allIRRs,Im[#]==0&]

Očividně špatně. Kořenů má být 31, takže minimálně jeden musí být reálný. Systém zřejmě neprovede substituci v->(1/(1+i)). V oboru reálných čísel řešení najde:

allIRRsReals=NSolve[pv[cf13,i],i,Reals]

Solve[v==(1/(1+i)),i]

pvExpressedInTermsOfDiscountFactors=pv[cf13,i]/.Solve[v==(1/(1+i)),i]//Simplify
solutionDiscountFactors=NSolve[%==0,v]

Text@Row@{"Diskontní faktory:  ",selDiscountFactors=Select[v/.solutionDiscountFactors,Im[#]==0&],
(* Tomu odpovídají úrokové míry, z ekonomického hlediska pochopitelně nesmyslné. *)
"\nÚrokové míry:       ",Map[Function[v,((1-v)/v)],selDiscountFactors]}

Durace (ekvidistantni casove intervaly)

Clear[dur];
Options[dur]={interestrates->"constant"};
(* dalsi mozne volby "variable" a "yieldcurve" *)
dur[cf_?(VectorQ∧Length[cf]>0),i_,opts___?OptionQ]:=Module[{n=Length[cf],interests},
interests=interestrates/.Flatten[{opts,Options[pv]}];
Which[interests=="constant",((cf*(Range[n]-1)).(1/(((1+i))^(Range[n]-1))))/pv[cf,i,opts],
	interests== "variable",((cf*(Range[n]-1)).(1/(FoldList[#1 * (1+#2)&,1,i])))/pv[cf,i,opts],
	interests=="yieldcurve",((Rest[cf]*Range[n-1]).(1/(((1+i))^(Range[n-1]))))/pv[cf,i,opts]]
	 ]

Nejdříve ukázky chybných volání:

ClearAll[cf,ii,rr,i1,i2,i3]
cf={cf0,cf1,cf2,cf3};
ii={i1,i2,i3};
rr={r1,r2,r3};
{dur[1,ii],dur[{},ii],dur[,ii]}

dur[cf,i]//TraditionalForm
dur[cf,ii,interestrates->"variable"]
dur[cf,rr,interestrates->"yieldcurve"]
dur[cf,i,in] (* in nemuze byt uvazovano jako option, vrati tedy dur[... *)

dur[{cf0,cf1,cf2,cf3},i,in]

Cviceni: Jaky je profil durace, zahrneme-li do grafu IRR?

Konec 2021-12-17

2022-01-07 Lekce 12

FAQ

Q1

A1

Finanční funkce 3

Present value of a coupon bond

Fair = dirty = hruba = spravedliva,
Pure = cista 
F... nominální hodnota
C... kupón
c=C/F... kuponova sazba!!!
t... hodnotící okamžik (settlement date)
n ... pocet obdobi do splatnosti n=T-t, invertovaný čas
i... tržní (hodnotící) úr. míra

Clear[n]
(∑_(j=1)^n)(v^j)//TraditionalForm

Clear[dirtyvalue,purevalue];
(* Vyzkousejte okamzite i odlozene prirazeni *)
dirtyvalue[c_,F_,n_,i_]=Module[{v},c F (v^(n-Floor[n])) (∑_(j=0)^(Floor[n]))(v^j)+F (v^n)/.v->(1/(1+i))]
purevalue[c_,F_,n_,i_]:=Module[{v},F ((v^n)+((c v ((v^n)-1))/(v-1)))/.v->(1/(1+i))]

Kuponova obligace s kuponovou sazbou c=0.1, splatnost T=10, nominalni hodnota F=1, hodnotici urokova sazba i=0.15, tj. diskontni obligace.

Znazorneno ve skutecnem (a ne invertovanem) case

p12=Plot[{dirtyvalue[0.1,1,10-t,0.15],purevalue[0.1`,1,10-t,0.15]},{t,0,10},Exclusions->None,PlotPoints->500,AxesLabel->{t,"P,V"},PlotLegends->{"dirty value","pure value"}]

Kuponova obligace s kuponovou sazbou c=0.1, splatnost T=10, nominalni hodnota F=1, hodnotici urokova sazba i=0.1. Graf uvádíme v normálním a ne invertovaném čase!

p11=Plot[{dirtyvalue[0.1,1,10-t,0.1],purevalue[0.1`,1,10-t,0.1]},{t,0,10},Exclusions->None,PlotPoints->500,AxesLabel->{t,"P,V"},PlotLegends->{"dirty value","pure value"}]

p3=Plot[dirtyvalue[0.1`,1,10-t,0.1],{t,0,10},Exclusions->None,PlotStyle->{{Dashing[{0.01,0.01}],Black}},AxesLabel->{t,PV},PlotLegends->{"dirty value"}]

Kuponova obligace s kuponovou sazbou c=0.1, splatnost T=10, nominalni hodnota F=1, hodnotici urokova sazba i=0.05, tj. premiova obligace.

p45=Plot[{dirtyvalue[0.1,1,10-t,0.05],purevalue[0.1,1,10-t,0.05]},{t,0,10},PlotPoints->500,Exclusions->None,AxesLabel->{t,PV},PlotLegends->{"dirty value","pure value"}]

Show[p12,p3,p45,PlotRange->All]

Manipulate[Plot[{dirtyvalue[c,F,tT-t,i],purevalue[c,F,tT-t,i],purevalue[c,F,tT-t,c]},{t,0,tT},PlotPoints->500,Exclusions->None,AxesLabel->{t,PV},PlotLegends->{"dirty value","pure value"},PlotRange->{{0,tT},{0,2F}}],
{{tT,10,"T"},5,30,1,Appearance->"Labeled"},
{{c,0.1,"c"},0.01,0.20,0.01,Appearance->"Labeled"},
{{F,1,"F"},1,1000,50,Appearance->"Labeled"},
{{i,0.15,"i"},0.01,0.20,0.01,Appearance->"Labeled"},SaveDefinitions->True]

**Duration of a coupon bond

Definice durace kuponove obligace

((c f(∑_(j=1)^n)j (v^j)+f n (v^n))/(c f(∑_(j=1)^n) (v^j)+f  (v^n)))/.v->(1/(1+i))//PowerExpand//FullSimplify
%/.n->T-t//Simplify

Clear[pureduration,dirtyduration,v];
pureduration[c_,f_,n_,i_]=1+(1/i)-((1+i+c n-i n)/(i+c (-1+(((1+i))^n))))
dirtyduration[c_,f_,n_,i_]=(c f (∑_(j=0)^(Floor[n])) (n-Floor[n]+j) (v^(n-Floor[n]+j))+f n (v^n))/(c f (v^(n-Floor[n])) (∑_(j=0)^(Floor[n]))(v^j)+f (v^n))/.v->(1/(1+i))//FullSimplify

Plot[{dirtyduration[0.1,1,10-t,0.15],pureduration[0.1,1,10-t,0.15]},{t,0,10},PlotPoints->500,Exclusions->None]

Options[Plot]

Plot[{dirtyduration[0.1,1,10-t,0.05],pureduration[0.1,1,10-t,0.05]},{t,0,10},PlotPoints->500,Exclusions->None]

PV, FV, D, C, IRR, nestejne intervaly mezi platbami

Calendars (Day Count Basis, Day Count Convention)

Calendar conventions play a crucial role in time value of money. There is a variety of calendar conventions for  financial instruments.

The actual date in the form {Year, Month, Day, Hour, Minute, Second}:

{Date[],DateList[],DateList[{"2.12.2015",{"Day",".","Month",".","Year"}}]}

We may extract just the date:

{Date[],Date[][[1;;3]]}

***Ve starších verzích bylo nutné nahrát balíček:

(***)Needs["Calendar`"]
?"Calendar`*"

Tyto funkce s případně pozměněnými názvy a někdy i jinak fungující (!) jsou v posledních verzích zabudované.

Today
Today//FullForm
today=Today//First

{Today,Today//DateList}

?*Day*

{DayName[today=Date[][[{1,2,3}]]],Date[][[1;;3]],Date[][[;;3]]}

?*Date*

DateQ[Today//Normal]

Beware of the order of the dates!!! The sign may differ. Also be careful if using other systems.

DaysBetween nahrazeno funkci DateDifference:

{DateDifference[today,{2015,3,28}],DateDifference[{2015,3,28},today]}

Chceme-li však počítat, potřebujeme se zbavit”days”:

DateDifference[{2015,3,28},today]//FullForm
DateDifference[{2015,3,28},today]//First

(***){DaysBetween[today,{2015,3,28}],DaysBetween[{2015,3,28},today]}

(**){DayCount[today,{2015,3,28}],DayCount[{2015,3,28},today]}

***V některých případech je výhodnější výstup se znaménkem. To se dá zařídit i u funkce DayCount. Zabudovaná funkce DateDifference však znaménko respektuje.

Poznamenejme, že správná konstrukce by byla

(***)dayCount[date1_?(DateObjectQ[DateObject[#]]&),date2_?(DateObjectQ[DateObject[#]]&)]:= ...,

ale bohužel funkce DateObject vytvoří datum i z neexistujícího data:

(***)DateObject[{2015,112,32}]
%//DateObjectQ

(***)Clear[dayCount];
Needs["Calendar`"]
dayCount[date1_?(DateQ[Normal[#]]&),date2_?(DateQ[Normal[#]]&)]:=Module[{d1=(date1//Normal)[[1;;3]],d2=(date2//Normal)[[1;;3]]},
Sign[AbsoluteTime[d2]- AbsoluteTime[d1]] DayCount[d1,d2]]
{dayCount[Today,{2015,3,28}],dayCount[{2015,3,28},today]}

DayCount Convention

{DateDifference[{2008,1,31},Today,DayCountConvention->"Thirty360"]//First,DateDifference[Today,{2008,1,31},DayCountConvention->"Thirty360"]//First}

(* Zkopírováno z nápovědy k DayCountConvention: *)conventions={"ActualActual", "Thirty360US", "Thirty360", "ThirtyE360", "ThirtyE360ISDA", "ThirtyEPlus360", "Actual365", "Actual360", "Actual365L", "ActualActualISDA", "ActualActualICMA"}

Text@Grid[Map[{#,DateDifference[{2013,1,1},{2009,2,28},DayCountConvention->#]}&,conventions],Frame->All]

Text@Grid[Map[{#,DateDifference[{2013,1,1},{2009,2,28},"Year",DayCountConvention->#]}&,conventions],Frame->All]

DayPlus[today,50]
DayPlus[today,50]//FullForm
{DayPlus[today,50][[1]],DayPlus[today,-50][[1]]}
(DayPlus[today,50]//Normal)[[1;;3]]

Present or Future Value, Mixed Time Value,  different day count basis

Hodnotící okamžik (startday) může předcházet všem datům uvedených v dates (pak je výsledek PV), nebo naopak všechna data mohou předcházet startday (pak je výsledek FV), je-li mezi, je výsledkem smíšená časová hodnota.

Vysvětlivky (kalendář Actual/360):

dif=Map[DateDifference[Today,#]&,{{2024,3,28},{2023,1,13},{2013,1,1}}]
dif1=Map[(DateDifference[Today,#]//First)&,{{2024,3,28},{2023,1,13},{2013,1,1}}]
discounts=1/((1+r)^(dif1/360.))

Procedure:

Clear[timeValue]
timeValue[cashflow_,dates_,r_,startDay_,dayCountBasis_:"ActualActual"]:=
Module[{diskontniFaktory,pocetLetMeziDaty},
pocetLetMeziDaty=Map[(DateDifference[startDay,#,"Year",DayCountConvention->dayCountBasis]//First)&,dates];
diskontniFaktory=(1/(((1+r))^pocetLetMeziDaty));
(* sklarni soucin: *)
cashflow.diskontniFaktory]

today=Today
Map[DateDifference[today,#,"Year",DayCountConvention->"Thirty360"]&,{{2003,1,1},{2003,1,13},{2004,3,28}}]
Map[(DateDifference[today,#,"Year",DayCountConvention->"Thirty360"]//First)&,{{2003,1,1},{2003,1,13},{2004,3,28}}]
(1/(((1+r))^(%)))

cf={-50,-900,1000};
dates1={{2003,1,1},{2003,1,13},{2004,3,28}};
Plot[timeValue[cf,dates1,r,Today],{r,0,0.08}]

{minDate=Sort[dates1]//First,maxDate=Sort[dates1]//Last}

Clear[r]
{timeValue[cf,dates1,r,minDate],timeValue[cf,dates1,r,maxDate]}
%/.r->0.0425

Ještě pro kalendářovou konvenci 30/360 (Za cvičení numericky prostudujte rozdíly oproti Actual/Actual:

timeValue[cf,dates1,r,minDate, "Thirty360"]
timeValue[cf,dates1,r,maxDate, "Thirty360"]

(***)
{maxDate=Max[Map[AbsoluteTime,dates1]]//DateList,
minDate=Min[Map[AbsoluteTime,dates1]]//DateList}
GraphicsRow@{Plot[timeValue[cf,dates1,r,minDate],{r,0,0.2}],Plot[timeValue[cf,dates1,r,maxDate],{r,0,0.2}]}
Plot[timeValue[cf,dates1,r,minDate]-timeValue[cf,dates1,r,maxDate],{r,0,0.2}]

Karel IV: vzorovy priklad sporeni

Kolik vynese koruna ulozena v roce zalozeni University Karlovy na 4% p.a.? Na zacatku roku, v den zalozeni, na konci roku? Jake jsou rozdily? Poznamenejme, ze vklad pri uvedene urokove mire se zdojnasobi asi za 18 let:

TimeValue[1,0.04,18]

Ještě si připomeneme pravidlo zdvojení:

(* Doubling Rule *)
{TimeValue[1,0.07,10],TimeValue[1,.1,7]}

koruna1348={timeValue[{1},{{1348,1,1}},0.04,Today],timeValue[{1},{{1348,4,7}},0.04,Today],timeValue[{1},{{1348,12,31}},0.04,Today]}
"Rozdíly mezi úložkami:"
Most[koruna1348]-Rest[koruna1348]

Zabudované finanční funkce 1

Opticky zabudovaných finančních funkcí sice není mnoho (asi méně než 20), avšak jak je v systému Mathematica obvyklé, jsou to tzv. superfunkce. Vhodně zvolenými volbami pokryjí finanční funkce poskytované jinými systémy. Navíc je možné je snadno adpatovat a využít k vlastnímu modelování. Výklad každé jedné z nich by asi vyplnil jeden semestr. Přitom se ještě navíc předpokládá znalost příslušných matematických modelů.

Budeme probírat jen některé finanční funkce, mezi jinými FinancialDerivative. Pomocí F1 se zkuste orientovat, co ta funkce umí, jaká je struktura vstupu, apod. S ohledem na to, že struktura vstupních parametrů je komplikovaná, je vítězná strategie zkopírovat  přilbližný vstup z Help a editovat.

(* Všechny instrumenty *)
FinancialDerivative[]

Annuity

AnnuityDue

Cashflow

TimeValue

EffectiveInterest

FinancialBond

FinancialDerivative

TradingChart

InteractiveTradingChart

FinancialIndicator
FinancialIndicator[All]//Length

Finanční funkce: efektivní úroková míra, časová hodnota, peněžní tok, anuita polhůtná (Annuity immediate, in arrears), anuita předlhůtná (due, in advance)

EffectiveInterest

Clear[p,t,r,i,f];
pp=Array[(Subscript[p, #])&,{5}];
tt=Array[(Subscript[t, #])&,{5}];
rr=Array[(Subscript[r, #])&,{5}];
ii=Array[(Subscript[i, #])&,{5}];

Úročení f-krát ročně:

Clear[r,f];
{EffectiveInterest[r,1/f],
EffectiveInterest[r,1/4]}//TraditionalForm
(* spojité úročení *)
EffectiveInterest[r,0]//TraditionalForm

Series[Exp[x],{x,0,4}]

Totéž pro více úrokových měr:

EffectiveInterest[rr,1/f]//TraditionalForm
(* Frekvence úročení f=1 *)
%/.f->1

Průměrná úroková míra (geometrický průměr, Compound annual growth rate (CAGR) corresponding to a schedule of rates) Viz též příklad zde

EffectiveInterest[rr]//TraditionalForm
{%/.Thread[rr-> {.05,.065,.04,.07,.085}],Mean[{.05,.065,.04,.07,.085}]}

Efektivní ú. m. při úročení f-krát ročně:

{{0,3,5,6,10},ii}//Transpose

EffectiveInterest[{{0,3,5,6,10},ii}//Transpose,1/f]//TableForm//TraditionalForm

***Převod spotových úrokových měr (ú. m.) na forwardové ú. m.:

Převod spotových ú. m. (Subscript[R, t]) (z výnosové křivky) na forwardové ú. m.  (Subscript[f, t])  (Convert a term structure of interest rates (yield curve) to a list of implied forward rates and the corresponding intervals over which they are valid)

(Subscript[R, 1])=(Subscript[f, 1])
(((1+(Subscript[R, t])))^t)=(((1+(Subscript[R, t-1])))^(t-1))(1+(Subscript[f, t]))

Thread[((1/Range[5])//Reverse)->rr]

Pozor! Jak vidíme, u okamžitých úrokových měr se uvádí počet investičních období, u forwardových počátek překlenovacího období.

EffectiveInterest[{1->0.01,2->0.015,3->0.02}]

EffectiveInterest[Thread[((1/Range[5])//Reverse)->rr]]//TraditionalForm

Thread[((Range[Length[rr]])^2)->rr]

EffectiveInterest[Thread[((Range[Length[rr]])^2)->rr]]//TraditionalForm

EffectiveInterest[{1/12->.01,3/12->.015,6/12->.02,1->.025,2->.03,3->.032,5->.035,7->.04,10->.045}]

***Vysvětlení:

(((1+(Subscript[R, (Subscript[t, 1])])))^(Subscript[t, 1]))(((1+(Subscript[f, (Subscript[t, 1]),(Subscript[t, 2])])))^((Subscript[t, 2])-(Subscript[t, 1])))=(((1+(Subscript[R, (Subscript[t, 2])])))^(Subscript[t, 2]))

{(((((((1+0.015))^(3/12))/(((1+0.01))^(1/12)))))^(1/(3/12-1/12)))-1,(((((((1+0.02))^(6/12))/(((1+0.015))^(3/12)))))^(1/(6/12-3/12)))-1}

Nestejně dlouhá období, v praxi nejběžnější případ:

(zz={1/12->.01,3/12->.015,6/12->.02,1->.025,2->.03,3->.032,5->.035,7->.04,10->.045})/.Rule->List
(* Možné též pomocí Apply, proveďte za cvičení *)

forwardrates=EffectiveInterest[spotrates={1/12->.01,3/12->.015,6/12->.02,1->.025,2->.03,3->.032,5->.035,7->.04,10->.045}]
ListLinePlot[{spotrates/.Rule->List,forwardrates},PlotStyle->PointSize[0.015], PlotLegends->{"Spot","Forward"},PlotTheme -> "Detailed"]

Převod Spot ⟶ Forward Obecně:

Thread[Range[Length[rr]]-> rr]

EffectiveInterest[Thread[Range[Length[rr]]-> rr]]

Najit nominalni urokovou miru odpovidajici efektivni urokove mire pri ctvrtletnim uroceni:

FindRoot[EffectiveInterest[r,1/4]==.05,{r,.2}]

!Průměrná úroková míra: Ukázka nesmyslnosti aritmetického průměru

Uvažujme ceny v časech 0,1,2.

We have already seen that the only correct average of the interest rates over several periods is based on the geometric mean. Here we give a brutal example showing that the arithmetic mean may lead to a nonsense.

Consider prices at times 0,1,2: (Subscript[P, 0])=100,(Subscript[P, 1])=50,(Subscript[P, 2])=100. Then, according to the definition of  returns (Subscript[R, t]), (Subscript[R, 1])=((Subscript[P, 1])-(Subscript[P, 0]))/(Subscript[P, 0])=-1/2, (Subscript[R, 2])=((Subscript[P, 2])-(Subscript[P, 1]))/(Subscript[P, 1])=1. The arithmetic mean (Subscript[(OverBar[R]), A])=((Subscript[R, 1])+(Subscript[R, 2]))/2=1/4 or 25 per cent and the geometric mean calculated from (((1+(Subscript[(OverBar[R]), G])))^2)=(1+(Subscript[R, 1]))(1+(Subscript[R, 2])) is (Subscript[(OverBar[R]), G])=0 which sounds more realistic.

(* Vektor cen *) ceny={100,50,100};
(* Vektor výnosů *)vynosy=((Rest[ceny]-Most[ceny])/(Most[ceny]))
Row@{"Aritmetický průměr: ",Mean[vynosy], "   Geometrický průměr: ",GeometricMean[1+vynosy]-1}

Těžko je uvěřit tomu, že průměrný výnos je 25%. Průměr založený na geometrickém průměru (rovný nule) očividně více odpovídá realitě.

Zabudované finanční funkce 2
(TimeValue, FinancialBond, FormulaData)

TimeValue

TimeValue[s,i,t] calculates the time value of a security s at time t for an interest specified by i.

Základní použití

For a simple amount a and an effective interest rate i, (RefLink[TimeValue, paclet:ref/TimeValue])[a,i,t] gives the future or accumulated value of a at time t.

(RefLink[TimeValue, paclet:ref/TimeValue])[a,i,-t] gives the present or discounted value of a simple amount a for an effective interest rate i.

Clear[i,v,T,PMT,FV,PV];
{(* FV *) TimeValue[PV,i,T]//TraditionalForm,
(* PV *) TimeValue[FV,i,-T]//TraditionalForm}

Cashflow a TimeValue

Cashflow[{(Subscript[cf, 0]),(Subscript[cf, 1]),...,(Subscript[cf, T])}] representuje peněžní tok v časech 0,1,...,T.

Cashflow[{(Subscript[cf, 0]),(Subscript[cf, 1]),...,(Subscript[cf, T])},q] representuje peněžní tok v časech 0,q,2q,...,T,q.

V (RefLink[Cashflow, paclet:ref/Cashflow])[{{(Subscript[time, 1]),(Subscript[c, 1])},…}],  (Subscript[time, i]) může být numerická hodnota nebo kalendářní datum.

Definice peněžního toku a něco k procvičení:

cfObject=Cashflow[cf={{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}];

(* Grafické znázornění *)
DateListPlot[cfObject]

cfObject//FullForm

(* Hlavička Cashflow se nelíbí, odstraníme: *)
DateListPlot[cfObject[[1]]]

(* Alternatině *)
(* Dvojice {datum, položka} dostaneme výměnou hlavičky Cashflow za List  *)
cfObject/.Cashflow->List
(* nebo *)
Apply[List,cfObject]
%//DateListPlot
(* Jedny závorky navíc se odstraní *)
(cfObject/.Cashflow->List)[[1]]

Hodnocení k datu {2009,1,1}, hodnoticí úroková míra .08:

Row@{"Present value:   ",TimeValue[Cashflow[cf={{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}],.08,{2009,1,1}]}
GraphicsRow@{DateListPlot[cf,PlotStyle->Thick,PlotLabel->"Cashflow"],
Plot[TimeValue[Cashflow[cf={{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}],r,{2009,1,1}],{r,0,.2},PlotLabel->"PV profile",PlotTheme->"Marketing"]}

Vnitřní míry výnosnosti - liší se datum! (Proč jsou v obou případech IRR totožná?)

{FindRoot[TimeValue[Cashflow[{{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}],r,{2000,1,1}],{r,0.1}],FindRoot[TimeValue[Cashflow[{{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}],r,{2019,1,1}],{r,0.1}]}

{TimeValue[Cashflow[{{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}],r,{2000,1,1}],TimeValue[Cashflow[{{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}],r,{2019,1,1}]}

TimeValue[Cashflow[{{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}],r,{2000,1,1}]
NSolveValues[TimeValue[Cashflow[{{{2010,1,1},-600},{{2011,1,1},300},{{2012,1,1},400}}],r,{2000,1,1}]==0,r]

Ale vnitřní míry výnosnosti pro jiný peněžní tok ({2010,1,1} -> {2010,1,15}) (Proč nejde použít NSolve?)

tv2=TimeValue[Cashflow[{{{2010,1,15},-600},{{2011,1,1},300},{{2012,1,1},400}}],r,{2000,1,1}]
NSolve[tv2==0,r]

FindRoot[tv2==0,{r,0.2}]

Obecný peněžní tok

Clear[CF];
Text@Row@{"PV(CF,i) = ",
TimeValue[ccff=Cashflow[ccfftab=Table[(Subscript[CF, i]),{i,0,5}]],i,0]}
Text@Row@{"FV(CF,i) = ",TimeValue[ccff=Cashflow[ccfftab=Table[(Subscript[CF, i]),{i,0,5}]],i,Length[ccfftab]-1](* = 5 *)}

Promenne urokove miry po obdobich

ii=Table[(Subscript[i, j]),{j,1,5}];
Text@Row@{"PV(CF,i) = ",TimeValue[ccff,ii,0]}
Row@{"\nFV(CF,ii) = ",TimeValue[ccff,ii,5]}

Urokove miry ze spotove vynosove krivky

RR=Table[(Subscript[R, j]),{j,1,5}];
ccff
rulesRR=Thread[Range[Length[RR]]->RR]
Print["PV(CF,RR) = ",TimeValue[ccff,rulesRR,0]]

Annuity, AnnuityDue

Soucasna hodnota polhutni anuity (Annuity Immediate), T... pocet splatek, PMT... pravidelna splatka, i... hodnotici urokova mira, v=1/(1+i) ... diskontni faktor

{TimeValue[Annuity[PMT,T],i,0]//TraditionalForm,
(pvAnnuityImmediate=TimeValue[Annuity[PMT,T],i,0]//Simplify),(pvAnnuityImmediate/.{i->((1-v)/v)})}//FullSimplify[#,Assumptions->{v>0}]&//TraditionalForm

PV perpetuity:

Limit[TimeValue[Annuity[PMT,T],i,0]//Simplify,T->∞]
%[[1]]
(* nebo *)
(* *** *)
Limit[TimeValue[Annuity[PMT,T],i,0]//Simplify,T->∞,GenerateConditions->False]

Limit[((PMT-(((1+i))^(-T)) PMT)/i),T->∞,Assumptions->i>0]

Budouci hodnota polhutni anuity (Annuity Immediate)

TimeValue[Annuity[PMT,T],i,T]//TraditionalForm

Soucasna hodnota predlhutni anuity (Annuity Due)

{pvAnnuityDue=TimeValue[AnnuityDue[PMT,T],i,0]//FullSimplify,pvAnnuityDue/.{i->((1-v)/v)}//Simplify[#,Assumptions->{v>0}]&}//TraditionalForm

(pvAnnuityDue/pvAnnuityImmediate)//Simplify

Budouci hodnota predlhutni anuity (Annuity Due)

TimeValue[AnnuityDue[PMT,T],i,T]//TraditionalForm

FinancialBond (obligace, dluhopis)

Pozor!!!: jiná terminologie, nutné se naučit. Vlastní použití pomocí F1 Help na funkci:

FinancialBond

Označení: “FaceValue” nominální hodnota F, “Coupon” kuponova sazba c, “Maturity” doba do splatnosti od okamziku vydani T, “Settlement” hodnotici okamzik t, “InterestRate” hodnotici urokova mira r, trzni urokova mira pro srovnatelnou investici, cenu kapitalu, “CouponInterval” rocni frekvence vyplaty kuponu 1/f, (f=2 znamena dvakrat rocne), “DayCountBasis” kalendářová konvence, “AccruedInterest” alikvotni urok (AI), “Value” čistá cena (bez AI) , “FullValue” hrubá, spravedlivá cena (včetně AI)

Spravedlivá cena = Čistá cena + alikvótní úrok
FullValue = Value + AccruedInterest

POZOR NA SYNTAXI!!! PRI RESENI ULOH ZKOPIRUJTE Z HELPU!!!

Poznámka: Properties:

({{"Value", price adjusted for accrued interest}, {"FullValue", unadjusted price}, {"AccruedInterest", accrued interest at settlement}, {"Duration", Macaulay duration}, {"ModifiedDuration", modified duration}, {"Convexity", convexity}, {"CouponPeriodDays", days in coupon period containing the settlement}, {"CouponToSettlementDays", days from previous coupon to settlement}, {"SettlementToCouponDays", days from settlement to next coupon}, {"NextCouponDate", next coupon date}, {"PreviousCouponDate", previous coupon date}, {"RemainingCoupons", remaining coupon payments}})

1 Priklad

Současná hodnotící úroková míra je  6%. Jaká je čistá cena kuponové obligace splatné za 30 let s roční kuponovou sazbou 5.75% a nominální hodnotou 1000Kč?

FinancialBond[{"FaceValue"->1000,"Coupon"->0.0575,"Maturity"->30},{"InterestRate"->0.06,"Settlement"->0}]

Současná hodnotící úroková míra je  6%. Jaká je spravedlivá cena kuponové obligace splatné za 30 let s roční kuponovou sazbou 5.75% a nominální hodnotou 1000Kč?

FinancialBond[{"FaceValue"->1000,"Coupon"->0.0575,"Maturity"->30},{"InterestRate"->0.06,"Settlement"->0},"FullValue"]

2 Priklad

10 - letá obligace, nominální hodnota 1000Kč, kupon dvakrát ročně, kuponová sazba 5.75% p.a., hodnocená 9 měsíců po vydání, hodnotící úr. míra r=5% p.a., čistá cena:

FinancialBond[{"FaceValue"->1000,"Coupon"->0.0575,"Maturity"->10,"CouponInterval"->(1/2)},{"InterestRate"->0.05,"Settlement"->(9/12)}]

Spravedlivá cena:

FinancialBond[{"FaceValue"->1000,"Coupon"->0.0575,"Maturity"->10,"CouponInterval"->(1/2)},{"InterestRate"->0.05,"Settlement"->(9/12)},"FullValue"]

Alikvótní úrok:

FinancialBond[{"FaceValue"->1000,"Coupon"->0.0575,"Maturity"->10,"CouponInterval"->(1/2)},{"InterestRate"->0.05,"Settlement"->(9/12)},"AccruedInterest"]

3 !!!Priklad

F=1000, c=0.04, kupon ctvrtletni, splatnost 31. 12. 2030, hodnocena ke dni 3. 1. 2017, r=0.06.

FinancialBond[{"FaceValue"->1000,"Coupon"->0.04,"Maturity"->{2030,12,31},"CouponInterval"->(1/4)},{"InterestRate"->.06,"Settlement"->{2017,1,3}}(* ,"Value" *)]

Graficky v závislosti na hodnotící úrokové míře (přesné vstupní hodnoty) a problém: podezřelý graf a doba výpočtu

Plot[FinancialBond[{"FaceValue"->1000,"Coupon"->4/100,"Maturity"->{2030,12,31},"CouponInterval"->(1/4)},{"InterestRate"->r,"Settlement"->{2017,1,3}}],{r,0,.15}]

Graficky v závislosti na hodnotící úrokové míře (přibližné vstupní hodnoty, dva prakticky stejné intervaly pro intervaly úrokové míry): problémy setrvávají

GraphicsRow@{Plot[FinancialBond[{"FaceValue"->1000.,"Coupon"->.04,"Maturity"->{2030,12,31},"CouponInterval"->.25},{"InterestRate"->r,"Settlement"->{2017,1,3}}],{r,0.,.15}],Plot[FinancialBond[{"FaceValue"->1000.,"Coupon"->.04,"Maturity"->{2030,12,31},"CouponInterval"->.25},{"InterestRate"->r,"Settlement"->{2017,1,3}}],{r,0.,.13}]}

V tomto případě jednoduchá odpomoc: Evaluate

Plot[FinancialBond[{"FaceValue"->1000,"Coupon"->4/100,"Maturity"->{2030,12,31},"CouponInterval"->(1/4)},{"InterestRate"->r,"Settlement"->{2017,1,3}}]//Evaluate,{r,0,.15}]

Ještě jedna univerzálně použitelná metoda spočívá v tom, že se nejdříve předem spočítá to, co se spočítat dá a teprve poté použijeme pro konstrukci grafu, tabulky atp. Všimněte si času výpočtu. V tomto případě je v podstatě jedno, zda ve funkci FinancialBond zadáme přesné nebo přibližné hodnoty.

fb20220107precise=FinancialBond[{"FaceValue"->1000,"Coupon"->4/100,"Maturity"->{2030,12,31},"CouponInterval"->(1/4)},{"InterestRate"->r,"Settlement"->{2017,1,3}}]//Assuming[r>0,Simplify[#]]&
Plot[fb20220107precise,{r,0,.15}]

(* Připomeňme, že jakmile kdekoli ve výrazu napíšeme přibližné číslo (stačí za libovolným přesným číslem dát desetinnou tečku, zde u "CouponInterval" místo 1/4 píšeme 1./4),
je celý výraz považován za přibližný. *)fb20220107approx=FinancialBond[{"FaceValue"->1000,"Coupon"->4/100,"Maturity"->{2030,12,31},"CouponInterval"->(1./4)},{"InterestRate"->r,"Settlement"->{2017,1,3}}]//Assuming[r>0,Simplify[#]]&
Plot[fb20220107approx,{r,0,.15}]

*** Begin

plotInputForm=Plot[FinancialBond[{"FaceValue"->1000,"Coupon"->0.04,"Maturity"->{2030,12,31},"CouponInterval"->(1/4)},{"InterestRate"->r,"Settlement"->{2017,1,3}}],{r,0.11498,0.11499},PlotRange->All]//InputForm

casesLine=Cases[plotInputForm,Line[___],∞][[1]][[1]];
casesLineSort=Sort[casesLine,#1[[2]]>#2[[2]]&]

*** End

4a  Priklad (alikvótní úrok, různé kalendáře)

Alikvotni urok pri kalendarich Automatic, “30/360”, “Actual/365”, "Actual/360". Ostatni je zrejme z predchoziho vykladu.

Map[{#,FinancialBond[{"FaceValue"->1000,"Coupon"->0.07,"Maturity"->{2030,12,31},"CouponInterval"->(1/2)},{"InterestRate"->0.06,"Settlement"->{2017,11,15},"DayCountBasis"->#},"AccruedInterest"]}&,{Automatic,"30/360","Actual/365","Actual/360"}]//
(* *** *)TableForm[#,TableHeadings->{None,{"Kalendářová konvence","Alikvótní úrok"}}]&

Více kalendářů:

calendars={"30/360","30E/360","30E/360German","30E+/360","ActualICMA","ActualISDA","Actual/365","Actual/360","Actual/365L","ActualAFB"};

Map[{#,FinancialBond[{"FaceValue"->1000,"Coupon"->0.07,"Maturity"->{2030,12,31},"CouponInterval"->(1/2)},{"InterestRate"->0.06,"Settlement"->{2017,11,15},"DayCountBasis"->#},"AccruedInterest"]}&,{Automatic,calendars}//Flatten]//
(* *** *)TableForm[#,TableHeadings->{None,{"Kalendářová konvence","Alikvótní úrok"}}]&

4b  Priklad (alikvótní úrok, různá hodnotící data)

Table[{settle,FinancialBond[{"FaceValue"->1000,"Coupon"->0.07,"Maturity"->{2030,12,31},"CouponInterval"->(1/2)},{"InterestRate"->0.06,"Settlement"->settle,"DayCountBasis"->"Actual/360"},"AccruedInterest"]},{settle,{{2010,11,12},{2010,12,12},{2010,12,30},{2010,12,31}}}];
Grid[Prepend[%,{"Settlement","Accrued Interest"}],Dividers->{{False,True},{False,True}}]

Zde je zdánlivý paradox (alikvótní úrok je větší než kupónová platba) je způsoben použitým kalendářem Actual/360.

ListPlot[Table[FinancialBond[{"FaceValue"->1000,"Coupon"->0.07,"Maturity"->{2030,12,31},"CouponInterval"->(1/2)},{"InterestRate"->0.06,"Settlement"->DayPlus[{2010,11,0},d],"DayCountBasis"->"Actual/360"},"AccruedInterest"],{d,1,80}]]

Table[FinancialBond[{"FaceValue"->1000,"Coupon"->0.07,"Maturity"->{2030,12,31},"CouponInterval"->(1/2)},{"InterestRate"->0.06,"Settlement"->DayPlus[{2010,11,0},d],"DayCountBasis"->"Actual/360"},"AccruedInterest"],{d,1,63}](*//TableForm *)

Cviceni:
Graficky znazornete alikvotni urok jako funkci hodnoticiho data pro obdobi 1.11.2010 az 31.12.2013. Navod: Pouzijte funkci DatePlus nebo DayPlus .

5 Priklad

Vynos do splatnosti (YTM, Yield To Maturity, zde nazyvany “Implied yield to maturity”) obligace, ktera se 3. 5. 2013 prodavala za trzni cenu 900.

FinancialBond[{"FaceValue"->1000,"Coupon"->0.05,"Maturity"->{2018,6,31},"CouponInterval"->(1/4)},{"InterestRate"->i,"Settlement"->{2013,5,3}},"FullValue"]

FindRoot[FinancialBond[{"FaceValue"->1000,"Coupon"->0.05,"Maturity"->{2018,6,31},"CouponInterval"->(1/4)},{"InterestRate"->ytm,"Settlement"->{2013,5,3}},"FullValue"]==900,{ytm,.1}]

Home 6 Priklad

konkretnihodnoty0={F->1000,c->0.05,T->10,f->1,r->0.06};konkretnihodnoty1={F->1000,c->0.05,T->10,f->1,r->0.06,t->0};
konkretnihodnoty2={F->1000,c->0.05,T->10,f->1,r->0.06,t->1/2};

Explicitní vzorec a ceny pro konkrétní hodnoty:

(fbCleanValue=FinancialBond[{"FaceValue"->F,"Coupon"->c,"Maturity"->T,"CouponInterval"->(1/f)},{"InterestRate"->r,"Settlement"->t},"Value"])//Apart//PowerExpand//Simplify//TraditionalForm
(fbDirtyValue=FinancialBond[{"FaceValue"->F,"Coupon"->c,"Maturity"->T,"CouponInterval"->(1/f)},{"InterestRate"->r,"Settlement"->t},"FullValue"])//Apart//PowerExpand//Simplify//TraditionalForm
(* Pro konkretni hodnoty: *)
{fbDirtyValue/.konkretnihodnoty1,fbDirtyValue/.konkretnihodnoty2}
(* rozdíl mezi oběma hodnotami *)
%[[2]]-%[[1]]

{(fbDirtyValue-fbCleanValue)/.konkretnihodnoty1,(fbDirtyValue-fbCleanValue)/.konkretnihodnoty2}

Alikvótní úrok

fbAccruedInterest=FinancialBond[{"FaceValue"->F,"Coupon"->c,"Maturity"->T,"CouponInterval"->(1/f)},{"InterestRate"->r,"Settlement"->t},"AccruedInterest"]
fbAccruedInterest/.konkretnihodnoty1
fbAccruedInterest/.konkretnihodnoty2

Value (Čistá cena)

(fbPureValue=FinancialBond[{"FaceValue"->F,"Coupon"->c,"Maturity"->T,"CouponInterval"->(1/f)},{"InterestRate"->r,"Settlement"->t},"Value"])//Apart//TraditionalForm
{fbPureValue/.konkretnihodnoty1,fbPureValue/.konkretnihodnoty2}

FullValue

(fullvalue=FinancialBond[{"FaceValue"->F,"Coupon"->c,"Maturity"->T,"CouponInterval"->(1/f)},{"InterestRate"->r,"Settlement"->t},"FullValue"])//Apart//TraditionalForm
{fullvalue/.konkretnihodnoty1,fullvalue/.konkretnihodnoty2}

Plot[{fbPureValue/.konkretnihodnoty0,fbDirtyValue/.konkretnihodnoty0},{t,0,10}]

Zde by mělo by vyjít c,F{f,t}:

differenceBetweenFairValueAndPureValue=fbDirtyValue-fbPureValue//FullSimplify
{differenceBetweenFairValueAndPureValue/.konkretnihodnoty1,differenceBetweenFairValueAndPureValue/.konkretnihodnoty2}

Alikvótní úrok

(accrued=FinancialBond[{"FaceValue"->F,"Coupon"->c,"Maturity"->T,"CouponInterval"->(1/f)},{"InterestRate"->r,"Settlement"->t},"AccruedInterest"])//Apart//TraditionalForm
accrued+value==fullvalue//Simplify
{accrued/.konkretnihodnoty1,accrued/.konkretnihodnoty2}

7 Priklad (Durace, konvexita)

FinancialBond[{"FaceValue"->F,"Coupon"->c,"Maturity"->T,"CouponInterval"->(1/f)},{"InterestRate"->r,"Settlement"->0},"Duration"]//FullSimplify
(* pro roční frekvenci *)
(%/.f->1)//FullSimplify//TraditionalForm

Podobně konvexita, místo “Duration” použít “Convexity”.

Home 8 Priklad (Hodnoceni pri uziti urokovych mer ze spotove vynosove krivky 1)

vynosovakrivka=Thread[Range[5]->(RR=Table[(Subscript[R, i]),{i,5}])]
vynosovakrivka2=Thread[{1,2,3,5,10}->RR]

EffectiveInterest[vynosovakrivka]

EffectiveInterest[vynosovakrivka2]

FinancialBond[{"FaceValue"->F,"Coupon"->c,"Maturity"->5},{"InterestRate"->vynosovakrivka2,"Settlement"->0}]
%//Apart//TraditionalForm

Home 9 Priklad (Hodnoceni pri uziti urokovych mer ze spotove vynosove krivky 2)

(RefLink[FinancialBond, paclet:ref/FinancialBond]) can be given a term structure of interest rates or a list of future spot rates:

FinancialBond[{"FaceValue"->1000,"Coupon"->.035,"Maturity"->10,"CouponInterval"->1/2},{"InterestRate"->vynosovakrivka2,"Settlement"->2/12,"DayCountBasis"->"ActualISDA"}]//Simplify

FinancialBond[{"FaceValue"->1000,"Coupon"->.035,"Maturity"->10,"CouponInterval"->1/2},{"InterestRate"->{1->.02,2->.03,3->.04,5->.045,10->.06},"Settlement"->2/12,"DayCountBasis"->"ActualISDA"}]

FinancialBond[{"FaceValue"->1000,"Coupon"->.035,"Maturity"->10,"CouponInterval"->1/2},{"InterestRate"->{.03,.03,.04,.05,.05},"Settlement"->4/12,"DayCountBasis"->"Actual/365"}]

When dates are given along with a rate structure that varies with time, time 0 is assumed to occur at the nearest point before the settlement date that represents an integral number of years from the maturity date. In this case, time 0 occurs on December 31, 2010:

FinancialBond[{"FaceValue"->1000,"Coupon"->.035,"Maturity"->{2020,12,31},"CouponInterval"->1/2},{"InterestRate"->{1->.02,2->.03,3->.04,5->.045,10->.06},"Settlement"->{2011,2,4},"DayCountBasis"->"ActualISDA"}]

**FormulaData

FormulaData[]

propertiesFormulaData=FormulaData["Properties"]

FormulaLookup["duration"]

FormulaLookup["bondprice"]

bondPriceBetweenCoupons=FormulaData[{"BondPriceBetweenCoupons","DirtyPrice","RegularCoupon"}]

bondPriceBetweenCouponsProperties=Map[{#,FormulaData[{"BondPriceBetweenCoupons","DirtyPrice","RegularCoupon"},#]}&,propertiesFormulaData]//TableForm

fl=FormulaLookup["bondprice"];
Cases[fl,{"BondPriceBetweenCoupons","DirtyPrice",___}]//TableForm

***Begin

bondPriceBetweenCouponsShortFirstCoupon=FormulaData[{"BondPriceBetweenCoupons","DirtyPrice","ShortFirstCoupon"}]

Map[{#,FormulaData[{"BondPriceBetweenCoupons","DirtyPrice","ShortFirstCoupon"},#]}&,propertiesFormulaData]//TableForm

***End

Zabudované finanční funkce 3 (FinancialDerivative, Options ,Opce)

Opakování

Evropské a americké opce (vanilla options)

r ... bezriziková úr. míra (nekdy značena  (Subscript[r, 0]))
(Subscript[S, t]) ... cena podkladového aktiva (akcie) v čase t
(Subscript[c, t]) resp. (Subscript[p, t]) ... cena evropské CALL resp. PUT opce
K ... realizační cena (strike)
T ... čas vypršení evropské opce (expiry)

Výplatní funkce (payoff function) evropské opce

v okamžiku vypršení

CALL: (SuperPlus[((Subscript[S, T])-K)])

PUT: (SuperPlus[(K-(Subscript[S, T]))])

PUT - CALL parita (platí pouze pro evropské opce!)

({{({{(Subscript[S, t])+(Subscript[p, t])=(Subscript[c, t])+K,(e^(-r(T-t)))}})}})

Mnemotechnická pomůcka pro zapamatování: státní podnik = císařsko-královské

Důkaz: viz též [1], str. 54. Uvažujme portfolio +PUT +akcie -CALL, vše na stejnou akcii, opce evropské se stejnou dobou vypršení. Hodnota portfolia v čase t≤T je

({{(Subscript[Π, t])=(Subscript[S, t])+(Subscript[p, t])-(Subscript[c, t]).}})

V čase vypršení T je hodnota tohoto portfolia

({{({{(Subscript[Π, T])=(Subscript[S, T])+(SuperPlus[(K-(Subscript[S, T]))])-(SuperPlus[((Subscript[S, T])-K)]).}})}})

V případě (Subscript[S, T])≤K je (Subscript[Π, T])=(Subscript[S, T])+K-(Subscript[S, T])-0=K, v případě (Subscript[S, T])>K je (Subscript[Π, T])=(Subscript[S, T])+0-((Subscript[S, T])-K)=K. To znamená, že portfolio je bezrizikové vedoucí k jistému zisku K. Budoucí hodnota je  (Subscript[Π, T])=K  a současná hodnota je tedy (Subscript[Π, t])=K,(e^(-r(T-t))).

Současná hodnota výplatní funkce (payoff function) evropské opce v čase t≤T

Diskontujeme k času t:

CALL:   (SuperPlus[(e^(-r(T-t)))((Subscript[S, T])-K)])

PUT:   (SuperPlus[(e^(-r(T-t)))(K-(Subscript[S, T]))])

Black-Scholesův vzorec

Risk Neutral Valuation

We assume that the stochastic process of the prices of an asset  (Subscript[{(Subscript[S, t])}, t≥0]) is governed by a geometrical Brownian motion, hence

({{({{ℒ((Subscript[S, T])|(Subscript[S, t]))=L,N(ln (Subscript[S, t])+(μ-(1/2)(σ^2))(T-t),(σ^2)(T-t))}})}})

where μ is the rate of return on the underlying asset and σ its volatility.

Rizikově neutrální hodnocení: Investoři se chovají racionálně, čím větší riziko (volatilita), tím vyšší očekávaný výnos požadují. Čím nižší výnos očekávají, tím menší riziko jsou ochotni podstoupit.  Vyloučením rizikových preferencí dojdou investoři ke shodě na jediném rizikově neutrálním výnosu μ=r. Pozor, v žádném případě to neznamená, že by výnos podkladového aktiva byl roven r !!!

Alternativní princip vedoucí k témuž závěru: Očekávaný výnos z držení akcie v hodnotě (Subscript[S, t])  v období (t,T) by měl být stejný jako bezrizikový výnos z investice  ve výši (Subscript[S, t])  při úrokové míře r:

({{({{(SuperStar[E])((Subscript[S, T])|(Subscript[S, t]))=FV((Subscript[S, t]),r)=(Subscript[S, t])(e^(r(T-t)))}}).}})

Hvězdičkou zde i v dalším značíme skutečnost, že za výnos bereme rizikově-neutrální výnos r.

Neuvažujeme-li žádné rizikové preference investorů, je

({{({{(SuperStar[ℒ])((Subscript[S, T])|(Subscript[S, t]))=L,N(ln (Subscript[S, t])+(r-(1/2)(σ^2))(T-t),(σ^2)(T-t))}}).}})

Then

({{({{(SuperStar[E])((Subscript[S, T])|(Subscript[S, t]))=}})}})

Mean[LogNormalDistribution[Log[(Subscript[S, t])]+(r-(1/2)(σ^2))(T-t),σ(Sqrt[T-t])]]//Simplify//TraditionalForm

Similarly for the variance:

({{({{(SuperStar[var])((Subscript[S, T])|(Subscript[S, t]))=}})}})

Variance[LogNormalDistribution[Log[(Subscript[S, t])]+(r-(1/2)(σ^2))(T-t),σ(Sqrt[T-t])]]//Simplify//TraditionalForm

See [1], pp. 55-56.

Hodnota (cena) evropské opce

Jako přirozené se jeví vzít za hodnotu evropské opce v čase t podmíněnou střední hodnotu současné hodnoty výplatní funkce při dané hodnotě podkladového aktiva (Subscript[S, t]) při čemž střední hodnota je uvažovaná při bezrizikové (tj. rizikově neutrální) úrokové míře r:

({{({{(Subscript[c, t])=(e^(-r(T-t)))(SuperStar[E])((SuperPlus[((Subscript[S, T])-K)])|(Subscript[S, t]))}, {(Subscript[p, t])=(e^(-r(T-t)))(SuperPlus[(SuperStar[E])(K-(Subscript[S, T]))])|(Subscript[S, t]))}})}})

(* 65 sec!!! *)ct=(E^(-r(T-t)))Expectation[Max[0,((Subscript[S, T])-K)],(Subscript[S, T])\[Distributed]LogNormalDistribution[Log[(Subscript[S, t])]+(r-(1/2)(σ^2))(T-t),σ(Sqrt[T-t])]]

ct[[2,2]]//FullSimplify

Tuto formuli lze převést do běžně uváděného tvaru (Black-Scholes formula)

({{({{(Subscript[c, t])=(Subscript[S, t])Φ((Subscript[d, 1]))-K (e^(-r(T-t)))Φ((Subscript[d, 2])),
(Subscript[d, 1,2])=((log((Subscript[S, t])/K)+(r±(σ^2)/2)(T-t))/(σ(Sqrt[T-t]))).}})}})

Hodnota PUT opce se získá z PUT - CALL parity: ({{({{(Subscript[p, t])=(Subscript[c, t])+K,(e^(-r(T-t)))}})-(Subscript[S, t]).}})

**Poznámka (opce na akcie vyplácející dividendu)

Vyplácí-li akcie dividendu s dividendovou intenzitou d, pak se v předchozím vzorci nahradí r→r-d. Vyplácením dividendy se snižuje hodnota firmy a tudíž i kapitálový výnos.

**Citlivosti (Comparative Statics, The Greeks)

Statics je sice vžitý, ale asi chybně použitý termín nevystihující podstatu.

Nechť (Subscript[V, t]) označuje hodnotu CALL resp. PUT opce, (Subscript[V, t])=(Subscript[c, t]) resp. (Subscript[V, t])=(Subscript[p, t]). Z Black-Scholesova vzorce je patrné, že (Subscript[V, t]) je funkcí pěti proměnných (parametrů):

({{({{(Subscript[V, t])=(Subscript[V, t])((Subscript[S, t]),K,σ,T-t,r)}}).}})

Derivace podle jednotlivých proměnných se nazývají citlivosti a protože se označují řeckými písmeny, jsou též známé jako “The Greeks”. Jejich výpočet je přímočarý, ale v některých případech technicky dosti komplikovaný. Uvedeme jen jednu míru citlivosti delta, derivaci podle aktuální ceny akcie:

({{({{Δ=((∂(Subscript[V, t]))/(∂(Subscript[S, t])))}}).}})

Pro CALL resp. PUT dostaneme

({{({{(Subscript[Δ, c])=Φ((Subscript[d, 1]))   resp.   (Subscript[Δ, p])=(Subscript[Δ, c])-1=-Φ(}})-(Subscript[d, 1])).}})

Charakteristiky Δ se používá k tzv. delta-zajišťování, delta hedging. Uvažujme portfolio skládající se z dlouhé pozice jedné akcie a krátké pozice v A kusech CALL opcí na tutéž akcii. Hodnota portfolia je tedy (Subscript[Π, t])=(Subscript[S, t])-A,(Subscript[c, t]). Chceme najít A takové, aby hodnota portfolia byla invariantní vůči (malým) změnám ceny akcie, tj.

({{({{((∂,(Subscript[Π, t]))/(∂(Subscript[S, t])))}})=0.}})

Hledané A=1/(Subscript[Δ, c]), nazývané zajišťovací poměr, hedge ratio. Vzhledem k tomu, že se delta mění v čase, musí se portfolio často měnit → dynamické zajišťování, dynamic hedge. To může být nákladné kvůli transakčním nákladům. Tudíž vhodné pro makléře a tvůrce trhu, kteří mají relativně nízké transakční náklady. Všimněme si, že čím nižší (Subscript[S, t]) ve srovnání s K, tím vyšší je zajišťovací poměr. Podobnou mírou citlivosti je elasticita ceny CALL opce vzhledem k ceně akcie definovaná jako (Subscript[E, c])=(Subscript[Δ, c])(Subscript[S, t])/(Subscript[c, t]). Vždy je (Subscript[E, c])>1. (Dokažte za cvičení.) Proto je CALL opce vždy riskantnější než její podkladové aktivum. Analogie k Δ je durace.

**Další míry citlivosti viz [1], str. 60-61.

*Implied Volatility (Implikovaná volatilita)

Ve výše uvedeném vzorci pro (Subscript[V, t]) v okamžiku t vždy známe hodnoty (Subscript[S, t]),K,T-t,r. Při aplikaci Black-Scholesova vzorce pro neznámou volatilitu obvykle použijeme výběrovou směrodatnou odchylku z historických (známých) dat logaritmických výnosů ln((Subscript[S, t+1])/(Subscript[S, t])) pro nějaké rozumné historické hodnoty. Sofistikovanější metody jsou založené na modelech volatility typu ARCH, GARCH, jejich zobecněních a modifikacích. Viz zabudované funkce (nezahrnují zdaleka všechny dnes používané modely):

?*ARCH*

?*AR*

Můžeme ale též přistoupit k odhadu volatility jiným způsobem. V daném časovém okamžiku t, (teď, hodnotící časový okamžik), známe nejenom  hodnoty (Subscript[S, t]),K,T-t,r, ale i tržní hodnotu opce (Subscript[V, t]^M). Po substituci známých hodnot do Black-Scholesovy formule dostaneme rovnici pro neznámou σ:

({{(Subscript[V, t]^M)=({{(Subscript[V, t])((Subscript[S, t]),K,σ,T-t,r)}}).}})

Tato rovnice nemusí mít žádné řešení (řešení je nutné hledat numericky), může mít právě jedno (nejpříjemnější situace, i když i tam můžeme býti překvapeni) nebo více řešení - z těch je pak zapotřebí citlivě vybírat.

Důležité! Volatilita a implikovaná volatilita viz [1], str. 61-62.

Ilustrace

Technické záležitosti týkající se funkce FinancialDerivative:

Označení: “StrikePrice” realizacni cena K, “Expiration” doba do splatnosti, doba do vyprseni T, pokud se uvede “ReferenceTime” t, pak je to T-t,  “InterestRate” bezrizikova urokova mira (Subscript[r, 0]), “Volatility” volatilita ceny podkladoveho aktiva σ (underlying asset), “CurrentPrice” soucasna cena podkladoveho aktiva (Subscript[S, 0]) resp. (Subscript[S, t]) . “Dividend” je dividendova intenzita q. Vsechny udaje se vztahuji ke stejnemu casovemu obdobi, typicky 1 rok.

(* vsechny zabudovane derivaty, zde zvane "Contracts" *)
FinancialDerivative[](* //Length *)

POZOR NA SYNTAXI!!! PRI RESENI ULOH ZKOPIRUJTE Z HELPU!!! Typicky ma FinancialDerivative 3 az 4 argumenty, kazdy z nich je seznam (list).

1 Priklad (hodnoty opci)

(* Evropska CALL s dividendou *)
FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}]

(* Americka CALL s dividendou *)FinancialDerivative[{"American","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}]

**2 Priklad (hodnoty opci a jejich citlivosti, The Greeks)

V ... price of the option, Δ=(∂/(∂(Subscript[S, t])))V,  Γ=((∂^2)/(∂(Subscript[S, t]^2)))V,  Ρ=(∂/(∂r))V,  Θ=(∂/(∂t))V,  𝒱=(∂/(∂σ))V

Opce z predchoziho prikladu, vystupem hodnota opce a citlivosti

FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}, {"Value", "Greeks"}]

3 Priklad (Grafické znázornění závislosti ceny opce na ceně podkladového aktiva)

Manipulate[Plot[FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->T},  {"InterestRate"-> 0.1, "Volatility" ->σ, "CurrentPrice"-> s, "Dividend"->0.0}],{s,40,60},AxesOrigin->{Automatic,0},PlotRange->{0,20},PlotStyle->{Thick,Red},AxesLabel->{"(Subscript[S, t])",Automatic}],{{T,0.05},0.0001,1,Appearance->"Labeled"},{{σ,0.5},0.01,1,Appearance->"Labeled"},SaveDefinitions->True]

Manipulate[Plot[{FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->T},  {"InterestRate"-> 0.1, "Volatility" ->σ, "CurrentPrice"-> s, "Dividend"->0.0}],FinancialDerivative[{"European","Put"}, {"StrikePrice"-> 50.00, "Expiration"->T},  {"InterestRate"-> 0.1, "Volatility" ->σ, "CurrentPrice"-> s, "Dividend"->0.0}]},{s,40,60},AxesOrigin->{Automatic,0},PlotRange->{0,20},PlotStyle->Thick,AxesLabel->{Style["(Subscript[S, t])",18],Automatic},PlotLegends->{"CALL","PUT"}],{{T,0.05},0.0001,1,Appearance->"Labeled"},{{σ,0.5},0.01,1,Appearance->"Labeled"},SaveDefinitions->True]

Manipulate[Plot[FinancialDerivative[{"American","Call"}, {"StrikePrice"-> 50.00, "Expiration"->T},  {"InterestRate"-> 0.1, "Volatility" ->σ, "CurrentPrice"-> s, "Dividend"->0.0}],{s,40,60},AxesOrigin->{Automatic,0},PlotRange->{0,25},PlotStyle->Thick,AxesLabel->{"(Subscript[S, t])",Automatic}],{{T,0.05},0.0001,1,Appearance->"Labeled"},{{σ,0.5},0.01,1,Appearance->"Labeled"},SaveDefinitions->True]

4 Příklad (Grafické znázornění závislosti na ceně podkladového aktiva, různé doby do splatnosti)

Plot[{Table[FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->t},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> st, "Dividend"->0.0}],{t,{0,0.01,0.1,0.5,1}}]}//Flatten,{st,30,60},PlotLabel->"Values of CALL options for various expiry times",PlotStyle->Thick,PlotStyle->Thick,AxesLabel->{Style["(Subscript[S, t])",18],Automatic}]

Manipulate[Plot[FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->t},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> st, "Dividend"->0.0}],{st,40,60},PlotRange->{0,15},PlotStyle->{Thick,Red},AxesLabel->{Style["(Subscript[S, t])",16],Automatic}],
{{t,0,"Doba do vyprseni"},0,1,Appearance->"Labeled"},SaveDefinitions->True]

***BEGIN*****************************************************
Hodnota evropske CALL a citlivosti (Value and all Greeks of a European call option):

FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}, {"Value", "Greeks"}]

Podle (podle mne pochybne konstrukce, viz DHS)  teorie by mela byt hodnota americke CALL stejna jako evropske. Ejhle, neni!!!

FinancialDerivative[{"American","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}, {"Value", "Greeks"}]

***END***********************************************

Hodnocení derivátů typu Cap (strop) a Floor  (dno)

Důvod, proč ve funkci FinancialDerivative není volba Cap resp. Floor (přesněji Caplet a Floorlet) vidím v tom, že tyto pojmy nejsou jednoznačně definovány a možností je celá řada. Obvykle jsou však kombinací elementárních finančních instrumentů (obligací, opcí, apod.)

Uvedeme ilustraci Cap na evropskou CALL opci s dobou vypršení T a realizační cenou K. Chrání investora v krátké pozici před neomezenou ztrátou. V případě, že cena (Subscript[S, T]) podkladového aktiva je v okamžiku vypršení vyšší než B,  vyplácí se B.

vyplataCAPnaCALL[St_,K_,B_]:=Min[Max[St-K,0],B]
Plot[vyplataCAPnaCALL[st,1,2],{st,0,5},PlotStyle->Thick]

Dlouhá pozice v tomto finančním instrumentu je ekvivalentní držení portfolia dvou CALL opcí, obě se stejnou dobou vypršení, jedna v dlouhé pozici s realizační cenou K, druhá v krátké pozici s realizační cenou K+B.

vyplataportfolia[St_,K_,B_]:=Max[St-K,0]-Max[St-K-B,0]
Plot[vyplataportfolia[st,1,2],{st,0,5},PlotStyle->Thick]

Cena tohoto instrumentu podle Black-Scholesova vzorce je tedy (musíme přidat bezrizikovou úrokovou míru r,0, volatilitu σ a dobu do vypršení T,t.

Clear[cenaCAPnaCALL];
cenaCAPnaCALL[St_,K_,B_,r0_,σ_,Tt_]:=FinancialDerivative[{"European","Call"}, {"StrikePrice"-> K, "Expiration"->Tt},  {"InterestRate"-> r0, "Volatility" -> σ, "CurrentPrice"-> St}]-FinancialDerivative[{"European","Call"}, {"StrikePrice"-> K+B, "Expiration"->Tt},  {"InterestRate"-> r0, "Volatility" -> σ, "CurrentPrice"-> St}]

Plot[cenaCAPnaCALL[st,1,2,0.05,0.4,1],{st,0,5},PlotRange->{0,2},PlotStyle->Thick]

Vyzkoušejte si manipulovat s některými parametry,  v následující ilustraci K=1, B=2, (Subscript[r, 0])=0.05 jsou fixované, nezávisle proměnná je cena podkladového aktiva (Subscript[S, t]):

Manipulate[Plot[cenaCAPnaCALL[st,1,2,0.05,σ,Tt],{st,0,5},PlotRange->{0,2},PlotStyle->Thick,AxesLabel->{Style["(Subscript[S, t])",16],Automatic}],{{σ,0.3},0.1,0.5,Appearance->"Labeled"},{{Tt,1},0.01,2,Appearance->"Labeled"},SaveDefinitions->True]

FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50}, {"Value", "Greeks"}]

FinancialDerivative[{"American","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50}, {"Value", "Greeks"}]

FinancialDerivative v systému  Mathematica  (v této verzi (13) zatím omezeno jenom na opce)

FinancialDerivative

Označení: “StrikePrice” realizacni cena K, “Expiration” doba do splatnosti, doba do vyprseni T, pokud se uvede “ReferenceTime” t, pak je to T-t,  “InterestRate” bezrizikova urokova mira (Subscript[r, 0]), “Volatility” volatilita ceny podkladoveho aktiva σ (underlying asset), “CurrentPrice” soucasna cena podkladoveho aktiva (Subscript[S, 0]) resp. (Subscript[S, t]) . “Dividend” je dividendova intenzita q. Vsechny udaje se vztahuji ke stejnemu casovemu obdobi, typicky 1 rok.

(* vsechny zabudovane derivaty, zde zvane "Contracts" *)
FinancialDerivative[](* //Length *)

POZOR NA SYNTAXI!!! PRI RESENI ULOH ZKOPIRUJTE Z HELPU!!! Typicky ma FinancialDerivative 3 az 4 argumenty, kazdy z nich je seznam (list).

1 Priklad (hodnoty opci)

FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}]

FinancialDerivative[{"American","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}]

**2 Priklad (hodnoty opci a jejich citlivosti, The Greeks)

V ... price of the option, Δ=(∂/(∂(Subscript[S, t])))V,  Γ=((∂^2)/(∂(Subscript[S, t]^2)))V,  Ρ=(∂/(∂r))V,  Θ=(∂/(∂t))V,  𝒱=(∂/(∂σ))V

Opce z predchoziho prikladu, vystupem hodnota opce a citlivosti

FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}, {"Value", "Greeks"}]

3 Priklad (Graficke znazorneni)

Manipulate[Plot[FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->T},  {"InterestRate"-> 0.1, "Volatility" ->σ, "CurrentPrice"-> s, "Dividend"->0.05}],{s,40,60},AxesOrigin->{Automatic,0},PlotRange->{0,25},PlotStyle->{Thick,Red}],{{T,0.5},0.0001,1,Appearance->"Labeled"},{{σ,0.5},0.01,1,Appearance->"Labeled"},SaveDefinitions->True]

Manipulate[Plot[FinancialDerivative[{"American","Call"}, {"StrikePrice"-> 50.00, "Expiration"->T},  {"InterestRate"-> 0.1, "Volatility" ->σ, "CurrentPrice"-> s, "Dividend"->0.05}],{s,45,55},AxesOrigin->{Automatic,0},PlotRange->{0,25},PlotStyle->Thick],{{T,0.5},0.0001,1,Appearance->"Labeled"},{{σ,0.5},0.01,1,Appearance->"Labeled"},SaveDefinitions->True]

4 Priklad (Graficke znazorneni)

Plot[FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> st, "Dividend"->0.05}],{st,30,60}]

Plot[Table[FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->t},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> st, "Dividend"->0.05}],{t,{0,0.01,0.1,0.5,1}}],{st,30,60}]

Manipulate[Plot[FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->t},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> st, "Dividend"->0.05}],{st,40,60},PlotRange->{0,15},PlotStyle->Thick],
{{t,0,"Doba do vyprseni"},0,1,Appearance->"Labeled"},SaveDefinitions->True]

***BEGIN*****************************************************
Hodnota evropske CALL a citlivosti (Value and all Greeks of a European call option):

FinancialDerivative[{"European","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}, {"Value", "Greeks"}]

Podle (podle mne pochybne konstrukce, viz DHS)  teorie by mela byt hodnota americke CALL stejna jako evropske. Ejhle, neni!!!

FinancialDerivative[{"American","Call"}, {"StrikePrice"-> 50.00, "Expiration"->1},  {"InterestRate"-> 0.1, "Volatility" -> 0.5, "CurrentPrice"-> 50, "Dividend"->0.05}, {"Value", "Greeks"}]

***END***********************************************

Hodnocení derivátů typu Cap (strop) a Floor  (dno)

Důvod, proč ve funkci FinancialDerivative není volba Cap resp. Floor (přesněji Caplet a Floorlet) vidím v tom, že tyto pojmy nejsou jednoznačně definovány a možností je celá řada. Obvykle jsou však kombinací elementárních finančních instrumentů (obligací, opcí, apod.)

Uvedeme ilustraci Cap na evropskou CALL opci s dobou vypršení T a realizační cenou K. Chrání investora v krátké pozici před neomezenou ztrátou. V případě, že cena (Subscript[S, T]) podkladového aktiva je v okamžiku vypršení vyšší než B,  vyplácí se B.

vyplataCAPnaCALL[St_,K_,B_]:=Min[Max[St-K,0],B]
Plot[vyplataCAPnaCALL[st,1,2],{st,0,5},PlotStyle->Thick]

Dlouhá pozice v tomto finančním instrumentu je ekvivalentní držení portfolia dvou CALL opcí, obě se stejnou dobou vypršení, jedna v dlouhé pozici s realizační cenou K, druhá v krátké pozici s realizační cenou K+B.

vyplataportfolia[St_,K_,B_]:=Max[St-K,0]-Max[St-K-B,0]
Plot[vyplataportfolia[st,1,2],{st,0,5},PlotStyle->Thick]

Cena tohoto instrumentu podle Black-Scholesova vzorce je tedy (musíme přidat bezrizikovou úrokovou míru r,0, volatilitu σ a dobu do vypršení T,t.

Clear[cenaCAPnaCALL];
cenaCAPnaCALL[St_,K_,B_,r0_,σ_,Tt_]:=FinancialDerivative[{"European","Call"}, {"StrikePrice"-> K, "Expiration"->Tt},  {"InterestRate"-> r0, "Volatility" -> σ, "CurrentPrice"-> St}]-FinancialDerivative[{"European","Call"}, {"StrikePrice"-> K+B, "Expiration"->Tt},  {"InterestRate"-> r0, "Volatility" -> σ, "CurrentPrice"-> St}]

Plot[cenaCAPnaCALL[st,1,2,0.05,0.4,1],{st,0,5},PlotRange->{0,2},PlotStyle->Thick]

Vyzkoušejte si manipulovat s některými parametry:

Manipulate[Plot[cenaCAPnaCALL[st,1,2,0.05,σ,Tt],{st,0,5},PlotRange->{0,2},PlotStyle->Thick],{{σ,0.3},0.1,0.5,Appearance->"Labeled"},{{Tt,1},0.01,2,Appearance->"Labeled"},SaveDefinitions->True]

Konec 2022-01-07

***Misc

Actuarial Computation

Actuarial Computation:

paclet:guide/ActuarialComputation

particularly

Non-life insurance

Hyperlink["Actuarial Computation","paclet:guide/ActuarialComputation"]

FinancialData

https://demonstrations.wolfram.com/search.html?query=financial+indicator

FinancialData["^DJI","Name"]
djiMembers=FinancialData["^DJI","Members"];

(* 2018 *)
(* ** BEGIN *)
(* Zatím obtížnější, ale často užívaná konstrukce; bude vysvětleno později. *)Grid[Map[({#,FinancialData[#,"Name"],FinancialData[#,"Company"]})&,djiMembers],Frame->All]
(* ** END *)

(* 2019-10-07 *)
(* ** BEGIN *)
(* Zatím obtížnější, ale často užívaná konstrukce; bude vysvětleno později. *)Grid[Map[({#,FinancialData[#,"Name"],FinancialData[#,"Company"]})&,djiMembers],Frame->All]
(* ** END *)

Optimization

Hyperlink[Button["Optimalisace"],"paclet:guide/Optimization"]

?*Optimization*

?*Minimize*

Numerical Equation Solving and Root Finding

Hyperlink[Button["See: Numerical Equation Solving and Root Finding"],"paclet:tutorial/NumericalOperationsOnFunctions"]

2021-11-29 Estimation

SetDirectory[NotebookDirectory[]]
vwVynosy=Get["vwVynosy"];
SmoothHistogram[%]