.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

Optimáló eljárás az elõzõ játék automatikus megoldására 4. reziduumok elemzése 11. valamint korrelációja 9. Kör illesztése a sugár irányú négyzetes eltérések minimálásával 15. Adatsorok egyszerû statisztikái. Egyszeû függvények illesztése 10. Klaszter analízis a dinamikus K−közép módszerével 16. feladat állományai MS−DOS / Windows bináris Linux bináris 2. (a+b)^n együtthatóinak kiszámítása a Pascal háromszög segítségével 2. feladat állományai MS−DOS / Windows bináris Linux bináris . feladat állományai MS−DOS / Windows bináris Linux bináris 16.. Egy kiválasztott kör pontjainak koordinátái 13.. 16 EXE ELF Telepítõ készletek MS−DOS / Windows Linux Feladatok kidolgozása 1. Illesztések értékelése: variancia analízis. Osztályozás tanulóminta adatai alapján Ajánlott irodalon 3 5 6 7 10 16 17 22 28 32 39 43 44 49 54 58 61 CD−ROM melléklet: \TELEPITO WIN LINUX \FELADATOK 01 EXE ELF 02 EXE ELF . Tetszõleges függvény illesztése optimáló eljárás segítségével 12. Aknamezõn biztonságos útvonalat keresõ eljárás 6. Játék pszeudo−véletlen számokkal 3. Kör illesztése a legkisebb négyzetek módszerével 14. Szélsõérték keresése az aranymetszés módszerével 5. Rendezési eljárások sebességének összehasonlítása 8.GNU C/C++ példaprogramok 1 Mérnöki számítások C/C++ nyelven 16 feladat a GNU C használóinak Tartalom 1. Pszeudo−véletlen számokat tartalmazó adatállomány készítése 7.

a következõ két internet címet javasolhatom: http://www. A CD−ROM mellékleten található telepítõ készletek segítségével a számítógépen létrehozható a szükséges fejlesztõi környezet. frissítések). C++ programozási ismeret. ezért a mellékleten megtalálható a Java.com/djgpp http://gcc.EXE önkicsomagoló programot 3. Ha frissíteni szeretné.. indítsa el az INSTALL. A megértést a változók. Ha Linux környezetben hibaüzenetet kap a matematikai függvények hiányára hivatkozva. A feladatgyûjtemény célja a mérnöki munka. akik mérési eredményeik kiértékelése érdekében nem riadnak vissza a számítógép programozásától.EXE programot Linux rendszerekben a GNU C fordító beépített elem. eljárások beszédes nevei és a fenntartott szavak kiemelése tovább segíti. használja a következõ parancsot: gcc forras. amely elsõsorban a mûszaki képzésben résztvevõ egyetemi és fõiskolai hallgatók számára készült. a csomagot megtalálja a [CD−ROM]\TELEPITO\LINUX\ könyvtárban. A telepítéshez szükséges tennivalókat tartalmazza a csomag README állománya. sok megjegyzéssel kiegészítve. operációkutatásban szerzett gyakorlat.delorie. kutatás során alkalmazható matematikai módszerek bemutatása. Fortran 77 fordító is.c −lm ahol az "−lm" kapcsoló a matematikai könyvtár hozzáfûzését jelenti. A feladatok megértését nagymértékben segíti Pascal vagy C. A könyv azonban nem csupán nekik ajánlható.org 2001. másolja át [CD−ROM]\TELEPITO\WIN\ tartalmát egy ideiglenes könyvtárba 2. Ez a környezet magába foglalja a fordító programot (gcc) és Windows. Linux rendszerekben a C fordító csak része a GNU Common Compilers csomagnak. Object C. Amennyiben további információkra van szüksége a GNU C fejlesztõi környezetrõl (leírások. valamint MS−DOS alatt az RHIDE keretrendszert és az Emacs nevû szerkesztõt.gnu. január Jó munkát kívánok: a szerzõ .GNU C/C++ példaprogramok 2 Elõszó Olyan feladatgyûjteményt tart kezében a kedves olvasó. hanem mindazoknak. optimálásban.. Telepítés Windows / MS−DOS alatt: 1. Ennek érdekében a közölt C és C++ forráskódok egyszerûek. indítsa el a LBINSTDJ..

i<n.. /* elsõ elem a sorban */ H[i][i]=1. } /* memória felszabadítás */ for (i=0.&n).n.i<n. /* beolvas egy 3 és 14 közötti számot */ do{ printf("n (3. scanf("%d".j++) printf("%5d". */ H = new int*[n].GNU C/C++ példaprogramok 3 [1a] Készítsünk programot. mert a legelsõ sor az n=0 kitevõ adatait tartalmazza */ n++.i++) { printf("%2d: ". #include <stdio.i<n.i++) { H[i][0]=1. } . /* H tartalmazza a háromszöget */ int i. /* segédváltozók */ printf("A kovetkezo nevezetes szorzat egyutthatoit szamolja ki \n").j. for (i=2.i++) H[i] = new int[i+1]. } /* Pascal−háromszög kiiratása */ for (i=0. /* megnöveljük "n" értékét. for (j=0. /* utolsó elem a sorban */ for (j=1. for (i=0. /* memória foglalás. printf("\n"). return(0).14) = ").j<=i. az értékeket célszerû egy mátrixba helyezni. Ha a programot késõbb bõvíteni szeretnénk. amely a képernyõre írja a Pascal−háromszög elsõ N sorát. delete[] H.H[i][j]).i). a háromszög minden sora csak a szükséges területet köti le. H[1][1]=1.j<i. }while (n<3 || n>14).i++) delete[] H[i]. /* feltöltés */ H[0][0]=1.i<n. scanf */ int main(void) { int **H. H[1][0]=1.h> /* hagyományos ki− és bemeneti függvények: printf.j++) H[i][j]=H[i−1][j−1]+H[i−1][j]. printf("ez a program: (a+b)^n \n").

V[j]). printf("ez a program: (a+b)^n \n"). /* V vektorban tárolja az értékeket */ int i. for (i=0.&n).14) = ").i<=n.j++) printf("%5d". } delete[] V. return(0).i++) { /* "i" azonosítja a Pascal−háromszög sorait */ V[i]=1..: ".n. for (j=0. do{ printf("n (3. /* segédváltozók */ printf("A kovetkezo nevezetes szorzat egyutthatoit szamolja ki \n").GNU C/C++ példaprogramok 4 [1b] Az elõzõ feladat egyszerüsített megoldása.j. /* a sor utolsó eleme */ for (j=i−1. } [1a] és [1b] programok eredménye a képernyõn A kovetkezo nevezetes szorzat egyutthatoit szamolja ki ez a program: (a+b)^n n (3. /* memória foglalás */ V = new int[n+1]. printf("%3d.j−−) V[j]+=V[j−1].i).14) = 7 0: 1 1: 1 1 2: 1 2 1 3: 1 3 3 1 4: 1 4 6 4 1 5: 1 5 10 10 5 1 6: 1 6 15 20 15 6 1 7: 1 7 21 35 35 21 7 1 . scanf("%d". #include <stdio. }while (n<3 || n>14). ha nem szükséges az adatok tárolása esetleges késõbbi felhasználásukhoz.j>0. scanf */ int main(void) { int *V. printf("\n")..h> /* hagyományos ki− és bemeneti függvények: printf.j<=i.

Gep=Beallit(100). amely kitalál egy egész számot 1−tõl 100−ig. /* számláló nullázása */ do{ printf("\n[%d] Mit tippel? ".N.ti_min)%maximum +1. break. hogy a beírt érték kisebb.h> /* pszeudo−véletlenszám elõállításához: gettime */ int Hasonlit(int mit. printf("\n Probalkozasok szama: %d. keresett szam: %d\n". return(0). } N++. visszatérési értékei: −1. } 5 ."). int r. /* "r" értéke az 1. vagy nagyobb. } int Beallit(int maximum) /* pszeudo−véletlen szám elõállítása az aktuális idõ adataiból */ { struct time T. case −1: printf("Tul keves. "). break.ti_hund + T.GNU C/C++ példaprogramok [2] Készítsünk játékprogramot.. r = (T.int mivel) /* két számot hasonlít össze. return(0)..h> /* hagyományos ki− és bemeneti függvények: printf.maximum tartományban van */ return(r). 0..N+1).Gep)) { case 1: printf("Tul sok. 1 */ { if (mit>mivel) return(1). case 0: printf("ELTALALTA!"). break. "). A program csak annyit válaszolhat. mint az általa választott.&Ember). printf("\n Kitalaltam egy szamot 1−tol 100−ig. if (mivel>mit) return(−1). switch(Hasonlit(Ember. } int main(void) /* fõprogram */ { int Gep. scanf */ #include <dos.ti_sec*T. scanf("%d". gettime(&T). #include <stdio.Gep). }while(Ember!=Gep && N<10)..N. A felhasználó 10 alkalommal kérdezhet rá. esetleg egyenlõek.Ember. N=0.

Ember.Gep). printf("%d. 28. 75. }while(Ember<1 || Ember>100). } N++.int mivel) /* két számot hasonlít össze. return(0). break. 7. Also=Gep. visszatérési értékei: −1.h> /* hagyományos ki− és bemeneti függvények: printf.&Ember).N+1. keresett szam: %d\n". break. N=0.\n"). 99 6 .N.Ember)) { case 1: printf("Tul sok. if (mivel>mit) return(−1). 63. Felso=Gep. 17. switch(Hasonlit(Gep.Ember). ezek a számok segítenek kipróbálni: 1. Also=0.N. }while(Ember!=Gep && N<10). 51.Felso. printf("\n Probalkozasok szama: %d. /* beolvas egy egész számot 1−tõl 100−ig */ do{ printf("\n Kitalalt egy szamot 1−tol 100−ig? "). scanf */ int Hasonlit(int mit.Gep). scanf("%d". 88. break. printf("Utolso tipp: %d\n". return(0). case 0: printf("ELTALALTAM!\n"). tippem: %d\n". Felso=101. 1 */ { if (mit>mivel) return(1). } Teszt adatok Ha a stratégián változtatni kíván. /* segédváltozók beállítása */ do{ /* a számítógép az alsó és a felsõ határ átlagát tippeli */ Gep = (Also+Felso)/2. case −1: printf("Tul keves.GNU C/C++ példaprogramok [3] Az elõzõ feladatban ismertetett játék szerepeit cseréljük fel! A számítógép legfeljebb 10 lépésben találja ki az általunk választott 1 és 100 közötti egész számot.\n"). 0. 49. #include <stdio. } /* a felezéses eljárást alkalmazva biztosan ki lehet találni minden számot legfeljebb 8 lépésbõl */ int main(void) { int Gep.Also.

/* az egyenlet együtthatói */ double fuggveny(double x) /* a parabola Y értékeit adja meg */ { double d.50] intervallumon úgy. scanf */ #include <math. } if (d==0) { printf("A fuggveny erinti az X tengelyt: \n").x1). /* diszkrimináns */ if (A==0) { printf("Ez nem masodfoku egyenlet! \n"). #include <stdio.. return.. ami alapján meghatározható a szélsõérték helye és a hozzá tartozó függvény érték. return. d = B*B − 4*A*C. /* x számítható a másodfokú egyenlet megoldó képletével */ x1 = (−B)/(2*A). double x1.GNU C/C++ példaprogramok 7 [4] Határozzuk meg az Y=A*x^2 + B*x + C másodfokú egyenlet szélsõ értékét a [−50. Az itt kiszámított és kiírt értékek segítenek az optimálás értékelésében */ void vizsgalat(void) { double d. } .B. printf("zerushely: X = %lg\n".C. } /* a következõ eljárás megvizsgálja. return. hogy az egyenlet együtthatóit a felhasználó adhassa meg. /* d = A*x^2 + B*x + C */ return(d). hogy valóban másodfokú−e az egyenlet és van−e tengelymetszete.x2.h> /* matematikai rutinok: sqrt */ double A. } if (d<0) { printf("A fuggveny nem metszi az X tengelyt.h> /* hagyományos ki− és bemeneti függvények: printf.\n"). d = C + x*(B + A*x).

X[3]=50. 3 5 amely értéke: a (kb. /* segédváltozók */ /* konvex. return..\n"). /* a szükséges 4 f(x) érték */ int i. /* a közbülsõ értékek */ X[1]=X[0]+arany*(X[3]−X[0]).j.fuggveny(x1)). x2 = (−B−sqrt(d))/(2*A). printf("zerushely: X(1) = %lg\n". /* az intervallum két végpontja */ X[0]=−50. hogy ekkor elegendõ csupán egy új pontot kiszámítani. vagy konkáv a parabola? */ if (A>0) printf("Minimumhely kereses. A keresett x érték a két középsõ x koordináta átlaga..x2).. printf("zerushely: X(2) = %lg\n".GNU C/C++ példaprogramok if (d>0) { printf("A fuggveny metszi az X tengelyt: \n"). if (A<0) printf("Maximumhely kereses.3819) . } } /* vizsgálat vége */ /* optimáló eljárás az aranymetszés módszerével: ekkor egy speciális arányszámot alkalmazunk. x1=(x1+x2)/2.. printf("szelsoertek helye: X = %lg\n erteke: Y = %lg\n".. 0.x1. /* arányszám beállítása */ arany = ((double)3 − sqrt((double)5) )/2. Négy Y értéket kell kiszámítani.lepes. /* a szükséges 4 x érték */ double Y[4].\n"). Az arányszám olyan különleges tulajdonságú. a másik három adott. ¡   8 .. if (A==0) { printf("A fuggveny nem parabola!\n"). /* arányszám */ double X[4]. vagy felsõ határ. } printf("Kereses a [−50. /* ebben az utolsó feltételben elhagyható a return utasítás */ return.50] tartomanyban. X[2]=X[3]−arany*(X[3]−X[0]). majd a középsõ 2 kettõ közül a kisebbik (maximum keresésekor) vagy nagyobbik (minimum keresésekor) helye lesz az új alsó.\n"). /* a másodfokú egyenlet megoldó képletével */ x1 = (−B+sqrt(d))/(2*A). */ void optimalas(void) { double arany.x1).

) vége */ printf("lepesek szama: %d\n". /* f(x) értékek kiszámítása */ if (A>0) { /* x^2 együtthatója pozitív. Esetünkben legyen a kívánt pontosság ±0.(X[1]+X[2])/2). X[1]=X[2]. while (fabs(X[2]−X[1])>0.. X[2]=X[3]−arany*(X[3]−X[0]). printf("B = "). } else { X[3]=X[2].0005 */ lepes = 0. } else { X[3]=X[2]. } } else { /* x^2 együtthatója negatív. } int main(void) /* fõprogram */ { printf("A = "). X[1]=X[2]. X[2]=X[1]. X[2]=X[3]−arany*(X[3]−X[0]). scanf("%lf".GNU C/C++ példaprogramok /* az optimálás akkor áll le. scanf("%lf". X[2]=X[1]. printf("f(x) = %lg\n". return(0). tehát minimumhelyet keresünk */ if (Y[1]>Y[2]) { X[0]=X[1]. tehát maximumhelyet keresünk */ if (Y[1]<Y[2]) { X[0]=X[1]. printf("C = ").001) { for (j=0.j++) Y[j]=fuggveny(X[j]). optimalas(). X[1]=X[0]+arany*(X[3]−X[0]).Y[0]).&B)..) vége */ lepes++. } 9 /* függvény együtthatóinak beolvasása */ .. } } /* if (A. scanf("%lf".&A). vizsgalat(). Y[0]=fuggveny((X[1]+X[2])/2).&C). } /* while (fabs(). printf("x = %lg\n".j<4.lepes). X[1]=X[0]+arany*(X[3]−X[0]).. amikor a szélsõértéket kellõ pontossággal megközelítettük .

V1=T. Kereses a [−50. r= (V1+V2*V3)%maximum..0667 Minimumhely kereses.k.V3. hogy az átjutás nem garantált az aknák véletlenszerû helyzete miatt.0666667 erteke: Y = −20.V2.Y.ti_sec. return(r).Lepes.Akna. lepesek szama: 21 x = 0. .. amely a mezõ P1(1.0667 10 [5] Készítsünk programot. int V1. amely egy 80x20 méretû mezõn véletlenszerûen elhelyez 70 aknát. cputs */ #include <dos.22329 zerushely: X(2) = −1.?). aknák elhelyezése és a képernyõre rajzolásuk */ void Beallit(void) { int i. } /* aknamezõ létrehozása.08996 szelsoertek helye: X = 0.h> /* idõ lekérdezése a véletlenszám elõállításához: gettime */ #define MAXLEPES 15000 /* maximális lépésszám */ #define AKNAK 70 /* aknák száma */ int **Mezo. V3=r.ti_min. /* véletlenszámok generálásának beállítása */ gettime(&T).h> /* hagyományos ki− és bemeneti függvények: sprintf */ #include <conio.. majd írjuk meg azt az eljárást. V2=T.GNU C/C++ példaprogramok a [4] feladat üzenetei a képernyõn A = 15 B = −2 C = −20 A fuggveny metszi az X tengelyt: zerushely: X(1) = 1.066703 f(x) = −20.10) pontjából indulva nagy valószínûséggel átjut a másik oldalra P2(80. Gondolni kell arra is.ti_hund.j. V1=V2. V3=T.. /* aknamezõ */ /* segédváltozók: pozíció. lépésszám */ /* változók a véletlenszám generáláshoz */ int Veletlen(int maximum) /* véletlenszám elõállítása 0−tól "maximum"−ig */ { int r. int X.50] tartomanyban.h> /* képernyõre írás: gotoxy. struct time T. aknajelzõ. V2=V3. #include <stdio.

while (i<AKNAK) { /* aknák elhelyezése: az elsõ három oszlopba nem rakunk aknát */ j=Veletlen(76)+3.j).j<22. if (Mezo[x][y]==1) { gotoxy(60.j.y2. } . cputs("ATJUTOTT!!"). } i=0.1). } if (x>=79) { gotoxy(60. for (i=0. elemek nullázása */ Mezo = new int*[80]. return.i. k=Veletlen(20).int y) { int x1.x2. } } } } /* Beallit() vége */ /* aktuális pozíció kiértékelése: hány darab akna van a szomszédságban? */ void Ertekel(int x. break. if (Mezo[j][k]==0) { Mezo[j][k]=1. } else { /* ha ugyanoda már raktunk aknát.i++) { Mezo[i] = new int[20]. Akna=−1. } } /* aknamezõ megjelenítése */ clrscr().j++) { gotoxy(1.").i++) { switch(Mezo[i][j−2]) { case 0: cputs(". break. megváltoztatjuk a véletlenszámok generálását */ V1++. cputs("Aknara lepett!!").i<80. for (j=2.i<80.j++) Mezo[i][j]=0.j<20.y1. for (i=0. case 1: cputs("A"). i++. for (j=0.GNU C/C++ példaprogramok 11 /* memória foglalás: 80x20 mátrix.1).

if (y1<0) y1=0. /* memória felszabadítása */ delete[] Buff. if (y2>19) y2=19.valtas. /* segédváltozók */ 12 .i++) { for (j=y1.1). } /* járható utat keresõ eljárás */ void Keres(void) { int dx. sprintf(Buff.X+1.dontes. /* aknák száma */ Akna=0. gotoxy(1.j++) if (Mezo[i][j]!=0) Akna=1. /* ellenõrzés */ if (X<0) X=0.Y koordináták. lépésszám */ void Cimsor(void) { char *Buff."X= %2d Y= %2d | LEPES= %3d". if (x1<0) x1=0. gotoxy(X+1. Cimsor(). cputs(Buff). Lepes++. /* ellenõrzés */ if (Y<0) Y=0.Y+1.int dy) { X+=dx. y1=y−1. /* buffer a kiiratáshoz */ /* memória lefoglalása */ Buff = new char[50]. if (x2>79) x2=79. y2=y+1. if (X>79) X=79.j<=y2. x2=x+1. cputs("").i<=x2. } } /* Ertekel() vége */ /* információk megjelenítése az elsõ sorban: X.lepes. Y+=dy.Y+2). Ertekel(X.Lepes). for (i=x1. } /* aktuális pozíció változtatása dx és dy alapján */ void Mozdit(int dx. if (Y>19) Y=19.dy.GNU C/C++ példaprogramok /* területhatárok kijelölése */ x1=x−1.Y).

else dy=1. if (dontes>60*Lepes/MAXLEPES) valtas++. vagy irányt kell váltani */ if (valtas>0) { /* kikényszerített irányváltás */ 13 . aknára lépett. /* elsõ oszlopba lépett.0).GNU C/C++ példaprogramok /* inicializálás. ezzel segítve. ameddig át nem jutott. Y=10. /* nem a megfelelõ irányba halad */ if (dx<=0) { /* az irányváltás valószínûsége a keresés elõrehaladtával csökken. nehogy beszoruljon: nagyobb hurkokar ír le */ dontes=Veletlen(100). if (dontes<20) dx=−1. /* ha a szélén rossz irányt választott. if (Y==19 && dy==1) dy=−1. dx=1. /* vizszintesen halad */ if (dy==0) valtas=0. korrigálni kell */ if (X==0 && dx==−1) dx=1. mert akna van a közelben */ Mozdit(−dx. while (Akna==0 && X<79 && valtas<4 && Lepes<MAXLEPES) { Mozdit(dx. } } else { /* azért állt meg. vagy beszorult valahova */ while (X<79 && Akna!=−1 && Lepes<MAXLEPES) { /* segédváltozó az irányváltás kikényszerítésére */ valtas=0. Mozdit(0. 50%−ában lefelé folytatja */ if (dontes<50) dy=−1. mert beszorult. /* az esetek 20%−ában balra.−dy).0) segítségével kiértékeltetjük az aktuális pozíciót */ Lepes=0.dy). aknára lépett. 80%−ban jobbra indul */ dontes=Veletlen(100). a Mozdit(0. X=0. korrigálni kell */ if (Y==0 && dy==−1) dy=1. } } if (Akna>0) { /* azért állt meg. /* vissza lép az elõzõ pozícióba */ if (dy==0) { /* vízszintesen haladt */ dx=0. } else { /* függõlegesen haladt */ dy=0. dy=0. dontes=Veletlen(100). else dx=1. vagy a szélére */ if (X<1 || (Y<1 && dx==0) || (Y>18 && dx==0)) valtas=4. /* az esetek 50%−ában felfelé. /* addig folyik a keresés. /* ha a szélén rossz irányt választott.

} /* fõprogram */ void main(void) { Beallit(). } else { dx=0. for (i=0. else dy=1. 50%−ában lefelé folytatja */ if (dontes<50) dy=−1. else dx=1. dontes=Veletlen(100). /* ha a szélén rossz irányt választott.) vége */ } /* while() vége */ if (Lepes>=MAXLEPES) { /* túllépte a megengedett lépésszámot.GNU C/C++ példaprogramok if (dx==0) { /* függõlegesen haladt */ dy=0.. } } /* Keres() vége */ /* memória felszabadítás */ void Vege(void) { int i. 80%−ában jobbra folytatja */ if (dontes<20) dx=−1. delete[] Mezo. /* az esetek 20%−ában balra.. /* az esetek 50%−ában felfelé.1). /* kurzor pozíconálása a képernyõ alsó részére */ gotoxy(1.. dontes=Veletlen(100). if (X==0 && dx==−1) dx=1. korrigálni kell */ if (Y==0 && dy==−1) dy=1."). Keres().. } } /* if (valtas. if (Y==19 && dy==1) dy=−1.i<80.23).i++) delete[] Mezo[i]. valószínûleg beszorult */ gotoxy(60. Vege().) vége */ } /* if (Akna. cputs("Nem sikerult. } 14 .

100% −> 40% Y irányú elmozdulás valószínûségei: −1 : 50% +1 : 50% X irányú elmozdulás valószínûségei: −1 : 20% +1 : 80% véletlenszám generálása más függvénnyel ¢ ¢ ¢ ¢ ¢ .GNU C/C++ példaprogramok 15 az [5] feladat a képernyõn A keresõ eljárás a következõ paraméterekkel állítható: MAXLEPES : maximális megengedett lépésszám irányváltás kikényszerítésére használt valószinûség : változó.

scanf("%d".&B).B. /* a paraméterek változtatása miatt az egymást követõ számok nem lesznek azonosak */ A = B. B = C. if (T!=NULL) { /* csak akkor menti az adatokat. } return(0). /* kezdõ értékek a pszeudo−véletlen számok generálásához */ int veletlen(int maximum) /* véletlenszerû számokat elõállító eljárás */ { int r. scanf("%d". scanf("%d". javításuk pedig egyszerû. Biztos.j).i<80000. /* állomány megnyitása */ T=fopen("ADAT. A szöveges állományok használata kényelmes.. r = (A + B*C)%maximum +1. /* beolvasás */ printf("A = "). } int main(void) /* fõprogram */ { FILE *T. /* segédváltozók */ printf("Adja meg a parametereket (A.. mert könnyen importálhatóak táblázatokba és az elterjedt statisztikai programok is olvassák.h> /* hagyományos ki− és bemeneti függvények: printf. Szerkesztésük. scanf */ int A. fclose(T).i++) { j=100+veletlen(500). ami biztos.GNU C/C++ példaprogramok 16 [6] Készítsünk programot.C): \n"). ha sikerült megnyitni az állományt */ for (i=0. } . printf("C = "). /* szöveges állomány az adatoknak */ int i.B.C.DAT". */ fflush(T). #include <stdio. } /* az fflush() utasítás a cache tartalmát lemezre menti. /* "j" egy 101 és 600 közötti véletlenszerû szám */ fprintf(T. A = r. /* "r" értéke 1 és maximum közötti egész szám */ return(r). printf("B = "). amelyik 80000 pszeudo−véletlen számot ír egy szöveges állományba.&C)."wt")."%d\n".&A).j.

printf("Adatok szama: %d\n". scanf */ #include <time. } } /* beolvasás vége */ ."%d\n". olvassunk be adatokat. /* memória foglalás */ if (A==NULL) { printf("Nincsen elegendo memoria! \n").GNU C/C++ példaprogramok [7] Az elõzõ programot felhasználva állítsunk elõ egy 80000 elemû egész számokból álló adatállományt. /* darabszám nullázása */ A = new int[MAXDATA]. A[darab++]=D.h> /* idõmérés */ /* konstans. /* szöveges állomány az adatokkal */ int D. if (T!=NULL) { /* ha a megnyitás sikeres volt. int darab. /* Adatok vektora */ /* Adatok száma */ /* idõmérõ */ 17 void Beolvas(char *Neve) /* adatok beolvasása "Neve" állományból */ { FILE *T. return.Neve).h> /* hagyományos ki− és bemeneti függvények: printf. #include <stdio.&D). } fclose(T)."rt"). /* segédváltozók */ darab=0.\n").darab). clock_t IDO. T=fopen(Neve. majd rendezzük az adatokat növekvõ számsorrendbe. ameddig van adat az állományban és még nem haladtuk meg a megengedett maximumot (MAXDATA) */ while (!feof(T) && darab<MAXDATA) { fscanf(T. } else { /* sikertelen megnyitasi kiserlet */ printf("Nem olvashato. } printf("Allomany: %s\n". a maximálisan feldolgozható adatok számát tartalmazza */ #define MAXDATA 80000 int *A. Többféle rendezési eljárást alkalmazva összehasonlíthatjuk azok sebességét.

\n"). printf("Beszurasos rendezes. ha a vizsgált szomszédok sorrendje nem megfelelõ.j. Az adatsor hátulról elõre haladva válik rendezetté.i−−) { csere=0.i<darab−1. */ void Beszurasos(void) { int i.i++) { tmp=A[i]. */ void Buborek(void) { int i. printf("Buborekos rendezes. mint a buborékok a vízben felfelé.. for (i=1. */ void EgyszeruCsere(void) { int i.i<darab.\n"). akkor kicseréli õket.j. A nagyobb számok úgy haladnak hátrafelé. A[i]=A[j]. A[j+1]=tmp. Az adatsor elölrõl hátrafelé haladva − a nagyobb sorszám felé − válik rendezetté. csere=1. for (j=0.\n").j<i.j<darab.. for (i=darab−1. /* ha nem volt csere = már rendezett */ } } /* buborékos rendezés vége */ /* beszúrásos rendezés: minden elemet az elõtte levõkkel hasonlít össze.tmp.. for (i=0. } } } } /* egyszerû cserés rendezés vége */ /* buborékos rendezés: két egymást követõ elemet hasonlít össze és csak akkor cserél. /* aktuális elem mentése */ 18 . Az adatsor elölrõl hátrafelé haladva válik rendezetté. } } if (csere==0) i=0.i++) { for (j=i.i>0. ott keresi meg azt a helyet..j++) { if (A[i]>A[j]) { tmp=A[i].tmp.GNU C/C++ példaprogramok /* egyszerû cserés rendezés: minden elemet összehasonlít az összes mögötte lévõvel és ha a sorrend nem megfelelõ. printf("Egyszeru cseres rendezes. A[j]=A[j+1]. A[j]=tmp..csere.tmp.j.j++) { if (A[j]>A[j+1]) { tmp=A[j]. ahova beilleszthetõ..

az adatsor két vége felõl közepe felé haladva rekurzívan vizsgálja az adatokat */ void Gyors(int bal. Az adatsor elölrõl hátrafelé haladva válik rendezetté */ void MinimumKeres(void) { int i.int jobb) { int i. printf("Minimum kivalasztasos rendezes.. /* elemek görgetése hátrafelé */ j−−.j. j−−.i++) { /* az "i" mögötti legkisebb keresése */ min=i. } A[j+1]=tmp.\n").i<darab−1. while (j>=0 && A[j]>tmp) { A[j+1]=A[j]. for (i=0. A[i]=A[j]. int tmp1.tmp.j<darab. do { while (A[i]<tmp1) i++.min. i++. } } } /* minimumkeresés vége */ /* a gyors rendezés nagyon hatékony eljárás. A[i]=tmp.GNU C/C++ példaprogramok j=i−1. while (tmp1<A[j]) j−−. for (j=i+1. /* beillesztés a megfelelõ pozícióba */ } } /* beszúrásos rendezés vége */ /* minimumkeresés: minden elemet a mögötte levõ elemek legisebbikével hasonlít össze. if (min!=j) { tmp=A[min]. A[min]=A[i].tmp2.j++) if (A[min]>A[j]) min=j.j. /* segédváltozók beállítása */ /* a középsõ elem értéke */ 19 . j=jobb.. i=bal. A[j]=tmp2. } } while (j>i). if (i<=j) { tmp2=A[i]. tmp1=A[(bal+jobb) / 2].

paraméterbõl.. vagy az értéke nincsen 1 és 5 között. } 20 .argv[0]). if (i<jobb) Gyors(i. return(1). printf("1 − Egyszeru cseres rendezes\n"). /* az idõ méréséhez */ if (argc!=3) { /* nem megfelelõ számú paraméter esetén kiírja a súgó−t */ printf("%s [file neve] [1/2/3/4/5]\n". hogy valóban monoton adatsor jött−e létre */ void Ellenor(void) { int i.i+1. */ printf("Ervenytelen parameter [1/2/3/4/5]: %s\n"."%d". printf("A[%d]=%d . return(2). char *argv[]) { int i. if (!sscanf(argv[2].j).jobb). while (i<darab−1 && A[i]<=A[i+1]) i++. A[%d]=%d\n". Gyors(0. amely azt vizsgálja. i=0. printf("5 − Gyors rendezes\n"). } i=0. if (i<darab−1) { printf("Hiba a rendezesben a %d. printf("3 − Beszurasos rendezes\n").darab−1).GNU C/C++ példaprogramok if (bal<j) Gyors(bal. } /* gyors rendezés vége */ /* ez a rutin végzi el a gyors rendezést */ void GyorsRendez(void) { printf("Gyors rendezes. } /* fõprogram */ int main(int argc.A[i+1]). printf("4 − Minimum kivalasztasos rendezes\n").\n").&i) || i<1 || i>5) { /* nem sikerült beolvasni a számot a 2. } /* ellenörzõ eljárás.A[i].i. } /* memória felszabadítás */ delete[] A..argv[2]). printf("2 − Buborekos rendezes\n"). double d.i). adatnal! \n".

42 Minimum kiválasztásos 183. 64MB RAM OS: Linux Mandrake 7. break. break. /* stopper indul */ switch (i) { case 1: EgyszeruCsere(). /* adatok beolvasása */ IDO=clock().2 ========================================= Módszer Idõ (sec) −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Egyszerü cserés 184.GNU C/C++ példaprogramok 21 Beolvas(argv[1]). break. return(0). } a [7] feladat értékelése Adatok száma: 80000 PC: Intel Celeron. printf("Szukseges ido: %lg sec\n". } /* szükséges másodpercek számítása */ d=(double)(clock()−IDO)/CLOCKS_PER_SEC.09 Gyors 0.01 Beszúrásos 111. case 4: MinimumKeres().d).10 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− .56 Buborékos 293. break. break. case 5: GyorsRendez(). case 3: Beszurasos(). Ellenor(). case 2: Buborek().

/* memória foglalás */ A = new double*[4].SS. /* segédváltozók */ int i.i<4. for (i=0. if (T!=NULL) { while (!feof(T) && darab<MAXDATA) { for (i=0.&d). scanf */ #include <math."%lf\n".i<3.h> /* matematikai eljárások: sqrt */ #define MAXDATA 3000 /* konstans: adatsorok maximális száma */ double **A. /* segédváltozók */ /* ha nincs elegendõ számú adat. /* adatállomány megnyitása és beolvasás */ T = fopen("adat. printf("\n"). /* beolvasott adatok száma */ void Beolvas(void) /* adatok beolvasása */ { FILE *T.k."%lf". } fscanf(T. } fclose(T). amely kiszámítja négy adatsor fontosabb statisztikai jellemzõit. for (i=0.min.dat".max.i<40. darab++."rt").GNU C/C++ példaprogramok 22 [8] Készítsünk programot. /* szöveges állomány */ double d.&d). /* adatmátrix */ int darab. /* segédváltozó */ int i.h> /* hagyományos ki− és bemeneti függvények: printf.i++) A[i] = new double[MAXDATA]. /* fejléc kiírása */ printf("Leiro statisztika\n"). A[3][darab]=d. nincs értelme a statisztikának sem */ if (darab<2) return.i++) printf("="). } } /* Leíró statisztika */ void Leiro(void) { double S. . #include <stdio. A[i][darab]=d.j. /* segédváltozó */ darab = 0.i++) { fscanf(T.

if (j>=darab) { printf("monoton csokkeno\n").4lf\n". /* monotonitás vizsgálata */ for (i=0.min. } else { printf("nem monoton\n").GNU C/C++ példaprogramok printf("# min. } else { j=1. S/=darab.i++) printf("−"). átlag. printf("\n").i<40. /* négyzetösszeg */ if (A[i][j]<min) min=A[i][j]. /* összeg */ SS+=A[i][j]*A[i][j]. atlag szoras\n"). /* maximum */ } SS = SS − S*S/darab.i<40.i++) { printf("%d : ". } else { j=1.i<4.4lf %8. max. if (j>=darab) { printf("szigoruan monoton csokkeno\n"). j=1. for (j=0. szórás számítása */ for (i=0. } } } } } /* elválasztó vonal */ for (i=0. /* minimum. if (j>=darab) { printf("monoton novekvo\n"). SS = sqrt(SS/(darab−1)). while (j<darab && A[i][j]<=A[i][j−1]) j++. /* minimum */ if (A[i][j]>max) max=A[i][j].i++) printf("−"). while (j<darab && A[i][j]>A[i][j−1]) j++. while (j<darab && A[i][j]>=A[i][j−1]) j++. min=max=A[i][0]. if (j>=darab) { printf("szigoruan monoton novekvo\n"). } else { j=1.SS).max.i++) printf("−").j++) { S +=A[i][j].4lf %8. maximum.i++) { S=SS=0. printf("\n").i<4. while (j<darab && A[i][j]<A[i][j−1]) j++.S.4lf %8. printf("%d %8.i+1. for (i=0. } /* elválasztó vonal */ for (i=0.i+1).j<darab. printf("\n"). } /* Leiro() vége */ 23 .i<40.

valószínûleg (p=95%) kiugró adatot talált */ if (r>0. for (i=0. /* ha meghaladja a kritikus értéket.k++) { if (d[j]>d[k]) { tmp=d[j]. 24 .j<darab−1. /* átmeneti tömb a rendezéshez */ /* ha nincsen elegendõ számú adat. [?] max. nincs értelme a statisztikának */ if (darab<2) return.GNU C/C++ példaprogramok /* kiugró értékek keresése: Dixon−próba */ void Kiugro(void) { double r. /* Dixon−próba az utolsó (legnagyobb) elemre */ r = d[darab−1]−d[darab−k]. printf("\n").i+1).r). /* 10 % meghatározása*/ /* Dixon−próba az elsõ (legkisebb) elemre */ r = d[0]−d[k].tmp. printf("%8.r). r/= d[darab−1]−d[k]. r/= d[0]−d[darab−k]. } } } printf("%d ". d[k]=tmp.k<darab. /* a négy adatsorra külön−külön */ for (i=0.j. d[j]=d[k]. /* fejléc kiírása */ printf("\nKiugro ertekek: Dixon−proba\n"). /* segédváltozó */ double *d. /* egyszerû cserés rendezés */ for (j=0. else printf(" [−] ").j++) { for (k=j+1. /* memória foglalás */ d = new double[darab].i<30.35) printf(" [+] "). k = darab/10. printf("# min. [?]\n"). printf("%8.4lf".i<4.k. printf("\n").4lf". for (i=0. /* Dixon−féle r érték.i++) printf("−").j++) d[j]=A[i][j]. segédváltozó */ int i.i<30.i++) { /* adatok átmásolása A mátrixból d tömbbe */ for (j=0.j<darab.i++) printf("=").

valószínûleg (p=95%) kiugró adatot talált */ if (r>0.S2.j++) { S1=S2=S3=S4=S5=0. M[i][j]=0. S5+=A[i][l]*A[j][l]. printf("\n").35) printf(" [+] ").i<4. S2+=A[i][l]*A[i][l].i++) printf("−"). } k = S5 − S1*S3/darab. /* fejléc kiírása */ printf("\nKorrelacios matrix (n=%d )\n". S2 −= S1*S1/darab. } } } 25 . else printf(" [−] "). S4+=A[j][l]*A[j][l]. for (i=0. S4 −= S3*S3/darab. for (i=0.j.k. printf("\n"). } /* Kiugro() vége */ /* adatsorok közötti lineáris kapcsolat keresése */ void Korrelacio(void) { double M[4][4]. S3+=A[j][l]. for (l=0.S5. M[i][j]=k. /* segédváltozók */ /* ha nincsen legendõ számú adat. /* memória felszabadítás */ delete[] d. nincs értelme a statisztikának */ if (darab<2) return. /* eredmény mátrix */ int i.l<darab. /* segédváltozók */ double S1.i<30.i++) { for (j=0.i++) printf("−").darab). } /* elválasztó vonal */ for (i=0.S4.l. printf("\n").GNU C/C++ példaprogramok /* ha meghaladja a kritikus értéket.l++) { S1+=A[i][l].S3. /* nullával osztást kerüljük el */ if (S2*S4>0) { k /= sqrt(S2*S4).j<4.i<38.

i<4. for (i=0.GNU C/C++ példaprogramok /* korrelációs mátrix kiiratása */ for (i=0. } /* fõprogram */ void main(void) { Beolvas().i<38. } else printf("%9s".j++) { 26 /* nullával osztást kerüljük el */ if (M[i][j]>−1 && M[i][j]<1) { k = M[i][j]*M[i][j]*(darab−2).i++) printf("−"). /* t−próba a korreláció ellenõrzésére: a nullhipotézis szerint a korreláció nem nulla */ /* fejléc kiírása */ printf("\nt−proba (H: r!=0) d.M[i][j]). } /* elválasztó vonal */ for (i=0.i++) delete[] A[i]. M[i][j] = sqrt(k). } /* Korrelacio() vége */ /* memória felszabadítása */ void Vege(void) { int i. /* else ág jelenti a +1 vagy −1 −es korrelációt: t értéke végtelen */ } printf("\n"). delete[] A. printf("\n"). } . printf("\n"). printf("\n").=%d\n".j<4. for (i=0. printf("\n").j<4.i++) { for (j=0.3lg".4lf".f. for (i=0.i<38. Kiugro(). Vege().i++) printf("−").i<4. printf(" %8. Leiro(). Korrelacio(). k/= 1 − M[i][j]*M[i][j].j++) printf(" %8. } /* elválasztó vonal */ for (i=0.i++) { for (j=0.darab−2).i<38."−−−−").i<4.i++) printf("−").M[i][j]).

=2998 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− −−−− 96.8695 −0.1108 [−] 2 0.7721 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 1 : szigoruan monoton novekvo 2 : szigoruan monoton novekvo 3 : szigoruan monoton csokkeno 4 : nem monoton −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Kiugro ertekek: Dixon−proba ============================== # min.0005 0.7084 2. max.7198 2 10.4169 4.9798 3 28.68e+07 −−−− 13.0088 [−] 0.7349 4 7.7886 4.2440 0.2440 0.6585 3.8 0.0000 1.3801 [+] 4 0.8 13. [?] −−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 1 0.6353 43. atlag szoras −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 1 0.0000 −0.3811 [+] 0.0000 9. [?] max.4 7.4 96.f.7601 8.0554 [−] 0.0000 −1.0088 [−] 3 0.0005 −0.0000 22.68e+07 13.8 −−−− −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 27 .2440 1.1111 [−] 0.8695 0.0248 13.8 96.4 0.GNU C/C++ példaprogramok a [8] feladat eredménye a képernyõn Leiro statisztika ======================================== # min.2440 −0.0000 29.0000 0.0000 0.8695 1.0000 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− t−proba (H: r!=0) d.0248 96.8695 −1.4 −−−− 7.0145 [−] −−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Korrelacios matrix (n=3000) −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 1.8196 25.5000 31.0000 33.

} } /* egyenes illesztése: Y = a + b*X */ void Egyenes(void) { double S1. Ezen alap típusok ismerete elegendõ lehet."%lf %lf\n". Y = new double[MAXDATA]."rt").S5.dat". scanf */ #include <math. /* memória foglalás */ X = new double[MAXDATA]. /* segédváltozó */ darab=0.h> /* matematikai függvények: sqrt */ #define MAXDATA 1000 /* konstans: adatsorok maximális száma */ double *X. r2 */ int i. beolvasás */ T=fopen("adat.&b). /* X értékek tömbje */ double *Y. Y[darab]=b. amely a mellékelt adatokra (ADAT.h> /* hagyományos ki− és bemeneti függvények: printf.&a.S3. /* beolvasott adatok száma */ /* adatok beolvasása */ void Beolvas(void) { FILE *T. if (T!=NULL) { while (!feof(T) && darab<MAXDATA) { fscanf(T. X[darab]=a.S4. /* állomány megnyitása.DAT) egyenest.B.GNU C/C++ példaprogramok 28 [9] Készítsünk programot. mert az egyszerûbb függvények általában visszavezethetõek egyenes illesztésére. #include <stdio. darab++.b. /* segédváltozók */ int i. /* segédváltozók: együtthatók. /* szöveges állomány */ double a. /* segédváltozó */ .R.S2. /* Y értékek tömbje */ int darab. /* segédváltozók: négyzetösszegek */ double A. } fclose(T). vagy parabolát illeszt a felhasználó választásától függõen.

S5+=X[i]*Y[i].A. darab=0. printf("Y = %lg + %lg * X\n". S1/= 1 − R*R. nullhipotézis: r2 nem nulla*/ if (R*R<1) { S1 = R*R*(darab−2). if (S3==0) { printf("Nullaval osztas: fuggoleges egyenes\n"). } /* meredekség */ B = S5/S3.i<darab.darab). S4+=Y[i]*Y[i]. S2/=darab. kilép */ if (darab==0 || X==NULL || Y==NULL) return. } } /* Egyenes() vége */ 29 . S1 = sqrt(S1). S3+=X[i]*X[i]. for (i=0.R. /* t−próba.B). /* négyzetösszegek számítása */ S1=S2=S3=S4=S5=0. S1=S2=0. } S1/=darab. } S5−=S1*S2/darab. S2+=Y[i].darab−2). printf("R−negyzet: %lg (n=%d)\n". /* tengelymetszet */ A = S2 − B*S1.GNU C/C++ példaprogramok /* ha nincsen adat. /* SQxy */ S3−=S1*S1/darab. else R = S5*S5/(S3*S4).S1. /* SQy */ /* R−négyzet számítása. for (i=0. printf("t−proba (H: r!=0) : %lg (df=%d)\n". ha lehetséges */ if (S3*S4==0) R=1.i<darab.i++) { S1+=X[i].i++) { S1+=X[i]. /* SQx */ S4−=S2*S2/darab. return. S2+=Y[i].

S[0]=S[1]=S[2]=0. S[3]+=Y[i]. S[6]−=S[1]*S[3]/darab.i<8. /* négyzetösszegek számítása */ for (i=0.GNU C/C++ példaprogramok /* parabola illesztése: Y = a + b1*X + b2*X^2 */ void Parabola(void) { double S[8]. S[1]+=X[i]*X[i]. S[5]+=X[i]*Y[i]. . r2 */ int i. S[2]−=S[1]*S[1]/darab.i<darab. S[1]−=S[0]*S[0]/darab.B2. S[1]+=X[i]. S[4]−=S[3]*S[3]/darab. } /* lineáris tag együtthatója */ B1 = S[2]*S[5] − S[7]*S[6]. /* segédváltozó */ /* ha nincsen adat. for (i=0. S[7]+=pow(X[i]. /* segédváltozók: négyzetösszegek */ double A. /* determinációs együttható */ R = B1*S[5] + B2*S[6]. /* négyzetes tag együtthatója */ B2 = S[1]*S[6] − S[7]*S[5]. S[2]+=pow(X[i].i++) { S[0]+=X[i]. S[5]−=S[0]*S[3]/darab. kilép */ if (darab==0 || X==NULL || Y==NULL) return.4). } S[7]−=S[0]*S[1]/darab. return.i<darab. /* számlálók nullázása */ for (i=0.B1. B2/= S[1]*S[2] − S[7]*S[7]. /* segédváltozók: együtthatók. R/= S[4]. S[6]+=X[i]*X[i]*Y[i].i++) S[i]=0.R. /* SP12 */ /* SQxy */ /* SQx2y */ /* SQx2 */ /* SQx */ /* SQy */ 30 if (S[1]*S[2]−S[7]*S[7]==0 || S[4]==0) { printf("Nullaval osztas: varatlan hiba\n").i++) { S[0]+=Y[i]. S[4]+=Y[i]*Y[i].3). B1/= S[1]*S[2] − S[7]*S[7].

do{ printf("Valasszon: "). S[1]/=darab.B1. /* t−próba.GNU C/C++ példaprogramok S[2]+=X[i]*X[i]. } S[0]/=darab. }while (i<1 || i>2).R. printf("2 − Y = a + b1*X + b2*X^2\n").B1. break. case 2: Parabola(). } } /* Parabola() vége */ /* a felhasználó által választott függvényt illeszti */ void Illeszt(void) { int i. /* tengelymetszet számítása */ A = S[0] − B1*S[1] − B2*S[2]. S[2]/=darab. printf("R−negyzet: %lg (n=%d)\n".darab−2). nullhipotézis: r2 nem nulla */ if (R*R<1) { B1 = R*R*(darab−2). } 31 . delete[] Y. scanf("%d".B2). /* segédváltozó */ printf("Melyik fuggvenyt illeszti?\n"). B1 = sqrt(B1). printf("Y = %lg + %lg * X + %lg * X^2\n". printf("t−proba (H: r!=0) : %lg (df=%d)\n". break.darab). printf("1 − Y = a + b*X\n"). } } /* memória felszabadítás */ void Vege(void) { delete[] X. B1/= 1 − R*R.&i). switch(i) { case 1: Egyenes().A.

705 + −0.4 (df=998) 32 [10] Végezzük el az elõzõ feladatban szereplõ függvények illesztését.GNU C/C++ példaprogramok /* fõprogram */ void main(void) { Beolvas(). .00765332 * X^2 R−negyzet: 0.257787 * X + −0. Vege(). /* segédváltozó */ darab=0.435 + 0.902 (df=998) Melyik fuggvenyt illeszti? 1 − Y = a + b*X 2 − Y = a + b1*X + b2*X^2 Valasszon: 2 Y = 90. /* szöveges állomány */ double a.999522 (n=1000) t−proba (H: r!=0) : 1444.933015 (n=1000) t−proba (H: r!=0) : 117.h> /* hagyományos ki− és beviteli függvények: printf. Y = new double[MAXDATA]. #include <stdio. /* memória foglalás */ X = new double[MAXDATA].431063 * X R−negyzet: 0. } a [9] program eredménye a képernyõn Melyik fuggvenyt illeszti? 1 − Y = a + b*X 2 − Y = a + b1*X + b2*X^2 Valasszon: 1 Y = 103.h> /* matematikai függvények: sqrt */ #define MAXDATA 1000 /* konstans: adatpárok maximális száma */ double *X. /* X értékek tömbje */ double *Y. /* segédváltozók */ int i. valamint az illesztés jóságának és a reziduumok autokorrelációjának elemzését. Illeszt(). fscanf */ #include <math.b. /* beolvasott adatsorok száma */ /* adatok beolvasása */ void Beolvas(void) { FILE *T. /* Y értékek tömbje */ int darab.

i++) { S1+=X[i]. /* nullával osztást kerüljük el */ if (S3==0) { printf("Nullaval osztas: fuggoleges egyenes\n").&b).R. beolvasás */ T=fopen("adat. /* SQy */ /* determinációs együttható számítása */ if (S3*S4==0) R=1.GNU C/C++ példaprogramok /* adatállomány megnyitása. return. if (T!=NULL) { while (!feof(T) && darab<MAXDATA) { fscanf(T. 33 . Y[darab]=b.B1. S4+=Y[i]*Y[i].S3. S3+=X[i]*X[i]. for (i=0.S2. else R = S5*S5/(S3*S4).S5. S5+=X[i]*Y[i].S4. darab=0. } } /* Beolvas() vége */ /* egyenes illesztése: Y = a + b*X */ void Egyenes(void) { double S1.tmp."%lf %lf\n". } S5−=S1*S2/darab. r2 */ int i. kilép */ if (darab==0 || X==NULL || Y==NULL) return.dat". /* négyzetösszegek számítása */ S1=S2=S3=S4=S5=0. /* segédváltozók: együtthatók. darab++. } fclose(T). /* SQx */ S4−=S2*S2/darab. /* segédváltozó */ /* ha nincs adat. X[darab]=a.&a. /* SQxy */ S3−=S1*S1/darab. /* segédváltozók: négyzetösszegek */ double A.i<darab. S2+=Y[i]. } /* meredekség számítása */ B1 = S5/S3."rt").

R.tmp.tmp."df". printf("Y = %lg + %lg * X\n". printf("Model %10.4lg\n".GNU C/C++ példaprogramok S1=S2=0.B1).tmp/(darab−2)).i<45. /* F−érték */ tmp/= (S4 − tmp)/(darab−2). printf("t−proba (H: r!=0) : %lg (df=%d)\n". printf("Hiba %10.4lg %5d %10. tmp = sqrt(tmp).i<darab. } printf("\nVariancia tablazat\n"). 34 .i++) { S1+=X[i].i++) printf("=")."SS". /* elsõ sor: a model által magyarázott eltérések */ tmp = S5*S5/S3. /* tengelymetszet számítása */ A = S2 − B1*S1.\n"). printf("R−negyzet: %lg (n=%d)\n"."MS".4lg %5d %10. S2+=Y[i].darab). tmp/= 1 − R."F"). printf("\n").1.tmp).4lg %5d\n". printf("%s %10s %5s %10s %10s\n".i++) printf("−"). } /* fejléc kiírása */ for (i=0. /* t−próba."Forras".tmp.A. printf("\n").darab−2). for (i=0. } S1/=darab. nullhipotézis: r2 nem nulla */ if (R<1) { tmp = R*(darab−2).4lg\n".i<45.i++) printf("−"). /* elválasztó */ for (i=0. /* második sor: a véletlen hibából adódó eltérések */ tmp = S4 − S5*S5/S3. if (S3==0) { printf("A tablazat nem keszitheto el nullaval osztas miatt.S4. printf(" %10. return. for (i=0.tmp).darab−2. S2/=darab.darab−1). /* összesen sor */ printf("Osszes %10. printf("\n").i<45.4lg".

4). S[6]+=X[i]*X[i]*Y[i]. S[3]+=Y[i]. /* négyzetösszegek számítása */ for (i=0. /* a Neumann−féle hányados várható értéke ideális esetben 2 körüli amennyiben az érték kettõtõl távol esik.tmp). valószínû a reziduumok autokorrelációja. if (i>0) { S4 = A + B1*X[i−1] − Y[i−1]. for (i=0.R. /* segédváltozók: együtthatók. } S[7]−=S[0]*S[1]/darab. S[6]−=S[1]*S[3]/darab. /* segédváltozó */ /* ha nincs adat. azaz nem sikerült a megtalálni a megfelelõ függvényt */ printf("Neumann−fele hanyados: %lg\n". S1=S2=0.GNU C/C++ példaprogramok printf("Reziduumok autokorrelaciojanak elemzese\n").tmp. S[2]+=pow(X[i]. S[4]+=Y[i]*Y[i].i<darab.i++) { S3 = A + B1*X[i] − Y[i].i<darab.B2. for (i=0.i++) { S[0]+=X[i].B1. } /* Egyenes() vége */ /* parabola illesztése: Y = a + b1*X + b2*X^2 */ void Parabola(void) { double S[8]. r2 */ int i. /* SP12 */ /* SQxy */ /* SQx2y */ /* SQx2 */ /* SQx */ /* SQy */ 35 . tmp/= S1*(darab−1).i++) S[i]=0. S1 += S3*S3. kilép */ if (darab==0 || X==NULL || Y==NULL) return. S[5]+=X[i]*Y[i]. /* segédváltozók: négyzetösszegek számításához */ double A. S[4]−=S[3]*S[3]/darab. S[2]−=S[1]*S[1]/darab. } } tmp = S2*darab. S2 += (S3−S4)*(S3−S4).3). S[1]+=X[i]*X[i]. S[5]−=S[0]*S[3]/darab. S[1]−=S[0]*S[0]/darab. S[7]+=pow(X[i].i<8.

S[2]/=darab.i++) { S[0]+=Y[i]. /* determinációs együttható */ R = B1*S[5] + B2*S[6]. } S[0]/=darab.\n"). for (i=0. return.darab−2). nullhipotézis: r2 nem nulla */ if (R<1) { tmp = R*(darab−2). S[0]=S[1]=S[2]=0.i<darab. /* négyzetes tag együtthatója */ B2 = S[1]*S[6] − S[7]*S[5]. printf("t−proba (H: r!=0) : %lg (df=%d)\n". /* t−próba. R = B1*S[5] + B2*S[6]. printf("R−negyzet: %lg (n=%d)\n". B1/= S[1]*S[2] − S[7]*S[7]. /* tengelymetszet számítása */ A = S[0] − B1*S[1] − B2*S[2]. B2/= S[1]*S[2] − S[7]*S[7]. } printf("\nVariancia tablazat\n").GNU C/C++ példaprogramok if (S[1]*S[2]−S[7]*S[7]==0 || S[4]==0) { printf("Nullaval osztas: varatlan hiba\n").B1.R. S[1]/=darab. printf("Y = %lg + %lg * X + %lg * X^2\n". tmp/= 1 − R. if (S[4]==R) { printf("A tablazat nem keszitheto el nullaval osztas miatt. S[2]+=X[i]*X[i].A. } /* lineáris tag együtthatója */ B1 = S[2]*S[5] − S[7]*S[6]. R/= S[4].darab).B2). S[1]+=X[i]. tmp = sqrt(tmp).tmp. } 36 . return.

tmp.R. for (i=0. printf("\n"). /* elválasztó vonal */ for (i=0.i<darab. S[1]=S[2]=0.i<45. printf("\n"). tmp/= S[1]*(darab−1).i++) printf("−"). S[1] += S[3]*S[3].R/2). printf("1 − Y = a + b*X\n")."df". /* második sor: véletlenszerû eltérések */ tmp = S[4]−R.i++) { S[3] = A + X[i]*(B1 + B2*X[i]) − Y[i].4lg %5d %10. /* a Neumann−féle hányados várható értéke ideális esetben 2 körüli amennyiben az érték kettõtõl távol esik. printf("Reziduumok autokorrelaciojanak elemzese\n")."F").darab−1). printf("Hiba %10.i++) printf("="). /* összesen sor */ printf("Osszes %10.i<45. F−érték */ printf("Model %10.4lg %5d\n". } /* Parabola() vége */ /* a felhasználó által választott illesztés elvégzése */ void Illeszt(void) { int i. valószínû a reziduumok autokorrelációja.4lg\n".2. printf("2 − Y = a + b1*X + b2*X^2\n")."SS". } } tmp = S[2]*darab.4lg\n". tmp = R*(darab−3)/(S[4] − R). printf("%s %10s %5s %10s %10s\n".4lg %5d %10. printf("\n"). /* segédváltozó */ printf("Melyik fuggvenyt illeszti?\n").i<45.darab−3.tmp)."MS". printf(" %10."Forras".i++) printf("−"). azaz nem sikerült a megtalálni a megfelelõ függvényt */ printf("Neumann−fele hanyados: %lg\n". /* elsõ sor: model által magyarázott eltérések. 37 .tmp/(darab−3)).4lg". for (i=0.GNU C/C++ példaprogramok /* fejléc kiírása */ for (i=0. if (i>0) { S[4] = A + X[i−1]*(B1 + B2*X[i−1]) − Y[i−1]. S[2] += (S[3]−S[4])*(S[3]−S[4]).tmp).S[4].

break. Vege().257787 * X + −0.785e+04 999 Reziduumok autokorrelaciojanak elemzese Neumann−fele hanyados: 0. case 2: Parabola(). } a [10] program eredménye a képernyõn Melyik fuggvenyt illeszti? 1 − Y = a + b*X 2 − Y = a + b1*X + b2*X^2 Valasszon: 2 Y = 90.02774 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Osszes 5.66 997 0. Illeszt(). break.00765332 * X^2 R−negyzet: 0.000165689 38 .084e+06 Hiba 27.999522 (n=1000) t−proba (H: r!=0) : 1444. switch(i) { case 1: Egyenes().&i).435 + 0.4 (df=998) Variancia tablazat ============================================= Forras SS df MS F −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Model 5. } /* fõprogram */ void main(void) { Beolvas().782e+04 2 2.GNU C/C++ példaprogramok do{ printf("Valasszon: "). scanf("%d".891e+04 2. } } /* Illeszt() vége */ /* memória felszabadítás */ void Vege(void) { delete[] X. delete[] Y. }while (i<1 || i>2).

} /* Y = f(x) számítása */ double Fuggveny(double x) { double d. /* Y értékek tömbje */ int darab.&b)."%lf %lf\n". } . /* a szinusz függvény együtthatói */ /* adatok beolvasása */ void Beolvas(void) { FILE *T. } fclose(T). /* állomány megnyitása */ T=fopen("adat.DAT állományban tárolt adatsorra! A feladat megoldására írjunk optimáló eljárást. fscanf */ #include <math. /* X értékek tömbje */ double *Y. if (T==NULL) { printf("Nem olvashato: ADAT.DAT\n").dat". return(d). /* segédváltozó */ d = PARAM[0] + PARAM[1]*sin(PARAM[2]*x + PARAM[3]). while (!feof(T) && darab<MAXDATA) { fscanf(T.b. #include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf.GNU C/C++ példaprogramok 39 [11] Illesszük az Y = A + B*sin( C*x + D ) függvényt az ADAT. /* szöveges adatállomány */ double a. } /* memória foglalás */ X = new double[MAXDATA]. Y = new double[MAXDATA]. return."rt"). X[darab]=a.&a. /* beolvasott adatok száma */ double PARAM[4]. /* segédváltozók */ darab = 0. Y[darab]=b.h> /* matematikai függvények: sin */ #define MAXDATA 4000 /* konstans: adatsorok maximális száma */ double *X. darab++.

for (i=0.j++) { /* irány meghatározása */ E0=Elteres(). kilép */ if (darab==0 || X==NULL || Y==NULL) return. /* segédváltozók */ int i.E1. /* paraméterenként külön−külön */ for (j=0. /* függõleges eltolás */ PARAM[1]=atlag/5. /* az optimálás induló lépéshosszai */ double E0.i<4. /* periódus */ PARAM[3]=1.i++) { fx = Fuggveny(X[i]). 40 . PARAM[j]+=LEPES[j]. d+= (Y[i]−fx)*(Y[i]−fx).j<4. /* 15 iterációs ciklus */ for (i=0. /* segédváltozók */ /* ha nincsen adat. iteracio: SS = %lg\n".i<darab.i++) LEPES[i]=PARAM[i]/10. E1=Elteres(). /* vízszintes eltolás */ /* induló lépéshossz a paraméter értékének 10 %−a */ for (i=0. /* segédváltozó */ d=0.i++) atlag+=Y[i].i++) { printf("%2d. } return(d).i<darab.Elteres()).j. /* segédváltozók */ int i. /* amplitudó */ PARAM[2]=2. PARAM[0]=atlag.GNU C/C++ példaprogramok /* eltérés négyzetösszegek számítása */ double Elteres(void) { double d. } /* közelítõ eljárás: cél az eltérés négyzetösszeg csökkentése */ void Kozelit(void) { double LEPES[4]. for (i=0.atlag. atlag/=darab.i.fx.i<15. /* kezdõ értékek meghatározása */ atlag=0.

/* addig változtatjuk a kívánt irányba.i++) printf("−"). } } /* iterációs ciklus vége */ } /* Kozelit() vége */ /* memória felszabadítás és statisztika készítése */ void Vege(void) { double Model.Hiba. for (i=0.Model/3.PARAM[2].4lf\n". printf("\n").3). /* függvény kiírása */ printf("\nY=%lg+%lg*SIN(%lg*x+%lg)\n".i++) atlag+=Y[i].R2. atlag/=darab.Fisher. PARAM[j]+=LEPES[j]. printf("\n").4lf %5d". for (i=0.i++) printf("="). Hiba +=(Y[i]−fx)*(Y[i]−fx).Fisher). Fisher = (Model*(darab−4))/(Hiba*3).i<darab. } /* fejléc kiírása */ for (i=0. printf("%15.i<60. printf("Forras SS df").atlag. /* adatok megjelenítése */ printf("Model %15. }while (E0−E1>0.i<darab. /* variancia táblázat számítása */ Model=Hiba=0. 41 . /* lépéshossz csökkentése */ LEPES[j]/=2.PARAM[1].Model. printf(" MS Fisher\n"). for (i=0.i++) { fx = Fuggveny(X[i]).i<60. Model+=(atlag−fx)*(atlag−fx).GNU C/C++ példaprogramok /* sikeres volt a lépés? Ha nem: ellenkezõ irányba próbáljuk meg */ if (E0<E1) LEPES[j]*=−1. E1=Elteres().PARAM[3]). /* segédváltozók */ int i. ameddig csökken az eltérés négyzetösszeg. vagy a csökkenés már nem számottevõ */ do{ E0=E1. atlag=0.fx.4lf %15.PARAM[0].001).

4lf\n". } /* fõprogram */ void main(void) { Beolvas(). darab = 0. 7.2 15838. } a [11] program eredménye a képernyõn 0.48917 1.1177 7. 3.darab−4). /* elválasztó vonal */ for (i=0. Vege(). 2. /* determinációs együttható */ R2=Model/(Model+Hiba).96236 1. 4.i++) printf("−").R2).1541 3 12704.54384 42 Y = 10. 14.Model+Hiba. 13.Hiba. printf("\n"). printf("%15. 10.3 3289. 9.i<60.4lf %5d". delete[] Y.99807 * x + −2.713276 0. 5.03383 ) ============================================================ Forras SS df MS Fisher −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Model 38113. printf("Ossz: %15. 6. Kozelit().GNU C/C++ példaprogramok printf("Hiba %15. 12.7028 Hiba 0.Hiba/(darab−4)).4581 28.4lf %5d\n".0001 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− Ossz: 38113.5249 3596 0.999986 .13645 3.765 88.3847 87033604. printf("R−negyzet = %lg\n".1439 0. 11.802 15. iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: SS SS SS SS SS SS SS SS SS SS SS SS SS SS SS = = = = = = = = = = = = = = = 46026 40657. 8. /* memória felszabadítás */ delete[] X.311 167.60239 * SIN( 2.5041 + −4. 1.6790 3599 R−negyzet = 0.darab−1).65 776.

"wt"). /* szöveges állomány az adatoknak */ double a.i<1000. if (T==NULL) { printf("Nem nyithato meg az allomany: ADAT.i++) { X = x + r*cos((a+i*b)*3. printf("Y = "). /* segédváltozók */ int i. scanf("%lf". return.&b). }while (a<0 || a>360). Y = y + r*sin((a+i*b)*3.14/180).360)= ").&x). b /= 1000."%lf %lf\n". printf("Sugar = ").&y). }while (b<a || b>360).DAT\n").y.DAT állományba menti.h> /* matematikai függvények: sin. do{ printf("Alfa (0.Y. do{ printf("Beta (%lg. cos */ /* fõprogram */ void main(void) { FILE *T. scanf("%lf".14/180).r.360)= ".X. printf("X = "). fprintf(T. printf("Adja meg a korivet hatarolo szogeket\n"). } /* koordináták számítása */ for (i=0.X. scanf("%lf". } /* cache ürítése. scanf("%lf".dat".&a). /* az 1000 adat lépésközének kiszámítása */ b −= a. } .&r). /* állomány megnyitása */ T=fopen("adat.. fprintf */ #include <math.x. /* segédváltozó */ /* adatok beolvasása */ printf("Adja meg a kor kozeppontjat\n"). scanf("%lf". fclose(T).a)..Y). #include <stdio. állomány lezárása */ fflush(T). amely a felhasználó által megadott paraméterekkel rendelkezõ körív 1000 pontjának X és Y koordinátáit ADAT.b. scanf.GNU C/C++ példaprogramok 43 [12] Készítsünk programot.h> /* hagyományos ki− és bemeneti függvények: printf.

A kör egyenlete: (x−u)^2 + (y−v)^2 = r^2 #include <stdio."%lf %lf\n". amelyik a 12. /* segédváltozók */ darab = 0. /* X koordináták tömbje */ double *Y. X[darab]=a.dat". while (!feof(T) && darab<MAXDATA) { fscanf(T. /* Y koordináták tömbje */ int darab. feladatban létrehozott adatokra kört illeszt. Y = new double[MAXDATA].h> /* hagyományos ki− és bemeneti függvények: printf. return.&a. /* a kör paraméterei */ /* adatok beolvasása */ void Beolvas(void) { FILE *T.h> /* matematikai függvények: sqrt */ #define MAXDATA 1000 /* konstans: adatsorok maximális száma */ double *X. } /* memória foglalás */ X = new double[MAXDATA]. } fclose(T). darab++. . scanf."rt"). /* állomány megnyitása */ T=fopen("adat. } /* Y érték számításaa megadott X koordinátához */ double Fuggveny(double x) { double d.DAT\n"). /* adatállomány */ double a. fscanf */ #include <math. hogy egy X értékhez két Y is tartozhat). Használjuk ismét a legkisebb négyzetek módszerét (figyelemmel arra.&b).GNU C/C++ példaprogramok 44 [13] Készítsünk programot. if (T==NULL) { printf("Nem olvashato: ADAT.b. /* beolvasott adatok száma */ double PARAM[3]. Y[darab]=b.

} /* optimáló eljárás: célja a négyzetes eltérések csökkentése */ void Kozelit(void) { double LEPES[3]. /* segédváltozók */ int i. ekkor gyököt sem vonhatunk belõle. printf("2 − adatok sulypontjabol indul\n").E1.fx. /* segédváltozók */ /* ha nincs adat. vagy majdnem teljes kört illeszthetünk */ printf("Az optimalas kezdeti beallitasa:\n"). } /* Fuggveny() vége */ /* eltérés négyzetösszeg számítása */ double Elteres(void) { double d. 45 . } return(d). scanf("%d". /* közelítés stratégiája: körívet. hogy d értéke negatív. /* lépéshossz */ double E0. return(d). d=0. /* segédváltozók */ int i.i<darab. kilépünk */ if (darab==0 || X==NULL || Y==NULL) return. for (i=0. /* a paraméterek változtatása során elõfordulhat.&i). /* az X[i] −hez tartozó megfelelõ Y érték keresése */ if (Y[i]<PARAM[1]) { fx = 2*PARAM[1] − fx. do{ printf("Valasszon: "). } d+= (Y[i]−fx)*(Y[i]−fx).atlag. */ d=sqrt(fabs(d))+PARAM[1]. printf("1 − origo kozeppontbol indul\n").j.i++) { fx = Fuggveny(X[i]). }while (i<1 || i>2).GNU C/C++ példaprogramok d=PARAM[2]*PARAM[2]−(x−PARAM[0])*(x−PARAM[0]).

PARAM[1]). } /* sugár becslése */ E0=0.PARAM[2]). PARAM[j]+=LEPES[j]. /* sikertelen próbálkozás esetén az irány megfordítása */ if (E0<E1) LEPES[j]*=−1. PARAM[1]=0. } PARAM[2]=sqrt(E0). do{ E0=E1. /* kezdeti lépéshossz beállítása */ LEPES[2]=PARAM[2]/10.i++) { printf("%2d. } PARAM[0]=E0/darab. for (i=0. E1+= (Y[i]−PARAM[1])*(Y[i]−PARAM[1]). /* iterációs közelítés. 15 ciklusban */ for (i=0.GNU C/C++ példaprogramok /* kezdeti paraméterek beállítása a választásnak megfelelõen */ if (i==1) { PARAM[0]=0. E1+=Y[i]. for (i=0.j++) { /* próba lépés */ E0=Elteres(). if (E0<E1) E0=E1.i<darab.i++) { E0+=X[i]. /* lépéshossz csökkentése */ } } } /* Kozelit() vége */ 46 . E1=Elteres(). E1=Elteres().PARAM[0].i. PARAM[1]=E1/darab. iteracio: SS = %lg\n".Elteres()). } else { E0=E1=0. printf("Sugar: R= %lg\n\n".i<darab. for (j=0.i<15. }while (E0−E1>0. LEPES[j]/=2. PARAM[j]+=LEPES[j]. Y= %lg\n". LEPES[0]=LEPES[1]=LEPES[2]/5.001).i++) { E1 = (X[i]−PARAM[0])*(X[i]−PARAM[0]). printf("\nKozeppont: X= %lg.j<3.

/* statisztika */ atlag=0. /* segédváltozók */ int i. } /* fõprogram */ void main(void) { Beolvas().darab). memória felszabadítás */ void Vege(void) { double Model.atlag.PARAM[1]. Vege().i++) { fx = Fuggveny(X[i]). Kozelit(). Model=Hiba=0. } Model+=(atlag−fx)*(atlag−fx).i<darab. Hiba +=(Y[i]−fx)*(Y[i]−fx).R2. R−négyzet kiszámítása.PARAM[0]). /* egyenlet megjelenítése */ printf("\n(X − %lg)^2 ". } R2=Model/(Model+Hiba).R2. printf("R−negyzet = %lg (n=%d)\n". printf("+ (Y − %lg)^2 = %lg^2\n". delete[] Y. darab = 0. atlag/=darab.i++) atlag+=Y[i].PARAM[2]).Hiba. /* memória felszabadítás */ delete[] X. for (i=0. } 47 .GNU C/C++ példaprogramok /* egyenlet kiírása.fx. for (i=0. /* a két lehetséges Y érték közül a megfelelõ kiválasztása */ if (Y[i]<PARAM[1]) { fx = 2*PARAM[1] − fx.i<darab.

216673 0.723373 0. 11. iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: SS SS SS SS SS SS SS SS SS SS SS SS SS SS SS = = = = = = = = = = = = = = = 60979.4999^2 R−negyzet = 1 (n=1000) .4 28435.00006)^2 + (Y − 3.85965 0. 8.0139 15. 10.9721 0.00004 Sugar: R= 18.13112 0.00002)^2 + (Y − 3. 1.8 5612. 10. 4. 13.5094 0.1009 4.99964)^2 = 18. 14. 7.137 89. 7. 9.37 345. 8. 2. 13.0726369 0. 11. 12. Y= 0 Sugar: R= 22.54863 12117. 3.807 2. 4.73 614.258 146. 6. 3. 14.84 2924. 2.11 1565.0766894 0.GNU C/C++ példaprogramok 48 a [13] feladat eredménye a képernyõn Az optimalas kezdeti beallitasa: 1 − origo kozeppontbol indul 2 − adatok sulypontjabol indul Valasszon: 1 Kozeppont: X= 0. 9. iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: SS SS SS SS SS SS SS SS SS SS SS SS SS SS SS = = = = = = = = = = = = = = = 6.115 58.64429 1.248485 0.4998^2 R−negyzet = 1 (n=1000) Az optimalas kezdeti beallitasa: 1 − origo kozeppontbol indul 2 − adatok sulypontjabol indul Valasszon: 2 Kozeppont: X= 1. Y= 4.99982)^2 = 18. 5. 6.992839 0.2038 14.262 219.99062.7 4789. 1.0144445 (X − 2.085 177. 5.0231675 (X − 2. 12.213671 0.31527 0.

h> /* hagyományos ki− és bemeneti függvények: printf. .h> /* matematikai függvények: sqrt */ #define MAXDATA 1000 /* konstans: adatsorok maximális száma */ double *X. fscanf */ #include <math. } /* sugár érték számítása a megadott X és Y koordinátákhoz */ double Fuggveny(double x. /* X koordináták tömbje */ double *Y."%lf %lf\n". Y = new double[MAXDATA]. Y[darab]=b.dat". darab++. /* Y koordináták tömbje */ int darab. scanf.DAT\n"). amely a 12. if (T==NULL) { printf("Nem olvashato: ADAT. feladat felhasználásával létrehozott adatokra kört illeszt. } fclose(T). #include <stdio. A négyzetes eltéréseket számoljuk sugár irányba! Figyeljük meg. hogy az elõzõ feladathoz képest csupán néhány részletet kell módosítani.&a. /* a kör paraméterei */ /* adatok beolvasása */ void Beolvas(void) { FILE *T. } /* memória foglalás */ X = new double[MAXDATA]. /* állomány megnyitása */ T=fopen("adat. /* adatállomány */ double a. /* beolvasott adatok száma */ double PARAM[3].double y) { double d.GNU C/C++ példaprogramok 49 [14] Készítsünk programot. while (!feof(T) && darab<MAXDATA) { fscanf(T."rt").b.&b). d = (x−PARAM[0])*(x−PARAM[0]) + (y−PARAM[1])*(y−PARAM[1]). /* segédváltozók */ darab = 0. X[darab]=a. return.

GNU C/C++ példaprogramok d = sqrt(d); return(d); } /* Fuggveny() vége */ /* eltérés négyzetösszeg számítása */ double Elteres(void) { double d,fx; /* segédváltozók */ int i; d=0; for (i=0;i<darab;i++) { fx = Fuggveny(X[i],Y[i]); d+= (PARAM[2]−fx)*(PARAM[2]−fx); } return(d); } /* optimáló eljárás: cél a négyzetes eltérések csökkentése */ void Kozelit(void) { double LEPES[3]; /* lépéshossz */ double E0,E1,atlag; /* segédváltozók */ int i,j; /* segédváltozók */ /* ha nincsen adat, kilépünk */ if (darab==0 || X==NULL || Y==NULL) return; /* optimálás induló paramétereinek becslése */ printf("Az optimalas kezdeti beallitasa:\n"); printf("1 − origo kozeppontbol indul\n"); printf("2 − adatok sulypontjabol indul\n"); do{ printf("Valasszon: "); scanf("%d",&i); }while (i<1 || i>2); /* választásnak megfelelõ paraméter becslés */ if (i==1) { PARAM[0]=0; PARAM[1]=0; } else { E0=E1=0; for (i=0;i<darab;i++) { E0+=X[i]; E1+=Y[i]; } PARAM[0]=E0/darab; PARAM[1]=E1/darab; }

50

GNU C/C++ példaprogramok /* sugár becslése */ E0=0; for (i=0;i<darab;i++) { E1 = (X[i]−PARAM[0])*(X[i]−PARAM[0]); E1+= (Y[i]−PARAM[1])*(Y[i]−PARAM[1]); if (E0<E1) E0=E1; } PARAM[2]=sqrt(E0); /* induló lépéshossz beállítása */ LEPES[2]=PARAM[2]/10; LEPES[0]=LEPES[1]=LEPES[2]/5; printf("\nKozeppont: X= %lg, Y= %lg\n",PARAM[0],PARAM[1]); printf("Sugar: R= %lg\n\n",PARAM[2]); /* közelítés 15 iterációs ciklusban */ for (i=0;i<15;i++) { printf("%2d. iteracio: SS = %lg\n",i,Elteres()); for (j=0;j<3;j++) { /* próba lépés */ E0=Elteres(); PARAM[j]+=LEPES[j]; E1=Elteres(); /* ha sikertelen volt a lépés, irány megfordítása */ if (E0<E1) LEPES[j]*=−1; do{ E0=E1; PARAM[j]+=LEPES[j]; E1=Elteres(); }while (E0−E1>0.001); LEPES[j]/=2; /* lépéshossz felezése */ } } } /* Kozelit() vége */ /* egyenlet kiírása, statisztika, memória felszabadítás */ void Vege(void) { double Model,Hiba,fx,atlag,R2; /* segédváltozók */ int i; /* egyenlet kiírása */ printf("\n(X − %lg)^2 ",PARAM[0]); printf("+ (Y − %lg)^2 = %lg^2\n",PARAM[1],PARAM[2]);

51

GNU C/C++ példaprogramok /* statisztika */ atlag=0; for (i=0;i<darab;i++) atlag+=Y[i]; atlag/=darab; Model=Hiba=0; for (i=0;i<darab;i++) { fx = PARAM[2]*PARAM[2] – (X[i]−PARAM[0])*(X[i]−PARAM[0]); /* gondolni kell arra is, hogy fx értéke lehet negatív, abból pedig nem tudunk gyököt vonni */ fx = sqrt(fabs(fx)) + PARAM[1]; /* a két lehetséges Y érték közül a megfelelõ kiválasztása */ if (Y[i]<PARAM[1]) { fx = 2*PARAM[1] − fx; } Model+=(atlag−fx)*(atlag−fx); Hiba +=(Y[i]−fx)*(Y[i]−fx); } R2=Model/(Model+Hiba); printf("R−negyzet = %lg (n=%d)\n",R2,darab); /* memória felszabadítás */ delete[] X; delete[] Y; darab = 0; } /* fõprogram */ void main(void) { Beolvas(); Kozelit(); Vege(); }

52

GNU C/C++ példaprogramok a [14] feladat eredménye a képernyõn Az optimalas kezdeti beallitasa: 1 − origo kozeppontbol indul 2 − adatok sulypontjabol indul Valasszon: 1 Kozeppont: X= 0, Y= 0 Sugar: R= 22.9721 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: iteracio: SS SS SS SS SS SS SS SS SS SS SS SS SS SS SS = = = = = = = = = = = = = = = 27548.3 6104.52 1115.64 497.118 28.9866 15.9215 8.87305 2.61902 0.474628 0.0324917 0.0111954 0.00148412 0.00133739 0.000322287 1.78156e−05

53

(X − 2.00002)^2 + (Y − 3.99988)^2 = 18.5^2 R−negyzet = 1 (n=1000) A CD−ROM mellékleten található adatok valódi egyenlete a következõ: (x−2)2 + (y−4)2 = 18,52 azaz a középpontja O(2;4) és sugara R = 18,5

GNU C/C++ példaprogramok

54

[15] A mellékletben található MINTA.DAT adatait (soronként 3 egész szám) válassza két osztályra a dinamikus K−közép módszerével. A klaszter analízis kiinduló adatait automatikusan határozza meg! A hozzárendelés eredményét mentse a KLASZTER.DAT szöveges állományba. #include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf */ #define SOR 30000 /* konstans: adatsorok maximális száma*/ #define OSZLOP 3 /* konstans: adatok száma egy sorban */ int **A; /* adatmátrix */ int darab; /* adatok száma */ int *C1; /* 1. klaszter centruma */ int *C2; /* 2. klaszter centruma */ /* adatok beolvasása */ void Beolvas(void) { FILE *T; /* szöveges állomány az adatokkal */ int i,a; /* segédváltozók */ darab=0; T=fopen("minta.dat","rt"); if (T==NULL) { printf("Hiba a megnyitas soran! \n"); return; } /* memória foglalás: OSZLOP x SOR mátrix */ A = new int*[OSZLOP]; for (i=0;i<OSZLOP;i++) A[i]=new int[SOR]; /* ameddig van adat és még nem olvastunk be "SOR" darabot */ while (!feof(T) && darab<SOR) { for (i=0;i<OSZLOP−1;i++) { fscanf(T,"%d",&a); A[i][darab]=a; } fscanf(T,"%d\n",&a); A[OSZLOP−1][darab]=a; darab++; } fclose(T); printf("[MINTA.DAT]\n"); printf("N = %d\n",darab); }

. /* 1. /* 1. printf("Klaszter kozepek becslese. /* minden tizediket kiválasztva megkeresi a legtávolabbiakat => gyorsabb */ dmax=0.k++) { C1[k]=A[k][c1]. C2 = new int[OSZLOP]. /* segédváltozók */ long d. klaszter középpontja */ long N1.i+=10) { for (j=i+10. /* centrumok adatainak mentése */ for (k=0. for (i=0. if (d>dmax) { dmax=d.j<SOR−11. printf("\n"). } /* képernyõre kiiratás */ printf("K#1: "). /* segédváltozók */ double d1. C2[k]=A[k][c2].dmax.\n"). /* 2. c1=i.c2.j+=10) { d=0. for (k=0.i++) printf(" %3d".j.i<OSZLOP. klaszter adatainak száma */ long N2.j. c2=j. for (i=0. printf("K#2: "). klaszter adatainak száma */ int i. } } } /* memória foglalás */ C1 = new int[OSZLOP].C2[i]).k. klaszter középpontja */ double *K2. for (i=0. /* 2.i<OSZLOP. } /* dinamikus K−közép módszere: minden iterációval újraszámolja a középpontot */ void Klaszter(void) { double *K1.i<SOR−11.GNU C/C++ példaprogramok 55 /* klaszter közepeinek becslése a legtávolabbi értékekkel */ void Centrum(void) { int i. /* eredmények szöveges állománya */ .k++) d+=(A[k][i]−A[k][j])*(A[k][i]−A[k][j]).d2.k<OSZLOP. printf("\n")..i++) printf(" %3d".k<OSZLOP. /* távolságok */ if (darab==0) return.C1[i]). /* távolságok */ FILE *T.c1.

N1).i++) { K1[i]=(double)C1[i]."2 %lg\n". N1++. for (i=0. klaszter középpontjától */ for (j=0. printf("\n").N2). elemszámokkal együtt */ printf("K#1 [N=%8d]: ". klaszter középpontjától */ d2=0. } if (d1<d2) { /* középpont újraszámolása */ for (j=0. /* távolság a 2. /* inicializálás */ for (i=0.i<darab.DAT"..GNU C/C++ példaprogramok 56 /* adatállomány megnyitása */ T=fopen("KLASZTER.j++) K2[j]=(N2*K2[j]+A[j][i])/(N2+1). fclose(T)."wt").d2). } /* memória foglalás */ K1 = new double[OSZLOP].i<OSZLOP.i++) printf(" %6.i++) { d1=0.j<OSZLOP.2lf". return. K2 = new double[OSZLOP]. printf("K#2 [N=%8d]: ".K1[i]).i<OSZLOP. fprintf(T. /* távolság az 1.j++) K1[j]=(N1*K1[j]+A[j][i])/(N1+1).j<OSZLOP. for (i=0. } printf("Klaszterezes. d2+=(K2[j]−A[j][i])*(K2[j]−A[j][i]). K2[i]=(double)C2[i].j++) { d1+=(K1[j]−A[j][i])*(K1[j]−A[j][i]). } .\n"). N1=N2=1.d1). } else { /* középpont újraszámolása */ for (j=0."1 %lg\n"..i<OSZLOP. fprintf(T. N2++. for (i=0. if (T==NULL) { printf("Hiba a megnyitasnal. állomány lezárása */ fflush(T)..j<OSZLOP. /* számított középpontok megjelenítése.. } } /* cache ürítése.K2[i]).i++) printf(" %6.\n"). printf("\n").2lf".

34 188.i<OSZLOP. delete[] C1.62 93.62 MINTA..DAT] N = 30000 Klaszter kozepek becslese.i++) delete[] A[i]. zöld és kék színkomponenseit jelentik.75 17. Vege().. K#1 [N= 11208]: 95. K#1: 8 23 9 K#2: 207 218 184 Klaszterezes. delete[] A. Az alábbi képek bemutatják a klaszter analízis erdeményét: VIRAG_A.GNU C/C++ példaprogramok 57 /* memória felszabadítás */ void Vege(void) { int i.. Centrum().DAT adatait a BMP2DAT programmal hoztuk létre.55 K#2 [N= 18794]: 69. for (i=0. Az adatok így soronként egy képpont vörös. delete[] C2.BMP VIRAG_B. Klaszter().BMP .16 137. } /* fõprogram */ void main(void) { Beolvas(). } a [15] feladat eredményei [MINTA..

/* segédváltozók */ db0=db1=0.a. for (i=0."rt").i<OSZLOP."%d". T=fopen("MINTA. T=fopen("INIT. Az eredményt mentsük el EREDMENY.DAT állományba (osztály és távolság adatokat). /* a tanulóminta statisztikai adatai */ if (T==NULL) { printf("Nem megnyithato! \n"). /* adatállomány */ if (T==NULL) { printf("Nem megnyithato! \n"). /* szöveges állomány */ int i.DAT tartalmazza.DAT". } . return.i++) O[i]=new int[OSZTALY]."rt"). db0++.GNU C/C++ példaprogramok [16] Osztályozzuk MINTA.&a).&a). #include <stdio.DAT adatait (az állomány soronként három egész számot tartalmaz)."%d\n". } fscanf(T. O[i][db0]=a. int db1. } fclose(T).DAT". int **A.h> /* hagyományos ki− és bemeneti függvények: printf. return.i++) { fscanf(T. Az osztályozáshoz szükséges adatokat INIT. scanf */ #define SOR 30000 #define OSZLOP 3 #define OSZTALY 3 int **O. /* beolvasás az adatállományból */ while (!feof(T) && db0<OSZTALY) { for (i=0. O[OSZLOP−1][db0]=a. /* adatsorok maximális száma */ /* adatok száma egy sorban */ /* osztályok maximális száma */ 58 /* osztályok adatai */ /* adatmátrix */ /* osztályok száma */ /* adatsorok száma */ void Beolvas(void) /* adatok beolvasása */ { FILE *T. } /* memória foglalás */ O = new int*[OSZLOP]. int db0.i<OSZLOP−1.

for (k=0.k. if (d<d2) { d2=d. } fscanf(T."wt"). for (j=0.DAT". o=j. if (T==NULL) { printf("Nem megnyithato! \n"). db1++. return. } fflush(T)."%d %d\n". } /* Beolvas() vége */ /* adatok osztályozása az osztályok középpontjaitól mért távolság alapján: eredmény mentése az EREDMENY.k++) d+=(A[k][i]−O[k][j])*(A[k][i]−O[k][j]).&a).d2).j.i++) { fscanf(T.o.i++) { d2=999999. } fclose(T). for (i=0. /* beolvasás az adatállományból */ while (!feof(T) && db1<SOR) { for (i=0.GNU C/C++ példaprogramok /* memória foglalás */ A = new int*[OSZLOP]. fclose(T). /* a legközelebbi osztály kiválasztása */ } } fprintf(T. A[OSZLOP−1][db1]=a. } /* memória felszabadítás */ void Vege(void) { int i.i<db1. A[i][db1]=a.o.i++) A[i]=new int[SOR].j++) { d=0. /* segédváltozók */ long d.&a). } for (i=0.i<OSZLOP.DAT állományba. /* távolságok */ T=fopen("EREDMENY. */ void Osztalyoz(void) { FILE *T.i<OSZLOP−1.k<OSZLOP."%d\n". /* távolság kezdõértéke */ o=0."%d". /* szöveges állomány */ int i.d2. 59 .j<db0.

i++) { delete[] O[i]. Vege(). } a [16] feladat eredménye 60 INIT.0.BMP .GNU C/C++ példaprogramok for (i=0. delete[] A.DAT adatai a következõ színeket azonosítják soronként: kék (0.BMP VIRAG_C.0). } /* fõprogram */ void main(void) { Beolvas().255.255). } delete[] O. Osztalyoz(). zöld (0.i<OSZLOP. delete[] A[i]. sárga (255.0).255. Az osztályozás eredényét az alábbi képek mutatják be: VIRAG_A.

Elsevier Applied Science Publishers Ltd. (2000): C/C++ programozás. Budapest.−II. Budapest.I. (1997): Numerikus módszerek I. optimization and machine learning. Bryson. (1993): Numerikus módszerek mérnököknek. LSI Oktatóközpont. 6. estimation and control. Essex UK. Budapest. 9.. Budapest. Bojarinov.J. 3. Springer−Verlag. Mezõgazdasági Kiadó. Bérczi N. Csizmás F. Akadémiai Kiadó. New York. A. Wright (1999): Numerical optimization.R. Budapest. 10. J. S. (1993): Mérések tervezése és eredményeik értékelése. Kafarov (1973): Optimalizálás a vegyiparban. A. Y. Goldberg.Sváb J. Budapest. Nocedal.. (1998): Genetic algorithms in search. Lieberman (1999): Bevezetés az operációkutatásba.Popper Gy. Mûszaki Könyvkiadó. Kemény S. Mûszaki Könyvkiadó.. J. .GNU C/C++ példaprogramok 61 Ajánlott irodalom 1. V. LSI Oktatóközpont. Obádovics Gy. Budapest. 2. Bodor L. 5. 8. 7. D. Addison Wesley Longman Inc. Deák A.C..E. Ho (1981): Applied optimal control: optimization.E. 11. (1981): Biometriai módszerek a kutatásban. Piggott (1986): Statistical procedures in food research. LSI Oktatóközpont. Hillier.V. Hemisphere Publishing Corporation 4.