numerikus integráló programprog-mat.elte.hu/diplomamunka/szakdolgozat.pdf · 2008. 1. 13. · a...

Numerikus integráló program

Programozó Matematikus SzakEsti tagozat

készítette: Tarnai Tibor

témavezető: Virágh Gábor

Budapest, 2008

Témabejelentő

TartalomjegyzékTémabejelentő............................................................................................................................................................................2

Bevezetés...................................................................................................................................................................................4

Felhasználói dokumentáció........................................................................................................................................................5

1 A megoldott probléma.................................................................................................................................................................................5

1.1. Működés.............................................................................................................................................................................................5

1.2. Szükséges ismeretek..........................................................................................................................................................................5

2 Felhasznált módszerek.................................................................................................................................................................................7

2.1. A Hermite (Lagrange) interpolációs módszer....................................................................................................................................7

2.2. A NewtonCotes módszer................................................................................................................................................................10

2.3. A kompozit Simpson módszer ........................................................................................................................................................11

2.4. A kompozit trapéz módszer ............................................................................................................................................................12

3 A program használata................................................................................................................................................................................13

3.1. Telepítés............................................................................................................................................................................................13

3.2. Felhasználói felület (GUI)...............................................................................................................................................................13

3.3. Megjegyzések, tanácsok a használathoz, hibajelzések....................................................................................................................14

Fejlesztői dokumentáció...........................................................................................................................................................15

1 A probléma részletes specifikációja............................................................................................................................................................16

2 Felhasznált módszerek................................................................................................................................................................................16

3 A program logikai szerkezete......................................................................................................................................................................16

3.1 Asszociációs diagram (Association diagram)...................................................................................................................................17

3.2 Osztálydiagram (class diagram)........................................................................................................................................................19

3.3 A Parser............................................................................................................................................................................................20

4 API dokumentáció......................................................................................................................................................................................26

4.1 ComponentController........................................................................................................................................................................26

4.2 ContextFactory..................................................................................................................................................................................26

4.3 DrawArea..........................................................................................................................................................................................27

4.4 Hermite.............................................................................................................................................................................................28

4.5 IntegrationMethod............................................................................................................................................................................29

4.6 Limit.................................................................................................................................................................................................29

4.7 MainWindow....................................................................................................................................................................................29

4.8 MethodList........................................................................................................................................................................................31

4.9 MethodUser.......................................................................................................................................................................................31

4.10 NewtonCotes....................................................................................................................................................................................31

4.11 ParserController...............................................................................................................................................................................31

4.12 Pmember.........................................................................................................................................................................................32

4.13 Polynom..........................................................................................................................................................................................33

4.14 Simpson...........................................................................................................................................................................................35

4.15 Trapezium........................................................................................................................................................................................35

5 Tesztelési terv, tesztelés eredmények..........................................................................................................................................................35

5.1 Hibakezelés.......................................................................................................................................................................................35

5.2 Helyes input melletti tesztek.............................................................................................................................................................35

3

Bevezetés

A program a numerikus integrálási módszereket, a közöttük levő különbségeket hivatott bemutatni szemléletes módon, azzal a céllal, hogy a felhasználó a lehető legegyszerűbben és leggyorsabban tudja az általa kiszámított integrál értékét ellenőrizni, illetve az integrálandó függvény egy egyszerű, intuitív grafikonját megnézni. Az eredeti feladatkiírásban nem szerepelt grafikus felhasználói felület, de azt gondolom, hogy a jelenlegi szoftverek olyan magas szintűek, és a felhasználóknak olyan magasak az elvárásaik, hogy egy parancssoros eszközt a legtöbben „fapados”nak bélyegeznének. Az eszköz funkcionálisan is többet tud az eredeti kiíráshoz képest, ugyanis Gergó Lajos tanár úr tanácsát megfogadva nemcsak egy integrálási módszer, hanem összesen négy algoritmust valósítottam meg, ezekről a tisztelt olvasó a felhasználói dokumentáció második részében kap részletesebb tájékoztatást. A fejlesztői dokumentáció első részében a program logikai szerkezetéről kaphatunk bővebb információt, ezután a parser által implementált grammatikába kaphatunk részletesebb betekintést. Az ezt követő részben kitérek az egyes objektumok struktúrájára és részletesen leírom, hogy melyik függvény pontosan mikor is hívódik fel és milyen célt szolgál. Legvégül a program tesztelési tervét és a hozzá tartozó teszteredményeket mutatom be.

4

Felhasználói dokumentáció

1 A megoldott probléma

1.1. Működés

A program alapvetően az egyváltozós valós függvények határozott integrálját számítja ki. A problémát a következő könyvek részletesen is taglalják [1][2][3][4] . A megoldott probléma alapvetően három részre bontható. Az első rész egy megfelelő intuitív és egyszerű felhasználói felület elkészítése volt. A második rész a feldolgozandó függvény szemantikus elemzőjét foglalja magába. A harmadik rész a numerikus módszerek megvalósítását jelentette. A most következő szakaszban csak a harmadik problémával foglalkozunk, az első kettő rész részletesebb kifejtését a fejlesztői dokumentációban találja meg a kedves felhasználó.

1.2. Szükséges ismeretek

A mostani rész bizonyos matematikai ismereteket tételez fel. Ezekről bővebben [5] ben lehet olvasni. Most pedig lássunk néhány elengedhetetlenül szükséges definíciót.

D: Legyen f : I ℝ ekkor azt mondjuk, hogy F∈D I az ffüggvény primit ív függvényeinek a halmaza , ha F '= f

D: (felosztások) ⊂[a ,b ] az [a , b] intervallum egy felosztása , ha véges és a , b∈ . Jelölés: ={x0 ,... , xn } .

Itt megjegyezzük, hogy a program csak egyenletes felosztásokkal dolgozik.

D: Az f függvény felosztásához tartozó alsó közel ítő

összeg ={x0 ,... , xn }s f ,=∑k=0

n−1

inf R f ∣[ x k , xk1 ]x k1−xk

5

D: Az f függvény felosztásához tartozó felső közel ítő

összeg ={x0 ,... , xn }S f ,=∑k=0

n−1

supr R f ∣[ xk , x k1]xk1−x k

D: Darboux féle alsó (felső) integrál. Legyen ∈ ,∀∈ : s f ,≤S f ,⇒supr s f , ≤inf S f ,

I * f :=supr s f ,≤inf S f ,=: I* f

D: Legyen f : [a ,b]ℝ korlátos függvény, ekkor azt mondjuk, hogy f Riemann integrá lható , ha I * f =I * f

D: Riemann közelítő összeg. Legyen f : [a , b]ℝ korlátos függvény, ∈[ a , b ]={x0 , ... , x n}xk≤k≤xk1 ekkor

R f , ,=∑k=0

n−1

f k xk1− xk

A továbbiakban tehát csak Riemann integrálható függvényekkel foglalkozunk. Az integrálhatósági feltételekkel kapcsolatos ismereteket a továbbiakban feltételezem. Bővebben ezekről [5] ben lehet olvasni. A lényeg tehát, hogy Riemann integrálható függvények esetében az alsó, felső és Riemann közelítő összeg – ha a felosztás finomsága (azaz a halmaz számossága) egyre nagyobb – a határozott integrál értékét egyre jobban közelíti. Fontos megjegyezni, hogy a numerikus módszereknek nem célja a primitív függvény megtalálása, és ez a legnagyobb előnye is egyben, ugyanis a primitív függvény megkeresése még tapasztalt matematikusok, sőt még programoknak sem mindig triviális. A numerikus módszerek lényege, hogy az integrál értéke tetszőlegesen megközelíthető legyen, és az elkövetett hibára is tudjon becslést adni.Végül pedig következzen a tétel, amelyik a határozott és a határozatlan integrál között teremti meg a kapcsolatot.

T: f ∈R[a ,b]∧∃F : F '= f ⇒∫a

b

f =F b−F a

ez a tétel az interpolációs módszernél bír igen nagy jelentőséggel.

6

2 Felhasznált módszerek

A most következő módszerek közös vonása, hogy a függvényről csak az osztópontok és az osztópontokhoz tartozó függvényértékek ismeretét tételezi fel, más szóval ezek a módszerek olyan algoritmusok vagy ha tetszik függvények, melyek ℝ

2xnℝ típusúak.

2.1. A Hermite (Lagrange) interpolációs módszer

Ez a módszer azon alapszik, hogy az integrálandó függvény helyett a függvény interpolációs polinomját határozza meg, majd ennek a polinomnak a primitív függvényét kiszámítva határozza meg a függvény határozott integrálját. Ehhez lássuk a következő definíciót:

D: legyen x0 ,... , xn az [a , b] intervallum egyenletes felosztása. Ekkor azt mondjuk, hogy p∈I [ x ] az f :ℝℝ függvény interpolációs polinomja, ha ∀ i : px i= f x i∀ x i helyen.

Egy ilyen polinom azért előnyös számunkra, mert egyrészt „jól” közelíti az eredeti függvényt (ez nyílván függ az intervallum felosztásának finomságától és a függvénytől), másrészt könnyű integrálni, ugyanis két alapvető integrálási szabályt kell csak alkalmaznunk.

D: ∫ xn= xn1

n1ami elég triviális, továbbá igaz a következő állítás:

T: ∫a

b

f g =∫a

b

f ∫a

b

g , ami annyit jelent, hogy összeget szabad

tagonként integrálni.

Az interpolációs polinomot osztott differenciák kiszámításával határozzuk meg, ezért legelőször is lássuk az osztott differencia definícióját.

D: f [ x , x ]:=lim x yf y − f x

y−x= f ' x , ez az úgynevezett elsőrendű

osztott differencia.

7

Ebből a definícióból következik a kadrendű osztott differencia definíciója:

D: f [ x , ... , x ]:= fk xk !

Most már minden ismeretünk megvan az interpolációs polinom előállításához, lássuk tehát a módszert:

Az osztott differencia táblázat felépítése:

• Minden alappontot annyiszor veszünk fel egymás után, amennyi a multiplicitása, pl. x i t mi1 szer egymás után.

• Beírjuk az f x i értékeket és a megfelelő f j xi

j !értékeket az

x i alappontra támaszkodó j−1 edrendű osztott differenciák helyére ( f j x i ismeretében)

• A táblázat többi részét az osztott differencia fogalom definíciója alapján töltjük ki.

• Az interpolációs polinom felírása a táblázatból a szokásos módon történik, a táblázat átlójában szereplő elemek, mint együtthatók segítségével.

Itt megjegyezzük, hogy ha csak a függvényértékek ismertek, az első illetve magasabb rendű deriváltak viszont nem, a Lagrange interpolációs polinomot kapjuk eredményül. Mivel a program csak egy formulát kap bemenetként, a deriváltak előállítását formálisan illetve numerikusan – nem valósítottam meg. A módszer érdekessége és egyben hiányossága az úgynevezett Runge anomália, amit az alábbi példa is szemléltet:

8

Illustration 1: Runge anomália

A piros vonal jelöli az interpolált függvényt, a kék jelöli az ötödfokú interpolációs polinomot, a zöld pedig a kilencedfokú interpolációs polinomot. Az interpolációs pontokban az elkövetett hiba definícióból adódóan 0, viszont két interpolációs pont között a kilencedfokú polinomnál nagyobb mint az ötödfokúnál, ami enyhén szólva nem várt eredmény (lásd a függvényértékeket az intervallum két végpontjához közeli helyeken). Más szóval ez azt jelenti, hogy a többi módszerrel ellentétben a Hermite interpolációs módban az osztópontok számának növelése – a függvény tulajdonságaitól függően egy bizonyos határ felett nem növeli (akár csökkentheti) az integrál értékének pontosságát.

9

Illustration 2: Hermite interpoláció

Fent látható egy példafuttatása a programnak. A sin(x) függvényt integráljuk 0tól 7ig 4 osztóponttal. A piros vonal jelöli az integrálandó függvényt, a zöld pedig az interpolációs polinomot. A bal alsó sarokban látható a maximális eltérés az integrálandó függvény és az interpolációs polinom között.

2.2. A NewtonCotes módszer

Először is lássunk néhány szükséges definíciót:

D: Legyen f : [a , b]ℝ korlátos és w : [a ,b]ℝ+ súlyfüggvény. Az

∫a

b

fw integrál kiszámításához közelítsük f et a

P x =∑i=0

n

f x i li x∈P [ x ]n−1 interpolációs polinommal,

ahol x0, ... , x n természetesen az alappontokat l ix az i. Lagrange

interpolációs polinomot jelöli.

Ekkor ∫a

b

fw≈∫a

b

Pw=∑i=1

n

f x i∫a

b

l i w=∑i=1

n

c i f x i

D: ∫a

b

fw közelítésére felírt formulát interpolációs típusúnak

nevezzük, ha c i=∫a

b

l i w

Ezeket a kvadratúra formulákat akkor nevezzük NewtonCotes formuláknak, ha a w≡1 . Az itt bemutatott módszer lényege tehát a Hermitehez képest, hogy nem az egész intervallumon interpolálunk, hanem csak az egyes osztópontok között. Ezekre a részintervallumokra számítjuk ki az interpolációs polinom integrálját, majd a végén ezeket összegezzük. Megjegyezzük, hogy a kompozit Simpson és a kompozit trapéz módszer illetve egyéb módszerek a NewtonCotes formula speciális esetei.

10

2.3. A kompozit Simpson módszer

A kompozit Simpson módszer a NewtonCotes speciális esete, azaz egy másodfokú Lagrange interpolációs polinommal közelítjük a részintervallumokat. A hozzátartozó levezetés nélkül a következő formula a végeredmény:

∫a

b

f x dx≈h3[ f x04∑

k=1

n/2

f x2k−12∑k=1

n/2

f x2k f xn]

11

Illustration 3: A NewtonCotes módszer a programban

2.4. A kompozit trapéz módszer

A kompozit Simpsonhoz hasonlóan a kompozit trapéz formula elsőfokú Lagrange interpolációs polinomot használ a részintervallumok közelítésére. A levezetett formula a következőképpen néz ki:

∫a

b

f x dx≈h2[ f x0∑

k=1

n−1

f xk f x n]

12

Illustration 5: A kompozit trapéz módszer a programban

Illustration 4: A kompozit Simpson módszer a programban

A NewtonCotes formula speciális eseteinek (kompozit Simpson, kompozit trapéz) kétségtelen előnye, hogy alacsony fokszámú polinomokat használva az integrál kiszámítása gyors és nem megy az eredmény pontosságának rovására. Erről a felhasználó az osztópontok növelésével győződhet meg.

Figyelem: a Hermite módszer 20nál több osztópontra nem ajánlott, ugyanis nagyon hosszú ideig eltarthat az interpolációs polinom előállítása.

3 A program használata

3.1. Telepítés

A programot először is telepíteni kell. A telepítéshez illetve futtatáshoz a java 1.6 os futási környezete szükséges, ez alatti verziókkal nem működik. A programot két disztribúcióban lehet letölteni, az egyik standalone, ami csak a intg.jar tömörített java állományt tartalmazza, a második egy futási környezetet is tartalmazó zip intg.zip fájl. A standalone disztribúciót (integr.jar) egyszerűen bemásoljuk egy általunk létrehozott könyvtárba és a java jar intg.jar paranccsal futtathatjuk is. A intg.zip fájlt szintén nagyon egyszerű telepíteni, csak egy általunk létrehozott könyvtárba ki kell csomagolni, és a integr.bat (Windows) illetve az integr.sh (Linux/Unix) szkriptekkel indíthatjuk a programot.

3.2. Felhasználói felület (GUI)

Miután a programot telepítettük, futtatáskor a következő felületet láthatjuk:

• az f(x) inputmezőbe az integrálandó függvény formuláját kell beírni

a függvény egy a fejlesztői dokumentációban megadott szintaktikát kell kielégítenie

• a from inputmezőbe az intervallum alsó határát kell beírni

• a to inputmezőbe az intervallum felső határát kell megadni

• a nop (number of points) mezőbe pedig az osztópontok számát kell megadni

• a result kiviteli mező tartalmazza az adott paraméterekkel kiszámított integrál értékét

13

3.3. Megjegyzések, tanácsok a használathoz, hibajelzések

• Mielőtt sok osztópontra ráengednénk a programot próbáljuk ki 1020 osztóponttal, hogy mennyire kielégítő az eredmény. Ez a Simpson és a trapéz módszerre nem vonatkozik.

• A program nem ellenőrzi, hogy a megadott függvény integrálhatóe vagy sem, ez nemkívánatos eredményekhez vezethet.

• Általában nem ajánlott a Hermite módszert sok (>20) osztópontra alkalmazni, ugyanis ez nagyon sok számítást és hosszú futási időt eredményezhet.

• Ha már több mint egy formulát adtunk meg inputként, akkor a fel (↑) le(↓) gombokkal váltogathatunk az előzőleg megadott inputok között. A lista végéről közvetlenül a lista elejére ugrunk. A program bezárásával a fent említett lista elveszik.

14

Fejlesztői dokumentáció

15

1 A probléma részletes specifikációja

A program képes egy a megadott grammatikának megfelelő egyváltozós valós függvényt integrálni négy különböző numerikus módszerrel. Ehhez biztosít egy kényelmes, intuitív felhasználói felületet, ahol a függvény grafikus megjelenítésén kívül látható a számítás aktuális állapota százalékosan, az integrálási határok illetve az osztópontok száma. A program platformfüggetlen, azaz operációs rendszertől és hardvertől egyaránt független (illetve minden olyan rendszeren használható, ahol a java virtuális gép futtatható).

2 Felhasznált módszerek

A program fejlesztési alapját UML modell szolgáltatta. A programot Eclipse (Europa) fejlesztőkörnyezetben készítettem, UML pluginként az Omondo által biztosított ingyenesen hozzáférhető bővítést telepítettem. A program a java által biztosított adatszerkezeteken kívül sajátot nem használ. Algoritmusokban a Hermite interpoláció jelentette a legnagyobb kihívást. Itt a numerikus analízisben elterjedt osztott differenciás módszert használtam egy alsó háromszög mátrix kitöltésére, melyben az osztott differenciák értékeit tárolom rendre.

3 A program logikai szerkezete

A programot az MVC ( Modell – View – Controller ) filozófiájának megfelelően strukturáltam, azzal a céllal, hogy legyen egy önállóan futtatható alkalmazás, másrészt legyen egy újra felhasználható része, amit kívülről is lehet használni. A Modell számítja az input alapján az output adatokat itt elsősorban az integrálási módszerekre kell gondolni , de külön használható a Hermite interpolációs osztály, a Polynom osztály és a Parser osztály is, ezek bővebb magyarázatához lásd az API dokumentációt. A View alatt természetesen a GUIt – felhasználói felületet – kell érteni. Ezt a Netbeans fejlesztőkörnyezettel terveztem, ugyanis az Eclipse tökéletes kódszerkesztése és egyéb kiváló funkciói ellenére nagy hiányossága, hogy nem tartalmaz egy integrált GUIdesignert. A felhasználói felületet a felhasználói dokumentációban részletesebben kifejtem. A Controller hivatott a View és a Modell közötti kapcsolatot megteremteni, ő vezérli a programfutást, továbbítja az inputot a felületről a Parsernak, a Parsertől visszajövő adatokat pedig továbbítja a GUIn kiválaszott integrálási módszernek. Az alábbi két képen lehet látni az osztályok tartalmazási viszonyait, ami nagyon szemléletesen ábrázolja a program logikai struktúráját.

16

3.1 Asszociációs diagram (Association diagram)

17

3.2 Osztálydiagram (class diagram)

19

3.3 A Parser

A Parsert a javacc (java compiler compiler 4.0) programmal készítettem. Ez a csomag https://javacc.dev.java.net/ oldalról tölthető le példakódokkal, grammatikákkal, ill. minden ami egy java nyelven írt parserhez szükséges. A program által leírt grammatika a következőképpen néz ki (kékkel a parser generáló inputját jelöltem, minden rész alatt megtalálható a hozzá tartozó magyarázat):

options { LOOKAHEAD = 1; CHOICE_AMBIGUITY_CHECK = 2; OTHER_AMBIGUITY_CHECK = 1; STATIC = true; DEBUG_PARSER = false; DEBUG_LOOKAHEAD = false; DEBUG_TOKEN_MANAGER = false; ERROR_REPORTING = true; JAVA_UNICODE_ESCAPE = false; UNICODE_INPUT = false; IGNORE_CASE = false; USER_TOKEN_MANAGER = false; USER_CHAR_STREAM = false; BUILD_PARSER = true; BUILD_TOKEN_MANAGER = true; SANITY_CHECK = true; FORCE_LA_CHECK = false;}

Ezek a javacc oldalán ajánlott alapértelmezett beállítások. Az egyedüli amit ezen változtattam, hogy a parserem statikus, azaz csak egy példány létezik belőle a futás során.

PARSER_BEGIN(Parser)

package numeric_integration;

public class Parser {

public static String variableId = "x";// **********************************************************

20

https://javacc.dev.java.net/

// ** The code below is generated ********************************// **********************************************************}PARSER_END(Parser)

Fent a parser formális definíciója látható, ebből lesz a Parser osztály java kódjának nem generált része.

SKIP : /* WHITE SPACE */{ " " | "\t" | "\f" }

A megengedett elválasztó elemek.

TOKEN:{ }

Az bemenetkén szolgáló formulát lezáró elemek.

TOKEN:{ }

TOKEN:{ }TOKEN:{ }TOKEN:{ }

TOKEN : /* OPEN_PAR */{ }

TOKEN : /* CLOSE_PAR */{ }

TOKEN : /* VARIABLE */{ }

/* OPERATORS */

21

TOKEN:{ }TOKEN:{ }TOKEN:{ }TOKEN:{ }TOKEN:{ }

Fent található a nyelvben megengedett elválasztó elemek (space, tab, newline), számok (egész és tizedes), a zárójelek, a változók, valamint a műveleti jelek definíciója.

/* ELEMENTARY FUNCTIONS */TOKEN:{ }TOKEN:{ }TOKEN:{ }TOKEN:{ }TOKEN:{ }TOKEN:{ }TOKEN:{ }TOKEN:{ }

Itt a felhasználható függvényeket soroltam fel, ha a fejlesztő további függvényeket szeretne definiálni először is ide kellene felvenni az új függvény nevét.

Az alábbiakban jön a nyelvtan definíciója. Itt fontos kiemelni, hogy az operátorok precedenciájának megfelelően kerül parsolva a kifejezés. Ezt bővítésnél is figyelembe kell venni. A parsolással egy időben a kifejezés is kiértékelésre kerül.

// Start of the GRAMMAR

double eval() throws NumberFormatException :{ double previousValue;}{ ( previousValue = Expression() { return previousValue; } )* }

double Expression() throws NumberFormatException :{ double i, value;

22

}{ value = addTerm() ( i = addTerm() { value += i; } | i = addTerm() { value = i; } )* { return value; } }

double addTerm() throws NumberFormatException :{ double i, value;}{ value = mulTerm() ( i = mulTerm() { value *= i; } | i = mulTerm() { value /= i; } )* { return value; }}

double mulTerm() throws NumberFormatException :{ double value, p;}{ value = Primary() ( p = Primary() { value = java.lang.Math.pow(value, p); } )* { return value; }}

double Primary() throws NumberFormatException :{ Token t; double d;}{ t = { return Double.parseDouble(t.image); } | d = Expression() { return d; } | d = Primary()

23

{ return d; } | d = Expression() { return java.lang.Math.sin(d); } | d = Expression() { return java.lang.Math.cos(d); } | d = Expression() { return java.lang.Math.tan(d); } | d = Expression() { return 1/java.lang.Math.tan(d); } | d = Expression() { return java.lang.Math.exp(d); } | d = Expression() { return java.lang.Math.log(d); } | d = Expression() { return 0.5*(java.lang.Math.exp(d) java.lang.Math.exp(d)); } | d = Expression() { return 0.5*(java.lang.Math.exp(d) + java.lang.Math.exp(d)); } }

24

A fent leírtakból könnyen látható, hogyan kell további függvényekkel bővíteni a grammatikát, illetve a meglévőket hogyan lehet módosítani például úgy, hogy működjön a java nyelv BigDecimal (tetszőlegesen hosszú decimális számok) osztályával. Külön ki kell emelni, hogy maga a parser nem támogatja a változók kiértékelését, csak a szintaktikus ellenőrzést, a változók kiértékelésének menetét későbbiekben fejtem ki a ParserController osztálynál. A parser generálását a következő parancs végzi: javacc Parser.jj . Ez a következő osztályokat generálja:

• ParseException.java

• Parser.java

• ParserConstants.java

• ParserTokenManager.java

• SimpleCharStream.java

• Token.java

• TokenMgrError.java

25

4 API dokumentáció

4.1 ComponentControllerEz az osztály hivatott az MVC tervmintában a Controller szerepét megvalósítani. Ez az osztály biztosítja a kapcsolatot a View és a Modell között.

• public void execute()

Lekérdezi a parsolt értékeket, majd egy külön szálon elindítja a számítást. A számítás kezdetével a „Start” gomb deaktiválódik, aminek eredményeképpen újabb számítás nem indítható.

• public double[][] getParsedValues()

Visszaadja a Parser által parsolt értékeket egy kétdimenziós dupla pontosságú tömbben. A tömb hossza természetesen az osztópontok számával egyezik meg, ezek száma a Limit osztályban találhatók meg.

• public void initMethod(PropertyChangeListener Listener, JProgressBar p, MethodUser u)

Inicializálja a ComponentController osztályt, minden számítás megkezdése előtt lefut, a Progressbar példányát átadja a kiválasztott számítási objektumnak (numerikus módszernek), a PropertyChangeListener egy figyelő, mely a progressbar tulajdonságainak változását figyeli.

• public void parseInput() throws ParseException

A System.in Objektumból tud olvasott formulát adja tovább a Parsernak. Hibás kifejezés esetén ParseException hibát vált ki.

• public void parseInput(String input) throws ParseException

A felületen megadott formulát adja tovább a Parsernek. Hibás kifejezés esetén ParseException hibát vált ki.

• public void selectMethod(String method)

A felületen kiválasztott módszert állítja be aktuális számítási módszernek, a számítási módszereknek az IntegrationMethod interfacet kell implementálniuk. Valójában itt egy pointer állítódik az adott numerikus módszert megvalósító osztály egy példányára.

4.2 ContextFactory

A BigDecimal osztály műveleteihez biztosítja a számítás pontosságát leíró kontextust.

• public static final MathContext getContext()

A számításokhoz használt BigDecimal osztály pontosságát

26

reprezentáló MathContext objektumokat gyárt, ez egy gyártó tervminta. A MathContext keretfeltételeit a Limit osztály tartja nyílván.

• public static final int getPrecision()

A MathContext objektum beállított pontosságát lehet ezzel a függvénnyel lekérdezni.

• public static final void setPrecision(int p)

A MathContext objektum pontosságát lehet ezzel a függvénnyel beállítani.

• private ContextFactory()

Mivel ez az osztály csak statikus függvényeket tartalmaz, az explicit példányosítást megakadályozzuk.

4.3 DrawArea

A rajzolófelület és a hozzátartozó objektumok reprezentáló osztálya.• public void addCoordinates(double[][] coordinates)

A rajzolófelületre kirajzolni kívánt koordinátákat lehet ezzel a függvénnyel az objektumba regisztrálni, a koordináták egy vektor típusú adatszerkezetben vannak tárolva. A rajzolófüggvény ezeknek a koordinátáknak a transzformált értékeit rajzolja ki a Canvasra.

• public void clear()

Az összes eddig tárolt koordinátát töröljük ezzel a hívással.

• public void drawCoordinateSystem(Graphics g)

A koordináta rendszert rajzolja meg, kiszámítja a függvény maximumából minimumából valamint az integrálási határokból, hogy milyen értékek jelenjenek meg a koordináta rendszerben.

• private double[] findMinMax(double[][] coordinates)

Megkeresi az eddig tárolt összes koordináta minimumát és maximumát, ezeket abszolút maximumnak illetve abszolút minimumnak nevezzük.

• public Dimension init()

Inicializálja a rajzolófelület (Canvas) koordinátáit és méretét.

• private int iX(double x)

Koordinátatranszformációt végez a fizikai és logikai koordináták között.

• private int iY(double x)

Koordinátatranszformációt végez a fizikai és logikai koordináták között.

• public double maxDeviation()

A Hermite interpoláció esetén a legnagyobb eltérést mutatja az interpolációs polinom és a függvény között, a tárolt koordinátákból számol, tehát nem feltétlenül a ténylegesen elkövetett hibát jeleníti meg.

27

• public void paint(Graphics g)

A java framework által felhívott paint függvényt terheli túl (overloading), a kirajzolást végzi. A paraméterként kapott Graphics objektum képes a rajzolófelület megfelelő módosítására.

4.4 Hermite

A Hermite interpolációt megvalósító osztály.• public Hermite()

Inicializálja az objektumot.

• public void addInput(Vector newinputData)

Új alappont függvényértékpárokat ad az objektumhoz, ekkor egyszerű Lagrange interpolációról beszélünk. Általánosabb esetben magasabbrendű deriváltakat is meg lehet itt adni. A szakdolgozat keretein belül ezt a szolgáltatást nem használtam ki, ugyanis a függvény deriváltjait előállítani nem triviális feladat.

• public void clearInput()

Inicializálja a Hermite osztály bemenő adatait.

• public Object countHermite()

Előállítja az interpolációs polinomot, teszi mindezt egy külön szálon. A numerikus módszereket megvalósító osztályok a Swingworker java osztályból származnak, így további módosítások nélkül külön szálon futtathatók.

• public Object doInBackground()

A Swingworker osztály felüldefiniált függvénye, a szál indítását követően hívódik meg. A countHermite függvényt hívja.

• public void done()

A szál befejeztével – azaz a számítás végén – hívódik meg és az őt tartalmazó objektumnak visszaadja az eredményt.

• private BigDecimal fact(long n)

Kiszámítja n faktoriálisát.

• private int findIndex(BigDecimal d)

Megkeresi egy adott osztott diferencia indexét az őt reprezentáló vektorban.

• public void printResult()

Ezzel lehet beállítani, hogy az eredményt a Hermite osztály adja vissza a számítás végén, vagy egy külső objektum kérdezi le.

• public void setInputData(double[][] input)

Az addInput lebutított változata.

• public void suppressResult()

Ezzel lehet beállítani, hogy az eredményt a Hermite osztály adja vissza a számítás végén vagy egy külső objektum kérdezi

28

le.

4.5 IntegrationMethod

Minden integrálási módszer ebből az osztályból származik.• public void clearResult()

Az eredményt törli.


Alapértelmezésben ez fut le a számítás végén, kivéve ha a származtatott osztály felüldefiniálja.

• public void setInputData(double[][] input)

Beállítja a numerikus módszer bemenő adatait.

• public void setProgress(JProgressBar p)

Regisztrálja a GUIn levő progressbar példányát.

• public void setUser(MethodUser u)

A módszer felhasználóját regisztrálja.

4.6 Limit

A számítás keretfeltételeit ( az intervallum két határa, az osztópontok száma ) nyílvántartó osztály. A lépésközt is ez az osztály számítja.

• public static double evalStep()

Kiszámítja az integrálási határok és az osztópontok alapján, hogy mekkora legyen a lépésköz, értéke dupla pontosságú lehet.

• public static double getLowerLimit()

Az integrálási intervallum alsó végpontját adja vissza a számításokhoz.

• public static int getNumberOfPoints()

Megadja az osztópontok számát.

• public static double getUpperLimit()

Az integrálási intervallum felső végpontját adja vissza a számításokhoz.

• public static void setLowerLimit(double low)

Beállítja az integrálási intervallum alsó végpontját.

• public static void setNumberOfPoints(int numPoints)

Beállítja az osztópontok számát.

• public static void setUpperLimit(double high)

Beállítja az integrálási intervallum felső végpontját.

4.7 MainWindow

Az MVC tervmintában szereplő View objektumot hivatott reprezentálni, ez a

29

program fő belépési pontja. Ez az osztály kezeli a GUIn kiváltott eseményeket.• public static void main(String args[])

A belépési pontja a programnak.

• public MainWindow()

A konstruktor. Meghívja az initComponents függvényt.

• public void count()

A „Start” gomb megnyomásakor hívódik meg, ez a függvény triggereli a számításokhoz szükséges akciókat.

• public void enableStart()

A „Start” gombot teszi újra klikkelhetővé.

• private int findInput(String input)

Az input történetben megkeresi egy adott input indexét az azt tároló vektorban.

• private void initComponents()

A képernyőn levő komponenseket inicializálja.

• private void jInputStringKeyPressed(java.awt.event.KeyEvent evt)

Akkor hajtódik végre, ha az inputmezőben van a kurzor és a felhasználó megnyom egy gombot, a fel le billentyűkre reagál, ez lépteti az input történetet fel illetve le.

• private void jStartActionPerformed(java.awt.event.ActionEvent evt)

Amikor a felhasználó erre a gombra kattint, ez a függvény hívódik fel, ellenőrzi hogy minden szükséges input meg lette adva, és felhívja a count függvényt.

• public void prePaint()

A rajzolási feladatok előtt kell felhívni, inicializáló függvény.

• public void propertyChange(PropertyChangeEvent evt)

A progressbaron történt változásokat hivatott a képernyőre frissíteni.

• public void retrieveInput() throws NumberFormatException

Az inputként megadott számokat olvassa be és parsolja tényleges számokká. Ha valamelyik nem sikerül NumberFormatException kivételt dob.

• public void setResult(BigDecimal result)

Az integrálási módszerek ezt a függvényt hívják meg a számítás végén. Ezzel állítják be a felhasználó objektumnak a számítás számszerű eredményét.

• public void setResult(Polynom p)

Az integrálási módszerek ezt a függvényt hívják meg a számítás végén. Ezzel állítják be a felhasználó objektumnak a számítás polinom eredményét.

30

4.8 MethodList

Ez az interface a felhasználható integrálási módszereket sorolja fel, konstansokat tartalmaz.

4.9 MethodUser

Ezt az interfacet kell minden olyan osztálynak implementálnia, ami az integrálási módszereket használni szeretné.


Ez a függvény hívódik meg a módszer végén, újra klikkelhetővé teszi a „Start” gombot.

• public void setResult(BigDecimal result)

Az integrál numerikus értékét állítja be.


Az eredménypolinomot állítja be a numerikus módszert felhasználó osztálynál.

4.10 NewtonCotes

Ez az osztály valósítja meg a NewtonCotes numerikus integráló módszert.• public Object doInBackground()

Ez a függvény végzi a tényleges számításokat, a progressbar állapotát változtatja. Ezután hívódik meg a done() függvény, az IntegrationMethodtól örökölt függvénye.


A doInBackground() után hívódik meg, azaz közvetlenül a munkaszál terminálása előtt. Beállítja az őt tartalmazó objektum eredményeit reprezentáló objektumait.


Üres implementáció.

• public void setResult(BigDecimal d)

Részeredményeket tart nyílván a végeredményt a done() függvény állítja be.


Üres implementáció.

4.11 ParserController

Ez az osztály hivatott egy plusz réteget megvalósítani a ComponentController és a Parser osztály közé. Erre azért van szükség, mert a Parser osztály egy generált osztály korlátozott módosítási lehetőségekkel.

• public static double[][] getParsedValues()

31

A Parser által parsolt értékeket adja vissza két dimenziós dupla pontosságú tömbben.

• public static void parseInput(byte[] input) throws ParseException

Bytetömbben érkező inputot dolgozza fel és adja tovább a Parser objektumnak. A változó(k) helyettesítése is ebben a függvényben történik. Lekérdezi a Limit osztályból a keretfeltételeket és a megfelelő értékkel helyettesíti a parsolni kívánt kifejezésben a változókat, majd így adja tovább a Parsernak, ezzel lényegében csupa konstansokból álló kifejezések parsolására szűkíti a parser feladatkörét.

• public static void parseInput(String input) throws ParseException

A Stringként érkező inputot dolgozza fel és adja tovább a Parser objektumnak. A változó(k) helyettesítése is ebben a függvényben történik. Lekérdezi a Limit osztályból a keretfeltételeket és a megfelelő értékkel helyettesíti a parsolni kívánt kifejezésben a változókat, majd így adja tovább a Parsernak, ezzel lényegében csupa konstansokból álló kifejezések parsolására szűkíti a parser feladatkörét.

4.12 Pmember

Ezt az osztályt a Polinom osztály használja fel, a Polinom együtthatóit és kitevőit reprezentálja.

• public Pmember add(Pmember p)

Két Pmember objektumot tud összeadni, az eredmény egy új Pmember objektumba kerül.

• public BigDecimal getCoefficient()

Lekérdezi egy Pmember objektum együtthatóját.

• public int getExponent()

Lekérdezi egy Pmember objektum kitevőjét.

• public Pmember multiply(BigDecimal d)

Egy Pmember típusú objektumot tud összeszorozni egy BigDecimal típusú objektummal. Az eredmény egy új Pmember objektumba kerül.

• public Pmember multiply(Pmember p)

Egy Pmember típusú objektumot tud összeszorozni egy Pmember típusú objektummal. Az eredmény egy új Pmember objektumba kerül.

• public Pmember negate()

Egy Pmember típusú objektum negáltját adja vissza egy új Pmember típusú objektumban.

• public void setCoefficient(BigDecimal d)

Egy Pmember típusú objektum együtthatóját lehet beállítani ezzel a függvénnyel.

32

• public void setCoefficient(long n)

Egy Pmember típusú objektum együtthatóját lehet beállítani ezzel a függvénnyel.

• public void setExponent(int n)

Egy Pmember típusú objektum kitevőjét lehet beállítani ezzel a függvénnyel.

• public void setPmember(Pmember p)

Egy Pmember típusú objektumot lehet ezzel a függvénnyel beállítani.

• public Pmember subtract(Pmember p)

Két Pmember objektumot tud kivonni, az eredmény egy új Pmember objektumba kerül.

• public String toString()

Egy Pmember objektumot tud String típussá konvertálni.

4.13 Polynom

Ez az osztály a programban levő polinomokat reprezentálja.• public Polynom(Vector v)

Egy Polinomot hoz létre az argumentumként megadott vektorral.

• public void add(Pmember m)

Egy polinomhoz ad hozzá egy Pmember típusú objektumot. Az eredmény a meglévő példányba kerül tárolásra.

• public void add(Polynom q)

Két polinomot ad össze. Az eredmény a meglévő példányba kerül.

• public void clear()

Inicializálja a polinomot. Az eredmény nullpolinom.

• public BigDecimal evalAt(BigDecimal x)

Kiértékeli a polinomot egy adott (valós) helyen.

• public BigDecimal evalAt(double x)

Kiértékeli a polinomot egy adott helyen.

• public int findByExp(int exp)

Megkeresi egy adott kitevőjű együttható indexét.

• public double[][] getCoordinates()

A Limit osztály által visszaadott keretfeltételek alapján kiértékeli a polinomot különböző alappontokban, majd az eredményt egy kétdimenziós dupla pontosságú tömbben adja vissza.

• public int getDeg()

Visszaadja a polinom fokszámát.

• public Pmember getMember(int num)

Egy adott indexű polinomtagot ad vissza, ha létezik ilyen.

33

• public int getSize()

Lekérdezi a polinomtagok számát.

• public Vector getVector()

A polinomot reprezentáló vektor másolatát adja vissza. Copy konstruktorként lehet használni.

• public BigDecimal integrate(double from, double to)

Adott intervallumon kiszámítja a polinom határozott integrálját.

• public boolean isnullPol()

Lekérdezi hogy a polinom nullpolinom e.

• public Polynom multiply(BigDecimal d)

Megszorozza a polinomot egy BigDecimal számmal. Az eredmény egy új példányba kerül.

• public Polynom multiply(Pmember m)

Megszorozza a polinomot egy Pmember polinomtaggal. Az eredmény egy új példányba kerül.

• public Polynom multiply(Polynom q)

Két polinomot szoroz össze. Az eredmény egy új példányba kerül. A szorzás módszere „minden tagot minden taggal”. Ennél hatékonyabb algoritmusok is léteznek, sajnos a különbség csak nagyon magas fokszámú (~1000) polinomoknál érezhető.

• public void negate()

Egy polinom negáltját adja vissza (minden tag negáltját).

• public Polynom pow(int n)

Egy polinom hatványát adja vissza. Az eredmény egy új példányba kerül, csak egész kitevővel működik.

• public void setMember(BigDecimal d, int exp)

A polinom egy adott kitevőjű és együtthatójú tagját állítja be. Ha volt már ilyen tag, akkor felülírja, ha nem akkor létrehozza.

• public void setMember(Pmember newVal)

A polinom egy adott kitevőjű és együtthatójú tagját állítja be. Ha volt már ilyen tag, akkor felülírja, ha nem akkor létrehozza.

• public final void setVector(Vector v)

A polinomot reprezentáló vektor felülírása egy új vektorral.

• public void subtract(Polynom q)

Két polinomot von ki egymásból. Az eredmény egy új polinomba kerül.

• public String toString()

Ez a függvény String típusúvá konvertálja a polinomot.

34

4.14 Simpson

Ez az osztály a kompozit Simpson módszert implementálja.• public Object doInBackground()

Ez a felüldefiniált függvény a Simpson formulát alkalmazza az osztópontok közti részekre, majd az ezekből keletkező részeredményeket összegzi.

4.15 Trapezium

Ez az osztály a kompozit trapéz módszert implementálja.• public Object doInBackground()

Ez a felüldefiniált függvény a trapéz formulát alkalmazza az osztópontok közti részekre, majd az ezekből keletkező részeredményeket összegzi.

5 Tesztelési terv, tesztelés eredmények

Alapvetően két részre lehet osztani a tesztelési tervet:

• hibakezelés

• a helyes input adatok mellett a számításra igénybe vett idő, és számítás helyességének ellenőrzése

5.1 Hibakezelés

Itt elsősorban a hibásan megadott formulákkal teszteltem, az egészen egyszerű kifejezések hibás megadását, mint például olyan kifejezések hogy sin(0.0 , sin(3.0)^2, illegális karakterek, mint sin(@), helytelen zárójelezést sin(cos(x) vagy sin(). Az integrálási intervallum is ellenőrzött, tehát a bal végpont határozottan kisebb kell, hogy legyen, mint a jobb oldali végpont, valamint az osztópontok száma pozitív egész kell, hogy legyen.

5.2 Helyes input melletti tesztek

Minden inputot az összes lehetséges (négy) numerikus módszerre leteszteltem. Először az elemi függvényekkel ellenőriztem 1től 2ig; 10, 15, 20, 25, 30 osztóponttal, majd ezeket egyre bonyolultabb függvényekké komponáltam. Ezeket 0tól 5ig integráltam a Hermite és a NewtonCotesnál 30 a kompozit Simpson és kompozit trapéz módszernél 100 osztópontot választottam. Minden egyes futást követően a Mapple 9.0 verziójával ellenőriztem le az eredményt, melyek kivétel nélkül kielégítőek voltak. Egyedül a Hermite interpolációnál merült fel az a probléma, hogy „sok” (30) osztópontnál nagyon sokáig számol a program, és az eredmény sem kielégítő.

35

36

Expression Method NoP Calculated by intg Calculated by Maple

sin(x)

Hermite

10 0.956449142415277453466160295647569000720977783203125

0,9564491424

15 0.9564491424152814502690489462111145257949829101562520 0.95644914244619405607750195486005395650863647460937525 0.95626455683668609708547592163085937530 282.7628004550933837890625

NewtonCotes

10 0.9576433910217354572580461535835638642311096191406250015 0.9584877477435334025557267523254267871379852294921875020 0.9584440135007036287717596678703557699918746948242187525 0.9582686297766791483354609226807951927185058593750000030 0.95808957186556564789015055794152431190013885498046875

Composite Simpson

10 0.958442759127894755577514729338872712105512619018554687515 0.8991924932164594430616944009670987725257873535156250000020 0.9586437725645900326254533752035058569163084030151367187525 0.9223671069005297262766163157721166498959064483642578125030 0.958178300293691838362963864028643001802265644073486328125

Composite Trapezium

10 0.9576433910217353323579558832534530665725469589233398437515 0.95848774774353432542861597198680101428180932998657226562520 0.95844401350070336509379131939567741937935352325439453125025 0.95826862977667893322974990155671548563987016677856445312530 0.9580895718655628376381194755140313645824790000915527343750

cos(x)

Hermite

10 0.067826442018052102156389082665555179119110107421875

0,0678264402

15 0.0678264420177864257865962827054318040609359741210937520 0.0678264420185122896000962100515607744455337524414062525 0.06780288809204648714512586593627929687530 13.91128051280975341796875

NewtonCotes

10 0.027974657861848939433002669829875230789184570312500015 0.003958251136739754372229072032496333122253417968750020 0.019934988878130610601147054694592952728271484375000025 0.029520487015231244853907810465898364782333374023437530 0.03590970440643082017828646712587215006351470947265625

Composite Simpson

10 0.02799800898553952716724113614077396050561219453811645507812515 0.03370221071607302967126917891960147244390100240707397460937520 0.019939143731895525839953320357267330109607428312301635742187525 0.04689320024939542055648217244723241492465604096651077270507812530 0.035913029994892830404351613537983212154358625411987304687500

Composite Trapezium

10 0.027974657861848654504671740639309973630588501691818237304687515 0.003958251136739811455473453394304783614643383771181106567382812520 0.019934988878131720986802005723959041461057495325803756713867187525 0.029520487015233043165841203547827831243921536952257156372070312530 0.035909704406429994992012988408447426991187967360019683837890625

37


tg(x)

Hermite

10 528.191767215728759765625

Float(undefined)

15 10036.85937520 4616524825 61351691865292830 9,18E+020

NewtonCotes

10 2.512651963766201035355152271222323179244995117187515 0.6040407197232280367416024091653525829315185546875020 0.925942231362899548230416257865726947784423828125025 2.88432933240418876152943994384258985519409179687500030 7.797474532292730131644020730163902044296264648437500

Composite Simpson

10 3.83068790489995331105532727633544709533452987670898437515 0.59721790057073881330396147859573829919099807739257812520 0.159012397010570127875439538911450654268264770507812500025 4.363644650365849114725946833459602203220129013061523437530 5.03764997156968126479359426639348384924232959747314453125

Composite Trapezium

10 2.51265196376621613438828717335127294063568115234375000015 0.604040719723510949323852514680766034871339797973632812520 0.9259422313634234208423734457937825936824083328247070312525 2.8843293324040430863908213154900295194238424301147460937530 7.79747453229284179232472240528295515105128288269042968750

ctg(x)

Hermite

10 0.07752058067892608761439987574703991413116455078125

0,0775207102

15 0.077520710142971793743527086917310953140258789062520 0.0775207101519939101308409590274095535278320312525 0.077509909954642353113740682601928710937530 19.70928227901458740234375

NewtonCotes

10 0.031988895181542575940625283692497760057449340820312515 0.004516456736253671166991807695012539625167846679687520 0.022738722046776738139328699617180973291397094726562525 0.033673708319740924821417138446122407913208007812500030 0.0409670044473853245392547250958159565925598144531250

Composite Simpson

10 0.03192038160197768759118730486079584807157516479492187500015 0.037768450470833405535620030946120095904916524887084960937520 0.022726448165645616369262560496622427308466285467147827148437525 0.052948162675172034171561241677750331291463226079940795898437530 0.04095714603856075879985410015393654248327948153018951416015625

Composite Trapezium

10 0.03198889518154256813436964179686583520378917455673217773437515 0.0045164567362526140698736343281893823586869984865188598632812520 0.0227387220467764547559858662184595345934212673455476760864257812525 0.0336737083197406301352666568860172446875367313623428344726562530 0.040967004447384674343211885538806882323115132749080657958984375

38


e(x)

Hermite

10 4.6707742704728811844461233704350888729095458984375

4.670774270

15 4.67077427047146542804512137081474065780639648437520 4.670774270414574047549649549182504415512084960937525 4.669645836867857724428176879882812530 1379.15270519256591796875

NewtonCotes

10 5.166304841754078891469248446810524910688400268554687515 4.994622310149566146719735115766525268554687500000000020 4.911272914370003350725824020628351718187332153320312525 4.862040352867755599319821158132981508970260620117187530 4.8295378243126994011191754907486028969287872314453125

Composite Simpson

10 5.1620067529907156522739342108252458274364471435546875015 4.48337884379156226266616158682154491543769836425781250020 4.91025015868767295001973138823814224451780319213867187525 4.559839149417787756979336677432002034038305282592773437530 4.8290907276824853178176510937191778793931007385253906250

Composite Trapezium

10 5.16630484175407883595809721555269788950681686401367187515 4.994622310149570615367409232021600473672151565551757812520 4.911272914370000880479594229655049275606870651245117187525 4.8620403528677533788737719078199006617069244384765625000030 4.82953782431269025565701014102160115726292133331298828125

ln(x)

Hermite

10 0.3862943711575272942582159885205328464508056640625

0,3862943611

15 0.38629436112498227728906385891605168581008911132812520 0.3862943610816396144969075976405292749404907226562525 0.38630035412984398135449737310409545898437530 3.9440991468727588653564453125

NewtonCotes

10 0.4528666540200046997100002954539377242326736450195312515 0.4312607459719197677827651205006986856460571289062500020 0.4202451298707269300436450976121705025434494018554687525 0.4135652261775570881496832953416742384433746337890625030 0.40908196516069728065900790170417167246341705322265625

Composite Simpson

10 0.4532265205548674374957940358399355318397283554077148437515 0.38411978611671666883342624032593448646366596221923828125020 0.420341851838401805302458669189036299940198659896850585937525 0.3855047977601885698245576250542399066034704446792602539062530 0.4091260200728225708555196860061187180690467357635498046875

Composite Trapezium

10 0.452866654020004259090237397344935743603855371475219726562515 0.4312607459719202031983575906792793830391019582748413085937520 0.420245129870726969508604176084531900414731353521347045898437525 0.413565226177556912508931352689955929236020892858505249023437530 0.4090819651606959332125479367192610880010761320590972900390625

39


sh(x)

Hermite

10 2.219115056269055141768831163062714040279388427734375

2,2191150560

15 2.21911505626829663739840725611429661512374877929687520 2.219115056709886957264643569942563772201538085937525 2.21910160315746907144784927368164062530 962.2739009857177734375

NewtonCotes

10 2.477857434990038631994480056164320558309555053710937515 2.3884975295975062747899642090487759560346603393554687520 2.3450119934202775517917416436830535531044006347656250025 2.3192922962261474095768676306761335581541061401367187530 2.302298272551417446241117659155861474573612213134765625

Composite Simpson

10 2.4757959903938022705460753059014678001403808593750000015 2.137280158629635412603775534989836160093545913696289062520 2.344523652742976360663362811465049162507057189941406250025 2.1708598737970342257286304743502114433795213699340820312530 2.30208513625621395692899540108555811457335948944091796875

Composite Trapezium

10 2.477857434990039187105992368742590770125389099121093750015 2.3884975295975074266463522576486866455525159835815429687520 2.3450119934202742627560311916568025480955839157104492187525 2.31929229622614756223253351663515786640346050262451171875030 2.302298272551410195096988076102206832729279994964599609375

ch(x)

Hermite

10 2.45165921420382471040966265718452632427215576171875

2,4516592140

15 2.45165921420313681622360491019207984209060668945312520 2.4516592147634881371232040692120790481567382812525 2.451680356391989334952086210250854492187530 1398.53944301605224609375

NewtonCotes

10 2.688447406764038039028719140333123505115509033203125015 2.606124780552061093175097994389943778514862060546875020 2.5662609209497307949376931901497300714254379272460937525 2.542748056641606302363811664690729230642318725585937530 2.52723955176128622923670263844542205333709716796875000

Composite Simpson

10 2.6862107625969134927501613674394320696592330932617187515 2.34609868516192660026220551117148716002702713012695312520 2.565726505944696589356368576773093082010746002197265625025 2.388979275620753406350615932751679793000221252441406250030 2.5270055914262715412998971942215575836598873138427734375

Composite Trapezium

10 2.688447406764039704363256078067934140563011169433593750015 2.6061247805520630360653910884138895198702812194824218750020 2.5662609209497267009902898848849872592836618423461914062525 2.5427480566416058305190261989991995505988597869873046875030 2.527239551761280102193385488362764590419828891754150390625

40


sin(x)^2+cos(x)^2

Hermite 30 4.99999999064949207649988238699734210968017578125

5,0000000000NewtonCotes 30 5.0000000000000020816681711721685132943093776702880859375

Composite Simpson 100 5.00000000000000020816681711721685132943093776702880859375Composite Trapezium 100 5.000000000000000242861286636752993217669427394866943359375

exp(sin(x))^3+cos(x)

Hermite 30 27.62704887747022297617149888537824153900146484375

29,3583389900NewtonCotes 30 29.03835379031390229176423645185423083603382110595703125


ln(x+1)5*x+2*sin(exp(x))

Hermite 30 663050222.4978923797607421875

55,4901715900NewtonCotes 30 58.768341190410339158756158894902910105884075164794921875


sin(sin(sin(sin(x))))

Hermite 30 3.54140489911943490142220980487763881683349609375

0,5733060489NewtonCotes 30 0.44795422918465900574691573865493410266935825347900390625

Composite Simpson 100 0.538818177913745764533171023202839933219365775585174560546875

Irodalomjegyzék[1] Methods of Numerical Integration Philip J. Davis, Philip Rabinowitz 2007 Dover Pubns ISBN 9780486453392

[2] Computer Methods for Mathematical Computations George E. Forsythe, Michael A. Malcolm, Cleve B. Moler 1977 Englewood Cliffs, NJ: PrenticeHall ISBN 0131653326

[3] Numerical Recipes in C William H. Press, Brian P. Flannery 1988 Cambridge, UK: Cambridge University Press ISBN 9780521431088 [4] Introduction to Numerical Analysis Josef Stoer, Roland Bulirsch 1980 New York: SpringerVerlag ISBN 9780387954523

[5] Analízis 1 Leindler Schipp Eötvös kiadó

41

TémabejelentőBevezetésFelhasználói dokumentáció 1 A megoldott probléma1.1. Működés1.2. Szükséges ismeretek

2 Felhasznált módszerek2.1. A Hermite (Lagrange) interpolációs módszer2.2. A Newton-Cotes módszer2.3. A kompozit Simpson módszer 2.4. A kompozit trapéz módszer

3 A program használata3.1. Telepítés3.2. Felhasználói felület (GUI)3.3. Megjegyzések, tanácsok a használathoz, hibajelzések

Fejlesztői dokumentáció1 A probléma részletes specifikációja2 Felhasznált módszerek3 A program logikai szerkezete3.1 Asszociációs diagram (Association diagram)3.2 Osztálydiagram (class diagram)3.3 A Parser

4 API dokumentáció4.1 ComponentController4.2 ContextFactory4.3 DrawArea4.4 Hermite4.5 IntegrationMethod4.6 Limit4.7 MainWindow4.8 MethodList4.9 MethodUser4.10 NewtonCotes4.11 ParserController4.12 Pmember4.13 Polynom4.14 Simpson4.15 Trapezium

5 Tesztelési terv, tesztelés eredmények5.1 Hibakezelés5.2 Helyes input melletti tesztek

numerikus integráló programprog-mat.elte.hu/diplomamunka/szakdolgozat.pdf · 2008. 1. 13. · a...

Documents