A Simula programozási nyelv

Példaprogramok

Traffic szimuláció

Készítette: Keserű András IV. prog-mat. 1994.

A probléma:

A program néhány közlekedési lámpával ellátott útszakasz közlekedését próbálja szimulálni, és nyomon követni a forgalomra tett hatását néhány külső körülménynek, illetve ezen körülmények megváltozásának következményeit.
Például ilyen körülmény a lámpák kapcsolási tulajdonságai, a forgalom érkezésének intenzitása, a forgalom által meghatározott sebesség, lámpák vezérlése.

A működés

A program egy egyszerű közlekedési sémát modellez , mely egy útszakaszon öt darab közlekedési lámpát feltételez. Ezen útszakasz forgalmát, telítettségét vizsgáljuk. A lámpák működése összehangolt, és egy adott sebességre van ütemezve. Ami azt jelenti, hogy az ezen a sebességgel való közlekedés, dugómentesség esetén, csupa zöld lámpát eredményez. Ez az ütemezett sebesség a forgalom sűrűségének függvényében a futás folyamán változhat, és erről üzenetet is kapunk. A forgalomban résztvevő járművek érkezése több szinten is véletlenszerű. Ugyanis a program folyamatosan véletlen hosszúságú időszakokat generál (1-5 óra), mely időszaknak meglesznek a maga véletlenszerű jellemzői. Ilyen jellemző például az, hogy az időszakban hány autó érkezése várható, valamint ezen autók milyen sebességet igyekszenek követni.
A program minden manőverről üzenetet küld, és mindig a legalsó sorban, az útszakasz egyes részeinek telítettségéről, valamint a lámpák pillanatnyi állásáról kapunk információt. A teljes sor jelképezi az útszakaszt, és a lámpákat I vagy - jel jelöli attól függően, hogy a lámpa jelenlegi állapota piros, vagy zöld.
A lámpák között, és előtt számok vannak. A lámpa előtti szám az adott lámpánál várakozó autók száma. A lámpák közötti másik szám az adott útrészen még haladó autók számát mutatja. A legelső szám a futtatás ideje alatt az útszakaszra érkező járművek száma, a legutolsó szám pedig azon járművek száma, amelyek már átmentek, mind az öt lámpánál, és elhagyták az útszakaszt.

Fejlesztői leírás

Beszéljünk először is az előbb megemlített globális változókról:
Lampavar: ennyi időegységenként vált egy lámpa
Lampaseb: egy lámpa mekkora késéssel van az előzőhöz képest ( 5 - 70 km/h , 6- 60 km/h . 7- 50 km/h )
Maxautoora: egy órán belül maximálisan hány autó érkezhet az útszakaszra
Lampavaltora: egy órán belül hányszor vált egy lámpa
Dugohatar: ha az első lámpánál eléri a várakozó autók száma ezt az értéket, akkor megváltozik a lámpák kapcsolási sebessége

A program magjában három process osztály található, ezek rendre a következők:
LAMPAVALT minden lámpához tartozik egy ilyen, az o aktiválásakor vált az adott lámpa. Az o feladata továbbá a következő lámpa aktiválása a megfelelő késleltetéssel.
LAMPAENGED belőle is tartozik egy minden lámpához , és feladata hogy aktiválásakor , ha a lámpa zöld akkor a sorában várakozó autókat tovább engedje.
AUToTIP az egy autót megszemélyesítő process , mely feladata, hogy a neki megadatott sebességgel számolt haladási időt figyelembe véve menjen tovább a következő lámpáig , vagy az utolsó lámpa után terminál.

Ezen kívül van még egy eljárás is, amelyet minden process meghív, miután megváltoztatott valamit az útszakaszon. Az eljárás neve Kiir_forgalom, és feladata az aktuális állapot kiírása, minden lapnyi információ után újrakezdeni ,valamint az ö feladata még a forgalmi telítettség figyelése is, és az esetleges közbeavatkozás. Ami konkrétan azt jelenti, hogy ha az első lámpa sormérete eléri a dugóhatárt, akkor gyorsítja a lámparendszert, illetve ha alacsony a forgalom (hosszabb ideig üres ugyanez a sor), akkor lecsökkenti a lámpák sebességét (azaz növeli a késleltetést).

Letöltés: Traffic

Áruház szimuláció

Készítette: Németh Zoltán prog-mat.

A probléma:

Egy ABC-áruház munkanapjának szimulálása az első vásárló megérkezésétől az utolsó távozásáig. A vásárlók belépnek a bejáraton, ha kell sorba állnak kosárért, majd kosárral a kezükben megkezdik a vásárlást. Némi bolyongás után eljutnak a pultokhoz. Ha van szabad pult odaállnak, ha nincs, akkor sorbaállnak. A pultokat elhagyva előbb utóbb eljutnak a pénztárakhoz. Ha van szabad pénztár odaállnak, ha nincs, akkor ismételten sorbaállnak. Fizetés után a kosarukat leteszik a kijáratnál, majd távoznak. Ha a kijáratnál megfelelő számú kosár összegyűlik, az áruház dolgozói elviszik a kosarakat a bejárathoz. Zárásnál előbb becsukják a bejáratot, majd kiszolgálják a még bent lévő vásárlókat és végül becsukják a kijáratot is.

Fejlesztői leírás:

Az input:
A program az "in" nevű file-ból olvassa ki sorrendben a következőket:
- a pultok számát,
- a pénztárak számát,
- a kosarak számát,
- hány összegyűlt kosár kell, hogy előrevigyék őket a bejárathoz,
- a vásárlók érkezési sűrűségét meghatározó faktort,
- a szimuláció tartamát.
Induláskor az output file nevét is meg kell adni.
Az output:
Az induláskor megadott output file-ba lista készül az áruházban végbemenő eseményekről. A vásárlók 1-tol számozódnak és a cselekményeinél mindig szerepel a megfelelő sorszám is. A listát néhány összegzés és statisztikai adat zárja.
Az osztályok:
Bejárat:
Egészen addig generálja a vásárló típusú objektumokat, amíg zarva hamis, utána pedig valahányszor hozzá kerül a vezérlés nem csinál semmit, rögtön továbbadja, hogy a még bent lévő vásárlók is kijuthassanak.
Vásárló:
Az "m" adattagra és a "melyik" függvényre azért van szükség, hogy a kiírásoknál a vásárlók sorszámát is tudjuk. A vásárló működése során a kosárra_varok, pultra_varok és a penztarra_varok sorokba áll be és aktivizál egy-egy kosarak1, pult, penztar és kosarak2 típusú objektumot, valamint a megfelelő számlálásokat elvégzi.
Kosarak1:
Valahányszor rá kerül a vezérlés átad egy kosarat, ha van kinek és, ha van miből. Vagyis kosarszam1-et csökkenti eggyel.
Kosarak2:
kosarszam2-t növelgeti eggyel és ha meghaladja atvitt_kosar_szam-ot, akkor átviszi a kosarakat, vagyis kosárszam2-t nullára, kosarszam1-et pedig kosarszam-ra állítja.
Pult:
Ha van pultra váró vásárló, akkor azt kiveszi a várakozók sorából és kiszolgálja, majd továbbindítja. Ha nincs, akkor visszaáll a pihenő pultok sorába.
Penztar:
Hasonló a pult-hoz.

Letöltés: Áruház

Farm szimuláció

Készítette: Papp Gábor IV. prog.-mat.

A probléma:

Ez a program egy nagyon kis farmot szimulál, ahol van egy farmer, egy szállító, aki a takarmányt szállítja, és két tehén. A programnak többféle különböző paramétert lehet megadni, ami sokféle és eltérő kimenetelt eredményezhet.

A program indításakor kétféle lehetőség közül választhatunk. Ha nem 0-t adunk meg, akkor beépített tesztadatokkal fut le a program, ha 0-t adunk meg, akkor mi adhatjuk meg az induló paramétereket.

Az induló paraméterek jelentése :
honap_hossz : A farmon eltelt idő hossza ( ez relatív, a többi időtartamot ehhez viszonylagosan kell megadni ).
evesido : Ennyi ideig eszik egy tehén.
kezdoosszeg: Ekkora pénzösszeggel indul a farm. (Ebből lehet költeni a tápra.)
ossztap: Ekkora tápmennyiséggel indul a farm. ( Ez növekszik, ha táp érkezik, csökken, ha egy tehén eszik belole. )
tehentap: Ennyi tápot eszik meg egy tehén egyszerre.
hozotttap: Ennyi tápot hoz egyszerre a szállítóautó.
tehenar: Ennyi pénzért fog eladni a farmer egy tehenet.
eladhato: Ekkora súllyal fog eladni egy tehenet.
tapar: Ennyit fizet a farmer a szállítóautónak.
hizas: Ez a hízási tényező, ha X mennyiségű tápot megeszik a tehén, akkor X*hizas-sal nő a súlya.
kezdosuly: Ekkora súllyal indulnak a farmon a tehenek.

Ezek után látható a szimulációs folyamat a képernyőn, ahol a lényegesebb adatok időről-időre megjelennek. A végeredmény az, hogy mennyi pénz maradt vagy folyt be a farmra.

Fejlesztői leírás:

A programot folyamatok alkotják, úgymint: farmer, tehén, autó. Ezenkívül van benne egy eljárás, ami az adatokat bekéri.

A folyamatok leírása :
farmer :
A folyamat indításakor aktivizálja a két tehén folyamatot, majd végtelen ciklusban ismétli a következőt : megvizsgálja, hogy van-e táp. Ha nincs, akkor aktivizálja a táposautó folyamatot. Ezután mindkét tehenet megvizsgálja, hogy elérték-e az eladhatósági súlykorlátot. Ha igen, akkor eladja őket, majd törli őket a folyamatok közül. Végül, ha mindkét tehén el lett adva, akkor saját magát állítja le a folyamat. Ha pedig nem, akkor hátrébb ütemezi magát.
tehen :
A folyamat indításakor a tehén súlya kezdősúly értéket kap. Ezután ha van annyi táp, amennyiből tud enni, akkor eszik, ha nem akkor csak hátrébb ütemezi magát ( amíg meg nem jön a táposautó ).
auto :
Miután aktivizálta öt a farmer, beállítja az új értékeket, majd felfüggeszti működését.

Lényeges az ütemezés szerepe, ugyanis a farmert csak kevés ideig lehet felfüggeszteni, különben a tehén folyamatok túlfuthatnak azon a korláton, mint amit a farmer ellenőriz.

Számos fejlesztési lehetőséget ad a program, pl.: Ne csak 2 tehén legyen, hanem több, a farmer vehessen is teheneket, a tehenek tejet is adhatnak, amit szintén értékesíteni lehet, stb. . Mindez azonban már meglehetősen nagy feladat lenne.

Letöltés: Farm

Fodrászat szimuláció

Készítette: Jakabffy Csaba IV. prog.-mat.

A probléma:

A program egy fodrászszalon szimulációját valósítja meg.
A fodrászatban dolgoznak fodrászok, hajmosók és pénztárosok.

A program indításakor meg kell adni néhány adatot :
- a hajmosók, hajvágók, pénztárosok számát,
- a hajmosási, hajvágási, fizetési periódus hosszát,
- az egész szimulációs periódus hosszát (természetesen ha lejárt a periódus, akkor még azután kiszolgálják a fodrászüzletben lévő vendégeket),
- a szimuláció eredményét hova írjuk, ha file-t adunk meg, akkor az eredmény a SIMULAT.TXT file-ban jelenik meg.

A hajmosókat Németh{n} Gizi-nek hívják, ahol n eleme 1..N hajmosók száma.
A hajvágókat Horváth{n} Rozi-nak hívják, ahol n eleme 1..N hajvágók száma.
A pénztárokat 1-tol pénztárosok számáig sorszámozzuk.

A bejárati ajtón véletlenszerű időközönként bejön egy ember, hogy levágassa a haját. A belépő emberek nevei Kovács{n} István, ahol n a belépési sorrendnek megfelelő szám.
Egy ember útja ezután sorrendben a következő :
- amikor van szabad hajmosó, megmossák a haját,
- amikor van szabad hajvágó, levágják a haját,
- amikor van szabad pénztáros, kifizettetik vele a fodrászkodás díját,
- hazamegy.

Letöltés: Fodrászat

Gépterem szimuláció

Készítette: Gulyás Roland IV. prog.-mat.

A probléma:

A program egy gépterem szimulációját végzi. A gépteremben N db gép van, melyet a felhasználók folyamatosan használnak. A gépek száma határt szab az aktív felhasználók számának. A user-ek folyamatosan érkeznek, ha kell várakoznak, majd dolguk végeztével távoznak.
Hogy a gépteremben ne alakulhasson ki feltorlódás egyes felhasználók végett, a rendszergazda kiküldhet felhasználókat a gépteremből a következő okok miatt:
- a felhasználó M ideje van már a gépteremben
- a felhasználó nem megengedett célra használja a gépet (pl. játszik rajta)

Letöltés: Gépterem

Lift szimuláció

Készítette: Csaki Gyorgy, IV. prog.terv. mat. Bp., 1995.03.10.

A probléma:

Egy irodaházban van egy lift, ami az ügyfeleket szállítja az emeletek között. Az egyes emeleteken lehet liftre várni, ügyintézőre várni, és jó esetben az ügyintézővel az ügyet intézni.

Megoldás:

Következő osztályokat definiáltam:

link class customer( i ); integer i; az i. emeleten lévő ügyfelek sora az iroda előtt, az ügyintézőre várva

link class wait_for_lift( i ); integer i; begin integer where; az i. emeleten levő ügyfelek sora a lift előtt; a listaelemek where változója tartalmazza, hogy melyik másik emeletre szeretne továbbmenni az illető

Következő osztályok folyamatok leszármazottjai, amik az egyes tevékenységeket végzik:

process class doorman; a portás; a véletlenszerűen érkező ügyfeleket helyezi el a liftre várakozók listájában a földszinten
process class assistant( i ); az i. emelet ügyintézője;
A rá várakozó sorból kiszolgálja az elsőt, majd beteszi a liftre várakozók listájába. A földszinten nincs iroda, csak porta.
process class lift( n, cap, speed ); ! n: az emeletek száma ; integer n, cap; ! cap: a lift kapacitása ; real speed; ! speed: ki-beszállási sebesség ; begin integer storey, debugg; ! storey: amelyik emeleten éppen van; ref( head ) q; ! q: a liftben levő személyek ; ! listájának feje ;

A szállítást végző folyamat; a lift mozgásának algoritmusa:

Ciklikusan le-föl mozgást végez a lift, amíg van igény a szállításra; ha nincs liftigénylés, akkor a lift passzív állapotba kerül, ha lesz új várakozó, akkor az új várakozó aktiválja a liftet. Lefelé megy a lift, ha a liftben valaki lefelé akar menni, vagy ha üres a lift és van alsóbb szinten liftigénylés. Felfelé hasonló meggondolással működik a lift. Ajtónyitáskor kiszállnak azok, akik épp az aktuális emeletre igyekeztek, es maximum annyian szállhatnak be, amennyi szabad kapacitása van még a liftnek. A kiszálló személyeket ki kell venni a liftben levő személyek listájából, és be kell tenni őket az ügyintézőre várakozók listájába. Ha az ügyintézőnél nincs senki (passzív), akkor az új várakozó aktivizálja. A földszinten kiszállókat nem kell betenni új listába, őket kiszolgálta az irodaház. A beszálló embereket a liftre várakozók listájából át kell tenni a liftben lévő emberek listájába.

A szimulációba beépítettem a nyomkivető utasításokat is, azaz az egyes folyamatok mindig kiírjak a képernyőre az új állapotukat:
A lift:
melyik emeleten van, hány ember van benne,
Az ügyintézők:
van-e náluk valaki, és a várakozó sorok hossza is kiíródik.

A listákhoz es folyamatokhoz szükséges változók:

ref( head ) array cust( 1:20 ), w_f_l( 0:20 );
minden emeleten levő sorokhoz listafejek, a földszinten csak a liftre váró sor kell

ref( doorman ) dm;
a portás objektum azonosítója

ref( assistant ) array assis( 0:20 );
az egyes emeletek ugyintezo objektumanak azonosítója

ref( lift ) lift1;
a lift objektum azonosítója

A szimuláció alkalmas több lift, portás, ill. ügyintéző egy emeleten való kezelésére is. A nehézséget a nyomonkövetés (képernyőre való kiíratás) jelentene. Módosítani annyit kellene, hogy nem csak egy liftet, ügyintézőt, portást kellene aktivizálni a megfelelő helyeken, hanem az összes szóba jöhetőt. A várakozó listákat nem kellene módosítani; amelyik lift előbb jön, vagy amelyik ügyintéző előbb fogad az veszi ki a várakozó személyt a listából, és mindegyik folyamat ugyanabba a listába teszi az új várakozókat.


A kezdeti paramétereket a standard inputról kell megadni.
A következő paramétereket lehet beállítani ebben a sorrendben:

Emeletek száma (0 <21)
Lift kapacitása (0 <11)
Érkező emberek maximális száma (0 < 5001)
Maximális futási idő (0.0 <= stop < 90000.0)
Irodista min munkaideje egy ügyfélre (0.0 <= min <500.0)
Irodista Max munkaideje egy ügyfélre (min <= Max <1000.0)
Az emberek ki-beszállási sebessége (0.0 <= s <100.0)
Randit kezdőértéke (integer)
Uniform kezdőértéke (integer)
negexp kezdőértéke (integer)
negexp várható értéke (real)
Emeletszám generáló, ff. száma ( 0 <= g <= 4 )

Az utolsó paraméter jelentése:
Ez az, ff. generálja egy új liftre várakozónak az új emeletszámot, azaz hogy melyik emeletre akar tovább menni. Az új szám mindig különbözni fog az aktuális emeletszámtól.
0: az új emeletszám a földszintről randit 0 és n között (minden emeletről mindenki a földszintre megy)
1: az új emeletszám mindenhonnan randit 0 es n között
2: mint előző, kivéve, hogy az 5. es 12. emeletről (ha van ilyen) (mindenki a földszintre akar menni)
3: normál eloszlás segítségével Generálja az új sorszámot
4: Poisson eloszlás segítségével Generálja az új sorszámot

Tesztelésre alkalmasak a standard inputra való átirányítással a következő file-ok (a számok a file-névben a generáló v.-re utalnak ):
i0, i1, i2, i2long, i3, i4

A program lefordítása:
samu16 lift.sim
A program indítása:
samrun lift.prg [ <i* ]


Letöltés: Lift