Numerikus integráló program

Numerikus integráló program Programozó Matematikus Szak Esti tagozat készítette: Tarnai Tibor témavezető: Virágh Gábor

Budapest, 2008

  Témabejelentő

Tartalomjegyzék Té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 Newton­Cotes 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  f fü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:  ={x 0 ,... , x n } . 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ő  n−1

összeg  ={x 0 ,... , x n }s  f , =∑ inf R f ∣[ x , x ] x k1−x k  k =0

5

k

k1

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

összeg  ={x 0 ,... , x n }S  f ,=∑ supr R f ∣[ x , x ]  x k1−x k  k

k=0

k1

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 ]={ x 0 , ... , x n } x k ≤k ≤x k1 ekkor  n−1

R f , , =∑ f k  x k 1− x k  k=0

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.

b

T:  f ∈ R[ a , b]∧∃F : F ' = f ⇒ ∫ f =F b−F a  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  2xn vagy ha tetszik függvények, melyek  ℝ  ℝ  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  x 0 ,... , x n 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 : p x 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:  T: 

n1

x ∫ x n = n1

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

b

b

b

a

a

a

∫  f g =∫ f ∫ 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 y osztott differencia.  7

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

Ebből   a   definícióból   következik   a   k­adrendű   osztott   differencia  definíciója: k  D:  f [ x , ... , x ]:= f  x

k!

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  mi1 ­szer egymás után. f  j  xi  Beírjuk az   f  x i  értékeket és a megfelelő   értékeket az  j!

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.

Illustration 2: Hermite interpoláció 9

Fent   látható   egy   példafuttatása   a   programnak.   A   sin(x)   függvényt   integráljuk   0­tól   7­ig   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 Newton­Cotes 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  b

∫ fw a

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

P  x =∑ f  x i  l i  x∈P [ x ]n−1 interpolációs polinommal,  i=0

ahol  x 0, ... , x n természetesen az alappontokat  l i  x  az i. Lagrange    interpolációs polinomot jelöli.  Ekkor  D: 

b

b

b

n

b

n

a

a

i=1

a

i=1

∫ fw≈∫ Pw =∑ f  x i ∫ l i w=∑ c i f  x i 

∫ fw a

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

nevezzük, ha  c i=∫ l i w a

Ezeket   a   kvadratúra   formulákat   akkor   nevezzük   Newton­Cotes  formuláknak, ha a   w≡1 . Az itt bemutatott módszer lényege tehát a  Hermite­hez 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   Newton­Cotes   formula  speciális esetei.

10

Illustration 3: A Newton­Cotes módszer a programban

2.3. A kompozit Simpson módszer  A kompozit Simpson módszer a Newton­Cotes 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: b

∫ a

11

n/ 2

n/ 2

h f  x  dx≈ [ f  x 0 4 ∑ f  x 2k −12 ∑ f  x 2k  f  x n] 3 k=1 k=1

Illustration 4: A kompozit Simpson módszer a programban

2.4. A kompozit trapéz módszer  A   kompozit   Simpson­hoz   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: b

∫ a

n −1

h f  x  dx≈ [ f  x 0 ∑ f  x k  f  x n] 2 k =1

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

12

A   Newton­Cotes   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  20­ná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

•

•

13

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

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

•

•

•

14

Mielőtt   sok   osztópontra   ráengednénk   a   programot   próbáljuk   ki  10­20   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.

  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   plugin­ké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 GUI­t  –   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 GUI­designer­t. 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 GUI­n 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

18

3.2  Osztálydiagram (class diagram)

19

3.3  A Parser A   Parser­t   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 parser­hez  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

// ** 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:{ <EOL: "\n" | "\r" | "\r\n" > } Az bemenetkén szolgáló formulát lezáró elemek. TOKEN:{  |  > } TOKEN:{ < #INTEGER: "0" | ["1"­"9"] ()* > } TOKEN:{ < #REAL:    ["1"­"9"] ()* "." ()* | [ "0" ]  "." ()* > } TOKEN:{ < #DIGIT: ["0"­"9"] > } TOKEN : /* OPEN_PAR */ {    } TOKEN : /* CLOSE_PAR */ {    } TOKEN : /* VARIABLE */ {    } /*          OPERATORS           */ 21

TOKEN:{   } TOKEN:{ <SUB:   "­" > } TOKEN:{ <MUL:   "*" > } 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:{  <SIN:   "sin" > } TOKEN:{   } TOKEN:{   } TOKEN:{   } TOKEN:{  <EXP:   "e" > } TOKEN:{   } TOKEN:{  <SH :   "sh"  > } 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() <EOL> { return previousValue; } )* <EOL> } double Expression() throws NumberFormatException : {     double i, value; 22

} {     value = addTerm() (    i = addTerm() { value += i; } |                          <SUB>   i = addTerm() { value ­= i; } )*    { return value; }   } double addTerm() throws NumberFormatException : {     double i, value; } {     value = mulTerm() ( <MUL>   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; }     |     <SUB>  d = Primary() 23

    { return ­d; }         |       <SIN>  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); }     |     <EXP>  d = Expression()      { return java.lang.Math.exp(d); }     |       d = Expression()      { return java.lang.Math.log(d); }     |     <SH>  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:

25

•

ParseException.java

•

Parser.java

•

ParserConstants.java

•

ParserTokenManager.java

•

SimpleCharStream.java

•

Token.java

•

TokenMgrError.java

4  API dokumentáció 4.1  ComponentController Ez 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  Parser­nak.   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 Parser­nek. 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  interface­t   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 

26

osztály   pontosságát 

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 Canvas­ra.

•

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.

•

public void done() 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 GUI­n 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 GUI­n 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 lett­e  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 progressbar­on 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   interface­t   kell   minden   olyan   osztálynak   implementálnia,   ami   az  integrálási módszereket használni szeretné. •

public void enableStart()  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.

•

public void setResult(Polynom p)  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 Newton­Cotes 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  IntegrationMethod­tól örökölt függvénye.

•

public void done()  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.

•

public void enableStart()  Ü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.

•

public void setResult(Polynom p)  Ü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. •

31

public static double[][] getParsedValues() 

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 Byte­tö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   1­től   2­ig;   10,   15,   20,   25,   30  osztóponttal,   majd   ezeket   egyre   bonyolultabb   függvényekké   komponáltam.  Ezeket 0­tól 5­ig integráltam a Hermite és a Newton­Cotes­ná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

Expression

Method

Hermite

Newton­Cotes sin(x) Composite Simpson

Composite Trapezium

Hermite

Newton­Cotes cos(x) Composite Simpson

Composite Trapezium

36

NoP

Calculated by intg

10 0.956449142415277453466160295647569000720977783203125 15 0.95644914241528145026904894621111452579498291015625 20 0.956449142446194056077501954860053956508636474609375 25 0.956264556836686097085475921630859375 30 ­282.7628004550933837890625 10 0.95764339102173545725804615358356386423110961914062500 15 0.95848774774353340255572675232542678713798522949218750 20 0.95844401350070362877175966787035576999187469482421875 25 0.95826862977667914833546092268079519271850585937500000 30 0.95808957186556564789015055794152431190013885498046875 10 0.9584427591278947555775147293388727121055126190185546875 15 0.89919249321645944306169440096709877252578735351562500000 20 0.95864377256459003262545337520350585691630840301513671875 25 0.92236710690052972627661631577211664989590644836425781250 30 0.958178300293691838362963864028643001802265644073486328125 10 0.95764339102173533235795588325345306657254695892333984375 15 0.958487747743534325428615971986801014281809329986572265625 20 0.958444013500703365093791319395677419379353523254394531250 25 0.958268629776678933229749901556715485639870166778564453125 30 0.9580895718655628376381194755140313645824790000915527343750 10 0.067826442018052102156389082665555179119110107421875 15 0.06782644201778642578659628270543180406093597412109375 20 0.06782644201851228960009621005156077444553375244140625 25 0.067802888092046487145125865936279296875 30 ­13.91128051280975341796875 10 ­0.0279746578618489394330026698298752307891845703125000 15 0.0039582511367397543722290720324963331222534179687500 20 0.0199349888781306106011470546945929527282714843750000 25 0.0295204870152312448539078104658983647823333740234375 30 0.03590970440643082017828646712587215006351470947265625 10 ­0.027998008985539527167241136140773960505612194538116455078125 15 0.033702210716073029671269178919601472443901002407073974609375 20 0.0199391437318955258399533203572673301096074283123016357421875 25 0.046893200249395420556482172447232414924656040966510772705078125 30 0.035913029994892830404351613537983212154358625411987304687500 10 ­0.0279746578618486545046717406393099736305885016918182373046875 15 0.0039582511367398114554734533943047836146433837711811065673828125 20 0.0199349888781317209868020057239590414610574953258037567138671875 25 0.0295204870152330431658412035478278312439215369522571563720703125 30 0.035909704406429994992012988408447426991187967360019683837890625

Calculated by Maple

0,9564491424

0,0678264402

Expression

Method

Hermite

Newton­Cotes tg(x) Composite Simpson

Composite Trapezium

Hermite

Newton­Cotes ctg(x) Composite Simpson

Composite Trapezium

37

NoP

Calculated by intg

10 528.191767215728759765625 15 ­10036.859375 20 ­46165248 25 ­613516918652928 30 9,18E+020 10 ­2.5126519637662010353551522712223231792449951171875 15 ­0.60404071972322803674160240916535258293151855468750 20 0.9259422313628995482304162578657269477844238281250 25 2.884329332404188761529439943842589855194091796875000 30 7.797474532292730131644020730163902044296264648437500 10 ­3.830687904899953311055327276335447095334529876708984375 15 0.597217900570738813303961478595738299190998077392578125 20 ­0.1590123970105701278754395389114506542682647705078125000 25 4.3636446503658491147259468334596022032201290130615234375 30 5.03764997156968126479359426639348384924232959747314453125 10 ­2.512651963766216134388287173351272940635681152343750000 15 ­0.6040407197235109493238525146807660348713397979736328125 20 0.92594223136342342084237344579378259368240833282470703125 25 2.88432933240404308639082131549002951942384243011474609375 30 7.79747453229284179232472240528295515105128288269042968750 10 0.07752058067892608761439987574703991413116455078125 15 0.0775207101429717937435270869173109531402587890625 20 0.07752071015199391013084095902740955352783203125 25 0.0775099099546423531137406826019287109375 30 ­19.70928227901458740234375 10 ­0.0319888951815425759406252836924977600574493408203125 15 0.0045164567362536711669918076950125396251678466796875 20 0.0227387220467767381393286996171809732913970947265625 25 0.0336737083197409248214171384461224079132080078125000 30 0.0409670044473853245392547250958159565925598144531250 10 ­0.031920381601977687591187304860795848071575164794921875000 15 0.0377684504708334055356200309461200959049165248870849609375 20 0.0227264481656456163692625604966224273084662854671478271484375 25 0.0529481626751720341715612416777503312914632260799407958984375 30 0.04095714603856075879985410015393654248327948153018951416015625 10 ­0.031988895181542568134369641796865835203789174556732177734375 15 0.00451645673625261406987363432818938235868699848651885986328125 20 0.02273872204677645475598586621845953459342126734554767608642578125 25 0.03367370831974063013526665688601724468753673136234283447265625 30 0.040967004447384674343211885538806882323115132749080657958984375

Calculated by Maple

Float(undefined)

0,0775207102

Expression

Method

Hermite

Newton­Cotes e(x) Composite Simpson

Composite Trapezium

Hermite

Newton­Cotes ln(x) Composite Simpson

Composite Trapezium

38

NoP

Calculated by intg

10 4.6707742704728811844461233704350888729095458984375 15 4.670774270471465428045121370814740657806396484375 20 4.6707742704145740475496495491825044155120849609375 25 4.6696458368678577244281768798828125 30 ­1379.15270519256591796875 10 5.1663048417540788914692484468105249106884002685546875 15 4.9946223101495661467197351157665252685546875000000000 20 4.9112729143700033507258240206283517181873321533203125 25 4.8620403528677555993198211581329815089702606201171875 30 4.8295378243126994011191754907486028969287872314453125 10 5.16200675299071565227393421082524582743644714355468750 15 4.483378843791562262666161586821544915437698364257812500 20 4.910250158687672950019731388238142244517803192138671875 25 4.5598391494177877569793366774320020340383052825927734375 30 4.8290907276824853178176510937191778793931007385253906250 10 5.166304841754078835958097215552697889506816864013671875 15 4.9946223101495706153674092320216004736721515655517578125 20 4.9112729143700008804795942296550492756068706512451171875 25 4.86204035286775337887377190781990066170692443847656250000 30 4.82953782431269025565701014102160115726292133331298828125 10 0.3862943711575272942582159885205328464508056640625 15 0.386294361124982277289063858916051685810089111328125 20 0.38629436108163961449690759764052927494049072265625 25 0.386300354129843981354497373104095458984375 30 3.9440991468727588653564453125 10 0.45286665402000469971000029545393772423267364501953125 15 0.43126074597191976778276512050069868564605712890625000 20 0.42024512987072693004364509761217050254344940185546875 25 0.41356522617755708814968329534167423844337463378906250 30 0.40908196516069728065900790170417167246341705322265625 10 0.45322652055486743749579403583993553183972835540771484375 15 0.384119786116716668833426240325934486463665962219238281250 20 0.4203418518384018053024586691890362999401986598968505859375 25 0.38550479776018856982455762505423990660347044467926025390625 30 0.4091260200728225708555196860061187180690467357635498046875 10 0.4528666540200042590902373973449357436038553714752197265625 15 0.43126074597192020319835759067927938303910195827484130859375 20 0.4202451298707269695086041760845319004147313535213470458984375 25 0.4135652261775569125089313526899559292360208928585052490234375 30 0.4090819651606959332125479367192610880010761320590972900390625

Calculated by Maple

4.670774270

0,3862943611

Expression

Method

Hermite

Newton­Cotes sh(x) Composite Simpson

Composite Trapezium

Hermite

Newton­Cotes ch(x) Composite Simpson

Composite Trapezium

39

NoP

Calculated by intg

10 2.219115056269055141768831163062714040279388427734375 15 2.219115056268296637398407256114296615123748779296875 20 2.2191150567098869572646435699425637722015380859375 25 2.219101603157469071447849273681640625 30 ­962.2739009857177734375 10 2.4778574349900386319944800561643205583095550537109375 15 2.38849752959750627478996420904877595603466033935546875 20 2.34501199342027755179174164368305355310440063476562500 25 2.31929229622614740957686763067613355815410614013671875 30 2.302298272551417446241117659155861474573612213134765625 10 2.47579599039380227054607530590146780014038085937500000 15 2.1372801586296354126037755349898361600935459136962890625 20 2.3445236527429763606633628114650491625070571899414062500 25 2.17085987379703422572863047435021144337952136993408203125 30 2.30208513625621395692899540108555811457335948944091796875 10 2.4778574349900391871059923687425907701253890991210937500 15 2.38849752959750742664635225764868664555251598358154296875 20 2.34501199342027426275603119165680254809558391571044921875 25 2.319292296226147562232533516635157866403460502624511718750 30 2.302298272551410195096988076102206832729279994964599609375 10 2.45165921420382471040966265718452632427215576171875 15 2.451659214203136816223604910192079842090606689453125 20 2.45165921476348813712320406921207904815673828125 25 2.4516803563919893349520862102508544921875 30 1398.53944301605224609375 10 2.6884474067640380390287191403331235051155090332031250 15 2.6061247805520610931750979943899437785148620605468750 20 2.56626092094973079493769319014973007142543792724609375 25 2.5427480566416063023638116646907292306423187255859375 30 2.52723955176128622923670263844542205333709716796875000 10 2.68621076259691349275016136743943206965923309326171875 15 2.346098685161926600262205511171487160027027130126953125 20 2.5657265059446965893563685767730930820107460021972656250 25 2.3889792756207534063506159327516797930002212524414062500 30 2.5270055914262715412998971942215575836598873138427734375 10 2.6884474067640397043632560780679341405630111694335937500 15 2.60612478055206303606539108841388951987028121948242187500 20 2.56626092094972670099028988488498725928366184234619140625 25 2.54274805664160583051902619899919955059885978698730468750 30 2.527239551761280102193385488362764590419828891754150390625

Calculated by Maple

2,2191150560

2,4516592140

Expression

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

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

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

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

40

Method Hermite Newton­Cotes Composite Simpson Composite Trapezium Hermite Newton­Cotes Composite Simpson Composite Trapezium Hermite Newton­Cotes Composite Simpson Composite Trapezium Hermite Newton­Cotes Composite Simpson

NoP

Calculated by intg

30 4.99999999064949207649988238699734210968017578125 30 5.0000000000000020816681711721685132943093776702880859375 100 5.00000000000000020816681711721685132943093776702880859375 100 5.000000000000000242861286636752993217669427394866943359375 30 27.62704887747022297617149888537824153900146484375 30 29.03835379031390229176423645185423083603382110595703125 100 29.2726706851906625229779723706968752594548277556896209716796875 100 29.2726706851906625229779723706968752594548277556896209716796875 30 663050222.4978923797607421875 30 ­58.768341190410339158756158894902910105884075164794921875 100 ­56.8456809847782322357712114779815237852744758129119873046875 100 ­56.63356838867567718295674417117169241464580409228801727294921875 30 3.54140489911943490142220980487763881683349609375 30 0.44795422918465900574691573865493410266935825347900390625 100 0.538818177913745764533171023202839933219365775585174560546875

Calculated by Maple

5,0000000000

29,3583389900

­55,4901715900

0,5733060489

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: Prentice­Hall 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: Springer­Verlag ISBN 9780387954523 [5] Analízis 1            Leindler­ Schipp           Eötvös kiadó

41