Szakdolgozat

Miskolci Egyetem

Közös fejleszt®i keretrendszer fuzzy szabály

interpolációs módszerekhez

Készítette:

Tóth Dávid

2008. Programtervez® Informatikus

Témavezet®:

Krizsán Zoltán

Miskolc, 2013

Miskolci Egyetem

Gépészmérnöki és Informatikai KarAlkalmazott Matematikai Tanszék Szám:

Szakdolgozat Feladat

Tóth Dávid (EN2L32) programtervez® informatikus jelölt részére.

A szakdolgozat tárgyköre: Fuzzy Szabály-Interpolációs módszerek keretrendszere

A szakdolgozat címe: Közös fejleszt®i keretrendszer fuzzy szabály interpolációs mód-szerekhez

A feladat részletezése:A MTATLAB-ból már ismert Fuzzy Rule Interpolation Toolbox (FRIT) alapján C++nyelven egy keretrendszer kialakítása. A meglév® 6 eljáráson túl további b®víthet®ségés könny¶ használat biztosítása.

Témavezet®: Krizsán Zoltán egyetemi tanársegéd

Konzulens: Dr. Karácsony Zsolt, egyetemi adjunktus

A feladat kiadásának ideje:

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .szakfelel®s

2

Eredetiségi Nyilatkozat

Alulírott . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ; Neptun-kód: . . . . . . . . . . . . . . . . . . .a Miskolci Egyetem Gépészmérnöki és Informatikai Karának végz®s . . . . . . . . . . . . . . . . . . .szakos hallgatója ezennel büntet®jogi és fegyelmi felel®sségem tudatában nyilatkozomés aláírásommal igazolom, hogy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .cím¶ szakdolgozatom/diplomatervem saját, önálló munkám; az abban hivatkozott szak-irodalom felhasználása a forráskezelés szabályai szerint történt.

Tudomásul veszem, hogy szakdolgozat esetén plágiumnak számít:

• szószerinti idézet közlése idéz®jel és hivatkozás megjelölése nélkül;

• tartalmi idézet hivatkozás megjelölése nélkül;

• más publikált gondolatainak saját gondolatként való feltüntetése.

Alulírott kijelentem, hogy a plágium fogalmát megismertem, és tudomásul veszem,hogy plágium esetén szakdolgozatom visszautasításra kerül.

Miskolc, . . . . . . . . . . . .év . . . . . . . . . . . .hó . . . . . . . . . . . .nap

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Hallgató

3

1.szükséges (módosítás külön lapon)

A szakdolgozat feladat módosítása

nem szükséges

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

dátum témavezet®(k)

2. A feladat kidolgozását ellen®riztem:

témavezet® (dátum, aláírás): konzulens (dátum, aláírás):

. . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . .

3. A szakdolgozat beadható:

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

dátum témavezet®(k)

4. A szakdolgozat . . . . . . . . . . . . . . . . . . . szövegoldalt

. . . . . . . . . . . . . . . . . . . program protokollt (listát, felhasználói leírást)

. . . . . . . . . . . . . . . . . . . elektronikus adathordozót (részletezve)

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . egyéb mellékletet (részletezve)

. . . . . . . . . . . . . . . . . . .tartalmaz.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

dátum témavezet®(k)5.

bocsátható

A szakdolgozat bírálatra

nem bocsátható

A bíráló neve: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

dátum szakfelel®s

6. A szakdolgozat osztályzata

a témavezet® javaslata: . . . . . . . . . . . . . . . .

a bíráló javaslata: . . . . . . . . . . . . . . . .

a szakdolgozat végleges eredménye: . . . . . . . . . . . . . . . .

Miskolc, . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

a Záróvizsga Bizottság Elnöke

4

Tartalomjegyzék

1. Bevezetés 6

2. Téma elméleti kifejtése 82.1. A Fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.2. Keretrendszerek tervezése . . . . . . . . . . . . . . . . . . . . . . . . . 102.3. Megvalósítás módja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.3.1. Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.3.2. DLL (Dinamic Link Library) . . . . . . . . . . . . . . . . . . . . 112.3.3. A kiválasztott stratégia . . . . . . . . . . . . . . . . . . . . . . . 13

2.4. FRI módszerek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3. 3 A keretrendszer 173.1. A keretrendszer szerkezete . . . . . . . . . . . . . . . . . . . . . . . . . 173.2. A keretrendszer osztályai . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.2.1. A kivételosztály . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.2.2. Az egylépéses FRI módszerek ®sosztálya . . . . . . . . . . . . . 223.2.3. A kétlépéses FRI módszerek ®sosztálya . . . . . . . . . . . . . . 24

3.3. A keretrendszer használata . . . . . . . . . . . . . . . . . . . . . . . . . 263.3.1. LIB használata Visual Studio 2010-ben . . . . . . . . . . . . . . 263.3.2. LIB használata Ubuntu alatt Eclipse-ben . . . . . . . . . . . . . 30

3.4. A keretrendszer kib®vítése . . . . . . . . . . . . . . . . . . . . . . . . . 313.5. A keretrendszerben található egylépéses módszerek . . . . . . . . . . . 33

3.5.1. KH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343.5.2. VKK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.5.3. MACI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.5.4. GK(CRF) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363.5.5. FIVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.6. A keretrendszerben található kétlépéses módszerek . . . . . . . . . . . . 373.6.1. FRIPOC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

3.7. Módszerek összegzése . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

4. Konklúzió 39

Irodalomjegyzék 41

Adathordozó használati útmutató 45

5

1. fejezet

Bevezetés

Szakdolgozatom egy olyan problémára próbál megoldást kínálni, mellyel a következ-tet® rendszereket használók már találkozhattak. A probléma, amit nevezhetünk akárhiányosságnak is, a következ®: nincs olyan keretrendszer, amely összefogná a fuzzy sza-bály interpolációs módszereket, vagy azok egy részét, és valós id®ben adná vissza azeredményt. El®ször azonban szeretném röviden bemutatni a téma elméleti hátterét.A fuzzy rendszerek a következtetést a fuzzy szabályok segítségével számolják ki. Akarakterisztikája ezeknek a rendszereknek leírható a szabályokkal. A klasszikus fuzzykövetkeztet® eljárások megkövetelik az input intervallum teljes lefedését, ami azt je-lenti, hogy minden egyes lehetséges meg�gyeléshez (observation) létezik legalább egymegel®z® antecedens, így kapjuk meg az érvényes következtetést (conclusion). A való-ságban sokkal gyakoribb a másik típusú fuzzy rendszer, a ritka fuzzy rendszer. Ennekoka lehet a hiányos ismeret, ami azt jelenti, hogy kevesebb ismeret áll rendelkezésre,mint amennyi szükséges lenne egy teljes szabály bázishoz, vagy a teljesítményt rontanánagyban egy teljesen fed® rendszer.

Számos fuzzy eljárás létezik, melyek eredményt adnak ebben az esetben is. EzeketFuzzy Szabály Interpolációs eljárásoknak hívják, melyek a meglév® szabályokból le tud-ják generálni a következtetést. Ezeket a módszereket két nagy csoportba lehet sorolniaz alapján, hogy milyen stratégia szerint generálják az eredményt: direkt eljárás (másnéven egylépéses eljárás), a másik pedig a kétlépéses eljárás. A kétlépéses módszerekel®ször interpolálnak egy ideiglenes szabályt, ez alapján kiszámolják a következtetéspozícióját és alakját.

A gyakorlatban többször el®fordul a ritka szabálybázisú fuzzy rendszer, mint a tel-jes lefedettség¶, mégis eddig nem volt olyan programozói keretrendszer, mely kezeltevolna ezt az esetet, és több fuzzy interpolációs módszert is tartalmazna. Sajnos ennekköszönhet®, hogy éles környezetben egyáltalán nem használták a ritka szabály bázisúfuzzy interpolációs módszereket. Több programozói könyvtár is létezik a teljes szabálybázisú rendszerekhez, de nincs egy se, ami a ritka szabály rendszer esetén is jó volna.

Eddig, ha egy olyan programot akartak fejleszteni, mely ritka szabálybázist hasz-nál, akkor a programozónak, vagy programozóknak a kiválasztott módszert egy prog-ramnyelven meg kellett írni. Ha azonban valamilyen okból kifolyólag át tértek másiknyelvre, akkor minden módszert újra és újra implementálni és tesztelni kellett, amiegyáltalán nem költséghatékony, a befektetett id®r®l nem is beszélve. Azon fejleszt®k-nek, akik nincsenek teljesen tisztában a fuzzy rendszerekkel, nagy segítséget nyújthat aMATLAB-os Fuzzy Toolbox [9] (ez a program könnyen használható, praktikus kutatá-sokhoz és bemutatókhoz, valamint letölthet® GNU liszensz alatt [10]), ahol különböz®

6

módszereket próbálhatnak ki és vethetik össze a kapott eredményeket. Azonban ha aprojekt fejlesztési költségébe nem volt beleszámolva a MATLAB szoftver költsége, azplusz kiadást jelent, ugyanakkor a MATLAB alap szint¶ használatához is érteni kell,ami pedig id®ben jelent kiesést.

Abban az esetben, ha gyors reakcióra van szükség, valós id®ben futó alkalmazás fej-lesztésr®l van szó, a módszereket abban a nyelvben kell implementálni ahol használniis fogják azokat, mert minden beágyazott réteg jelent®sen megnöveli a rendszer válasz-idejét, ezzel csökkentve a program használhatóságát. A már említett MATLAB-os FRIToolbox éles környezetbe való átültetése csak más nyelvbe való beágyazással történ-het, de ennek több hibája is van. Nem támogatja csak a MATLAB saját nyelvét, nemhasználható más matematikai ingyenes szoftverb®l vagy natív programozói nyelvb®l(Java, C# vagy Python). A beágyazást C++ alkalmazásba meg lehet tenni, de ebbenaz esetben az eredmények kiértékelése nem elég gyors.

Szakdolgozatom témája tehát egy olyan keretrendszer kifejlesztése, mely kezeli aritka szabálybázisú fuzzy rendszereket, könnyen b®víthet® és elég gyors m¶ködést biz-tosít egy valós id®ben futó alkalmazásnak. Els® lépésként a Windows és Linux operációsrendszerek támogatása a cél, azok elterjedtsége miatt. Szakdolgozatomban a témát azalábbi részekre taglalom:

• Fuzzy bemutatása, LIB és DLL összevevtése

• Keretrendszer ismertetése

• FRI metódusok jellemz®i

• Szerkezet és osztályok leírása

• Keretrendszer használata és kib®vítése

• FRI metódusok, melyek implementálásra kerültek

7

2. fejezet

Téma elméleti kifejtése

2.1. A Fuzzy

Az életben vannak dolgok, amikr®l egyértelm¶en megállapítható, hogy mik azok pon-tosan. Például egy pontyról meg tudjuk mondani, hogy hal, egy németjuhászról pedigazt, hogy kutya. Az ilyen helyzeteket könnyen szemléltethetjük a matematika nyelvénhalmazokkal, Venn diagram segítségével (2.1 ábra). Az A halmaznak minden elemér®lelmondható, hogy teljes egészében az A-ban helyezkedik el. Ha logikailag szeretnénkmegfogalmazni, akkor a halmazon belül lév® elemek igaz (1) értéket kapnak, az azonkívül es®k pedig hamis (0) értékkel írhatóak le.

Vannak viszont olyan fogalmak, tárgyak, stb, amirk®l már nem tudjuk egyértelm¶enmegmondani, hogy melyik csoportba, hova tartoznak. Vegyük például az ember fejénlév® hajszálakat, vagy éppen azok hiányát. Mi az a hajszál szám, ahonnan valakit márkopasznak lehet titulálni? Nyilván való, hogy ha egy szál haja sincs az illet®nek, az azegyén kopasz, és akinek dús frizurája van, ® egyáltalán nem sorolható ebbe a csoportba.A két végpont között azonban vannak köztes állapotok is, hiszen az utcán sétálva nemcsak dús hajú, vagy kopasz egyéneket látni. Emberi nyelven nem nehéz megfogalmaz-ni az ilyen és ehhez hasonló helyzeteket, de a matematika és az informatika nyelvén,hogy ez értelmezhet®vé váljon, a fuzzy halmazokat használjuk. A fuzzy lehet®vé teszi,hogy egy halmaz elemeir®l azt is meg tudjuk mondani, mennyire van benne, nem csak1-essel és 0-ával tudjuk jellemezni. Így tehát az imént említett A halmaz minden ele-méhez hozzá tudunk rendelni egy számot 0 és 1 között.

Ezek segítségével a halmaz elmélet nem korlátozódik éles határú halmazokra, ha-nem megadhatjuk, hogy az elemek mennyire tartozzanak bele egyes csoportokba, szokásezért ezeket elmosódott él¶ halmazoknak is nevezni. A különbség szemléltetésének ked-véért ezt is Venn diagramon mutatom be els®nek (2.2 ábra).

8

2.1. A Fuzzy

2.1. ábra. Hagyományos Venn diagram

2.2. ábra. Elmosódott él¶ halmaz Venn diagram használatával

Az általános iskolai padban ülve, matematika órán, még elegend®ek voltak az éles(crisp) halmazok, melyeknek elemeir®l egyértelm¶en meghatározható volt, hogy hovatartoznak. Kés®bb azonban ez a szemlélet már nem állja meg a helyét, hiszen vannakolyan dolgok, amelyek egyszerre több helyre is tartoznak, de nem egyforma mértékben.Az emberek számára ez könnyen érthet®, azonban mindezt a gondolatmenetet átültetnia számítógépbe már nem olyan egyszer¶. Az el®bbi példához visszatérve nem a haj-szálak alapján mondható valakir®l, hogy kopasz, hanem úgy is, hogy fejtetején milyen%-ban van haj. Így tehát a 2.3 ábrán Fuzzy halmazok segítségével már egyértelm¶entudjuk ábrázolni ezt az esetet.

Amint látszik, vannak bizonyos részek ahol egyértelm¶en megmondható, melyik

2.3. ábra. Fuzzy halmazok ábrázolása

9

2.2. A Fuzzy

csoportba tartozik az illet®, de vannak átfedések is.

2.2. Keretrendszerek tervezése

A most következ® rész ki fog térni a keretrendszerek fejlesztésében követend® mintákra,melyeknek f® forrása Kent Beck alkotása volt [17].

A keretrendszerek fejlesztésének, verzióváltásának egyik legnagyobb problémája az,hogy a programozók nem módosíthatják a felhasználók kódját. Az ügyfél szempontjá-ból viszont annál jobb, minél kevésbé lát bele a programba elegend® számára az, hazökken®mentesen tudja a rendszert használni.

Keretrendszer írásánál gondolni kell a majdani verzió frissítésekre, újabb változatmegjelentetésére. A veszélye ennek az inkompatibilitás, amikor a felhasználó kódja"elromlik", hibák keletkeznek anélkül, hogy ®(k) bármit is változtatott volna. Tehátegy-egy frissítés kiadásánál arra kell �gyelni, hogy a keretrendszerhez úgy kerüljön újfunkció, hogy a régiek továbbra is tökéletesen m¶ködjenek. Persze ezt nem könny¶ ki-vitelezni, f®leg úgy, hogy a mérleg másik nyelvén a költségek, a munkaóra alacsonyantartása szerepel. Egy általános programnál például elegend® a változókat, függvényeketprotected-ként létrehozni, keretrendszer esetében azonban el®nyösebb (még ha ez megis nehezíti olykor a dolgokat) private biztonsági módosítót használni.

Ha egy régi osztályt lecserélünk gyakran megéri a nevét meghagyni, így a kliensek-nek elegend® csupán az import-ot átírni, ami jóval kevesebb problémával jár, minthaa felhasználónak kéne a programját nagymértékben megváltoztatni emiatt. Emellettsokszor el®forduló megoldás az is, amikor egy-egy funkció neve más lesz (mert az újverzióban kicsit másabb szerepet tölt be), de az argumentumok sorrendje változat-lan marad. Így egy egyszer¶ cserével megoldhatók a frissítéssel bekerül® változtatások.Valamint arról sem szabad elfelejtkezni, hogy 1-1 módosítással mennyi felhasználótnyerhetünk vagy éppen veszíthetünk.A kompatibilitás meg®rzését úgy a legkönnyebb kivitelezni, ha a kliens a lehet® leg-kevesebbet látja, éppen annyit amennyit feltétlenül szükséges ahhoz, hogy használnitudja a keretrendszert. Optimális esetben ezek a részek, részletek a fejlesztés közbennem változnak, vagy csak nagyon minimálisan, ám ezt megjósolni nehéz. A kompati-bilitásnak 2 fajtája van, az egyik az el®refelé, a másik a visszafelé való kompatibilitás.Mind a kett®t fenntartani azonban túlzottan költséges lenne, ezért a tervezés elejénfontos leszögezni melyik lesz alkalmazva.

A kompatibilitás meg®rzésér®l elmondható, hogy általánosan két megoldás kínálko-zik. Az egyik a könyvtárosztály, melynek el®nye, hogy frissítéskor csak arra kell �gyelni,hogy az eddig jól m¶köd® metódusok továbbra is ugyan úgy használhatók legyenek,hátránya viszonyt, hogy korlátozott lehet®ség van a b®vítésére. A másik szóba jöhet®koncepció az objektumok. Az objektumoknak háromféle használata lehet: példányosí-tás, kon�guráció, vagy implementáció. A példányosítás akkor el®nyös, ha a kliensnekcsak az adatokra van szüksége. A kon�guráció már nagyobb rugalmasságot kínál, hiszenilyenkor a felhasználó saját változóival, vagy objektumaival példányosítja a metódust,azonban a tervez®nek �gyelnie kell arra, hogy így kevesebb szabadság áll rendelkezésre.Egy-egy objektum maximum kétféleképpen legyen példányosítható, különben nagyonbonyolulttá válna a rendszer. A harmadik az implementáció, mely a fejleszt®k szem-pontjából a legkevesebb mozgásteret engedi meg.

Az absztakció megvalósítására is két lehet®ség kínálkozik: az interface és a szuper-osztály. Az interface el®nye, hogy a kliens csak annyit lát, amennyit feltétlen szüksé-

10

2.3. A Fuzzy

ges neki, hátránya, hogy fejlesztés közben ha egy új metódus kerül a keretrendszerbe,minden implementáció hibás lesz. További jó tulajdonsága, hogy több interface is imp-lementálható.

A szuperosztály majdhogynem ellenkez® adottságokkal rendelkezik, mint az inter-face. Mikor új metódus kerül bele, azzal nem rontja el a felhasználó kódját, tehát afejlesztés ilyen szempontból könnyebb, viszont egyszerre csak egy osztályát lehet kiter-jeszteni. Fejlesztés közben csak a private metódusokat és adattagokat változtathatjukmeg, hogy a kompatibilitás megmaradjon. Jól át kell gondolni, melyek kapnak protectedbiztonsági besorolást, mert azt kés®bb már nem módosíthatjuk.

2.3. Megvalósítás módja

Ahhoz hogy a keretrendszer minél szélesebb körben elterjedhessen, szem el®tt kell tar-tani a következ® pontokat:

• könnyen kezelhet® és b®víthet® legyen

• több operációs rendszeren, esetleg több elterjedt programnyelven is elérhet® le-gyen

• a keretrendszer programozásába befektetett munka kell®en hatékony legyen

2.3.1. Library

A programnyelvek mindegyikének megvan a saját, betölthet® könyvtára, melyben azadott nyelv szintaktikájának megfelel® függvények, változók vannak letárolva, mely azazt felhasználó kód elejére másolódik fordítási id®ben. A DLL-el szemben hatalmasel®nye az, hogy program ami használja biztos lehet benne, hogy ez az a verziója akönyvtárnak, amire szüksége van, elkerülve így a függ®ségi hibákat (dependency prob-lems). Ezt a gyakran el®forduló hibát szokták "DLL hell"-nek nevezni, de err®l majdkés®bb. Statikus könyvtárakat használni jelent®s teljesítmény növekedéssel járhat, va-lamint lehet®vé teszi hogy a programmal egybe legyen fordítva, és így alkossanak egyfuttatható fájlt. Statikus könyvtárak esetén csak azok a részek tölt®dnek be, amik aprogram során meghívásra kerülnek direkt, vagy indirekt módon, mely szintén el®nya DLL-el szemben, ahol az egész tartalom betöltésre kerül, anélkül, hogy tudná melyfunkciója lesz használva.Ugyanakkor statikus könyvtár esetében a futtatható fájl nagyobb lesz, mivel bele épüla kódba, míg DLL esetén a funkciókat tartalmazó fájl máshol helyezkedik el, és úgyhivatkozik rá a program.

Hátránya valamint, hogy nem teszi lehet®vé azt, hogy más programnyelvekbe is be-tölthet® legyen, és a benne található függvényeket használni lehessen. Nem beszélve atípusok különböz®ségér®l. Továbbá egyszerre csak egy program használhatja a belinkeltkönyvtárat, tehát a megosztást nem támogatja.

2.3.2. DLL (Dinamic Link Library)

Ahogy a neve is mutatja Dinamic Link Library, magyarul talán leggyakrabban meg-osztott könyvtáraknak szokás hívni, azt jelenti, hogy a DLL-ben tárolt adatokat ésfüggvényeket több alkalmazás is képes használni egy adott id®ben. Vegyük például a

11

2.3. A Fuzzy

Windows-ban a USER32.dll, vagy KERNEL32.dll, ezek azok a DLL-ek, melyek szük-ségesek ahhoz, hogy a Win32 alrendszer m¶ködhessen.Ha egy függvényt egyszer megírtak és DLL-be rakták, akkor azt bármelyik alkalmazástudja használni anélkül, hogy a program forráskódjában direkt módon szerepelne. Ter-mészetesen ugyan ez a helyzet a benne tárolt adatokkal is.El®nyei:

• Alacsony memória használat: Azok a függvények és adatok, amiket összeállítot-tunk egy DLL-be, elérhet®ek az összes program számára, melyek használják azt.A DLL csak akkor tölt®dik be a memóriába, amikor szükség van rá. A DLL bel-sejében lév® kódok csak olvashatók, íráshoz nem adnak felhatalmazást, így mikormemóriába tölt®dnek, a memória read-only területére kerülnek. A rendszernekígy lehet®sége van le mapp-elni a DLL tartalmát a folyamat címtartományába.Ha több programnak is szüksége van rá, akkor azok is a memóriából le mapp-elikmaguknak, létrehozva így a saját példányukat a címtartományukban.

• Kevesebb ki-be töltés: Képzeljük el, hogy két alkalmazás egyszerre használjaugyan azt a DLL-t, az egyik végez és kilép. A DLL még bent marad a memóri-ában, mert �gyeli, számolja, hogy épp hány alkalmazás használja. Amikor ez aszámláló eléri a nullát, csak akkor törli magát.Gondoljunk bele egy másik helyzetbe, mikor egy program egy olyan DLL-t akarhasználni, ami már a memóriában van és más alkalmazás használja. A rendszernem tölti be újra a DLL-t, csupán át map-eli az új alkalmazásnak, így az is tud-ja használni. Ez rengeteg id®t és munkát spórol az operációs rendszernek, mivelsokkal lassabban olvasná be az adatot a HDD-r®l, mint a memóriából.

• "Csak a polcról kell levenni": Egy jól megtervezett DLL bármelyik másik prog-ramnak hasznos része lehet. Gondoljunk rá úgy, mint egy komponensre, aminek am¶ködésében és funkcionalitásában teljesen biztosak vagyunk. Csak be kell hívniegy másik projektbe és már be is tölti a kívánt funkciót/funkciókat.Képzeljünk el egy olyan DLL implementációt, ami elvégzi az összes lehetségesszámítást, melyre szükség van ahhoz, hogy gra�kus szoftvert fejlesszünk. Ha ezegyszer kész, bármelyik másik ilyen programba betehetjük, minden probléma nél-kül.

• Együttm¶ködés több programnyelvvel: Egy DLL amit egy nyelven megírtunk,használhatjuk olyan alkalmazásokban is, melyeket más nyelven írunk.Fejleszt®knél ez gyakori, hogy optimalizált rutinokat írnak assembly-ben, majdezeket összegy¶jtik egy DLL-be, és kés®bb meghívják C-ben vagy Visual Basic-ben.A fejleszt®k szempontjából nem túl szerencsés, hogy elég sok nyelv támogatjaa DLL használatát, viszont nagyon kevés az olyan, ami alkalmas az írásra is.Képzeljünk el egy alkalmazást, ami a DLL segítségével I/O m¶veleteket hajtvégre Visual Basic-ben, használva az inportb és outportb függvényeket a CRTnatív könyvtárból. A DLL-ek lehet®vé teszik az ilyen együttm¶köd® kódokat.

• Könny¶ utólagos javítások: Mivel könnyen el®fordulhat, hogy egy termék eladá-sa után derülnek ki a problémák, ezt kijavítani általában nagyon fáradtságosmunka. Újra build-elni egy nagy alkalmazást majd újra kiküldeni a vásárlóknaksok id®t vesz igénybe. Mindez elkerülhet®, ha a projekt úgy van megtervezve,

12

2.3. A Fuzzy

hogy könnyen kezelhet®, különálló modulokból kapcsolódik össze, melyek DLLformájában tárolódnak. Csak annyit kell tenni, hogy a hibás részt kijavítani ésa vásárlók számára elérhet®vé tenni, mint egy frissítést. Ugyanakkor ez az el®nya DLL-ek legnagyobb hátránya is lehet. Minden attól függ, mennyire gondosanvan megtervezve a kód.

Hátrány:

• A DLL hell: Ez a legnagyobb probléma, amit a DLL-ek okozni tudnak. Amennyi-re lehet, el kell kerülni az olyan helyzeteket, amikor a fordító olyan hibát dob,hogy nem talál egy bizonyos részt a DLL-ben. Vagy egy másik esetben példáultelepítésre kerül egy új program, ezt követ®en az eddig fent lév®k pedig hibásanfutnak le, vagy el sem indulnak. Ezek egyértelm¶en a "DLL hell"-nek nevezettproblémának a jelei. Leggyakrabban akkor fordul el® ilyen, ha a szoftver tele-pít®je nem �gyeli a verziószámban láv® eltéréseket, és vagy egy újabb DLL-t írfelül egy régebbivel, vagy pont ellenkez®leg, egy régit módosít az újra, amiben vi-szont nagy változások történtek. A DLL-eknek visszafelé kompatibiliseknek kénelenniük, ez csakis a tervezésen múlik, ezt azonban nehéz elérni.

Mit tartalmazhat egy DLL:A DLL-ek általában kódokat, adatokat és forrásokat tartalmaznak. A kódok a read-only részen tárolódnak így könnyen használhatja egyszerre több alkalmazás is, de azadatokkal más a helyzet. Minden egyes alkalmazás, melynek szüksége van az adatokra,megkapja a saját privát másolatát, hacsak nem valaki megosztottnak jelöli meg azokat.A kód részben tárolódnak az osztályok, illetve a függvények. Lehetnek olyan osztályok,melyekben a függvények és az adatok egy helyen tárolódnak, egy egységet alkotnak,de az önálló függvények használhatnak globális változókat is. Az el®bb felsoroltak egy,vagy több forrás fájlba van eltárolva, de ezek össze vannak csomagolva egy DLL �le-á.A DLL-ek másik DLL fájlból is importálhatnak függvényeket vagy osztályokat.

2.3.3. A kiválasztott stratégia

A fent leírtak alapján jól látszik, hogy a DLL egy univerzális megoldás lenne a toolboxszámára, ugyanakkor a statikus librarynak is vannak el®nyei és véleményem szerintkeretrendszer elterjedéséhez vezet® úton els® lépésnek tökéletesen elegend® a LIB. Aközeljöv®ben kilátás van egy francia kooperációra, mely ha sikeres lesz, minden bi-zonnyal elkészül majd a rendszerb®l egy DLL is, ezáltal kib®vítve a felhasználhatóságkörét és a célközönséget.

13

2.4. A Fuzzy

2.4. FRI módszerek

A Fuzzy logikával dolgozó rendszerek a szabályokon alapszanak. A szabálybázisnak kéttípusa létezik:

• s¶r¶ szabálybázis

• ritka szabálybázis

S¶r¶ szabálybázisról akkor beszélünk, ha az input tér teljesen le van fedve, tehát min-den lehetséges meg�gyeléshez létezik legalább egy olyan szabály, melynek antecedensrésze átfedésben van vele és ez alapján érvényes konklúziót lehet generálni. Amennyi-ben a fent leírt eset nem teljesül, a szabálybázist ritkának tekintjük. Ritka szabálybázisesetén a klasszikus következtetési módszerek nem használhatóak. Ekkor az eredménytkülönböz® közelít® eljárással számítják ki a rendelkezésre álló információk alapján. Eze-ket Fuzzy Szabály Interpolációs módszereknek hívják.S¶r¶ szabálybázisokat kezel® rendszerek már léteznek, de olyan, amely a ritka szabály-bázisú eljárásokat összefogná és egy egységes keretrendszert alkotna, mely ingyenesenelérhet® mindenki számára, még jelen pillanatban nincs. Arról nem is beszélve, hogya módszerek viszonylag nagy százaléka rosszul, vagy hiányosan dokumentált, esetlegnehezen fellelhet®, megnehezítve így a fejleszt®k dolgát. Ezért is fontos hogy össze le-gyenek gy¶jtve, így akik ritka fuzzy rendszerekkel szeretnének foglalkozni, a kutatás ésprogramozás résszel ne kelljen foglalkozniuk.Ritka szabálybázis többféleképpen keletkezhet:

• Szakért®t®l vagy más forrásból származó ismeretek, tapasztalatok nem elegend®-ek a teljes input terület lefedésére

• Lehetséges, hogy a szabálybázis kezdetben s¶r¶nek számított, de a kés®bbi han-golás folyamán, az antecedens halmazok formája és pozíciója változhat, melynekkövetkeztében a halmazok között úgynevezett lyukak alakulhatnak ki (2.4 ábra).

• A s¶r¶ szabálybázis a sok dimenziónak és az inputhalmazoknak köszönhet®en túlnagy, meghaladja a hardver tárolási kapacitását, ezért mesterségesen megritkít-ják.

• Amennyiben az el®bb említett helyzet nem jelent problémát, tehát a tárolás meg-oldható, a számítási id® még mindig elérhet olyan szintet, ami után már kényte-lenek megritkítani a szabálybázist.

2.4. ábra. Példa s¶r¶ és ritka szabálybázisra

14

2.4. A Fuzzy

A ritka szabálybázisú eljárások két csoportba sorolhatók. Az els® csoportba tartozóeljárások az eredményt közvetlenül állítják el® becslés segítségével, ezeket egylépésesmódszereknek nevezzük. A másik csoport tagjai el®ször egy ideiglenes szabályt alkotnaka már meglév®k alapján, melynek antecedens része legalább részben fedi a meg�gyelést,majd ezt követ®en az új szabály és a meg�gyelés közti hasonlóság alapján számítják kia becsült konklúziót. Az egylépéses módszerek legjelent®sebb tagjai:KH [1] (Kóczy és Hirota), MACI [2] (Tikk és Baranyai), FIVE [21] (Kovács és Kóczy),IMUL [4] (Wong, Gedeon, Tikk) és VKK [5] (Vass, Kalmár, Kóczy).Legismertebb kétlépéses eljárások:GM (Baranyi, Kóczy és Gedeon) [6], FRIPOC (Joahnyák és Kovács) [8], ST (Yan,Mizumoto és Qiao) [7], FIVE (Kovács és Kóczy) [21].A felsorolt módszerek közül nem mind, jelenleg 6 implementált a keretrendszerben, deez a szám változni fog, ahogy el®rehaladnak a fejlesztések. Ezek a következ®k:KH [1], VKK [5], CRF [13], MACI [2], FIVE [21], FRIPOC [8].Amint látható 5 egylépéses és 1 kétlépéses módszer található eddig a keretrendszerben.Mivel az egylépéses módszerek leprogramozása kevesebb id®t vesz igénybe és esetenkéntegyszer¶bbek is, mint a kétlépésesek, ezért ebb®l került több implementálásra. A fuzzyinterpolációs módszerek, melyek a keretrendszerbe kerülnek, �gyelembe veszik az FRItechnikákra vonatkozó általános szabályokat [11]:

• Érvénytelen eredmény elkerülése.

• Legyen forma®rz®. Ez azt jelenti, hogy a megadott meg�gyelésnek és a kiszámítottközelít® eredménynek az alakja hasonló kell, hogy legyen.

• A köztes kapcsolatok meg®rzése. Amennyiben a meg�gyelés két antecedens közötthelyezkedik el, akkor a becsült eredménynek a szabálybázis szerinti két konzek-vens közé kell esnie.

• Szabálybázissal való kompatibilitás. Megköveteli a modus ponens elvének teljesü-lését. Ez azt jelenti, hogy ha egy meg�gyelés egybeesik egy antecedens-el, akkora konklúziónak a szabálybázis szerinti konzekvensnek kell megfelelnie.

• A becsült eredménynek meg kell tartania a fuzzy tulajdonságot. Két ellentétesmegközelítése van ennek a témának az irodalomban. Az egyik szerint ha vanegy singleton meg�gyelésünk, akkor abból a módszernek egy szintén singletonkövetkeztetést kell készítenie. A másik vélemény szerint a konzekvens fuzzy tu-lajdonságait kell �gyelembe venni a szabályok alapján. Singleton-t csak akkorkaphatunk ha az összes konzekvens amit a szabályokban �gyelembe vesznek azinterpolációnál, mindegyik singleton.

• Közelít® képesség (stabilitás). A becsült szabálynak a lehet® legjobban közelíteniekell a kapcsolatot két dimenzió antecedens-ei és konzekvensei között.

• Szakaszonkénti linearitás megtartása. Ha a �gyelembe vett fuzzy halmazok sza-kaszonként lineárisak, akkor a közelített halmazoknak is meg kell tartaniuk ezt atulajdonságit.

• Többdimenziós antecedens univerzumok használhatósága. Ez azt jelenti, hogy azFRI módszernek hasonló karakterisztikát kell mutatnia ha kiegészítik, és többdimenziós bementi tere lesz.

15

2.4. A Fuzzy

• A fuzzy halmaz alakjára vonatkozó bármilyen jelleg¶ megszorítás nélküli alkal-mazás. Ezt a pontot nem feltétlen kell �gyelembe venni, mert a gyakorlatbanelég s¶r¶n találkozunk szakaszonként lineáris fuzzy halmaz és Gauss-görbe alakúhalmaz találkozásával.

16

3. fejezet

3 A keretrendszer

A keretrendszerrel szemben támasztott 3 f® követelmény:

• Kell®en gyors legyen ahhoz, hogy valós id®ben tudjon reagálni, így éles helyze-tekben is tökéletesen m¶ködjön

• Széles kör¶ használhatóság is fontos szempont. Azt szeretném elérni, hogy minéltöbb projektben alkalmazható legyen, így segítve a keretrendszer elterjedését.Ehhez pedig az kell, hogy minél több programozási nyelvbe beágyazható legyen. Aközeljöv®ben a Java, C#, és a MATLAB, illetve a Freemat matematika szoftverektámogatása a cél.

• Univerzális kezel®felület kialakítása. Mivel több módszert is tartalmaz a keret-rendszer, biztosítani kell a menet közbeni változtatás lehet®ségét, mindezt úgy,hogy küls®leg ne legyen különbség az eljárások közt, kényelmessé téve felhasználószámára a használatot.

Ahhoz hogy a fenti kritériumoknak megfeleljen a keretrendszer, többféleképpen iselérhet®vé kell tenni: el®ször is egy programozói könyvtár formájában, mely C++-banhasználható, valamint tervbe van véve egy úgynevezett wrapper osztály is a népszer¶bbprogramnyelvekhez (Java, Python, C#). Az FRI módszerek használatának egységesíté-se úgy lett megoldva, hogy bármelyik metódust ugyan azzal az interface-el lehet kezelni.Az osztály hierarchia és az objektumorientált minták biztosítják ezt. A toolbox f® célja,hogy egyszer¶sítse a programozók dolgát azzal, hogy szabványosított függvénykönyv-tárat ad a kezükbe.

Az el®z® fejezetben felsorolt 9 pontból, melyet Baranyai és szerz®társai határoztakmeg, csak az egyes feltétel teljesíthet®, mert több olyan módszer is van, mely a maradék8at csak részben, vagy egyáltalán nem tudja kielégíteni. Ha a program futása közbenabnormális m¶ködés következik be, akkor ez egy kivételt vált ki (err®l kés®bb). Mindenhibára különböz® hibakódot és kivétet generál a porgram a könnyebb, egyértelm¶bbhibakezelés végett.A keretrendszer f® koncepcióiról, valamint megvalósítási módjáról a [18]-cikkben is ol-vasni lehet.

3.1. A keretrendszer szerkezete

A toolbox alapja C++ban íródott, mivel ez egy gyors objektum orientált nyelv ésszéles körben elterjedt. Sok osztály már el®rede�niált, de az objektum orientáltságnak

17

köszönhet®en ezek felülírhatók, vagy származtathatóak bel®lük új osztályok. Csak afelhasználón múlik az, hogyan alakítja ezek után a kódot.A keretrendszer támogatja az eljárások mindkét típusát, az egylépéseseket és a két-lépéseseket egyaránt. A kompatibilitás érdekében ugyanúgy, mint a MATLAB-os FRIToolbox, a FIS fájlt használja adatok bevitelére. A FIS fájl tartalmazza a felhasználóritka szabálybázisát, mely alapján a választott módszer meghatározza az eredményt.Valós körülmények között általánosságban az mondható el, hogy a szabálybázis nemszokott változni, csak a meg�gyelés. Így tehát a jobb teljesítmény érdekében a meg�-gyelés nem feltétlen egy OBS fájlból származik, hanem egy függvény paramétereként isátadódhat a programnak. Általában az összes Fuzzy interpolációs módszernek lehetnektovábbi input adatai, melyet felhasználhatnak a fejleszt®k a kód írása során, ilyenekpéldául az alfa szintek. A paraméterek típusa és száma a kiválasztott módszert®l függ,tehát egy paraméter lehet akár egy speciális karakter lánc is.A CFRIMethod osztály a közvetlen, vagy közvetett szül®je az összes FRI metódusnak.Ez az osztály de�niálja a közös interface-t az FRI módszereknek, így biztosítva a kü-lönböz® módszerek egységes felületét. A felhasználó szemszögéb®l nézve négy egyszer¶lépést kell végrehajtania, hogy használni tudja bármelyik FRI módszert:

1. Rendszer létrehozása. Els® lépésben a fuzzy rendszert kell el®állítani FIS fájlhasználatával, vagy karakter lánccal. Ez a rendszer lehet ritka szabálybázisú is.

2. FRI módszer kiválasztása az el®z® lépésben létrejött rendszerhez. Ennél adja mega felhasználó, hogy melyik módszert szeretné használni. A háttérben a kiválasz-tott metódus neve alapján létrejön a megfelel® objektum. Fontos megjegyezni,hogy ezt a lépést futás közben többször is végre lehet hajtani.

3. FRI metódus inicializálása, ahol speciális paraméterek is megadhatók. A mód-szerek különböznek egymástól, így vannak olyanok amelyeknek további adatokravan szükségük. Ezek a paraméterek fontos szerepet játszhatnak a végeredménykiszámításában. Az init metódus futás közben is képes adatokat fogadni a fel-használótól, melyeket a kiválasztott módszer a számítások során felhasznál.

4. A konklúzió meghatározása, amire akkor kerül sor, ha meghívódik az interpolatemetódus. Ez a f® lépése az FRI módszereknek, melynek során a meg�gyelésb®lés az input szabálybázisból kiszámítódik a becsült eredmény. Amennyiben valósid®ben futó alkalmazásról van szó, ez a lépés többször is meghívódik.

3.1. ábra. Egylépéses módszerek struktúrája

18

Az egylépéses módszerek esetében, amit a 3.1-es kép illusztrál, az FRI metódusosztályát a CFIMethod osztályból kell származtatni. Ez az osztály deklarál egy vir-tuális metódust, melyet implementálni és felülde�niálni kell. Ez a metódus számoljaki a becsült eredményt a kapott meg�gyelés és a fuzzy rendszer felhasználásával. Ameg�gyelések egy Membership function (tagsági függvények) nev¶ vektorban vannakeltárolva, mint paraméterek, és innen lehet hivatkozni rájuk. A keretrendszer jelenlegaz alábbi egylépéses módszereket tartalmazza: KH [1] (CKH osztály) VKK [5] (CVKKosztály), MACI [2] (CMACI osztály), FIVE (CFIVE) [21], és CRF [13] (CCRF osz-tály). Ha új egylépéses módszert szeretnénk létrehozni, akkor annak a CFRIMethodosztályból kell származnia és az interpolate metódusát felül kell de�niálni.

3.2. ábra. Kétlépéses módszerek struktúrája

A másik csoport tagjait kétlépéses módszereknek hívjuk, és ahogy a 3.2-es ábránlátható az FRI metódus(ok) a CGeneralizedMethod osztályból származnak, majd pedigfelül kell de�niálni a következ® 3 osztályt: determineAntecedentShapes, determineCon-sequentPositions és a determineConsequentShapes osztályokat. Ezek a CGeneralized-Method osztályból hívódnak meg szigorúan ragaszkodva az el®bb látott sorrendhez. Itta meg�gyeléseket paraméterként kapják meg, ami a Membership Function vektorbanvannak karakter láncként tárolva. A keretrendszer jelenlegi állapotában egy kétlépésesmódszert tartalmaz ez pedig a FRIPOC [8] (CFRIPOC osztály). Tehát amennyiben aprogramozó egy új kétlépéses módszert szeretne implementálni, annak a következ®kép-pen kell történnie:

1. Származtatja a metódusát a CGeneralizedMethod osztályból

2. Felülde�niálja a következ® osztályokat: determineAntecedentShapes, determine-ConsequentPositions és determineConsequentShapes.

3.2. A keretrendszer osztályai

Ebben a fejezetben a toolbox-ot felépít® osztályokról lesz szó. Nem mind kerül bemu-tatásra, lesznek olyanok, amik részletezésre kerülnek, másokat pedig csupán felszínesen

19

érint ez a rész.A keretrendszerben a FIS �le (melyben találhatók az input "A", az output "B",

valamint a szabályok) beolvasását és írását a CFIS�le osztály végzi. Ez tartalmaz 2readFIS() és 2 writeFIS() függvényt, eltér® argumentum listával. Az írás és az olvasásis megtehet® két módon, �le átadásával, illetve stringstream használatával. A meg�-gyelés kezelésér®l a COBSFile osztály gondoskodik. Mivel itt írni nem, csak olvasnikell az adatot, 2db readOBS() függvény található benne, a már imént említett kétféleargumentumlistával (�le, illetve stringstream). A FIS �le-ból kiolvasott szabályoknakkülön osztályuk van, melyben letárolásra kerül maga a szabály, mint string, valamintaz input és output mérete a könnyebb kezelhet®ség érdekében. Lekérhet® továbbá asúlyozás és a szabályok kapcsolatai (1 illetve 0, mely a logikai AND-nek és OR-nakfelel meg). A fuzzy halmazok pontjait a CPoint osztály kezeli. X és Y koordinátákattárol és ezekr®l kérhet®k le információk. A pontból, vagy pontokból álló halmaz nevea tagsági függvény (MF), ennek is külön osztálya van CMembershipFunction néven.A függvények lehet®vé teszik, hogy lekérdezzük a halmaz X illetve Y koordinátáit egyvektorba, valamint a halmaz alakját és nevét is. Egy dimenzióban lev® tagsági függvé-nyek alkotnak egy-egy úgynevezett partíciót, ennek megfelel®en a következ® osztály aCPartition. Ebben rögzítésre kerülnek az MF-ek, az intervallum amin találhatók, va-lamint a nevei. Az eddig felsorolt osztályokból áll össze a CSystem osztály.A továbbiakban három, a keretrendszert alkotó osztály kerül részletezésre.

3.2.1. A kivételosztály

A kivétel nem más, mint egy, a program futását megszakító hiba mely lehet a véletlenm¶ve (melyet try-catch felépítéssel lehet "elkapni"), de ki lehet váltani szándékosanis (throw parancs használatával). A keretrendszer egyik érdekes feature-je, hogy különkivétel osztállyal rendelkezik. Ez a megoldás segíti mind a programozót a kód tesztelé-sénél, debuggolásnál, illetve a felhasználót a programja futtatása közben. Teszi mindeztúgy, hogy mikor kiváltódik a kivétel, akkor sokkal pontosabb információt szolgáltat ahibáról, mint amit tenne egy általános exception. Mint minden osztálynak, így en-nek is van konstruktora, méghozzá kett® melyeket a 3.1-es kód szemléltet. Ahogy az1. sorban látható az els® konstruktor argumentumként fogad egy egész számot, amia hibát kiváltó sort tárolja, valamint egy �le nevet. Ilyenkor a rendellenesség forrásaismeretlen. A különlegessége, hogy ez meghívja az osztály másik konstruktorát egyUNKNOWN_ERROR (a headerben) el®re de�niált értékkel. Ez látható a 2. sorban.A másik konstruktor annyiban tér el az el®z®t®l, hogy a paraméterként átadott hibakódalapján állítja be a változókat. A 6. sorban a hiba kódot, a 7-ben a hibás sor számát,a 8. sorban pedig a kivételt dobó �le neve kerül inicializálásra. Íme a két konstruktorttartalmazó kódrészlet:

1 CFRIException : : CFRIException ( const i n t l i n e , const char ∗ f i l e ) {2 CFRIException (CFRIException : :UNKNOWN_ERROR, l i n e , f i l e ) ;3 } ;4

5 CFRIException : : CFRIException ( i n t error_code , const i n t l i n e , const char ∗f i l e ) {

6 m_error_code = error_code ;7 m_line = l i n e ;8 m_file = f i l e ;

20

9 } ;

Code 3.1. Kivételosztály konstruktorai

Az adattagok (m_error_code, m_line m_�le ) a header-ben kerültek deklarálásra,valamint itt vannak de�niálva a hibakódok is. A hibakód pozitív egész szám (jelenlegmaximum 4 tizedes jegy¶), mely úgy épül fel, hogy az ezres és százas helyi értéken lév®szám egy b®vebb probléma kört határoz meg (pl: melyik metódus rendellenes m¶kö-déséb®l származik a probléma, 1xx: FIS �le hiba, 11xx FIVE hiba), a tizedes és egyeshelyi értéken lév® pedig a pontosabb megfogalmazást rejti (01-el kezd®dik a szám). Ígytehát egy adott hiba csoportnak maximum 99 kivétel de�níciója lehet.

1 i n t CFRIException : : getErrorCode ( ) {2 re turn m_error_code ;3 } ;4

5 const i n t CFRIException : : getLineNumber ( ) {6 re turn m_line ;7 }8

9 const char ∗ CFRIException : : getFileName ( ) {10 re turn m_file ;11 }

Code 3.2. A kivételosztály 3 egyszer¶ getter függvénye

Magában az osztályban 3 egyszer¶ getter függvény található (3.2 kódrészlet): getError-Code() 1-3. sor, getLineNumber() 5-7. sor, getFileName() 9-11. sor. Ezek arra szolgál-nak, hogy visszaadják a hibakódot, a sor számát ahol bekövetkezett a kivétel, valaminta �le nevét amin belül rendellenesség keletkezett.Továbbá az osztály tartalmaz egy olyan metódust, melynek neve GetMessage() ésvisszatér a �le nevével, a hiba szöveges üzenetével és a sor számával. A 3.3 kódrészletszolgál például a fentebb leírtakhoz.

1 s t r i n g CFRIException : : getMessage ( ) {2 s t r i ng s t r eam message ;3 switch (m_error_code ) {4 case −101: message << "FIS : F i l e not found or i n v a l i d ! " ; break ;5 case −102: message << "FIS : Convert to In t eg e r i s not p o s s i b l e ! " ;

break ;6 case −103: message << "FIS : F i l e a l r eady e x i s t ! P lease turn on the

f o r c ed mode i f you would l i k e to ab le to wr i t e i t . " ; break ;7 case −104: message << "FIS : Can not open f i l e " ; break ;8

9 case −201: message << " Input : x and y dimension not match ! " ; break ;10

11 case −401: message << "Rule : Input MF index i s too high " ; break ;12 case −402: message << "Rule : Input MF index i s too low" ; break ;

Code 3.3. A kivételek sorszámai

Érdemes meg�gyelni, hogy egy message változó került de�niálásra, mely stringstreamtípusú (2. sor) és ez lesz a függvény visszatérési értéke minden esetben.Amint látható egy sima switch case elágazás oldja meg a hibakódok visszafejtését szö-veges üzenetre (3. sortól). Ezután következnek a hibakódok, szépen tagolva.A 3.4 kódrészlet a kivételek sorszámának végét tartalmazza. Amennyiben olyan rend-ellenesség keletkezne a kód futása közben, amire nem volt felkészülve a rendszer, akkor

21

alapértelmezett értékként úgynevezett Unhandled exception-t állít be üzenetként (le-kezeletlen hiba), ez látható a 4. sorban. A switch elágazás a 3.4 kódrészlet 5. sorábanér véget, ezután kerül hozzáf¶zésre a visszatérési értékhez a �le neve, valamint a hibássor száma (6. sor). Végül a függvény a 8. sorban visszatér a message-el.

1 case −1201: message << "VKK: The obse rvat i on hasn ' t any l e f tantecedent " ; break ;

2 case −1202: message << "VKK: The obse rvat i on hasn ' t any r i gh tantecedent " ; break ;

3

4 de f au l t : message << "Unhandled except ion ! " ;5 }6 message << " in FILE : " << m_file << " at LINE : " << m_line ;7

8 re turn message . s t r ( ) ;9 }

Code 3.4. A kivételek sorszámai és a függvény visszatérése

3.2.2. Az egylépéses FRI módszerek ®sosztálya

Annak érdekében hogy a módszerek egységesek legyenek, létre kellett hozni egy ®sosz-tályt, melyb®l származtatható mindegyik: közvetve, vagy közvetlenül. Ez az osztály aCFRIMethod. Tárol minden fontos információt ahhoz, hogy számolni tudjon az inter-polációs módszer, mindezt úgy teszi, hogy a konstruktorába argumentumként kér egyCSystem típusú objektumot, valamint segédfüggvényeket is magába foglal. Az egyikilyen az init metódus, mely az argumentumként megkapott string-et szétdarabolva pa-ramétereket ad át a módszereknek, map-ben (m_methodParams, mely a headerbenlett de�niálva).

A módszerek egy része referencia pont alapú számításokat végez, ennek megfele-l®en, az osztályban deklarálásra került a getReferencePoint() függvény, melyet a 3.5kódrészlet mutat be.

1 CPoint CFRIMethod : : ge tRe fe rencePo int ( CMembershipFunction mf , s t r i n gRPType) {

2 i f (mf . ge tPo int s ( ) . empty ( ) ) {3 throw CFRIException (CFRIException : :FRIM_NO_POINTS, __LINE__, __FILE__

) ;4 }5

6 s t r i n g mftype = mf . getType ( ) ;7 double RPx, RPy;8

9 i f (RPType == " co r e c en t r e " ) {10 i f ( mftype == " s ing lmf " ) {11 RPx = mf . ge tPo int s ( ) [ 0 ] . getX ( ) ;12 RPy = mf . ge tPo int s ( ) [ 0 ] . getY ( ) ;13 }14 e l s e i f ( mftype == " t r imf " ) {15 RPx = mf . ge tPo int s ( ) [ 1 ] . getX ( ) ;16 RPy = mf . ge tPo int s ( ) [ 1 ] . getY ( ) ;

Code 3.5. Az CFRIMethod osztály Referencia pont lekérésére alkalmas függvénye

Amint látható, bekér egy MF halmazt, valamint a referencia típusát (1. sor), ésez alapján adja meg a referenciapont X és Y koordinátáit. Valamint azt is érdemes

22

meg�gyelni a függvény elején, a 2-4. sorban, hogy használja a kivételosztályt, amit azel®z® pontban részleteztem. A 6. sorban egy változóban letárolásra kerül a megadotthalmaz típusa, a 7. sor pedig deklarálja a referencia pont X és Y koordinátáit. Ezutána 9. sorban egy elágazás dönt a referencia pont típusának ismeretében, hogy merrehaladjon tovább az irányítás. A ref.pont számításnak 3 változatát kezeli, ezek sorban:

• corecentre

• corecentreprojection

• supportcentre

Minden referenciapont alapú elágazáson belül van még egy IF, mely a halmaz típu-sa alapján ágazik el, mivel ezt �gyelembe véve máshogy kell kiszámítani az X és Ykoordinátákat. Ezek lehetnek:

• singlmf 10. sor (egyérték¶ halmaz)1

• trimf 14. sor (háromszög alakú halmaz)

• trapmf (trapéz alakú halmaz)

• polymf (poligon alakú halmaz)

A függvény visszatérési értéke természetesen szintén egy saját osztály objektuma, aCPoint.

Mivel a keretrendszer alapja a MATLAB-os FRIToolbox, az eljárások is az alapjánlettek átírva. Ennek megfelel®en szükségszer¶ volt néhány MATLAB-os eljárást lekó-dolni C++-ba, hogy könnyebb legyen a módszerek leprogramozása. Az egyik ilyen aFind() függvény, melynek 4 példánya is megtalálható.

A függvény bekér egy vektort, egy operátort (=, <, >, <=, >=), valamint egyszámot ami a viszonyítási alap lesz és visszaadja azon számok halmazát (vektorban),melyek kielégítik a feltételt. A további hármat nem részletezném, megegyezik a m¶kö-dése a MATLAB-ossal.

Az utolsó bemutatásra kerül® függvény a CFRIMethod osztályból, az interpolate,melyet minden metódusnak felül kell dei�nálnia és majd ez fogja elvégezni a számí-tásokat. A 3.6 kódrészlet mutatja a megvalósítását. Az 1. sorban argumentumkéntmegkapja a meg�gyelést, azonban ha nem de�niálják felül, akkor a 2. sorban dob egy"metódus nincs implementálva" hibát, hiszen ebben az esetben a módszer nem is lehetmegírva.

1 vector<CMembershipFunction> CFRIMethod : : i n t e r p o l a t e ( CObservationobse rvat i on ) {

2 throw "method not implemented ! " ;3 }

Code 3.6. CFRIMethod Interpolate függvénye

Amit még érdemes megemlíteni, hogy a keretrendszer fejlesztése közben integrálásrakerült egy C++-os matematikai függvénytár, az Armadillo [25]. Ez a könyvtár speciáli-san mátrixok és vektorok kezelését segíti el® és talán ez áll a legközelebb a MATLAB-osfüggvények egy részéhez. Az utoljára implementált FIVE módszer már kihasználja en-nek az el®nyeit.

23

Amint látszik az osztálydiagramon ( 3.3 ábra ) a függvények elég nagy része használ-ja az armadillo-t. Erre els®sorban a FIVE miatt volt szükség, de amennyiben a többimódszer is átírásra kerül majd, hasznos lehet azok számára is.

3.3. ábra. FRImethod osztálydiagramja

3.2.3. A kétlépéses FRI módszerek ®sosztálya

Az egylépéses módszerek közvetlenül származnak a CFRIMethod osztályból (ezekr®lvolt szó eddig), a kétlépéses módszerek viszont közvetve származnak csupán bel®le,mert beiktatásra került a CGeneralizedMethod (másnéven GM) osztály is. Erre azértvolt szükség, mert a kétlépéses módszerek az interpolálás el®tt új szabályt hoznak létre,majd 3 fontos feladatot kell, hogy elvégezzenek. Ezek a számítások sorban a követke-z®k: az új szabály antecedens fuzzy halmazainak alakjának meghatározása, a konzek-vens halmazok referencia pontjának kiszámítása, utolsó lépcs®ben pedig a konzekvenshalmaz alakját határozza meg. Amennyiben ezzel a 3 feladattal végzett,a m¶ködésükmár nem tér el a fentebb bemutatottól.Ezért került tehát a GM.cpp-be az alábbi 3 függvény: determineAntecedentShapes(),determineConsequentPositions és a determineConsequentShapes. A GM.cpp az el®bbi3 virtuális függvényt (leszármaztatáskor ezeket mindenképp felül kell de�niálni), vala-mint az interpolate metódust tartalmazza, tehát úgymond mintaként szolgál a mód-szerek megírásához.Az 3.7 programkód a GM.cpp teljes kódja.

1 #inc lude "GM. h"

24

2

3 GM: :GM(CSystem ∗ pSys ) : CFRIMethod( pSys )4 {5 m_type = "GM" ;6 }7

8 GM: : ~GM( void )9 {

10 }11

12 vector<CMembershipFunction> GM: : i n t e r p o l a t e ( CObservation obse rvat i on )13 {14 determineAntecedentShapes ( obse rvat i on ) ;15 determineConsequentPos i t ions ( obse rvat i on ) ;16 re turn determineConsequentShapes ( obse rvat i on ) ;17 }

Code 3.7. GM program kódja

Amint látható az 1. sorban meghívásra kerül a GM header-je, a 3-6. sorban talál-ható a konstruktor, a 8-10. sor pedig a destruktort tartalmazza. A 12-17- sorban minda 3 függvénynek a meg�gyelést kell csupán átadni. A 14. sorban lév® eljárás az antece-dens oldali fuzzy halmazok alakját hivatott megállapítani, a 15. sorban a konzekvenspozícióját kiszámoló függvény van, valamint a 16. sorban az utolsó lépés, a konzekvensalakját meghatározó függvény kapott helyet, mellyel vissza is tér a GMA m¶ködés megértéséhez a 3.8-as kódrészlet a GM header-jét tartalmazza:

1 #i f n d e f __CGM_H2 #de f i n e __CGM_H3

4 #inc lude "FRIMethod . h"5

6 c l a s s GM :7 pub l i c CFRIMethod8 {9 protec ted :

10 /// Az i n t e r p o l á l t s zabá ly antecedens halmazai a lak jának ameghatározása

11 v i r t u a l void determineAntecedentShapes ( CObservation obse rvat i on ) = 0 ;12 /// A konzekvens halmazok he lyze tének ( r e f e r e n c i a pont ja inak )

meghatározása13 v i r t u a l void determineConsequentPos i t ions ( CObservation obse rvat i on ) =

0 ;14 /// Az i n t e r p o l á l t s zabá ly konzekvens halmazai a lak jának meghatározása15 v i r t u a l vector<CMembershipFunction> determineConsequentShapes (

CObservation obse rvat i on ) = 0 ;16

17 pub l i c :18 GM(CSystem ∗ pSys ) ;19 ~GM( void ) ;20

21 vector<CMembershipFunction> GM: : i n t e r p o l a t e ( CObservation obse rvat i on ) ;22 } ;23

24 #end i f

Code 3.8. A GM header-je

25

A kommentelés olvashatóvá teszi a kódot. A 4. sorban az FRIMethod.h behívásra kerül,melyre azért van szükség, mert 6-7. sorban ebb®l származik maga a GM is. A 11. 13. és15. sorban érdemes meg�gyelni, hogy a függvények "virtual" módosítót kaptak, ezzeljelezve a fejleszt®k felé, hogy ezeket feltétlenül felül kell de�niálni. A 18. és 19. sorbana konstruktor, illetve a destruktor látható, lehet®vé téve így a memóriagazdálkodásbóladódó problémák megel®zését.

3.3. A keretrendszer használata

A keretrendszer jelenleg a statikus könyvtárnak köszönhet®en C++ alól érhet® el. Eb-ben a részben két fejleszt®környezetben való használat kerül bemutatásra, az egyik acsak Windows alatt elérhet® Visual Studio, míg a másik a Linux alatt is alkalmazhatóEclipse.Amennyiben a keretrendszer sikeres lesz, a közeljöv®ben támogatást fognak élvezni másnyelvek is, például a java, MATLAB és a FreeMat is [12].

3.3.1. LIB használata Visual Studio 2010-ben

A következ® pár pontban szeretném bemutatni hogyan lehet m¶ködésre bírni a toolboxkönyvtárát Visual Studio 2010 alatt, kezdve egészen az elejér®l, a projekt létrehozásá-val, a végét pedig az eredmény kiíratásával zárnám. A lépéseket képekkel illusztráloma könnyebb megértés érdekében.

1. Mindenek el®tt létre kell hozni egy C++ Win32 alkalmazás projektet a VisualStudioban. Elérési útja: File → New → Project . . . (ugyanez elérhet® a Ctrl +Shift + N billenty¶ kombinációval). A projekt megkonstruálása közben �gyelnikell arra, hogy az Application Type Console application legyen, az Additionaloptions-ben a Precompiled header bekapcsolva maradhat, ez gyorsítja majd aprogram futását. További header-ökre (AFC, MFC) nincs szükség. A m¶velet a3.4 ábrán látható.

26

3.4. ábra. C++ Projekt létrehozása

2. Nagyon fontos, hogy a project con�guration-t Debug-ról át kell állítani Release-re. Ezután a projekt beállítás ablakot kell el®hozni, mely úgy érhet® el, hogyjobb-gombot nyomunk a frissen létrehozott projektre és a legalsó, Properties op-ciót választjuk. A Code Generation fület kell megkeresni, mely a Con�gurationProperties→ C/C++→ Code Generation úton érhet® el. Ezen belül át kell állí-tani a Runtime Library beállítását Multi-Threaded DLL (/MD)-r®l Multi-Threaded (/MT)-re. Magyarázat a 3.5 ábrán látható.

3.5. ábra. Runtime Library beállítása

3. Ugyan abban az ablakban ahol a 2-es lépés végrehajtásra került, át kell navigál-ni a Linker-re, melyet a Con�guration Properties → Linker → Input útvonalonlehet elérni (3.6 ábra ). Ezen is belül az Additional Dependencies-hez kell hoz-záadni a library elérhet®ségét. Amennyiben a FRIT lib a projekt mellett van,

27

akkor a hozzáadandó szöveg a következ®: fritoolbox/fritoolbox.lib. Természetesenamennyiben máshol lett elhelyezve a library, akkor azt az útvonalat kell odaírni.

3.6. ábra. Library hozzáadása

4. Negyedik és egyben utolsó lépés nem más, mint egy teljesen egyszer¶ példa po-rogram írása mely használja a toolbox egy metódusát. El®sször a kód elejéninclude-olni kell a library-t melyet az alábbi kód segítségével lehet megtenni:

1 #inc lude " f r i t o o l b o x \ f r i t o o l b o x . h"

Code 3.9. FRIToolbox behívása

Ezzel elérhet®vé válik az összes eljárás valamint minden függvény, amit a toolboxtartalmaz. A program main részében, a metódus választás el®tt els®ként be kellolvasni egy .FIS illetve egy .OBS �le-t. A FIS �le-ban van a leírása az inputnak(A halmazok), az outputnak (B halmazok), valamint a szabályok is itt találhatók.Az OBS-ban a meg�gyelés (A*) található. Ezek beolvasására szolgáló kód alábbolvasható:

1 CSystem ∗pSys = CFISFile : : readFIS ( "example . f i s " ) ;2 CObservation obs = COBSFile : : readOBS( "example . obs" ) ;

Code 3.10. FIS �le és OBS �le beolvasása

Ez a kód elvégzi a beolvasást az example.�s, illetve az example.obs �le-okból,ugyanakkor fontos megemlíteni, hogy mind a readFIS() mind pedig a readOBS()képes stringstream kezelésére is.Ezek után, hogy sikerült letárolni a fuzzy rendszert, valamint a meg�gyelést, akövetkez® lépés az FRI metódus kiválasztása. Ehhez létre kell hozni egy FRI-Toolbox objektumot, aminek az els® argumentuma a módszer neve (stringkéntmegadva, �gyelni kell az idéz®jelekre), a második pedig az imént beolvasásrakerült pSys fuzzy rendszer.

28

1 FRIToolbox f r i t = FRIToolbox ( "FIVE" , pSys ) ;

Code 3.11. FRI módszer kiválasztása

A következ® lépés a módszer interpolate függvényének meghívása a meg�gyeléssel,mint argumentummal. Ez a kialakítás lehet®vé teszi, hogy az interpolate metó-dust szükség esetén mindig más observation-el hívjuk meg, anélkül, hogy a fuzzyrendszert újra be kellene tölteni.

1 vector<CMembershipFunction> mfs = f r i t . i n t e r p o l a t e ( obs ) ;

Code 3.12. Interpoláció meghívása

Amint látható a visszatérési érték egy vektor lesz, ami CMembershipFunction-b®l áll és minden dimenzióban tartalmazza a kiszámított értékeket. Az eredménymegjelenítésére a legegyszer¶bb módszer az mfs objektum toString() metódusá-nak meghívása.Az utolsó képen (3.7 ábra) látható a mintaprogram maga, valamint egy futásieredmény.

3.7. ábra. Mintaprogram futási eredménye

Összefoglalva tehát a keretrendszer használatát:

• include-olni kell a toolbox header �le-ját

• a program main részében a FIS és az OBS �le-t be kell olvasni

• ki kell választani a használni kívánt FRI módszert

• meghívni annak interpolate metódusát

Már ez a néhány szimpla lépés is lehet®vé teszi a toolbox használatát.

29

3.3.2. LIB használata Ubuntu alatt Eclipse-ben

Az el®z® blokkban egy egyszer¶ példa került bemutatásra, hogyan is lehet alkalmazni atoolbox-ot Windows alatt Visual Studio-t használva. A koncepció egyik fontos pontja,hogy ne csak egy operációs rendszer alatt legyen elérhet® a keretrendszer, ezért ez arész a Linux alatti m¶ködésr®l ad egy rövid áttekintést. Mivel a példaprogram kódjaszerepelt már fentebb, az itt felsorolásra kerül® pontokban nem lesz róla szó, hiszenmindkét OS-en ugyanúgy m¶ködik.

1. Els® lépésként az Eclipse-ben létre kell hozni egy üres C++ projektet. Ez a File→ New→ C/C++ úton érhet® el (3.8 ábra). A megjelen® ablakban az Executab-le/Empty project opciót kell választani, a többi beállítási lehet®ség nem lényeges,maradhat alapértelmezetten.

3.8. ábra. Üres C++ projekt létrehozása

2. Miután elkészült az üres projekt, a következ® lépés a header hozzáadása. A Pro-ject Explorer-ben jobb-gomb a most készített projektre, majd a Properties opciótkell választani, melynek hatására megjelenik egy ablak a beállítási lehet®ségekkel.Az ablakon belül a C/C++ Build→ Settings-en belül a Cross G++ compiler→Includes opciót kell választani (3.9 ábra). Az Include path(-l)-nál az Add gombotmegnyomva lehet beírni a toolbox header-jének elérési útját.

3.9. ábra. Include path beállítása

30

3. Ezek után már csak a static library (fritoolbox.a) útvonalát kell megadni. Eztugyanazon a panelen lehet megtenni, mint az el®z® lépést. A különbség annyi,hogy a Cross G++ Linker/Libraries opcióhoz kell navigálni (3.10 ábra). Akárcsak az imént, a hozzáadás itt is hasonlóan m¶ködik. A megjelen® kis ablakba atoolbox nevét kell írni kiterjesztés (.a, .lib) nélkül, csak ezt: FRIToolbox. Ezen3 lépés elvégzésével a fejleszt®i környezet már készen áll arra, hogy használja akeretrendszer minden metódusát és a függvényeit.

3.10. ábra. Static Library hozzáadása

3.4. A keretrendszer kib®vítése

Ahogy szinte minden keretrendszer, úgy a szakdolgozatom által bemutatott is egy fo-lyamatosan változó, fejl®d®, nem pedig statikus program. Ennek megfelel®en ebben aszakaszban szeretném leírni hogyan lehet az FRI Toolboxhoz hozzáadni új metóduso-kat, így elérve azt, hogy a felhasználó, ha szükség van rá implementálja a saját, vagyakár más által már leprogramozott interpolációs módszert. A következ® pár pontbantehát arról lesz szó, hogyan lehet új FRI módszert hozzáadni a lehet® legkönnyebbena toolboxhoz.

Az 3.13 kód szemlélteti a kib®víési eljárás menetét. 1-2. sorban beágyazásra kerül aFRIMethod valamint az FRIException header �le-ja. A 4. sorban létrehozásra kerül aprogramozó saját osztálya, melyet a CFRIMethod osztályból kell leszármaztatnia. Az5. és 6. sor deklarál egy stringet, ami az új eljárás nevét fogja majd tárolni, valamint egyinteger változót, ami az Alfa vágatok számát tartalmazza. Ennek a függvénynek kell ki-számolnia az interpolációt. A példa kedvéért egy háromszög alakú fuzzy halmazzal fogvisszatérni a függvény. Az osztály konstruktorában (9-13. sor) inicializálásra kell hogykerüljenek a kezdeti értékek, jelen esetben ez az eljárás neve, ami a resoultname válto-zóban tárolódik. Amennyiben ez nem történik meg, javasolt egy init metódus (15-21.sor) írása amely betölti ezt a feladatot. Ennek void típusúnak kell lennie, valamint egystring változójú argumentumot szükséges fogadnia. Ez a metódus fogja beállítani azinterpoláció paramétereit. A megírt osztálynak mindenképp magába kell foglalnia egyInterpolate metódust,ami argumentumaként CObservation típust fogad el, valamint avisszatérési értéke egy vector<CMembershipFunction> (23-31. sor).

31

1 #inc lude "FRIMethod . h"2 #inc lude "FRIException . h"3

4 c l a s s InterpolateNew : pub l i c CFRIMethod{5 pr i va t e : s t r i n g resoultname ;6 i n t acuts ;7

8

9 InterpolateNew ( s t r i n g name) {10 // adatok b e á l l í t á s a11 // példa :12 resoultname=name ;13 }14

15 void i n i t ( s t r i n g i n i ) {16 // adatok i n i c i a l i z á l á s a17 // példa :18 s t r i n g s t r ;19 const char ∗ c = s t r . c_str ( ) ;20 acuts=a t o i ( c ) ;21 }22

23 vector<CMembershipFunction> i n t e r p o l a t e ( CObservation obse rvat i on ) {24 // számítások e l v é g z é s e25 //majd az eredménnyel va ló v i s s z a t é r é s :26 CMembershipFunction mf=CMembershipFunction ( "MF1='"+resoultname+" ' :27 ' t r im f ' , [ −0 .5 0 0 . 5 ] ! [ 0 1 0 ] " ) ;28 vector<CMembershipFunction> r e t ;29 r e t [0 ]=mf ;30 re turn r e t ;31 }32 }

Code 3.13. Új FRI metódus mintakódja

A fenti kód egy minta, amely segítséget nyújt a saját osztály megírásában. Azon-ban ahhoz, hogy az új módszer teljesen része legyen a toolbox-nak, bele kell írni azfritoolbox.cpp-be. Ez a fájl hivatott arra, hogy meghívja az összes interpolációs mód-szert.A 3.14 kód az fritoolbox.cpp kódból egy részlet. Az els® sorban behívásra kerül a header�le, a 3-5. sorban a konstruktor található ami bemenetül egy interpolációs módszer ne-vét, valamint egy fuzzy rendszert kér. 8-10. sorig a changeMethod függvény van, amivelmeg lehet változtatni az eljárást. A 12-14. sorban lév® függvény segítségével lekérhet®a választott módszer neve.A kódrészletb®l a kib®vítés szempontjából fontos rész a 16. sortól kezd®dik, innen indulaz interpolate függvény (plusz paraméterek és meg�gyelés fogadására képes). Ebbentalálható egy összetett IF szerkezet, ami megállapítja melyik módszer nevével hívódottmeg a toolbox. Amennyiben az elágazás igaz értéket kap, a kell® módszerb®l létre-jön egy példány, meghívódik az init függvénye végül pedig az FRI eljárás interpolatefüggvénye, a meg�gyeléssel. Ez az metódus egyben a visszatérési értéke az FRIToolboxinterpolate metódusának.Az új módszer hozzáadásának példája a 23. sortól látható, ami követi az el®bb felsorolt3 lépést. Ha nincs ilyen módszer, amilyen nevet kapott a toolbox, akkor a 29. sorbanhibát dob, mely tájékoztatja a felhasználót, hogy a keretrendszerben nem találhatóilyen módszer.

32

A 33-35. sorban a másik interpolate metódus taláható, melyre azért volt szükség, mertvannak olyan módszerek amik nem igényelnek további paramétereket. Ez meghívja azel®z® interpolate metódust, így könnyítve meg a felhasználó dolgát, hogy ne kelljenüres stringet megadni paraméterként.Az alábbi 3.14 kód tehát megmutatja hogyan is lehet az új módszer a keretrendszerrésze.

1 #inc lude " f r i t o o l b o x . h"2

3 FRIToolbox : : FRIToolbox ( s t r i n g method , CSystem ∗pSys ) :4 CFRIMethod( pSys ) { m_smethod = method ;5 m_pSys = pSys ;6 }7

8 void FRIToolbox : : changeMethod ( s t r i n g methodName) {9 m_smethod = methodName ;

10 }11

12 s t r i n g FRIToolbox : : getMethodName ( ) {13 re turn m_smethod ;14 }15

16 vector<CMembershipFunction> FRIToolbox : : i n t e r p o l a t e ( s t r i n g params ,17 CObservation obse rvat i on ) {18 i f ( m_smethod . compare ( "FIVE" ) == 0 ) {19 CFIVE ∗ f r i = new CFIVE(m_pSys) ;20 f r i −>i n i t ( params ) ;21 re turn f r i −>in t e r p o l a t e ( obse rvat i on ) ;22 }

...

23 \} e l s e i f ( m_smethod . compare ( "UjModszer" ) == 0 ) {24 // I t t h ívód ik meg az új metódus25 InterpolateNew ∗ f r i = new InterpolateNew (m_pSys) ;26 f r i −>i n i t ( params ) ;27 re turn f r i −>in t e r p o l a t e ( obse rvat i on ) ;28 } e l s e {29 throw "method not implemented ! " ;30 }31 }32

33 vector<CMembershipFunction> FRIToolbox : : i n t e r p o l a t e34 ( CObservation obse rvat i on ) { re turn i n t e r p o l a t e ( "" , obse rvat i on ) ;35 }

Code 3.14. Az fritoolbox.cpp forrása

3.5. A keretrendszerben található egylépéses módsze-

rek

Az egylépéses módszerek alkotják a fuzzy szabály interpolációs eljárások egyik csoport-ját. Ezek a módszerek a következményhalmazt mindenféle megel®z® számítás nélküladják meg, a rendelkezésre álló (legalább egy-egy) közrefogó szabály alapján. Az

33

el®z®ekben már volt róla szó, hogy jelen pillanatban a keretrendszer 5 egylépéses mód-szert tartalmaz. A továbbiakban röviden bemutatásra kerülnek ezek a módszerek imp-lementálásuk sorrendjében.

3.5.1. KH

Kóczy és Hirota [1] vezette be els®ként az alfa vágat alapú KH fuzzy távolság fogalmát(3.11ábra). Ez az eljárás segít rendezni a fuzzy halmazokat. Az A halmaz akkor el®zimeg B halmazt, ha bármely alfa vágat esetén [0, 1] inf(A) < inf(B), illetve sup(A) <sup(B) teljesül, ahol az inf az alfavágatnál a halmaz alsó pontja, sup-nál pedig a fels®pontja. Csak CNF halmazokra m¶ködik a rendezési algoritmus, azonban van egy nagyhibája. Amennyiben A és B halmaznak van közös része, tehát van olyan intervallumahol mind a kett® értelmezve van, akkor nem lehet egyértelm¶en megmondani melyikhalmaz van el®rébb (3.12 ábra).

3.11. ábra. KH távolság értelmezése

3.12. ábra. Egy példa arra, amikor a KH távolság nem tud rendezni

Az interpolációs módszer alapgondolata az volt, hogy a becsült eredményhalmaz-nak ugyanolyan arányban kell felosztania a két közrefogó konzekvens halmazok közöttitávolságot, mint ahogy a meg�gyelés a két legközelebbi antecedens közti távolságot. Azeljárás minden alfa vágat szintjén elvégzi ezeket a számításokat. Szakaszonként lineárishalmazok esetében elegend® csak a töréspontok magasságában alfa vágatokkal számol-ni. Ugyan az eljárás nem ®rzi meg a szakaszonkénti linearitást, de az eltérés olyan kicsi,hogy elhanyagolható. A módszer el®nye, hogy rendkívül gyors, azonban vannak olyanesetek, melyekre nem ad érvényes eredmény halmazt.

34

3.5.2. VKK

Vass, Kalmár és Kóczy [5] szintén alfa vágat alapú rendezést javasolt a fuzzy halma-zokra. A távolságot azonban teljesen máshogy értelmezik, mint a fenti esetben. Azalfa vágatot nem az el®z® módon, a halmaz két széls® pontjával határozzuk meg, ha-nem a halmaz középpontjával és a halmaz szélességével. Két halmaz távolságát pediga középpontok euklideszi távolságával értelmezi (3.13 ábra). Ez alapján az A halmazakkor el®zi meg a B halmazt, ha minden alfa vágat magasságában A középpontja el®-rébb helyezkedik el, mint B középpontja. A megoldás el®nye, hogy gyorsítja a távolságszámítást, viszont még mindig csak részleges rendezést biztosít.

3.13. ábra. VKK távolság értelmezése

Az interpolációs eljárás kiküszöböli a KH [1] egyik legnagyobb hibáját, az érvényte-len eredmény halmazt. Ezt úgy érték el, hogy a távolságot másképp de�niálták, mint aKH [1] és a halmazok szélességével számol a módszer. Az el®z®höz hasonlóan ez is csakCNF halmazokkal m¶ködik. Hátránya, hogy nem tudja kezelni azt az esetet, amikorvalamelyik halmaznak az alfa vágat magasságában a szélessége nulla (singleton). A sza-kaszonkénti linearitást ez az eljárás sem ®rzi meg, de az eltérés itt is olyan kisméret¶,hogy elhanyagolható.

3.5.3. MACI

Tikk és Baranyai [2] dolgozták ki a módosított alfa vágat alapú eljárást (Modi�ed Alp-ha based Cut Interpolation, innen kapta a nevét). Az eljárás lényege, hogy a Yam általpublikát [23] vektorreprezentációs módszert alkalmazva a fuzzy halmazokat olyan térbetranszformálják ahol minden esetben érvényes következmény halmazt eredményezneka számítások.A szemléletesség kedvéért a továbbiakban háromszög alakú fuzzy halmazokon lesz be-mutatva a módszer. Minden halmazt két részre bont, jobb (alsó), bal (fels®) részre, ésa vektorokban a halmazok karakterisztikus pontjait tárolja. A számításokat ezek utánkülön végzik a jobb illetve a baloldalra. Az élek vektorait síkbéli pontokkal ábrázolvaelmondható az, hogy csak akkor kapunk érvényes következtetés halmazt, ha a B* ponta B1 és B2 által határolt téglalapon belül, valamint az l vonalon felül helyezkedik el(3.14. ábra).

Transzformáljuk a B1 és B2 konzekvenseket egy olyan koordináta rendszerbe, amelykizárja az abnormalitás lehet®ségét. A B1 és B2 konvexitása biztosítja az új rendszerbelinem negatív értékeket. Ezek után számítsuk ki a következtetés helyét az új koordinátarendszerben, majd végül transzformáljuk vissza a kapott eredményt az eredeti rend-szerbe. Ez a megoldás biztosítja a következtetés koordinátáinak monoton növekedését.

35

3.14. ábra. Gra�kus szemléltetése az éleket leíró vektoroknak

3.5.4. GK(CRF)

A módszert Gedeon és Kóczy [13] dolgozták ki, innen az egyik neve, valamint mégConservating of Relative Fuzzynes-nek is szokták hívni. Az eljárást trapéz alakú CNFhalmazokra dolgozták ki, az eddigiekhez hasonlóan két közrefogó halmaz segítségévelszámolja ki az eredményt. Az el®z®ekt®l eltér®en, ez nem az alfa vágatok alapján becsü-li az eredményt. A szerz®k ugyanis rájöttek arra, hogy az antecedens halmazok száraiáltalában hosszabbak, mint a meg�gyelés élei. Ezért elegend® csak a számítandó ol-dalon lév® antecedens azonos oldali tartójával kalkulálni (3.15.ábra). A következményhelyzetének becslésére pedig a meg�gyelés és a szomszédos antecedens magjának távol-ságát használja fel. Többdimenziós esetre is kiterjeszthet®, ilyenkor a magok euklideszitávolságát használja.

3.15. ábra. Magtávolságok és magszélességek

3.5.5. FIVE

Az utoljára bemutatásra (és implementálásra) kerül® egylépéses módszer a Fuzzy In-terpolation in the Vague Envirement (innen a neve). Az eljárást 1997-ben Kovács ésKóczy fejlesztette ki [21]. A módszer lényege, hogy a becsléseket az úgynevezett bi-zonytalan térben [20] végzi el, ahol a fuzzy halmazok alakját skálafüggvények írják le.Hátrányaként róható fel, hogy skálafüggvényt csak háromszög illetve trapéz halmazokesetén találhatunk csak, valamint nem ®rzi meg a szakaszonkénti linearitást. El®nyeviszont a többdimenziós esetek kezelése és a gyorsaság, ami annak köszönhet®, hogy abizonytalan tereket el®re elkészíti. Továbbá elengedhetetlen a bementi és az antecedensoldali bizonytalan tér összeolvasztása [24].

36

3.6. A keretrendszerben található kétlépéses módsze-

rek

A fuzzy szabály interpolációs módszerek másik csoportja a kétlépéses eljárások. Annyi-ban különböznek az egylépéses társaiktól, hogy miel®tt elkezdenék kiszámolni a kö-vetkezményhalmazt, megel®z® számításokat végeznek. Ezeket a lépéseket a Baranyai,Kóczy és Gedeon által létrehozott GM [6] határozza meg. A koncepció lényege, hogy akövetkeztetést két lépésben állítja el® (innen a neve). El®ször egy új szabályt interpolálmagának, melyben az antecedens oldali halmazok referencia pontjai egybe esnek azazonos dimenzióban lév® meg�gyelés referencia potjával. Ehhez 3 pontot kell megvaló-sítania:

• Az új szabály antecedens oldali halmazainak alakját határozza meg

• A konzekvens halmazok referencia pontját számolja ki

• Végül a könzekvens halmazok alakját határozza meg

Ezután a 3 számítás után jöhet a következmény halmaz megállapítása, melynek alap-ötlete, hogy amennyire hasonlít a meg�gyelés alakja az antecedensére, annyira kellhasonlítania a következmény halmaznak a konzekvensére.

3.6.1. FRIPOC

A keretrendszer egyetlen kétlépéses módszere a polárvágat alapú szabály interpolációseljárás, melyet Johanyák és Kovács dolgoztak ki [15]. A GM-et [6] követve els® lépésbena segédszabály antecedens és konzekvens nyelvi értékeinek meghatározásának érdeké-ben polár-vágat alapú halmaz-interpolációt (FEAT-p) [14] hajt végre. Mivel ezek aszámítások nem függnek egymástól, ezért amennyire az adott programnyelv engedi,párhuzamosítással akár jelent®s mértékben gyorsítható a módszer ezen része. A She-pard interpoláció [16] egy adoptált változata segítségével meghatározható az új szabálykonzekvens halmazának referencia pontja.A következtetési folyamat második lépésében a szintén polár-vágat alapú SURE-p [15]eljárás segítségével határozzuk meg a következményt.

37

3.7. Módszerek összegzése

Az alábbi fejezetben a keretrendszerben található módszereket hasonlítom össze fontostulajdonságaik alapján. Az els® lényeges szempont a lépések száma. A különbségr®lfentebb már lehetett olvasni, és arról is, hogy 5 egylépéses és 1 kétlépéses eljárás kerültimplementálásra.A következ® oszlopban az összehasonlítás a módszerek azon tulajdonsága alapján törté-nik, hogy kezelnek-e többdimenziós inputot, tehát egyszerre több antecedens dimenziófogadására és feldolgozására is képesek-e. Látszik, hogy az egyetlen ilyen módszer aFIVE.Az utolsó összehasonlítás alapját a módszerek azon jellegzetessége képezi, hogy mindenbemenetre érvényes konklúziót, tehát helyes fuzzy halmazt adnak-e eredményül. Lát-szik, hogy a KH valamint a VKK nem rendelkezik ezzel a képességgel, olykor homokóraalakú következménnyel térnek vissza.

módszer neve lépések száma több dimenziós inpu-tot is kezel-e

mindig érvényes-e akövetkezmény

KH 1 kiterjesztve igen nem

VKK 1 kiterjesztve igen nem

CRF(GK) 1 kiterjesztve igen igen

MACI 1 kiterjesztve igen igen

FIVE 1 igen igen

FRIPOC 2 kiterjesztve igen igen

3.1. táblázat. Módszerek összegzése

38

4. fejezet

Konklúzió

Szakdolgozatom végére kiderült, hogy több megoldás is létezik melyek feldolgozták as¶r¶ szabálybázis alapú módszereket, de eddig nem volt olyan, amely a ritka szabály-bázisú eljárásokkal foglakozott volna, leszámítva a Johanyák által írt MATLAB FRIToolbox-ot [8]. Ennek azonban a hátulüt®je, hogy csak MATLAB alól használható, ésnem alkalmas valós környezetben való futtatásra.Az általam bemutatott keretrendszer, a MATLAB FRI Toolbox-hoz hasonlóan (leg-alábbis az abban felhasznált módszereket tekintve) a ritka szabálybázisú eljárásokatfoglalja össze. A rendszer mindenki számára elérhet® Windows-on illetve Linux-on egy-aránt. A támogatott programnyelv ugyan jelenleg csak C++ (LIB technológiának kö-szönhet®en), de ez a nyelv elég gyors ahhoz, hogy valós környezetben is használható le-gyen. Az egységes kezel®felületnek hála bármely FRI módszert, könnyen lehet használnisaját kódból, hiszen elegend® belinkelni a toolbox könyvtárát, beolvasni a FIS és OBS�le-t, utána a kiválasztott módszer nevével és a fuzzy rendszer megadásával meghívniaz interpolate függvényt. A fejlesztést és a használatot is megkönnyíti a kivételosz-tály, ami módszerekre bontva tartalmazza a kivételek pontos leírását. A keretrendszerkib®vítése, abba új módszer belehelyezése nagyon könnyen elvégezhet®, pusztán pársor hozzáadásával. A dolgozatom példát szolgáltat arra, hogyan lehet a keretrendszertéletre kelteni Windows alól Visual Studio 2010-et használva, illetve Ubuntu alól Eclipsesegítségével. Kitér arra is hogyan lehet a toolbox-ot b®víteni, továbbá mintát ad egyúj módszer megírására is.A rendszer még fejlesztés alatt áll, jelenleg 5db egylépéses és 1db kétlépéses módszerttartalmaz, ezek a következ®k: KH , VKK , CRF (GK) , MACI, FIVE és FRIPOC. Eza lista minden bizonnyal b®vülni fog, hiszen további módszerek implementálását bárkinagyon egyszer¶en megteheti (akár egylépéses, vagy kétlépéses módszerr®l legyen szó),akinek igénye van rá,A toolbox-ban rengeteg lehet®ség rejlik, ilyen például a több programnyelv támogatá-sa, amit a LIB helyett DLL-el, illetve wrapper classokkal lehet elérni és a közeljöv®benreményem szerint meg is fog valósulni, ezzel el®segítve az elterjedést. Valamint azt ismérlegelni lehet, hogy érdemes-e a FIVE-nál használt matematikai könyvtár (Arma-dillo) segítségével újra leprogramozni a már meglév® módszereket, ezzel elérve némiteljesítmény javulást.Továbbá elkészült egy benchmark rendszer is, amely megkönnyíti a már implementáltés kés®bbiekben beültetésre kerül® FRI módszerek összehasonlítását, mind a futási ide-jüket tekintve, mind pedig a módszerek használhatóságát �gyelembe véve. Ezek alapjánkonkrét javaslotokat tesz, mely módszer alkalmas a feladatok megoldására.

39

Úgy érzem, hogy a szakdolgozat megírása alatt sokat fejl®dtem. Megtanultam csapat-ban dolgozni, megismerkedtem a keretrendszerek tervezésének fontos szempontjaival éslépésével, valamint a C++ nyelvben is már jobban kiismerem magam.

40

Irodalomjegyzék

[1] L. T. Kóczy and K. Hirota, "Rule interpolation by -level sets in fuzzy approximatereasoning," BUSEFAL, vol. 46, no. Automne, pp. 115-123, 1991.

[2] D. Tikk and P. Baranyi, "Comprehensive analysis of a new fuzzy rule interpolationmethod," IEEE Trans. on Fuzzy Systems, vol. 8, no. 3, pp. 281?296, 2000.

[3] S. Kovács and L. T. Kóczy, "Application of an approximate fuzzy log-ic controller in an agv steering system, path tracking and collision avo-idance strategy," Tatra Mountains Math. Publ., vol. 16, pp. 456-467, 1999,http://www.mat.savba.sk/tatra/Full/16/31kovacz.ps.

[4] K. W. Wong, T. D. Gedeon, and D. Tikk, "An improved multidimensional -cutbased fuzzy interpolation technique," in Proc. of the Int. Conf. on Arti�cial Intelli-gence in Science and Technology (AISAT'00), V. Karri and M. Negnevitsky, Eds.,Hobart, Tasmania, Australia, December, 2000, pp. 33-38.

[5] G. Vass, L. Kalmár, and L. T. Kóczy, "Extension of the fuzzy rule interpolationmethod," in Proc. of the Int. Conf. on Fuzzy Sets Theory and its Applications(FSTA?92), Liptovsk�y Jan, Slovakia, 1992, pp. 1?6.

[6] P. Baranyi, L. T. Kóczy, and T. D. Gedeon, "A generalized concept for fuzzyrule interpolation," IEEE Trans. on Fuzzy Systems, vol. 12, no. 6, pp. 820?837,December 2004.

[7] S. Yan, M. Mizumoto, and W. Z. Qiao, "An improvement to Kóczy and Hirota's in-terpolative reasoning in sparse fuzzy rule bases," Int. J. of Approximate Reasoning,vol. 15, pp. 185?201, 1996.

[8] Johanyák, Zs. Cs. and Kovács, Sz.: Fuzzy Rule Interpolation Based on Polar Cuts, inComputational Intelligence, Theory and Applications, Springer Berlin Heidelberg,2006, pp. 499-511.

[9] Z. C. Johanyák, D. Tikk, S. Kovács, and K. W. Wong, "Fuzzy rule interpolationMatlab toolbox - FRI toolbox," in Proc. of the IEEE World Congress on Computa-tional Intelligence (WCCI?06), 15th Int. Conf. on Fuzzy Systems (FUZZ-IEEE?06).Vancouver, BC, Canada: Omnipress, July 16?21, 2006, pp. 1427?1433.

[10] ] Z. Johanyák. Fuzzy rule interpolation matlab toolbox website. [Online]. Available:http://fri.gamf.hu

41

[11] D. Tikk, Z. C. Johanyák, S. Kovács, and K. W. Wong, "Fuzzy rule interpolationand extrapolation techniques: Criteria and evaluation guidelines," Journal of Ad-vanced Computational Intelligence and Intelligent Informatics, vol. 15, pp. 254?263,2011.

[12] Freemat website. [Online]. Available: http://freemat.sourceforge.net

[13] Kóczy, L.T., Hirota, K. and Gedeon, T. D.: Fuzzy rule interpolation by the con-servation of relative fuzziness, in Journal of Advanced Computational Intelligence,Vol. 4/1, 2000, pp. 95-101.

[14] Johanyák, Zs. Cs. and Kovács, Sz.: Fuzzy set approximation using polar co-ordinates and linguistic term shifting, 4rd Slovakian-Hungarian Joint Symposiumon Applied Machine Intelligence (SAMI 2006), Herl'any, Slovakia, 2006, pp. 219-227.

[15] Johanyák, Zs. Cs. and Kovács, Sz.: Fuzzy Rule Interpolation Based on Polar Cuts,in Computational Intelligence, Theory and Applications, Springer Berlin Heidel-berg, 2006, pp. 499-511.

[16] Shepard, D.: A two dimensional interpolation function for irregularly spaced data,in Proceedings of the 23rd ACM International Conference, New York, USA, 1968,pp. 517-524.

[17] Kent Beck Implementation Patterns, Addison-Wesley, 2008

[18] Zoltán Krizsán, Szilveszter Kovács: Fuzzy Rule Interpolation Developer ToolboxLibrary. SACI 2012: 119-123

[19] Krizsán Zoltán:KÖZÖS FEJLESZT�I KERETRENDSZER FUZZY SZABÁLYINTERPOLÁCIÓS MÓDSZEREKHEZ, Miskolci Egyetem (2012)

[20] Klawonn, F.: Fuzzy Sets and Vague Environments, in Fuzzy Sets and Systems,Vol.66, 1994, pp. 207-221.

[21] Kovács, Sz. and Kóczy, L.T.: The use of the concept of vague environment inapproximate fuzzy reasoning, Fuzzy Set Theory and Applications, Tatra MountainsMathematical Publications, Mathematical Institute Slovak Academy of Sciences,vol.12., pp.169-181, Bratislava, Slovakia, (1997).

[22] Johanyák Zs. Cs.: Fuzzy szabály-interpolációs módszerek és mintaadatok alapjántörtén? automatikus rendszergenerálás, PhD disszertáció, Hatvany József Informa-tikai Tudományok Doktori Iskola, Miskolci Egyetem, Miskolc, 2007.

[23] Yam, Y. and Kóczy, L. T.: Representing membership functions as points in highdimensional spaces for fuzzy interpolation and extrapolation, in IEEE Transacti-onsnon Fuzzy Systems, Vol. 8., Issue 6, 2000, pp. 761-772

[24] Kovács, Sz.: Extending the Fuzzy Rule Interpolation "FIVE" by Fuzzy Observa-tion, Theory and Applications, Springer Berlin Heidelberg, 2006, pp. 485-497.

[25] Armadillo C++ linear algebra library http://arma.sourceforge.net/

42

Ábrák jegyzéke

2.1. Hagyományos Venn diagram . . . . . . . . . . . . . . . . . . . . . . . . 92.2. Elmosódott él¶ halmaz Venn diagram használatával . . . . . . . . . . . 92.3. Fuzzy halmazok ábrázolása . . . . . . . . . . . . . . . . . . . . . . . . . 92.4. Példa s¶r¶ és ritka szabálybázisra . . . . . . . . . . . . . . . . . . . . . 14

3.1. Egylépéses módszerek struktúrája . . . . . . . . . . . . . . . . . . . . . 183.2. Kétlépéses módszerek struktúrája . . . . . . . . . . . . . . . . . . . . . 193.3. FRImethod osztálydiagramja . . . . . . . . . . . . . . . . . . . . . . . 243.4. C++ Projekt létrehozása . . . . . . . . . . . . . . . . . . . . . . . . . . 273.5. Runtime Library beállítása . . . . . . . . . . . . . . . . . . . . . . . . . 273.6. Library hozzáadása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283.7. Mintaprogram futási eredménye . . . . . . . . . . . . . . . . . . . . . . 293.8. Üres C++ projekt létrehozása . . . . . . . . . . . . . . . . . . . . . . . 303.9. Include path beállítása . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.10. Static Library hozzáadása . . . . . . . . . . . . . . . . . . . . . . . . . 313.11. KH távolság értelmezése . . . . . . . . . . . . . . . . . . . . . . . . . . 343.12. Egy példa arra, amikor a KH távolság nem tud rendezni . . . . . . . . 343.13. VKK távolság értelmezése . . . . . . . . . . . . . . . . . . . . . . . . . 353.14. Gra�kus szemléltetése az éleket leíró vektoroknak . . . . . . . . . . . . 363.15. Magtávolságok és magszélességek . . . . . . . . . . . . . . . . . . . . . 36

43

Táblázatok jegyzéke

3.1. Módszerek összegzése . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

44

Adathordozó használati útmutató

A DVD melléklet alapvet®en 2 f® könyvtárra osztható. A gyökérben külön választot-tam a Visual Studio-ba betölthet® project-et valamint a már lefordított könyvtárakat,az fritoolbox.lib, illetve fritoolbox.a-t. (el®bbi windowsos, utóbbi, linuxos használatra).Az FRIT project mappában a project fájlt megnyitva (fritoolbox.sln) Visual Studiobanki lehet próbálni hogyan is lehet új metódsust hozzáadni a keretrendszerhez, ahogy aszakdolgozat el®bbi pontjaiban látható volt. A könyvtárak pedig Könyvtárak mappá-ban található. Szintén meg lehet nézni m¶ködés közben, akár Linux alatt is, a fentebbismertetett módon. A toolbox tartalma:

Base.cpp

Convert.cpp

CRF.cpp

FEAT_P.cpp

FISFile.cpp

FIVE.cpp

FRI.cpp

FRIEXception.cpp

FRIMethod.cpp

FRIPOC.cpp

fritoolbox.cpp

GM.cpp

KH.cpp

MACI.cpp

MembershipFunction.cpp

Observation.cpp

OBSFile.cpp

Partition.cpp

Point.cpp

Rule.cpp

Shapes.cpp

StringUtils.cpp

System.cpp

VKK.cpp

Mivel maga a keretrendszer megírása csapatmunka volt, ezért vannak olyan osz-tályok, �le-ok melyen többen is dolgoztunk. A fájlok melyeket önállóan írtam, vagyközrem¶ködésem köthet® hozzájuk: VKK.cpp VKK.h, MACI.cpp, MACI.h, FIVE.cpp,FIVE.h, CFRIMethod.cpp CFRIMethod.h, fri.cpp, fri.h, FRIException.cpp, FRIEx-ception.h. A DVD nem tartalmazza a keretrendszerhez tartozó benchmark rendszert.

45