Van egy számsorunk, amely gyakorlatilag független elemekből áll, és engedelmeskedik egy adott eloszlásnak. Általános szabály, hogy egyenletes eloszlás.
Véletlen számokat generálhat az Excelben különböző módon és módon. Vegyük csak a legjobbakat közülük.
Véletlenszámú függvény az Excelben
- A RAND függvény egy véletlenszerű, egyenletes eloszlású valós számot ad vissza. 1-nél kisebb, 0-nál nagyobb vagy azzal egyenlő.
- A RANDBETWEEN függvény egy véletlenszerű egész számot ad vissza.
Nézzük meg példákkal a felhasználásukat.
Véletlen számok mintavétele RAND használatával
Ez a függvény nem igényel argumentumot (RAND()).
Például 1 és 5 közötti véletlenszerű valós szám generálásához használja a következő képletet: =RAND()*(5-1)+1.
A visszaadott véletlen szám egyenletesen oszlik el az intervallumon belül.
Minden alkalommal, amikor a munkalap kiszámítása megtörténik, vagy a munkalap bármely cellájának értéke megváltozik, egy új véletlen számot ad vissza. Ha el akarja menteni a generált sokaságot, akkor a képletet az értékével helyettesítheti.
- Kattintson a véletlen számot tartalmazó cellára.
- A képletsorban válassza ki a képletet.
- Nyomja meg az F9-et. ÉS ENTER.
Ellenőrizzük az első mintából származó véletlenszámok eloszlásának egyenletességét eloszlási hisztogram segítségével.
A függőleges értékek tartománya a frekvencia. Vízszintes - „zsebek”.
RANDBETWEEN funkció
A RANDBETWEEN függvény szintaxisa (alsó korlát; felső korlát). Az első argumentumnak kisebbnek kell lennie, mint a másodiknak. Ellenkező esetben a függvény hibát jelez. Feltételezzük, hogy a határok egész számok. A képlet elveti a tört részt.
Példa a függvény használatára:
Véletlen számok 0,1 és 0,01 pontossággal:
Hogyan készítsünk véletlenszám-generátort Excelben
Készítsünk véletlenszám-generátort, amely egy bizonyos tartományból generál értéket. Ilyen képletet használunk: =INDEX(A1:A10,INTEGER(RAND()*10)+1).
Készítsünk véletlenszám-generátort a 0 és 100 közötti tartományban 10-es lépésekben.
A szövegértékek listájából ki kell választani 2 véletlenszerű értéket. A RAND függvény segítségével az A1:A7 tartomány szövegértékeit véletlen számokkal hasonlítjuk össze.
Az INDEX funkció segítségével válasszunk ki két véletlenszerű szövegértéket az eredeti listából.
Egy véletlenszerű érték kiválasztásához a listából használja a következő képletet: =INDEX(A1:A7,RANDBETWEEN(1,COUNT(A1:A7))).
Normál eloszlású véletlenszám-generátor
A RAND és RANDBETWEEN függvények egyenletes eloszlású véletlen számokat állítanak elő. Bármely érték azonos valószínűséggel eshet a kért tartomány alsó és felső határába. Ez hatalmas szórást eredményez a célértékhez képest.
A normál eloszlás azt jelenti, hogy a generált számok többsége közel van a célszámhoz. Állítsuk be a RANDBETWEEN képletet, és hozzunk létre egy normál eloszlású adattömböt.
Az X termék ára 100 rubel. A teljes gyártott tétel normál eloszlást követ. A valószínűségi változó is normális valószínűségi eloszlást követ.
Ilyen körülmények között a tartomány átlagos értéke 100 rubel. Hozzunk létre egy tömböt, és készítsünk egy 1,5 rubel szórással normál eloszlású gráfot.
A következő függvényt használjuk: =NORMINV(RAND();100;1.5).
Az Excel kiszámította, hogy mely értékek vannak a valószínűségi tartományon belül. Mivel a 100 rubel költségű termék előállításának valószínűsége maximális, a képlet gyakrabban mutat 100-hoz közeli értékeket, mint mások.
Térjünk át a grafikon ábrázolására. Először létre kell hoznia egy táblázatot a kategóriákkal. Ehhez a tömböt pontokra osztjuk:
A kapott adatok alapján normál eloszlású diagramot állíthatunk elő. Az értéktengely az intervallumban lévő változók száma, a kategóriatengely a periódusok.
Kérjük, függessze fel az AdBlockot ezen az oldalon.
Néha szükség lehet véletlen számok generálására. Egy egyszerű példa.
Példa: A győztes meghatározása egy újrahirdetési versenyben.
A listán 53 fő szerepel. Közülük kell győztest választani. Ha maga választja, elfogultsággal vádolhatják meg. Tehát úgy dönt, hogy programot ír. A következőképpen fog működni. Adja meg a résztvevők számát N, majd a program egy számot jelenít meg - a nyertes számát.
Már tudja, hogyan kell számot kérni egy játékostól. De hogyan lehet rákényszeríteni a számítógépet, hogy véletlen számot gondoljon? Ebben a leckében megtudhatja, hogyan kell ezt csinálni.
rand() függvény.
Ez a függvény egy véletlenszerű egész számot ad vissza nulla és RAND_MAX közötti tartományban. A RAND_MAX egy speciális C állandó, amely a rand() függvény által visszaadható maximális egész számot tartalmazza.
A rand() függvény az stdlib.h fejlécfájlban van definiálva. Ezért, ha a rand-ot szeretné használni a programjában, ne felejtse el mellékelni ezt a fejlécfájlt. Ebben a fájlban a RAND_MAX állandó is definiálva van. Megtalálhatja ezt a fájlt a számítógépén, és láthatja a jelentését.
Lássuk ezt a funkciót működés közben. Futtassuk a következő kódot:
Lista 1.
#beleértve
Valahogy így kell kinéznie.
1. ábra Öt véletlenszám, amelyet a randfüggvény generál
De szeretnénk számokat kapni 1-től 53-ig, és nem mindent egymás után. Íme néhány trükk, amelyek segítenek korlátozni a rand() függvényt.
Korlátozza a véletlen számokat felülről.
Aki az iskolában várta a pillanatot, amikor jól jön a matematika, készüljön. Elérkezett a pillanat. A véletlen számok felülről történő korlátozásához használhatja az osztás maradékának megszerzésére szolgáló műveletet, amelyet az utolsó leckében tanult meg. Valószínűleg tudja, hogy a K számokkal való osztás maradéka mindig kisebb, mint a K szám. Például, ha 4-gyel osztja, 0, 1, 2 és 3 maradékai maradhatnak. Ezért, ha a véletlen számokat felülről a K számra szeretné korlátozni, akkor egyszerűen vegye ki a K-val való osztás maradékát. Mint ez:
2. lista.
#beleértve
2. ábra Öt 100-nál kisebb véletlenszám
Korlátozza az alábbi számokat.
A rand függvény véletlen számokat ad vissza az intervallumból. Mi van akkor, ha csak M-nél nagyobb számokra van szükségünk (például 1000)? Mit kellene tennem? Ez egyszerű. Adjuk hozzá az M értékünket ahhoz, amit a rand függvény visszaadott. Ekkor ha a függvény 0-t ad vissza, a végső válasz M, ha 2394, akkor a végső válasz M + 2394 lesz. Ezzel a művelettel úgy tűnik, hogy az összes számot M egységgel előre toljuk.
Állítsa be a rand függvény felső és alsó határát.
Például kapjon számokat 80 és 100 között. Úgy tűnik, csak a fenti két módszert kell kombinálnia. Valami ilyesmit fogunk kapni:
3. lista.
#beleértve
Próbáld meg futtatni ezt a programot. Meglepődött?
Igen, ez a módszer nem fog működni. Futtassuk ezt a programot kézzel, hátha hibáztunk. Tegyük fel, hogy a rand() a 143-as számot adta vissza. A maradék 100-zal osztva 43. Ekkor 80 + 43 = 123. Tehát ez a módszer nem működik. Egy hasonló kialakítás 80 és 179 közötti számokat eredményez.
Bontsuk le a kifejezésünket lépésről lépésre. A rand()%100 0 és 99 közötti számokat adhat vissza. Azok. a szegmensből.
Az Operation + 80 szegmensünket 80 egységgel jobbra tolja. Kapunk.
Amint látja, a problémánk a szegmens jobb oldali szegélyében van, 79 egységgel jobbra tolódott el. Ez az eredeti számunk 80 mínusz 1. Tisztítsuk meg a dolgokat, és mozgassuk vissza a jobb oldali szegélyt: 80 + rand()%(100 - 80 + 1) . Akkor mindennek úgy kell működnie, ahogy kell.
Általában, ha számokat kell kapnunk a szegmensből, akkor a következő konstrukciót kell használnunk:
A + rand()%(B-A+1) .
Ennek a képletnek megfelelően átírjuk az utolsó programunkat:
4. lista.
#beleértve
Eredmény:
3. ábra Véletlen számok egy tartományból
Nos, most meg tudod oldani a lecke eredeti problémáját. Szám létrehozása egy szegmensből. Vagy nem tudsz?
De először még néhány hasznos információ. Futtassa le az utolsó programot háromszor egymás után, és írja le az általa generált véletlenszámokat. Észrevetted?
srand() függvény.
Igen, minden alkalommal ugyanazok a számok jelennek meg. – Annyira generátor! - te mondod. És nem lesz teljesen igaza. Valójában mindig ugyanazok a számok generálódnak. De ezt a srand() függvény használatával tudjuk befolyásolni, ami szintén az stdlib.h fejlécfájlban van definiálva. Ez inicializálja a véletlenszám-generátort egy magszámmal.
Fordítsa le és futtassa többször ezt a programot:
5. lista.
#beleértve
Most változtasd meg a srand() függvény argumentumát egy másik számra (remélem nem felejtetted el, mi az a függvény argumentum?), majd fordítsd le és futtasd újra a programot. A számsornak meg kell változnia. Amint megváltoztatjuk az argumentumot a srand függvényben, a sorozat is megváltozik. Nem túl praktikus, igaz? A sorrend megváltoztatásához újra kell fordítani a programot. Ha ez a szám automatikusan bekerülne oda.
És meg lehet csinálni. Például használjuk a time() függvényt, amely a time.h fejlécfájlban van definiálva. Ez a függvény, ha a NULL értéket adjuk át argumentumként, az 1970. január 1. óta eltelt másodpercek számát adja vissza. Íme egy pillantás, hogyan készült.
6. lista.
#beleértve
Megkérdezheti, mi az a NULL? Ésszerű kérdés. Addig is elmondom, mi ez a különleges fenntartott szó. Azt is meg tudom mondani, hogy mit jelent a nullmutató, de... Ez nem nyújt Önnek semmilyen információt, ezért azt javaslom, hogy ne gondoljon rá jelenleg. És csak emlékezz rá, mint valami okos trükkre. A következő leckékben ezt a dolgot részletesebben is megvizsgáljuk.
Oktatási algoritmusos feladatokban meglehetősen gyakori, hogy véletlenszerű egész számokat kell generálni. Természetesen ezeket megkaphatja a felhasználótól, de problémák adódhatnak a tömb 100 véletlen számmal való kitöltésével.
A C nyelv szabványos könyvtárfüggvénye (nem C++) rand() jön a segítségünkre.
int rand(void);
Pszeudo-véletlen egész számot generál 0 és RAND_MAX közötti értéktartományban. Ez utóbbi egy konstans, amely a nyelvi megvalósítástól függően változik, de a legtöbb esetben 32767.
Mi van, ha véletlen számokra van szükségünk 0-tól 9-ig? Ebből a helyzetből tipikus kiút a modulo osztás művelet használata.
Ha számokra van szükségünk 1-től (nem 0-ig) 9-ig, akkor hozzáadhatunk egyet...
Az ötlet a következő: generálunk egy véletlen számot 0-tól 8-ig, és az 1-es hozzáadása után egy 1-től 9-ig terjedő véletlen számmá alakul.
És végül a legszomorúbb dolog.
Sajnos a rand() függvény pszeudo-véletlen számokat generál, pl. olyan számok, amelyek véletlenszerűnek tűnnek, de valójában értéksorozatok, amelyeket egy okos algoritmussal számítanak ki, amely az úgynevezett gabonát veszi paraméterként. Azok. A rand() függvény által generált számok attól függnek, hogy a gabona milyen értékkel rendelkezik a meghívásakor. A szemcsét pedig a fordító mindig 1-es értékre állítja be. Vagyis a számsor álvéletlen lesz, de mindig ugyanaz.
És nem erre van szükségünk.
A srand() függvény segít kijavítani a helyzetet.
void srand(unsigned int seed);
Egyenlőre állítja a szemcsét annak a paraméternek az értékével, amellyel meghívták. És a számsor is más lesz.
De a probléma továbbra is fennáll. Hogyan készítsük el a gabonát véletlenszerűvé, mert minden attól függ?
Egy tipikus kiút ebből a helyzetből a time() függvény használata.
time_t time(time_t* timer);
Szintén a C nyelvből öröklődik, és ha paraméterként null mutatót használunk, akkor az 1970. január 1. óta eltelt másodpercek számát adja vissza. Nem, ez nem vicc.
Most átadhatjuk ennek a függvénynek az értékét a srand() függvénynek (ami implicit cast), és csodálatos véletlenszerű szemcsét kapunk.
A számok pedig csodálatosak és nem ismétlődőek lesznek.
A rand() és srand() függvények használatához tartalmaznia kell egy fejlécfájlt
Íme egy teljes példa.
#beleértve
#beleértve
#beleértve
névtér használata std;
int main()
{
cout<< "10 random numbers (1..100): " << endl;
srand(idő(NULL));
for(int i=0;i<10;i++) cout << rand() % 100 + 1 << " ";
cin.get();
visszatérés 0;
}
Az álvéletlen számokat generáló függvény prototípusa az stdlib.h könyvtárfájlban található:
1
2
3
4
5
6
unsigned long int next = 1;
int rand (üres)
{
következő = következő * 1103515245;
return ((unsigned int )(next / 65536) * 2768);
}
A rand() függvény nem vesz fel argumentumokat, hanem a következő változóval működik globális hatókörrel.
Ha sorozatot kell generálnia a tartományban , akkor a következő képletet kell használni:
Szám = rand()%(M2-M1+1) + M1;
Ahol Szám– generált szám. M2-M1+1– a számábrázolás teljes skálája. M1– a megadott tartomány eltolása 0-hoz képest; % - az osztály többi része.
Ha például egy sorozatot kell generálnia a [-10;10] tartományban, akkor a függvényhívás így fog kinézni
Szám = rand()%(10+10+1)-10
Szám = rand()%(21)-10
Ha megkapjuk a 21-gyel osztás maradékát, 0 és 20 közötti számot kapunk. A kapott számból 10-et kivonva a kívánt tartományba eső számot kapjuk [-10;10].
A rand() függvény által generált szekvencia azonban a program minden futtatásakor ugyanúgy fog kinézni.
Ahhoz, hogy a program minden egyes indításakor különböző sorozatokat generáljon, a globális változót ezután 1-től eltérő értékkel kell inicializálni. Ehhez használja a függvényt
void srand (unsigned int seed)
(következő = mag;)
Annak biztosítására, hogy a következő inicializálása a program minden egyes indításakor más legyen, leggyakrabban az aktuális időt használják mag argumentumként.
Példa Töltsön ki egy 20 elemből álló tömböt véletlenszerű számokkal a 0 és 99 közötti tartományban.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#beleértve
#beleértve
#beleértve
#define 20-as MÉRET
int main() (
int a;
srand(idő(NULL ));
for (int i = 0; i
a[i] = rand() % 100;
printf("%d " , a[i]);
}
getchar();
visszatérés 0;
}
A végrehajtás eredménye
Gyakran felmerül a feladat egy meglévő értékkészlet véletlenszerű sorrendbe rendezése. Erre a célra egy pszeudovéletlen számgenerátort is használnak. Ez létrehoz egy tömböt, és kitölti értékekkel.
Maga a keverési eljárás a következő. Véletlenszerűen két tömbindex értéket generálunk, és az elemek értékeit a kapott indexekkel felcseréljük. Az eljárást legalább N-szer megismételjük, ahol N a tömbelemek száma.
Példaként vegye fontolóra 20 érték megkeverését (1-től 20-ig), és az eljárást 20-szor ismételje meg.
Megvalósítás C-ben
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#beleértve
#beleértve
#beleértve
#define 20-as MÉRET
int main() (
int a;
srand(idő(NULL ));
for (int i = 0; i< SIZE; i++)
{
a[i] = i + 1;
printf("%2d " , a[i]);
}
for (int i = 0; i< SIZE; i++)
{
// Véletlenszerűen generál két elemindexet
int ind1 = rand() % 20;
int ind2 = rand() % 20;
// és elemet cserél ezekkel az indexekkel
int temp = a;
a = a;
a = hőmérséklet;
}
printf("\n" );
for (int i = 0; i< SIZE; i++)
printf("%2d " , a[i]);
getchar();
visszatérés 0;
}
A végrehajtás eredménye
Gyakran felmerül a korábban megadott tömbelemek véletlenszerű kiválasztása. Ezen túlmenően biztosítani kell, hogy ezen elemek kiválasztásakor ne forduljon elő ismétlés.
Ennek a választásnak az algoritmusa a következő:
- Véletlenszerűen kiválasztjuk egy tömbelem indexét
- Ha egy azonos indexű elemet már kijelöltünk, haladjunk jobbra, amíg el nem érjük a következő kijelöletlen elemet. Ugyanakkor ügyelünk arra, hogy a „jobbra mozgás” ne lépje túl a tömb határait. Ha a tömb határain kívül esőt észlelünk, akkor elölről kezdjük a tömbelemek megtekintését.
- Egy elem kiválasztása
- Az elem rögzítése a kiválasztott módon
- Ismételje meg ezeket a lépéseket az összes többi elemnél
Megvalósítások C-ben
Ennek eredményeként egy új b tömböt kapunk, amelyet az a tömb elemeinek véletlenszerű kiválasztásával alakítunk ki.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#beleértve
#beleértve
#beleértve
#define 20-as MÉRET
int main() (
int a;
int b; // eredményül kapott tömb
srand(idő(NULL ));
// Töltse ki a tömböt egymást követő értékekkel 1 és 20 között
for (int i = 0; i< SIZE; i++)
{
a[i] = i + 1;
printf("%2d " , a[i]);
}
for (int i = 0; i< SIZE; i++)
{
int ind = rand() % 20; // tetszőleges index kiválasztása
míg (a == -1) // miközben az elem "ki van választva"
{
ind++; // jobbra lépés
ind %=20; // ha elérjük a megfelelő határt, térjünk vissza az elejére
}
b[i] = a; // írja be a tömb következő elemét b
a = -1; // az a tömbelem megjelölése "kijelöltként"
}
printf("\n" );
// Kiírja a kapott tömböt
for (int i = 0; i< SIZE; i++)
printf("%2d " , b[i]);
getchar();
visszatérés 0;
}
A végrehajtás eredménye
Címkék: C véletlen, C véletlenszámok, véletlenszám generálás, RNG, pszeudo-véletlen számok, Monte Carlo módszer
Álvéletlen számok
Az álvéletlen számok előállítása összetett matematikai probléma. Ez a cikk nem foglalkozik ezzel a témával. A következőkben a „véletlenszám” fogalma pszeudo-véletlent fog jelenteni, hacsak nincs másképp meghatározva.
A véletlen számok használatára mindenhol találkozhatunk példákkal. Az álvéletlen számokat a tervezésben és a grafikában, a számítógépes játékokban szintek generálására és a mesterséges intelligencia szimulálására használják. A véletlen számok halmazait használják a matematikai algoritmusokban (lásd Monte Carlo módszerek).
Nyilvánvalóan a véletlen számok generálásának problémája nem oldható meg klasszikus processzoron, mivel a számítógép működése definíció szerint determinisztikus. Azonban lehetséges nagyon hosszú számhalmazok létrehozása úgy, hogy azok eloszlása ugyanazokkal a tulajdonságokkal rendelkezik, mint a valóban véletlenszerű számok halmazai.
Fontos, hogy egy adott probléma megoldásához ki kell választania a megfelelő generátort, vagy legalább ismernie kell a tulajdonságait. Például egy fizikai folyamat modellezésekor a véletlenszám-generátor megválasztásától függően teljesen eltérő és gyakran hibás eredményeket kaphatunk.
Nézzünk egy szabványos generátort.
#beleértve
Először is inicializálni kell a véletlenszám-generátort (RNG, vagy RNG - véletlenszám-generátor), be kell állítani a magot, amely alapján a generálás a jövőben megtörténik. Fontos, hogy ugyanazon kezdeti érték esetén a generátor ugyanazokat a számokat adja vissza.
Srand(42);
Rendeljen r változóhoz egy véletlenszerű értéket
R = rand();
Az érték 0 és RAND_MAX közötti tartományba esik.
Annak érdekében, hogy a következő indításkor új számkészletet kapjon, minden alkalommal más értékekkel kell inicializálnia a generátort. Használhatja például a rendszeridőt:
Srand(idő(NULL));
Srand(_getpid());
A process.h könyvtár getpid függvénye visszaadja a folyamatazonosítót (a függvény nem POSIX verziója, a getpid is használható).
Központi határérték tétel
Nagyon fontos, hogy azonnal emlékeztessük vagy bemutassuk a központi határtételt. Informális definíció: gyengén függő valószínűségi változók összegének eloszlása normális. Ujj alakú magyarázat: ha több valószínűségi változót adunk össze, függetlenül azok eloszlásától, az összeg eloszlása normális lesz. Gyakran láthat ilyen kódot
#beleértve
Véletlen számok generálása egy adott intervallumon
Először kapunk egy véletlen számot nullától egyig:
Állandó lebegés RAND_MAX_F = RAND_MAX; float get_rand() ( return rand() / RAND_MAX_F; )
Ahhoz, hogy egy számot kapjunk a nullától N-ig terjedő intervallumban, szorozzuk meg N-t egy nullától egyig terjedő véletlen számmal. Ahhoz, hogy véletlen számot kapjunk M-ről N-re, a kapott számot eltoljuk M-el.
Float get_rand_range(const float min, const float max) ( return get_rand() * (max - min) + min; )
Egész szám megszerzéséhez az intervallum hosszával való osztás maradékát vesszük. De az osztás maradéka eggyel kisebb számot ad vissza, mint a mi intervallumunk, ezért növeljük eggyel:
Int get_rand_range_int(const int min, const int max) ( return rand() % (max - min + 1) + min; )
Példa véletlen számok felhasználására integrál kiszámításához. Legyen egy változó sima függvénye. Korlátozzuk egy négyzetre a-tól b-ig, és 0-tól valamilyen pontig, ami nyilvánvalóan nagyobb, mint a függvényünk.
Véletlenszerűen dobunk pontokat a négyzetünkre. Ha a funkció felett helyezkednek el (az ábrán zöld keresztek láthatók), akkor az első A csoportba, ha a funkció alá (az ábrán piros), akkor a második B csoportba soroljuk őket. A pontok helyzete véletlenszerű és egyenletes eloszlású (a szabvány miatt a generátor egyenletes eloszlást ad. Ez az egyszerű példa egyébként már jól mutatja, mennyire fontos az RNG tulajdonságainak ismerete). Ekkor a piros pontok aránya a pontok teljes számához viszonyítva egyenlő lesz a grafikon alatti terület és a teljes terület arányával. A teljes terület pedig a (b-a) négyzet q-val.
Src="/images/c_random_integral.png" alt=" Minden, ami véletlenszerűen a függvényünk fölé esik, zöld, minden alatta piros.
A zöld és a piros aránya megegyezik a grafikon feletti terület és a grafikon alatti terület arányával."> Всё, что случайно попадает выше нашей функции - зелёное, всё что ниже - красное. !}
A zöld és a piros aránya megegyezik a grafikon feletti terület és a grafikon alatti terület arányával.
Alkalmazzuk számításainkat – kétféleképpen keressük meg az x^2 függvény integrálját a 0-tól kettőig terjedő intervallumon.
#beleértve
Játssz a ROUNDS értékkel, változtasd meg, és nézd meg, hogyan változik a számítási pontosság.
Valódi véletlen számok generálása
Valós véletlenszámok generálásához néhány véletlenszerű fizikai folyamaton alapuló generátorokat használnak. Például a hőzajról, a radioaktív anyag hasadásainak számáról, a légköri zajról stb. Az ilyen generátorok hátránya az alacsony működési sebességük (a generált számok száma másodpercenként); természetesen az ilyen generátorok általában külön készülékek.
