Codes Flashcards
Kód v ISO C pre Eulerovu metódy pre rovnicu y” - 5 + 2y’ = 0:
include <stdio.h></stdio.h>
double in[2];
double st[2] = {1.0, 1.0};
double time = 0;
double step = 0.01;
void update() {
in[0] = -2 * st[0] + 5;
in[1] = st[0];
}
void euler_step(double h) {
update();
for(int i = 0; i < 2; i++)
st[i] += in[i] * h;
time += h;
}
int main() {
while(time < 20) {
printf(“Time: %lf Y’: %g Y: %g\n”, time, st[0], st[1]);
if(time + step > 20) // dokrocenie
euler_step(20 - time);
else
euler_step(step);
}
printf(“Time: %lf Y’: %g Y: %g\n”, time, st[0], st[1]);
return 0;
}
Pomocou Eulerovej metódy riešte y’’ + y = 0. V systéme sa vyskytujú stavové udalosti, ktoré
vypíšu všetky stavové premenné. Stavová podmienka je y’ > y. Chovanie stavovej udalosti
píšte do funkcie StateEvent(). Simulácia je od času 0 do 50 s. ISO C kód + nakresliť a
zapísať počiatočné hodnoty.
include <stdio.h></stdio.h>
#include <stdbool.h>
double in[2];
double y[2] = {1.0, 1.0};
double t = 0;
double normalstep = 0.1;
double minstep = 0.01;
void update() { // y'' + y = 0
in[0] = -1 * y[1];
in[1] = y[0];
}
void Euler(double h) {
update();
for(int i = 0; i < 2; i++)
y[i] += in[i] * h;
t += h;
}
void StateEvent(void) {
printf("%f %f\n", y[0], y[1]);
}
void main() {
const double end = 50.0;
double step = normalstep; // normalstep je velkost kroku eulerovej metody
while (t < end) {
double backup[2] = {};
for (unsigned i = 0; i < 2; i++) { backup[i] = y[i];}
double time_backup = t; // zalohujeme si hodnoty stavovych premennych aj casu pred vykonanim iteracie
bool cond = y[0] > y[1]; // musime si ulozit podmienku pred aj po eulerovej iteracii
Euler(step); // eulerom sa blizime k nejakemu momentu/eventu, ktory chceme zaznamenat
bool newcond = y[0] > y[1]; // musime si ulozit
if (cond != newcond) { // zistujeme, ci sme neprekrocili nejaky moment, ktory treba zaznamenat
if (step <= minstep) { // minstep je nejaka nasa pozadovana presnost, s kt. chceme moment zachytit
StateEvent(); // logging eventu
step = normalstep; // mozeme pokracovat v iterovani, dokym nenarazime na dalsi moment
} else { // moment sme prekrocili, ale este nemame ocakavanu presnost
t = time_backup; // vratime si preto zalohovane hodnoty
for (unsigned i = 0; i < 2; i++) { y[i] = backup[i];}
step /= 2; // zmensime velkost kroku
if (step < minstep) { // v pripade prilis nizkeho kroku ho nastavime na pozadovany
step = minstep; // dolezite pre spravne dokrocenie
}
} // po zalohe sa skusame s vacsou presnostou dostat k danemu momentu
}
}
}</stdbool.h>
Eulerova metóda s kalendárom
include <stdio.h></stdio.h>
#define PRINTSTEP 0.01
double in[2];
double st[2] = {1.0, 1.0};
double time = 0;
double step = 0.01;
// treba upravit podla rovnice (jej blokovej schemy)
void update()
{
in[0] = -2 * st[0] + 5;
in[1] = st[0];
}
void euler_step(double h)
{
update();
for(int i = 0; i < 2; i++)
st[i] += in[i] * h;
time += h;
}
void print()
{
printf(“Time: %lf Y’: %g Y: %g\n”, time, st[0], st[1]);
cal_insert(print, 0, time + PRINTSTEP);
}
int main(){
cal_init();
cal_insert(END, -100, 20);
cal_insert(print, 0, time);
struct ev_notice e;
while (!cal_empty()) {
e = cal_get_first();
cal_pop();
if(e.atime > 20) // 20 = endtime
break;
while (time < e.atime) {
if (time + step > e.atime)
euler_step(e.atime - time); // dokrocenie
else
euler_step(step); // normalny krok
}
e.evptr();
}
return 0;
}
Majme systém hromadnej obsluhy typu M/M/2 s frontou obmedzenou na max. 1 prvok. Počet
požiadaviek v systéme je Markovský proces. Pre i-tý stav je pi pravdepodobnosť, že v systéme
je prítomných i transkakcií.
a) Nakreslite graf stavov systému, napíšte všetky rovnice pre ustálený stav a všeobecne
vyriešte. (Pozor na prácu viacerých zariadení súčasne - inak 0b.)
b) Predpokládajte, že požiadavky prichádzajú so strednou hodnotou intervalu medzi príchodmi
15 sekúnd a intenzita obsluhy pre každé zariadenie je μ = 3 (3 spracované transakcie za
minútu). Vypočítajte priemernú dĺžku fronty v ustálenom stave.
POZOR: Je požadovaný celý postup, všeobecný aj číselný výsledok (najlepšie v tvare zlomku)
s0,s1,s…
p0,p1,p…
lambda?
delka fronty
pocet transakci
s0 : μp1 - λp0 = 0
s1 : λp0 - λp1 + 2μp2 - μp1 = 0
s2 : λp1 - λp2 + 2μp3 - 2μp2 = 0
s3 : λp2 - 2μp3 = 0
p0 + ρ * p0 + (1/2) * ρ² * p0 + (1/4) * ρ³ * p0 = 1
p0 * [1 + ρ + (1/2) * ρ² + (1/4) * ρ³] = 1 => > p0 = 1 / [1 + … * ρ³]
lambda 60/15 = 4
x = d0p0 + d1p1 + d2p2 + d3p3 // v stavoch p0, p1 a p2 je dĺžka fronty nula
x = n0p0 + n1p1 + n2p2 + n3p3 // n0 = 0, n1 = 1, n2 = 2, n3 = 3
Uvažujme nasledujúce spojité náhodné rozloženie: 20 % jeho hodnôt je rovnomerne rozložených na intervale <30, 40), 80 % je rovnomerne rozložených na intervale <50, 100>. Nakreslite graf jeho funkcie hustoty pravdepodobnosti s popisom oboch osí grafu. Napíšte pseudokód generátora pre toto rozloženie s použitím funckie double Random() vracajúcou rovnomerne rozložené hodnoty na intervale <0, 1>. (10 bodov)
y pro:
30,40 = 0,02
50,100 = 0,016
double generator() {
x = Rand(); // generovanie náhodnej veliciny = pomocou x vyberieme rozsah, v ktorom sa pohybujeme
y = Rand(); // generovanie uz konkretnej hodnoty v 1 z 2 rozsahov
if(x <= 0.2)
return y * 10 + 30;
else
return y * 50 + 50;
}
Máme histogram, v ktorom je min.hodnota=10, max=20 a střední hodnota=15. Na základe toho je možné aproximovať to do rovnomerného rozloženia. (10 bodov)
a) Stanov parametre rovnomerneho rozdelenia.
b) Nakresli a popíš funkciu hustoty pravdepodobnosti.
R(10,20)
y = 1/10; (S = a*b)
Předpokládejme soubor dat, který po vynesení do histogramu dává hypotézu, že se jedná o výstup spojité náhodné proměnné řídící se normálním rozložením s vypočtenými statistikami (min, max, střední hodnota): (14, 26, 20)
- Navrhněte parametry zadaného rozložení tak, aby aproximovalo zadaný soubor dat. Zohledněte pravidlo 3 sigma. - Nakreslete graf funkce hustoty pravděpodobnosti navrženého rozložení s vyznačení všech relevantních parametrů na x-ové ose grafu. (10 bodů)
Normálne rozdelenie sa označuje N a obsahuje 2 parametre: strednú hodnotu μ a rozptyl σ². => N(µ, σ²).
µ (“mí”)= 20
3𝜎 = max−stredni = 6
rozptyl = 𝜎² = (6/3)²=4
Naše výsledné rozloženie bude teda možno zapísať ako N(20, 4).
GRAF:
Kopecek
Předpokládejme soubor dat získaný jako výstup nějaké náhodné proměnné, který obsahuje hodnoty A,B,C,D s těmito četnostmi zastoupení: (40, 40, 10, 10). Soubor dat aproximujte vhodným rozložením. Sestavte tabulku distribuční funkce rozložení a napište pseudokódem funkci pro generování navrženého rozložení. (10b)
P(A) = 0.4
P(B) = 0.4
P(C) = 0.1
P(D) = 0.1
Tabuľka distrib. funkce F(x):
a | b | c | d
0.4 | 0.8 | 0.9 | 1
double generator() {
double x = Random();
if (x < 0.4)
return A;
else if(x < 0.8)
return B;
else if(x < 0,9)
return C;
return D;
}
Uvažujme nasledujúce spojité náhodné rovnomerné rozloženie: Minimálna hodnota je 20, max. je 40 a stredná hodnota je 30. Navrhnite parametre rozloženia, aby to aproximovalo zadaný súbor dát. Nakreslite obrázok so všetkými relevantnými parametrami. (10 bodov)
Rozloženie = R(20,40).
Funkcia hustoty pravdepodobnosti f(x) je: 0.05 ak x patrí do intervalu <20,40), inak je 0.
Distribučná funkcia F(x) je 0 pre x < 20, 0.05(x-20) pre x ∈ <20, 40), 1 pre x >= 40.
V jazyku ISO C napíšte funkciu pre výpočet jedného kroku RK_step(double t, double state[], unsigned N, double stepsize); ktorej predáte modelový čas t, stav všetkých integrátorov v poli state, ich počet N a dĺžku kroku. Funkcia nesmie používať globálne premenné. Vzorec definujúci túto numerickú metódu je:
Chovanie modelu bude popísané funkciou Dynamic(double t, double st[], unsigned N, /out/ double in[]); v ktorej sa vypočítajú vstupy (in[i]) všetkých N integrátorov pre dané stavy (st[i]) a aktuálny modelový čas t.
Definujte ju konkrétne pre systém zadaný rovnicou y’’’ + 8y’ - 1 a nastavte správnu hodnotu konštanty N. K rovnici doplňte nenulové počiatočné podmienky. Definujte všetky potrebné premenné pre zadaný model a napíšte funkciu void SimRun(double t1, double t2); implementujúcu algoritmus riadenia spojitej simulácie s využitím funkcie RK_step. Nezabudnite “dokročiť” na čas konca simulácie t2. Riešenie, ktoré bude mať max. 30 riadkov, stručne okomentujte.
include <stdio.h></stdio.h>
void Dynamic(double t, double st[], unsigned N, /out/ double in[]) { // to, ze sa double t predava do funkcie, ale nepouziva,
in[0] = -8 * st[1] + 1; // netreba riesit, je to proste signatura dana zadanim, ktoru
in[1] = st[0]; // treba dodrzat, podobne aj s parametrom N (v tomto pripade)
in[2] = st[1];
}
void RK_step(double t, double state[], unsigned N, double stepsize) { // rovnako ignorujte double t aj tu
double base[N], k1[N], k2[N];
for(int i = 0; i < N; i++)
base[i] = state[i]; // pomocne pole base = y(t)
Dynamic(t, state, N, k1); // vypocet koeficientov k1 (vid vzorec)
for(int i = 0; i < N; i++)
state[i] = base[i] + k1[i] * (3.0 / 4.0) * stepsize; // vid vzorec pre k2 (2. argument)… y(t) + h * (3 / 4 * k1)
Dynamic(t + (3.0 / 4.0) * stepsize, state, N, k2); // vypocet koeficientov k2 (vid vzorec)
for(int i = 0; i < N; i++)
state[i] = base[i] + ((1.0/3.0) * k1[i] + (2.0/3.0) * k2[i]) * stepsize; // vypocet vyslednej hodnoty y(t+h) (vid vzorec)
}
void SimRun(double t1, double t2) {
unsigned N = 3;
double state[] = {1.0, 1.0, 1.0}; // nenulove pociatocne podmienky
double stepsize = 0.04;
while(t1 < t2) {
if(t1 + stepsize > t2) { // ak by simulacia mala normalnym krokom vyjst von z urceneho casoveho intervalu
RK_step(t1, state, N, t2 - t1); // dokrocenie, je to kvoli floating point nepresnostiam
t1 = t2;
} else {
RK_step(t1, state, N, stepsize); // normalny krok
t1 += stepsize;
}
printf(“Time: %g, 1: %g, 2: %g, 3: %g\n”, t1, state[0], state[1], state[2]);
}
}
int main() {
SimRun(0.0, 20.0);
return 0;
}
