1+1

(*takto vypada komentar*)
(*Funguje podobne jako komunikace na webu, tj napisi co pozaduji, Shift+Enter odeslu do kernelu(jadra) a dostanu vystup*)

2

(Sqrt[2])

(*odmocninu muzeme napsat pomoci Palettes/Other/Basic Math Input, nebo dalsi moznost Ctrl+2   *)

(Sqrt[4])

(*Vysledek je vzdy nejkratsi a nejpresnejsi odpoved*)

(Sqrt[2.])

(*Nepresnou dvojiku vytvorim pomoci 2.  *)

(30/7)

(*Zlomek mohu vytvorit klavesovou zkratkou ctrl+/*)

(30/7.)

N[(30/7)]

(*Pouziti funkce N pro vycisleni zlomku*)

N[1/7,50]

(*Funkce muze mit dva parametry, druhy urcuje pocet platnych cislic (v tomto pripade 50)*)

x
cos
(*modra barva znamena, ze symbol jeste neni v jadre, funkce implementovane uvnir jadra pri spusteni zacinaji velkym pismenem*)
π
(*Pi mohu vzit z palety a nebo Esc+p+Esc*)
Cos

d=5

(* Na prirazeni hodnoty do promene pouzije jedno = (v tomto pripade do d davam 5), neni nutne specifikovat typ promenne predem (int, funkce, pole,...) *)

ClearAll[d]

(*Funkce ClearAll vymaze vsechny promenne na ktere ji aplikuji*)

d=5;
C=2+d
(*Pripravene funkce v jadru nelze prepsat, po tomto prikazu prijde, ze C je Protected*)

Sin=3

N=2+d

a=3
b=2
b==4
(*Pro rovnice pouzivame dvojity = , (ptáme se na to zda b je rovno 4)*)

b==a

a=2
b==a

Solve[x*Log[x]==2,x]
(*Funkce Solve pocita nediferencialni rovnice, prvni argument je rovnice, druhy je co chci vypocitat*)

FindRoot[x*Log[x]==2,{x,2}]
(*Funkce FindRoot pocita nediferencialni rovnice ale numerickym, prvni argument je rovnice, druha je list ve tvaru{co chci pocitat, kde zacni}*)

FindRoot[Sin[x]==0,{x,3}]

(x+1)*(x-1)
(*kulate zavorky jsou pro vyrazy*)

jsou vsude diverzanti

(*Mezera znamena nasobeni (Nepouzivat!!!), pote seradi promenne podle abecedy*)

2 3

2*3

Sin[π]

π
ω
(*omega napisi bud z palety nebo dle Esc+o+Esc (podobne i ostatni pismena recke abecedy)*)

list={2.5,{E,π,I},diverzant,a}
(*List tvorim pomoci slozenych zavorek, list muze obsahovat dalsi listy*)

NestList[x,f[x],4];

list[[1]]
list[[2]]
list[[2,2]]
(*Prvek v listu volam pomoci dvojhranatych zavorek ([[]]), poté se dostavam do dalsich urovni listu*)

list[[3]]=protistatny

list

list[[4]]=zivel

list

Plot3D[Sin[x]*Cos[x]+(E^(x*y)),{x,-1,1},{y,-1,1}]
(*Funkce Plot3D zobrazi graf funkce dvou promennych*)

N[(Sqrt[2])]
(*Standartni volani funkci*)

(Sqrt[2])//N
(*Volani funkce pro line programatory*)

N[(Sqrt[2]),100]

N@(Sqrt[2])
(*Dalsi typ volani funkce  *)

(Sqrt[2])@N

Sin@Cos

Sin@{a,b,c}

%
(*Posledni output*)

(775/21.)

%-36

(*Zde zacina druhé cviceni*)

Plot[(E^((-t)/0.05))*Sin[314*t],{t,0,0.1},AxesLabel->{x,f[x]}]

(*Popis os funkce se dela pouzitim AxesLabel, prvni parametr je pro osu x , druhy je pro osu y *)

Options[Plot]

(*Pomoci funkce Option zobrzime mozna nastaveni nepovinych parametru Plotu*)

x=divezant;
Plot[(E^((-t)/0.05))*Sin[314*t],{t,0,0.1},AxesLabel->{x,f[x]}]
(*Je li v promene x neco, tak pri tomto zapisu se dosadi do x*)

Plot[(E^((-t)/0.05))*Sin[314*t],{t,0,0.1},AxesLabel->{"x","f(x)"}]
(*Aby se nedosazovalo, pouzijeme format string, coz udelame pomoci uvozovek*)

Plot[(E^((-t)/0.05))*Sin[314*t],{t,0,0.1},AxesLabel->{"x","f(x)"},GridLines->Automatic,AxesOrigin->{0,-1},PlotLabel->"muj graf",PlotStyle->{Red,Thick,Dashed}]

(*GridLines-mrizka, AxesOrigin-poloha osy, PlotLabel-nazev grafu, PlotStyle-styl car (cervene, tucne, carkovane )*)

Plot[(E^((-t)/0.05))*Sin[314*t],{t,0,0.1},AxesLabel->{"x","f(x)"},GridLines->Automatic,AxesOrigin->{0,-1},PlotLabel->"muj graf",PlotStyle->{RGBColor[1,0,1],Thickness[0.005],Dashed},AxesStyle->{Directive[20,Blue,Italic],Directive[10,Red,Bold]}]

(*AxesStyle-20 je velikost pisma, barva a skloneni pisma, nemusime u PlotStyle mit jen predefinovane parametry, ale mohu je volat na argument funkce RGBColor,Thichness,...-viz Help*)

Plot[(E^((-t)/0.005))*Sin[314*t],{t,0,0.1},AxesLabel->{"x","f(x)"},GridLines->Automatic,AxesOrigin->{0,0},PlotLabel->"muj graf",PlotStyle->{Red,Thick,Dashed},PlotRange->{Automatic,{-0.2,1}}]

(*PlotRange urcuje okno grafu, ktery chci videt*)

Plot[{(E^((-t)/0.008))*Sin[314*t],(E^((-t)/0.05))},{t,0,0.1},PlotStyle->{{Red,DotDashed},{Blue,Thick}},AxesLabel->{"t","(Subscript[u, 1])(t), (Subscript[u, 2])(t)"}]

(*Pouzitim Format-Text Color-vyber barvy, muzeme obarvit popis osy, ktery jsme pred tim oznacili*)

proexport=Plot[{(1/(Abs[Sin[x]]+1)),Cos[Sin[x]],ArcTan[x+2]},{x,0,10},PlotRange->All,PlotStyle->{{Green,DotDashed,Thick},{Yellow,Dashed,Thickness[0.02]},{Blue}},AxesLabel->{"x","(1/(Abs[Sin[x]]+1)),Cos[Sin[x]],ArcTan[x+2]"},PlotLabel->"Graf"]

(*Pred pouzitim Export je nutne vlozit graf do promenne*)

SetDirectory[NotebookDirectory[]]

(*Dale volim kam chci ukladat soubory, timto prikazem reknu> ukladej to tam, kde je ulozen tento notebook(standartni soubor ve Wolfram Mathematica), samozrejmne je dulezite nejprve ulozit samotny notebook*)

Export["kefalin.png",proexport,ImageResolution->300]
Export["jasanek.jpg",proexport,ImageResolution->300]

(*Ukazka exportu, pro grafy pouzivat zasadne .png, *)

x=2;
Plot[Evaluate[Sin[x]],{x,0,3π}]
Plot[Sin[x],{x,0,3π}]

(*Pokud je v x nejaka hodnota, tak Plot se vyresi, jako by tam nebyla, pokud ale pouziji Evaluate, tak se nejprve funkce(u nas sinus) vyhodnoti a pak se dosazuje z intervalu, pro ktery chci graf*)

ClearAll[x]
res=Solve[a*(x^2)+b*x+c==0,x]

a=2;
b=(7/8);

(*Reseni kvadraticke rovnice*)

{2,student,kefalin}/.{kefalin->prokuraTOR}

(*/. Podiva se, co je vlevo a pro toto hleda vpravo  pravidlo(sipka) a zobrazi,to co je za sipkou v prvidlu (v tomto pripade nahradi kefalin za prokuraTOR)*)

{x,y,z}/.{x->1,y->5}

(*v tomto pripade se dosadi pouze za x a y, za z neni co dosazovat, protoze nenasel pravidlo pro z*)

{2,student,kefalin}/.{kefalin->diverzant,kefalin->basa}

(*je-li vice pravidel, pro stejnou promennou, provede se pouze to prvni pravidlo v poradi (v tomto pripade dostaneme za kefalina diverzanta)*)

{x,y,z}/.{x->1,x->5}
{x,y,z}/.{x->1,x->5}[[2]]

(*pokud chci pouzit druhe prvidlo, pro stejnou promenou, musim rici,ze chci druhy prvek (pomoci dvojhranatych zavorek)*)

x/.x->z/.z->y

(*mohu pouzit i vice prvidel za sebou (Zde za x dam z, za ktere dam y)*)

res=x/.Solve[{2*x+y==t,t+y+4*x==(t^2)},{x,y}][[1]]

(*Timto vytvorim dve rovnice o dvou neznamych*)

Plot[res,{t,-1,2}]

Plot[Evaluate[x/.Solve[{2*x+y==t,t+y+4*x==(t^2)},{x,y}][[1]]],{t,-1,2}]

(*3.cvicenie*)


(*Zavedieme si manipulate, vid  help. Prvym argumentom je plot. Parametre tykajuce sa plotu vzdy do prikazu plotu!!! Parametre, ktore chceme manipulovat su umiestnene az za prikazom plot!!! a to vo forme {parameter,od,do,krok}*)

Manipulate[Plot[a*Sin[2 π*f*t+φ],{t,0,0.05},PlotRange->{Automatic,{-1,1}}],{{a,0.5},0,1},{{f,100},50,300,50},{φ,0,2 π}]
(*pripadne {{parameter,pociatocne nastavenie hodnoty},od,do,krok}*)

Manipulate[Plot[E^(-t/τ)*Sin[2 π*f*t],{t,0,0.1},AxesLabel->{"t","u"},PlotStyle->{Thick,Hue[x]},PlotLabel->{"graf"},PlotRange->{Automatic}],{τ,0.001,0.01},{f,50,500,25},{x,0,1}]

(*Prisla chvila vsetkych chvili, a tak si zadefinujme funkciu. Najprv si vycistime nazov funkcie*)

ClearAll[funkce];

(*Pri definicii dame do argumentu nazov premennej s podtrzitkom, ktore znamena, ze vstupom funkcie moze byt cokolvek tj list, string atd,...*)

funkce[promenna_]:=(((Sin[promenna]))^2)

(*dosadime*)

funkce[-(π/2)]

ClearAll[funkce2];

(*Majme ulohu kde chceme vytvorit funkciu ktora, nebude reprezentovana jednym vyrazom, ale seriou operacii, a preto pouzijeme prikaz Module. Chceme riesit kvadraticku rovnicu a  chceme oba korene v liste {x1,x2} *)

c=3;
x1=x/.Solve[a*(x^2)+b*x+c==0,x][[1]];
x2=x/.Solve[a*(x^2)+b*x+c==0,x][[2]];

(*Hned na zaciatku prikazu module je list s lokalnymi premennymi, dalej su dielcie operacie*)

funkce2[a_,b_]:=Module[{c,x1,x2},
c=2;
x1=x/.Solve[a*(x^2)+b*x+c==0,x][[1]];
x2=x/.Solve[a*(x^2)+b*x+c==0,x][[2]];
{x1,x2}
]

funkce2[1,2]

(*Ukazka ako mozeme dat do funkcie list*)

list={0,(π/6),(π/3),(π/2)};

funkce[list]

funkce[diverzant]

(*Ukazme si funkciu a nieco naviac - seriovy rezonancny obvod*)

ClearAll[R,L,c]

L=0.01;
R=10;
c=(10^(-6));
amplitudova[ω_]:=Abs[R+I*ω*L+(1/(I*ω*c))]

fazova[ω_]:=Arg[R+I*ω*L+(1/(I*ω*c))]

(*Ukazka grafu s osami v logaritmickych meritkach. Velicina na osi x nikdy nesmie byt 0. Dalsie moznosti LogPlot, LogLinearPlot*)

LogLogPlot[amplitudova[frekv],{frekv,0.1,(10^9)},PlotStyle->{Thick,Blue},AxesLabel->{"ω [rad.(s^(-1))]","Abs(Z)[Ω] "},GridLines->Automatic,PlotRange->{Automatic,{0.01,(10^7)}},PlotLabel->"Amplitudova charakteristika"]

LogLinearPlot[fazova[frekv],{frekv,0.1,(10^9)},PlotStyle->{Thick,Blue},AxesLabel->{"ω [rad.(s^(-1))]","Arg(Z)[rad] "},GridLines->Automatic,PlotRange->{Automatic,{((-π)/2),(π/2)}},PlotLabel->"Fazova charakteristika"]

amplitudova[ω_,R_]:=Abs[R+I*ω*L+(1/(I*ω*c))]
(*A ukazka manipulate pre premenlivy odpor R*)
Manipulate[LogLogPlot[amplitudova[frekv,r],{frekv,0.1,(10^9)},PlotStyle->{Thick,Blue},AxesLabel->{"ω [rad.(s^(-1))]","Abs(Z)[Ω] "},GridLines->Automatic,PlotRange->{Automatic,{0.01,(10^7)}}],{r,0.1,10}]

Total (*vid help, bude sa hodit*)

(*pre definovanie funcie pre vypocet paralelneho radenia odporov mozme pouzit rozne metody, fantazii sa medze nekladu*)

par[listodporov_]:=(((Total[(listodporov^(-1))]))^(-1))

par2[listodporov_]:=(((Plus@@((listodporov^(-1)))))^(-1))
par3:=(((Plus@@((#)^(-1))))^(-1))&;
(*Podobne pre seriove odpory*)
ser[listodporov_]:=Total[listodporov]

(*A pekne to funguje*)

par[{R1,R2,R3}]
par2[{R1,R2,R3}]
par3[{R1,R2,R3}]
ser[{R1,R2,R3}]

(*pre zadanu schemu z tabule - spolahlivejsia metoda z hladiska chybovosti*)

R8=par[{R5,R6}]
R9=ser[{R8,R7}]
R10=par[{R2,R9,ser[{R3,R4}]}]
Rvysl=ser[{R10,R1}]

(*Metoda pre odvaznych*)

Rvys2=ser[{R1,par[{R2,ser[{R3,R4}],ser[{R7,par[{R5,R6}]}]}]}]//FullSimplify

par[{R1,R2}]//FullSimplify

(((a^2)-(b^2))/(((a-b))^2))

%//FullSimplify

(*4. Cviceni*)

ClearAll[rce,res,ries,R1,R2,R3,R4];
(*Vycistime si premene, aby nenastala kolizia s predoslymi vypoctami*)

rcesouc={R1*IR1==U3-U2,R2*IR2==U2-U1,R3*IR3==U1,Uz1==-U3,Uz2==U3-U2};
(*zadame rovnice pre suciastky*)
rceuzly={IR2+Iz==IR3+Iout,Iz2+IR2+Iz==IR1,Iz2==IR1+Iz1};
(*yadame rovnice pre uzly*)
nezn={U1,U2,U3,IR1,IR2,IR3,Iz1,Iz2};
(*Vytvor9me list neznamych, Iout vystupuje ako parameter*)

rce=Union[rcesouc,rceuzly];
(*zlucime rovnice pre uzly a suciastky,prikaz union navyse odstrani duplicity*)
rce=rce/.{R1->80,R2->100,R3->200,Uz1->12,Uz2->-50,Iz->0.06}
(*dosadime zname hodnoty do rovnic*)

res=Solve[rce,nezn][[1]]
(*Analyticky riesime sustavu rovnic*)

u1=res[[1,2]];

(*do u1 si ulozime vysledok pre U1*)

u1

U1/.res
(*Alebo druha moznost, lepsia*)

Manipulate[Plot[Tanh[A*Sin[314t]]+B,{t,0,0.08},PlotStyle->{Blue,Thick}],{A,0.1,100},{{B,0},-1,1,0.1}]
(*Ukazka tvorby obdlznikoveho signalu*)