f[x]:=x^2

f[x]

f[2]

ClearAll[f]
f[x:_]:=(x^2);
f[2]

(*list, jeden ze zakladnich objektu v Math *)
listik={1,5,8,9,{alfa,romeo},{{1,{2,3}}}};

(*vyber prvku z listu*)
listik[[3]]
Part[listik,3]

listik[[-4]]

listik[[-2]][[-1]]

listik

listik[[-2,-1]]

First[listik]

Last[listik]

listik[[-1,1,2,1]]

(*nulty prvek = "hlavicka", Head*)
listik[[0]]

listik

FullForm[listik]

TreeForm[listik]

vyr=x+Sin[3(x^2)+1]

TreeForm[vyr];

vyr[[2,1,1]]

(*ctrl , da novy sloupec, ctrl enter da novy radek*)

listik2=(({{1, 2, 6}, {5, 8, 9}, {7, 2, 13}}))

(*pro zobrazovani a JEN zobrazovani slouzi MatrixForm*)
mfl=MatrixForm[listik2]

Det[listik2]
Det[mfl]

(*Transpose  esc tr esc*)

Transpose[listik2]
MatrixForm[%]

listik2\[Transpose]

(*neni spatne si hledat v helpu "See also"*)

?Transpose

(*tvorba listu, prikaz Table*)
Table[opice,{12}]

Table[(i^2),{i,12}]

Table[i,{i,0.3,5,0.5}]

Table[(E^i)+(Pi^j),{i,5},{j,5}]
MatrixForm[%]

Table[(E^i)+(Pi^j),{i,5},{j,i+1}]
MatrixForm[%]

(*funkce a Set "=" a SetDelayed ":="*)
?=

?:=

a=2+3

?a

a:=2+3

?a

a

b=Random[]

?b

Table[b,{10}]

b:=Random[]
Table[b,{10}]

?b

(*nez budeme zkusenejsi, budeme slusnaci a jmeno funkce vdy predem vycistime*)

ClearAll[f];
f[x:_]:=Sin[π*x];
f[1]

ClearAll[f];
x=6.3;
f[x_]:=Sin[π*x]
?f

ClearAll[f];
x=6.3;
f[x_]=Sin[π*x]
f[0]
?f

ClearAll[f];
f[x_]:=Integrate[Sin[x],x]
f[1]

ClearAll[f,x];
f[x_]=Integrate[Sin[x],x]
f[1]
?f

(*za podtrzikem omezeni patternu*)
ClearAll[f];
$RecursionLimit=5000;
f[n_Integer]:=n*f[n-1];
f[0]:=1;
{f[1.6],f[5]}
(*Trace ukazuje, jak se vyraz vyhodnocuje*)
Trace[f[3]];
Timing[Table[f[i],{i,1,1500}]][[1]]

(*funkce muze pri volani menit svoji definice*)
ClearAll[f];
$RecursionLimit=5000;
f[n_Integer]:=f[n]=n*f[n-1];
f[0]:=1;
{f[1.6],f[5]}
(*Trace ukazuje, jak se vyraz vyhodnocuje*)
Trace[f[3]];
Timing[Table[f[i],{i,1,1500}]][[1]]

ClearAll[f];
$RecursionLimit=5000;
f[n_Integer]:=f[n]=n*f[n-1];
f[0]:=1;

f[5]

Trace[f[6]]

(*funkce muzeme pretezovat*)
ClearAll[f];
f[x_]:=Sin[x];
f[x_Integer]:=x;
f[5]:=0;
{f[0.1],f[3],f[5]}

ClearAll[f,test];
test[x_]:=x>2;
f[x_]:=(x^2);
f[x_?test]:=x+2;
Plot[f[x],{x,0,4}]

(*vnitrni testovaci funkce  vypadaji BlablablaQ*)

ClearAll[f];
f[n_?EvenQ]:=(n/2);
f[n_?OddQ]:=(n/Pi);
f[n_]:="ape";
{f[2],f[3],f[2.1]}

(*u pasrametru si muzeme zvolit jeho strukturu
*)
ClearAll[f];
f[{t_,y_}]:=t+2y;
{f[4],f[{E,Pi}]}

(*kdyz funkce potrebuje mezivypocty, pouzijeme prikaz Module*)
ClearAll[f];
f[x_,n_Integer]:=Module[{celaCast,necelaCast},
celaCast=Round[x];
necelaCast=x-celaCast;
celaCast+n*necelaCast
]
f[4.5,3]

(*ReplaceAll , tj. /. a Rule, tj -> a RuleDelayed, tj :->  *)

(*hodne prikazu vraci strukturu {x->neco}*)
FindRoot[Cos[x]==x,{x,0}]

Solve[(x^2)==Pi]

?/.

(*pravidla vypadaji takto*)
{x->2,Rule[x,2]}

(*jak to funguje*)
(x^2)+1/.x->E

(x^2)+1/.{x->E,x->Pi,x->1}

(x^2)+1/.{{x->E},{x->Pi},{x->1}}

(*priklad: vite, ze Total[list] secte prvky listu. Vypoctete soucet korenu rovnice (x^12)+x+1.==0*)

Solve[(x^12)+x+1.==0]
x/.%
Total[%]

(*napiste funkci, ktera vraci hodnotu x vyhovujici rovnici Cos[x]==a*x, a je parametr funkce*)
ClearAll[f];
f[a_]:=x/.FindRoot[Cos[x]==a*x,{x,0}];
f[0.5]

(*napiseme dalsi funkci, ma vracet x+y*)
ClearAll[f];
f[{a_,b_,c_,d_}]:=x+y/.Solve[{a*x+y==b,x+c*y==d}][[1]];
f[{1,2,3,4}]
?f

ClearAll[g,a,b,c,d,x,y];
g[{a_,b_,c_,d_}]=x+y/.Solve[{a*x+y==b,x+c*y==d},{x,y}][[1]];
g[{1,2,3,4}]

?g

listik=Range[10]

TreeForm[listik];

TreeForm[a+b+c+d];

listik/.List->Plus

listik/.List->Times

listik
listik/.{5->Pi,8->E}

listik=Table[i,{i,1.8,10.2,0.6}]
listik/.x_:>Round[x]

test[x_]:=x>5;
listik/.x_?test:>Round[x]

(*zde zacina treti prednes*)

(*pure functions*)

((#)^2)&[5]

#1+((#2)^2)&[Pi,E]
%//TreeForm;

Select[{1,2,4,7,6,2},#>2&]

{#>2&[6],#>2&[1]}

test[x_]:=x>2;
{test[6],test[2]}

Select[{1,2,4,7,6,2},test]

ClearAll[f,test];
test[x_]:=x>2;
f[x_]:=(x^2);
f[x_?test]:=x+2;
Plot[f[x],{x,0,4}];

ClearAll[f];
f[x_]:=(x^2);
(*potreba zavorek, znak & ma velkou prioritu*)
f[x_?(#>2&)]:=x+2;
Plot[f[x],{x,0,4}];

ClearAll[f,test];
f[x_]:=(x^2);
test=#>2&;
f[x_?test]:=x+2;
Plot[f[x],{x,0,4}];

(*Map*)
ClearAll[f];
listik=Range[10]
Map[f,listik]
f/@listik

rodina={otec,matka,syn,dcera};
ostrihejVlasy/@rodina

(*Apply*)
listik={ja,ty,on,ona};
Apply[f,listik]
f@@listik

natocPecko@@listik

TreeForm/@{listik,f@@listik}

Plus@@listik

((#)^3)&/@Range[10]
Plus@@%

((#)^3)&/@Range[10]
%/.List->Plus

matice=Table[i+j-1,{i,4},{j,4}];
matice//MatrixForm

Plus@@matice

matice/.List->Plus

(*odvoceni Simpsonova integralu*)
vyr[x_]:=a*(x^2)+b*x+c;
rce={vyr[x0-Δx]==fMinus,vyr[x0]==f0,vyr[x0+Δx]==fPlus};
solabc=Solve[rce,{a,b,c}][[1]];
integrand=vyr[x]/.solabc;
integral=Integrate[integrand,{x,x0-Δx,x0+Δx}]//Simplify

listik=Range[11];
Partition[listik,3];
Partition[listik,3,1];
Partition[listik,3,2];

nasIntegral[fce_,{a_,b_},n_?OddQ]:=Module[{Δx,xka,funkcniHodnoty,trojice},
Δx=N[((b-a)/(n-1))];
xka=Range[a,b,Δx];
funkcniHodnoty=fce/@xka;
trojice=Partition[funkcniHodnoty,3,2];
(*trojice/.{f1_?NumericQ,f2_,f3_}:>f1+4*f2+f3*)
((Δx)/3)Total[#.{1,4,1}&/@trojice]
];
nasIntegral[Sin,{0,Pi},11]

f=3*((#)^3)+1+((#)^2)+5#+6&;
integral=Integrate[f[x],{x,0,1}];
nasIntegral[f,{0,1},3];
%-%%

ClearAll[f];
Nest[f,x0,5]
NestList[f,x0,5]

NestList[Cos,0.,50];
%//ListPlot