% SIMLIB-ref.tex

%% TODO: doplnit, upravit

\documentclass[a4paper]{article}
\usepackage{czech}                 % Česká sazba
\usepackage{epsfig}                % obrázky
 
\begin{document}

\begin{titlepage}
\hrule
\vfill
\begin{center}

{\Huge\bf Stručná referenční příručka SIMLIB \\}

\bigskip            {Petr Peringer \\}

\bigskip                \today

\end{center}
\vfill
\hrule
\end{titlepage}



\section{Úvod}

Tento  text shrnuje  stručné informace  o standardních  třídách,
objektech a funkcích obsažených v SIMLIB. Jsou vynechány všechny
nepodstatné detaily implementace - aby se popis nemusel s dalším
vývojem knihovny příliš měnit. Protože jde o příručku, používáme
abecedního řazení položek.


\section{Hierarchie tříd SIMLIB}

(zjednodušeno)

\begin{verbatim}
   SimObject
       aBlock
           Frict
           Graph
           Insv
           Integrator
           Lim
           Qntzr
           Status
               Blash
               Hyst
               Relay
       aCondition
           BoolCondition
       aQueue
           Queue
       Entity
           Process
           Event
       Facility
       Histogram
       Stat
       Store
       TStat
       Variable
\end{verbatim}


\section{Třída aBlock}

Bázovou třídou pro všechny třídy objektů se spojitým chováním a jedním
výstupem je abstraktní třída aBlock. Tato třída definuje
podstatné společné vlastnosti pro všechny spojité bloky, především
získání hodnoty bloku metodou Value. Deklaruje též virtuální
metody pro vyhodnocení bloku. Bloky lze navzájem propojovat.

Value
  double Value()=0;

Metoda Value je určena pro získání hodnoty výstupu bloku.
Je definována pro všechny třídy odvozené ze třídy aBlock.


\section{Třída aCondition}

Tato třída je abstraktní bázovou třídou pro všechny třídy, popisující
stavové podmínky. Definuje základní operace, nutné pro detekci změn
stavových podmínek a pro vyvolání příslušných stavových událostí.

\section{Třída aQueue}

Třída aQueue představuje abstraktní frontu objektů. Slouží
jako bázová třída pro fronty s různě definovaným uspořádáním. Umožňuje
uchovávání objektů tříd, odvozených z třídy Entity. Platí
pravidlo, že jeden objekt může být v jednom okamžiku nejvýše v jedné
frontě.

Clear

  virtual void Clear();

Tato metoda zruší všechny objekty ve frontě a inicializuje frontu.

Empty

  int Empty();

Metoda Empty testuje, je-li fronta prázdná.

Get

  virtual Entity *Get(Entity *e)=0;

  virtual Entity *Get()=0;

Metoda Get vyjme zadaný, resp. frontou definovaný (obvykle
první) prvek z fronty.

GetFirst,GetLast

  Entity *GetFirst();

  Entity *GetLast();

Metody GetFirst a GetLast vyjmou první, resp. poslední
prvek z fronty.

Insert

  virtual void Insert(Entity *e)=0;

Metoda Insert zařadí prvek e do fronty podle uspořádání,
které definuje fronta. Tato metoda je nejčastěji používána pro vstup
objektu do fronty.

Length

  unsigned Length();

Metoda Length vrací počet objektů, zařazených ve frontě.

\section{Třída Blash - vůle v převodech}

Tato třída popisuje stavové bloky se spojitým chováním a charakteristikou,
která je uvedena na obrázku:

Konstruktor

  Blash(Input x, double p1, double p2, double tga);

Konstruktor vytvoří blok a inicializuje jeho parametry. Parametr
tga je tangentou úhlu alfa.

Value

  double Value()=0;

Metoda Value vrací hodnotu výstupu bloku, tj. stav bloku.


\section{Třída BoolCondition - stavová podmínka}

Tato abstraktní třída popisuje chování stavových podmínek, které
reagují (voláním metody Action) na změnu hodnoty vstupu
(metoda Test), a to buď z hodnoty nula (FALSE) na hodnotu
různou od nuly (TRUE), nebo obráceně. Pro detekci změny podmínky
je použita metoda půlení intervalu. Metody Test a Action
nejsou v této třídě definovány, třída se používá jako bázová
pro uživatelské třídy, které tyto metody definují.

Action

  virtual void Action()=0;

Metoda popisuje reakci na změnu pravdivostní hodnoty podmínky. Tato
metoda musí být definována v odvozené třídě.


Mode

  enum DetectionMode { DetectUP, DetectDOWN, DetectALL }

  void Mode(DetectionMode m);


Metoda Mode umožňuje rozlišení různých případů změny podmínky.
DetectUP způsobí detekci změny pouze z hodnoty FALSE na
hodnotu TRUE, DetectDOWN  detekuje opačnou změnu. DetectALL
zapne detekci obou změn.


Test

  virtual int Test()=0;


Metoda Test slouží pro zápis vstupu podmínky. Vyhodnocuje
se průběžně při simulaci a změna pravdivostní hodnoty způsobí vyvolání
metody Action. Tato metoda musí být definována v  odvozené
třídě.

Příklad

Integrator i1(x);
class MyCondition : BoolCondition {
  int Test()    { return i1.Value()>10; }
  void Action() { x = -x.Value(); }
public:
  MyCondition() { Mode(DetectUP); }
};

\section{Třída Entity}

Tato třída je abstraktní bázovou třídou pro všechny prvky modelu,
které mají popsáno svoje chování událostmi nebo procesy. Definuje
chování společné událostem i procesům, především jde o zařazování
do front a plánování akcí. Entita může být zařazena pouze v jedné
frontě (nemůže být na dvou místech současně).


Activate

  virtual void Activate();

  virtual void Activate(double t);


Plánuje aktivaci entity na čas t (implicitně ihned).


Head

  aQueue *Head();


Vrací ukazatel na frontu, ve které je objekt zařazen.


Idle

  int Idle();


Test, je-li naplánována reaktivace entity. V případě, že není aktivační
záznam entity v kalendáři, vrací nenulovou hodnotu (TRUE). To znamená,
že entita čeká v některé frontě, nebo čeká na WaitUntil
podmínku.


Into

  void Into(aQueue *Q);


Zařadí objekt do fronty Q, uspořádání je definováno frontou.


Out

  void Out();


Vyjme prvek z fronty, je-li v některé zařazen.


Passivate

  virtual void Passivate();


Deaktivuje entitu, tj. vyřadí její aktivační záznam z kalendáře.


Priority

  tPriority Priority;


Priorita entity. Používá se při řešení problémů s plánováním více
entit na jeden a tentýž okamžik. Typ tPriority má rozsah od nuly
do 255. Nejnižší priorita je nulová.

\section{Třída Event}

Tato abstraktní třída popisuje vlastnosti entit, jejichž chování
v čase je popsáno událostmi (tj. akcemi, během jejichž provádění
nedochází ke změně modelového času - nelze je přerušit). Události
jsou ekvivalentní procesům, které nepoužívají přerušovací příkazy.
Jejich implementace je efektivnější než u procesů. Používají se především
při periodickém sledování stavu modelu, jako generátory objektů nebo
pro modelování jednorázových dějů. Dědí vlastnosti třídy Entity.


Activate

  virtual void Activate();

  virtual void Activate(double t);


Plánuje aktivaci události na čas t (implicitně ihned). Aktivací
události se rozumí provedení metody Behavior.


Behavior

  virtual void Behavior()=0;


Výkonná funkce, definující akce události. Uživatel ji musí definovat
v odvozené třídě. Tato funkce je nepřerušitelná.


Konstruktor

\begin{verbatim}
  Event(tPriority p=DEFAULT_PRIORITY);
\end{verbatim}


Vytvoří událost se zadanou prioritou. Implicitní priorita události
je rovna nule (nejnižší).


Priority

  tPriority Priority;


Priorita události. Používá se při řešení problémů s plánováním více
událostí na jeden a tentýž okamžik. Typ tPriority má rozsah
od nuly do 255. Nejnižší priorita je nulová.


Schedule

  void Schedule(double t);


Plánuje aktivaci události na dobu t. Je ekvivalentní metodě
Activate(t).


Terminate

  void Terminate();


Zrušení aktivní události.

\section{Třída Facility}

Tato třída představuje zařízení s výlučným přístupem. To znamená,
že toto zařízení smí být obsazeno pouze jednou entitou. Zařízení
má dvě fronty - frontu vstupní Q1 a frontu přerušené obsluhy
Q2.


Busy

  int Busy();


Metoda vrací nenulovou hodnotu (TRUE), je-li zařízení obsazeno.


Clear

  virtual void Clear();


Inicializace zařízení. Zruší entity ve frontách a fronty, pokud byly
vytvořeny dynamicky zařízením.


in - entita v obsluze

  Entity *in;


Obsahuje ukazatel na entitu právě obsluhovanou zařízením nebo NULL
v případě, že zařízení není obsazeno.


Konstruktor,Destruktor

  Facility();

  Facility(char *name);

  Facility(Queue *queue1);

  Facility(char *name, Queue *Queue1);

  virtual ~Facility();


Inicializuje zařízení jménem name, je možné explicitně zadat
vstupní frontu. Implicitně je zařízení volné.


Q1,Q2 - fronty u zařízení

  Queue *Q1;

  Queue *Q2;


Vstupní fronta a fronta entit, jejichž obsluha byla přerušena.


QueueLen

  unsigned QueueLen();


Délka vstupní fronty zařízení. Tento údaj je použitelný pro omezení
délky fronty.


QueueIn

  virtual void QueueIn(Entity *e, tPriority sp);


Metoda QueueIn zařadí entitu e do vstupní fronty
Q1 podle priorit v tomto pořadí:

 (1) priorita obsluhy (největší je první)
 (2) priorita entity
 (3) FIFO


Podle stejných pravidel je řazena i fronta Q2.


Release

  virtual void Release(Entity *e);


Uvolní zařízení. Je chybou, provede-li se uvolnění neobsazeného zařízení.
Je chybou, uvolňuje-li zařízení jiná entita než ta, která je obsadila.


Seize

  virtual void Seize(Entity *e, tPriority sp);


Obsazení zařízení entitou e s prioritou obsluhy sp.
Je-li zařízení již obsazeno entitou s menší prioritou obsluhy než
je sp, potom přeruší obsluhu této entity, zařadí ji do fronty
přerušené obsluhy a obsadí zařízení entitou e. Jinak vstoupí
do vstupní fronty zařízení metodou QueueIn. Entity, čekající
ve frontě přerušených mají při stejné prioritě obsluhy přednost před
entitami, čekajícími ve vstupní frontě. Uspořádání front je popsáno
v popisu metody QueueIn.


tstat - statistika zařízení

  TStat tstat;


Tato časová statistika umožňuje výpočet průměrného využití zařízení.


SetName, SetQueue

  void SetName(char *name);

  void SetQueue(Queue *queue1);


Explicitní nastavení jména, resp. vstupní fronty. Používá se především
při inicializaci polí zařízení.


Output

  virtual void Output();


Operace tisku stavu a statistik zařízení včetně statistik front.



\section{Třída Frict - tření}

Třída Frict implementuje nestavové bloky s charakteristikou tření:


Konstruktor

  Frict(Input x, double r1, double r2, double tga);



Value

  double Value()=0;


Metoda Value vrací hodnotu výstupu bloku.

\section{Třída Graph}

Tato třída je určena pro záznam hodnot získaných při spojité simulaci
do výstupního souboru. Výstup hodnot probíhá automaticky, soubor
musí být otevřen voláním funkce OpenOutputFile v popisu
experimentu. Tento soubor lze po skončení simulačních experimentů
prohlížet výstupním editorem (program OE).


Konstruktor

  Graph(char *name, Input x, double step);


Parametrem konstruktoru je jméno grafu, tj. jméno ukládaného průběhu,
vstupní objekt, jehož hodnota bude zaznamenávána a interval ukládání
vstupních hodnot do souboru.

Příklad:

Integrator Teplota(x,20);
Graph G("Teplota",Teplota,0.01);

int main()
{
  OpenOutputFile("ZAZNAM.OUT");
  Init(0,10);
  Run();
}

\section{Třída Histogram}

Objekty třídy Histogram sledují četnost vstupních hodnot
v zadaných intervalech. Histogram má tyto parametry:



name       jméno histogramu

low        dolní mez = začátek prvního intervalu

step       krok = šířka intervalů

count      počet intervalů




Kromě toho se sledují hodnoty, které jsou menší, než dolní mez prvního
intervalu a větší, než horní mez posledního intervalu. Situaci ilustruje
obrázek:


Clear

  virtual void Clear();


Inicializace histogramu.


Konstruktor,Destruktor

  Histogram();

  Histogram(double low, double step, int count);

  Histogram(char *name, double low, double step, int count);

  ~Histogram();


Vytvoření a rušení histogramu se zadanými parametry.


operator () - záznam hodnoty

  void operator ()(double x);


Tato operace zaznamená hodnotu x do histogramu.


operator [] - četnost v intervalu

  unsigned operator [](unsigned i);


Tato operace vrací četnost v i-tém intervalu histogramu.
Je-li index i mimo meze vrací nulu.


Output

  virtual void Output();


Operace tisku histogramu do standardního textového výstupu. Tiskne
se formou tabulky.

Příklad:

Histogram H("Histogram1",0,0.1,100);
double x;
  ...
  H(x);           // záznam hodnoty proměnné x
  H(5);           // záznam hodnoty 5
  ...
  H.Output();     // tisk histogramu H



\section{Třída Hyst - hystereze}

Hystereze je nelinearita s vnitřním stavem. Charakteristika hystereze
je na obrázku:


Konstruktor

  Hyst(Input x, double p1, double p2, double y1, double y2, double  tga);


Vytvoří a inicializuje parametry bloku.


Value

  double Value()=0;


Metoda Value vrací hodnotu výstupu bloku.

Příklad:

Hyst H(x,-1,1,-5,5,3.5);
  ...
  printf("výstup bloku hystereze =%g\n",H.Value());



\section{Třída Input}

Objekty této třídy se používají jako vstupy spojitých bloků. Objekt
reprezentuje odkaz na spojitý blok.


Konstruktor

  Input(aBlock *b);


Inicializuje objekt třídy Input odkazem na blok, zadaný jako parametr.


Value

  double Value();


Vyhodnotí objekt na který se odkazuje.

Příklad:

  class B1 : aBlock {
    Input in;
     ...
    B1(Input i): in(i) {}
     ...
  };

\section{Třída Insv - necitlivost}

Necitlivost je typická nestavová nelinearita s charakteristikou:


Konstruktor

  Insv(Input x, double p1, double p2);

  Insv(Input x, double p1, double p2, double tgalfa, double tgbeta);


Implicitně jsou úhly alfa a beta 45 stupňů.


Value

  double Value()=0;


Metoda Value vrací hodnotu výstupu bloku.


\section{Třída Integrator}

Třída Integrator implementuje popis numerické integrace při spojité
simulaci. Integrátor má definovány tři základní operace:


 o  inicializace, nastavení počáteční hodnoty

 o  nastavení hodnoty, tj. skoková změna stavu integrátoru

 o  numerická integrace (skrytá vlastnost objektu)


Init

  void Init(double initvalue);

  double operator = (double x)


Metoda Init nastaví inicializační hodnotu integrátoru. Tuto
hodnotu integrátor vždy použije pro svou inicializaci před začátkem
simulace.


Konstruktor

  Integrator(Input x);

  Integrator(Input x, double initvalue);


Vytvoření a inicializace integrátoru hodnotou initvalue nebo
nulou.


Set

  void Set(double value);

  double operator = (double x)


Nastaví hodnotu integrátoru. Lze použít k provedení nespojité změny
hodnoty integrátoru.


Operátor =

  double operator = (double x)


Operátor přiřazení má dva různé významy podle místa použití. Při
použití ve stavu INITIALIZATION (tj. mezi voláním funkcí Init
a Run v popisu experimentu) nastaví inicializační hodnotu
integrátoru (je ekvivalentní metodě Init). Použije-li se
ve stavu SIMULATION (probíhá simulace), potom nastavuje hodnotu výstupu
integrátoru (je ekvivalentní metodě Set).


Value

  double Value();


Metoda Value vrací hodnotu výstupu integrátoru.

Příklad:

Integrator i1(x,1),
           i2(i1);  // vytvoření a inicializace

class Udalost1 : Event {
  void Behavior() {
    i1 = 1.0;       // nastavení hodnoty - skoková změna
    ...
  }
};

main() {
  Init(0,10);
  i1 = 1.0;         // inicializace integrátoru
  ...
  Run();
}


\section{Třída Lim - omezení}

Objekty třídy Lim omezují vstupní hodnotu na zadaný interval
od p1 do p2. Strmost charakteristiky je možno zadat
jako poslední parametr formou tangenty úhlu alfa. Charakteristika
omezení je na obrázku:


Konstruktor

  Lim(Input x, double p1, double p2);

  Lim(Input x, double p1, double p2, double tgalfa);


Value

  double Value();


Metoda Value vrací hodnotu výstupu bloku.

\section{Třída Process}

Abstraktní třída Process popisuje vlastnosti objektů (entit), jejichž
chování v čase je popsáno procesem (tím rozumíme proceduru, přerušitelnou
některými příkazy). Používá se jako bázová třída pro třídy vytvářené
uživatelem. Dědí vlastnosti třídy Entity.


Activate

  void Activate(double t);

  void Activate();


Plánuje aktivaci entity na modelový čas t, případně ihned.
Aktivace znamená buď start popisu chování v případě nově vytvořené
entity, nebo pokračování provádění popisu chování v případě, že proces
již běžel (a byl například deaktivován příkazem Passivate).


Behavior

  virtual void Behavior()=0;


Popis diskrétního chování procesu. Uživatel musí definovat tuto metodu
ve třídě, která zdědí třídu Process. Metoda je přerušitelná
příkazy Wait, WaitUntil, Seize, Enter,
Passivate, Cancel.


Cancel

  virtual void Cancel();


Ukončení procesu a zrušení objektu. Nemusí se uvádět v případě, že
by šlo o poslední příkaz v metodě Behavior.


Enter

  virtual void Enter(Store *s, tCapacity ReqCap);


Obsadí kapacitu ReqCap skladu s, je-li volná. Jinak
vstoupí do vstupní fronty skladu s. Uvolnění skladu viz metoda Leave.


Konstruktor,Destruktor

\begin{verbatim}
  Process(tPriority p=DEFAULT_PRIORITY);

  virtual ~Process();
\end{verbatim}

Vytvoří proces se zadanou prioritou. Implicitní priorita procesu
je rovna nule (nejnižší). Destruktor zruší objekt (proces).


Leave

  virtual void Leave(Store *s, tCapacity ReqCap);


Uvolní kapacitu ReqCap skladu s. Obsazení skladu
viz metoda Enter.


Passivate

  virtual void Passivate();


Vyřadí aktivační záznam procesu z kalendáře. Proces čeká až bude
opět aktivován. Po aktivaci pokračuje od následujícího příkazu v
popisu chování.


Priority

  tPriority Priority;


Priorita procesu. Typ tPriority má rozsah od nuly do 255.
Nejnižší priorita je nulová.


Release

  virtual void Release(Facility *f);


Uvolní zařízení f. Je chybou, provede-li se uvolnění zařízení
před jeho obsazením. Je chybou, uvolňuje-li zařízení jiný proces
než ten, který je obsadil metodou Seize.


Seize

  virtual void Seize(Facility *f);

  virtual void Seize(Facility *f, tPriority PrioS);


Obsadí zařízení f, je-li volné. Je-li zařízení obsazeno
entitou s menší prioritou obsluhy PrioS, potom přeruší obsluhu
této entity, zařadí ji do fronty přerušené obsluhy a obsadí zařízení.
Jinak vstoupí do vstupní fronty zařízení f. Entity, čekající
ve frontě přerušených mají přednost před entitami, čekajícími ve
vstupní frontě. Fronty jsou uspořádány podle priority obsluhy a podle
priority entity. Viz též třída Facility.


Wait

  virtual void Wait(aQueue *Q);

  virtual void Wait(double DeltaTime);


Čekání entity ve frontě Q nebo čekání po dobu DeltaTime.
Čekání po dobu DeltaTime znamená plánování reaktivace procesu
na čas Time + DeltaTime.


WaitUntil

  virtual void WaitUntil(int expr);


Obecné čekání na splnění podmínky expr. Parametr je neustále
vyhodnocován a platí-li, proces pokračuje, jinak čeká. K vyhodnocování
podmínky expr dochází vždy po skončení události nebo po
přerušení procesu. Pokud se čeká na změnu nějaké proměnné, je třeba
zajistit přerušení procesu po příkazu, který ji změní.

\section{Třída Qntzr - kvantizátor}

Kvantizátor provádí zaokrouhlení vstupní hodnoty na násobek kvantizačního
kroku.


Konstruktor

  Qntzr(Input x, double p);


Parametr p je kvantizační krok.


Value

  double Value();


Metoda Value vrací hodnotu výstupu kvantizátoru.

\section{Třída Queue}

Třída Queue představuje prostředek pro uchování objektů
tříd, odvozených z třídy Entity. Fronta je seřazena podle
priorit entit Fronta udržuje statistiku počtu entit ve frontě a statistiku
dob pobytu entit ve frontě.


Clear

  virtual void Clear();


Zruší všechny entity ve frontě, inicializuje statistiky fronty.


Empty

  int Empty();


Test, je-li fronta prázdná.


Get

  Entity *Get(Entity *e);

  Entity *Get();


Vyjme zadaný, resp. první prvek z fronty.


Insert

  virtual void Insert(Entity *e);


Vloží zadanou entitu do fronty podle její priority.


Konstruktor, Destruktor

  Queue();

  Queue(char *name);

  virtual ~Queue();


Vytvoří prázdnou frontu se jménem name. Destruktor zruší
frontu, včetně zařazených objektů.


Length

  unsigned Length();


Získá počet entit ve frontě. Je použitelné v případě modelování front
s omezenou délkou.


Output

  void Output();


Tato metoda vytiskne do standardního textového výstupního souboru
statistiky a stav fronty.


SetName

  void SetName(char *name);


Nastaví jméno fronty. Používá se při inicializaci polí front. Jméno
slouží k identifikaci fronty ve výstupních datech při tisku metodou
Output.


StatN, StatDT - statistiky fronty

  TStat StatN;

  Stat StatDT;


Statistika počtu prvků ve frontě a statistika doby přítomnosti entit
ve frontě.

\section{Třída Relay - relé}

Charakteristika relé je uvedena na obrázku:


Konstruktor

  Relay(Input x, double p1, double p2, double p3, double p4, double  y1,
  double y2);


Value

  double Value();


Metoda Value vrací hodnotu výstupu relé.

\section{Třída SimObject}

SimObject je základní bázovou třídou (kořenem) hierarchie tříd v
SIMLIB. Specifikuje základní vlastnosti objektů modelu. Definuje
metody pro vytvoření a zrušení objektu. Třída SimObject je
abstraktní bázovou třídou, tj. nelze vytvářet objekty této třídy.

\section{Třída Stat}

Tato třída slouží pro sběr statistických údajů. Uchovává následující
informace vypočtené ze vstupních hodnot x:

  double sx;       // suma hodnot x
  double sx2;      // suma čtverců hodnot x
  double min;      // minimální hodnota
  double max;      // maximální hodnota
  unsigned long n; // počet záznamů



Clear

  virtual void Clear();


Inicializace statistiky.


Konstruktor,Destruktor

  Stat(char *name);

  ~Stat();


Inicializace a rušení objektu.


operator () - záznam hodnoty do statistiky

  void operator ()(double x);


Záznam hodnoty x do statistiky.


Output

  virtual void Output();


Operace tisku statistiky do standardního textového souboru.

Příklad:

Stat Statistika("Statistika");
  ...
  Statistika(x);        // záznam hodnoty x
  ...
  Statistika.Output();  // tisk statistiky


\section{Třída Status - stavová proměnná}

Třída popisuje vlastnosti stavových proměnných. Jsou z ní odvozeny
třídy stavových bloků (např. relé,hystereze). Každý objekt této třídy
má atribut, který definuje jeho stav.


Init

  void Init(double initvalue);


Metoda Init nastaví inicializační hodnotu stavu objektu.


Konstruktor

  Status(Input x);

  Status(Input x, double initvalue);


Inicializace stavu objektu nulou nebo zadanou hodnotou initvalue.


operator =

  double operator = (double x)


Operátor přiřazení má dva různé významy podle místa použití. Při
použití ve stavu INITIALIZATION (tj. mezi voláním funkcí Init
a Run v popisu experimentu) nastaví inicializační hodnotu
(je ekvivalentní metodě Init). Použije-li se ve stavu SIMULATION
(probíhá simulace), potom nastavuje hodnotu objektu (je ekvivalentní
metodě Set).


Set

  void Set(double value);

  double operator = (double x)


Nastaví stav objektu. Lze použít kdekoli v popisu modelu k provedení
nespojité změny hodnoty stavu.


Value

  double Value();


Metoda Value vrací hodnotu výstupu objektu.

\section{Třída Store}

Tato třída představuje sdílený prostředek s určitou kapacitou (počtem
míst). To znamená, že několik entit může současně používat část kapacity
skladu. Pokud požadovaná kapacita není k dispozici, musí entita počkat
ve vstupní frontě Q.


Capacity

  tCapacity Capacity();


Vrací celkovou kapacitu skladu.


Clear

  virtual void Clear();


Inicializace skladu, jeho vstupní fronty a statistik.


Empty

  int Empty();


Metoda Empty vrací TRUE, je-li sklad prázdný.


Enter

  virtual void Enter(Entity *e, tCapacity cap);


Entita e obsadí kapacitu cap skladu, je-li volná.
Jinak vstoupí do vstupní fronty skladu voláním metody QueueIn.


Free

  tCapacity Free();


Vrací volnou kapacitu skladu.


Full

  int Full();


Metoda Full vrací TRUE, je-li kapacita skladu zcela obsazena.


Konstruktory,Destruktor

  Store();

  Store(tCapacity capacity);

  Store(char *name, tCapacity capacity);

  Store(tCapacity capacity, Queue *queue);

  Store(char *name, tCapacity capacity, Queue *queue);

  virtual ~Store();


Konstruktory umožňují inicializaci skladu, nastavení jeho kapacity
a vstupní fronty. Implicitní kapacita je 1, pokud nezadáme frontu,
sklad si ji vytvoří. Typ tCapacity je celočíselný (unsigned
long).


Leave

  virtual void Leave(tCapacity cap);


Uvolní požadovanou kapacitu cap skladu. Je chybou, žádá-li
se o uvolnění větší kapacity, než je obsazeno.


Output

  virtual void Output();


Tiskne stav skladu, jeho fronty a statistiky.


Q - vstupní fronta

  Queue *Q;


Ukazatel na vstupní frontu. Sklad si vytvoří vstupní frontu dynamicky,
je-li to zapotřebí.


QueueIn

  virtual int QueueIn(Entity *e);


Operace vstupu do fronty u skladu. Zařadí do fronty podle priority
entity, při shodě priorit podle strategie FIFO.


QueueLen

  unsigned QueueLen();


Zjistí délku fronty u skladu.


SetName,SetCapacity,SetQueue

  void SetName(char *name);

  void SetCapacity(tCapacity capacity);

  void SetQueue(Queue *queue);


Tyto operace nastavují parametry skladu, používají se při inicializaci
polí skladů.


tstat - statistika skladu

  TStat tstat;


Slouží pro výpočet průměrně obsazené kapacity.


Used

  tCapacity Used();


Vrací použitou kapacitu skladu.



\section{Třída TStat}

Tato třída slouží pro sběr statistických údajů. Objekty této třídy
sledují časový průběh vstupní veličiny. To umožňuje výpočet průměrných
hodnot veličin v zadaném časovém intervalu od inicializace statistiky
do okamžiku výstupu. Časová statistika uchovává tyto údaje vypočtené
ze vstupních hodnot x:

\begin{verbatim}
  double sxt;        // suma hodnot x*dtime
  double sx2t;       // suma čtverců hodnot (x^2)*dtime
  double min;        // minimální hodnota x
  double max;        // maximální hodnota x
  double t0;         // čas inicializace
  double tl;         // čas poslední operace
  double xl;         // poslední zaznamenaná hodnota x
  unsigned long n;   // počet záznamů do statistiky
\end{verbatim}



Clear

  virtual void Clear();


Inicializace statistiky.


Konstruktor,Destruktor

  TStat();

  TStat(char *name);

  ~TStat();


Inicializace a rušení objektu.


operator () - záznam hodnoty do statistiky

  void operator ()(double x);


Tato operace provede záznam hodnoty x do statistiky.


Output

  virtual void Output();


Operace tisku časové statistiky.

Příklad:

TStat  TS("TS");
  ...
  TS(x);        // záznam hodnoty v čase Time
  ...
  TS.Output();  // výstup



\section{Standardní objekty a proměnné}

Součástí každého modelu jsou standardní proměnné, které jsou deklarovány
implicitně. Identifikátorů standardních proměnných nelze použít pro
označení jiných objektů modelu. Tyto proměnné plní zvláštní úlohu
při řízení simulace. Jejich hodnoty nastavují funkce Init,
Run, SetStep a SetAccuracy.


AbsoluteError

\begin{verbatim}
  double AbsoluteError;
\end{verbatim}


Proměnná AbsoluteError obsahuje požadovanou maximální absolutní
chybu numerické integrace. Je nastavována funkcí SetAccuracy.
Implicitní hodnota je nulová, to znamená, že v úvahu se bere pouze
požadovaná maximální relativní chyba integrace.


Current

\begin{verbatim}
  Entity *Current;
\end{verbatim}


Proměnná Current je ukazatel na právě aktivní entitu, tj.
objekt s diskrétním chováním, jehož popis chování (metoda Behavior)
se právě provádí.


EndTime

\begin{verbatim}
  double EndTime;
\end{verbatim}


Proměnná EndTime obsahuje čas ukončení simulace.


MaxStep,MinStep

\begin{verbatim}
  double MaxStep,MinStep;
\end{verbatim}


Proměnné MaxStep a MinStep udávají povolený rozsah
kroku numerické integrace. Nastavují se voláním funkce SetStep.


Phase

\begin{verbatim}
  enum PhaseEnum {START,INITIALIZATION, SIMULATION, TERMINATION};

  PhaseEnum Phase;
\end{verbatim}


Proměnná Phase obsahuje označení právě probíhající fáze experimentu,
může nabývat hodnot: START,INITIALIZATION, SIMULATION, TERMINATION


RelativeError

\begin{verbatim}
  double RelativeError;
\end{verbatim}


Proměnná RelativeError obsahuje požadovanou maximální relativní
chybu numerické integrace. Integrační metoda bere tento požadavek
v úvahu při volbě velikosti integračního kroku.


StartTime

\begin{verbatim}
  double StartTime;
\end{verbatim}


V proměnné StartTime je zaznamenán počáteční modelový čas,
nastavený funkcí Init při inicializaci experimentu.


Time

\begin{verbatim}
  double Time;
\end{verbatim}


Proměnná Time reprezentuje modelový čas.


Objekt T




\section{Standardní funkce}


Abort

\begin{verbatim}
  void Abort();
\end{verbatim}


Funkce ukončí simulační program.


Activate

\begin{verbatim}
  void Activate(Entity *e);
\end{verbatim}


Funkce pro aktivaci entit. (viz třída Entity)


Init

\begin{verbatim}
  void Init(double StartTime, double StopTime);
\end{verbatim}


Funkce inicializuje kalendář, nastaví rozsah modelového času a proměnnou
Time, inicializuje systém řízení simulace.


Passivate

\begin{verbatim}
  void Passivate(Entity *e);
\end{verbatim}


Funkce pro deaktivaci entit. (viz třída Entity)


Run

\begin{verbatim}
  void Run();
\end{verbatim}


Funkce zahájí simulaci od aktuální hodnoty času a pokračuje až do
času, zadaného při předcházejícím volání Init. Simulaci
lze předčasně ukončit stiskem klávesy ESC nebo programově funkcí
Stop.


SetOutput

\begin{verbatim}
  void SetOutput(char *name)
\end{verbatim}


Nastaví standardní textový výstupní soubor pro všechny metody Output.


Stop

\begin{verbatim}
  void Stop();
\end{verbatim}


Funkce ukončí právě probíhající simulační běh. Je možno pokračovat
v dalších experimentech.




\section{Generátory náhodných čísel}

Základem pro generování různých pseudonáhodných rozložení je generátor
rovnoměrného rozložení na intervalu <0,1). Tento generátor je realizován
funkcí Random, kterou lze předefinovat uživatelem definovanou
funkcí. To umožňuje použít vlastní generátor pseudonáhodných čísel
s lepšími vlastnostmi.


Exponential

  double Exponential(double mv);


Funkce Exponential generuje pseudonáhodná čísla s exponenciálním
rozložením a střední hodnotou mv.


Normal

  double Normal(double mi, double sigma);


Funkce Normal generuje pseudonáhodná čísla s normálním rozložením,
střední hodnotou mi a směrodatnou odchylkou sigma.


Poisson

  int Poisson(double lambda);


Funkce Poisson generuje pseudonáhodná čísla Poissonova rozložení
se střední hodnotou lambda.


Random

  double Random();


Standardní funkce Random generuje pseudonáhodná čísla s
rovnoměrným rozložením v intervalu od nuly do jedné. Horní mez intervalu
(číslo jedna) negeneruje.




RandomInit


  void RandomInit();


Funkce RandomInit inicializuje generátor pseudonáhodných
čísel. Po jejím zavolání funkce Random generuje opět stejnou
posloupnost pseudonáhodných čísel.

Uniform

\begin{verbatim}
  double Uniform(double l, double h);
\end{verbatim}


Funkce Uniform generuje pseudonáhodná čísla s rovnoměrným
rozložením v intervalu od l včetně do h. Horní
mez není zahrnuta do intervalu.

Ostatní generátory

Uvedeme pouze přehled ostatních generátorů:

\begin{verbatim}
double Beta(double th, double fi, double min, double max);
double Erlang(double alfa, double beta);
double Gama(double alfa, double beta);
int    Geom(double q);
int    HyperGeom(double p, int n, int m);
double Logar(double mi, double delta);
int    NegBinM(double p,int m);
int    NegBin(double q, int k);
double Rayle(double delta);
double Triag(double mod, double min, double max);
double Weibul(double lambda, double alfa);
\end{verbatim}






\section{Poznámky k implementaci SIMLIB}

Současná verze  knihovny je 2.12.  

\subsection{MSDOS}

Knihovnu lze použít  s těmito překladači:

   Borland C++ v3.1 
   Borland C++ v4.0 (vypnout exception handling)
   Borland C++ v5.0 (vypnout exception handling)
   DJGPP = GNU C++ pro MSDOS

Paměťové požadavky knihovny samotné se pohybují kolem 100KB.

Pro 16 bitové překladače Borland C++ knihovna používá paměťový  model 
LARGE, v integrovaném  prostředí  musí  být  pro  každý  model vytvořen
projekt, tj.  seznam modulů a knihoven,  které se budou spojovat do  jednoho
programu.  Běžné modely  vystačí s  knihovnou SIMLIB a jedním modulem
obsahujícím popis modelu i experimentu.

Pro překlad modelu je napsána dávka SIMLIB.BAT.


\subsection{Linux}

V tomto prostředí je prováděn vývoj knihovny. Používá se překladač

   GNU C++ v2.7.2 

a vývojové prostředí xwpe.

Překlad modelu provede skript SIMLIB.


\end{document}
