bodor lászló, bérci norbert, baranyai lászló - c, c++ programozás feladatokkal, cd...

GNU C/C++ példaprogramok 1

Mérnöki számítások C/C++ nyelven16 feladat a GNU C használóinak

Tartalom

1. (a+b)^n együtthatóinak kiszámítása a Pascal háromszög segítségével 32. Játék pszeudo−véletlen számokkal 53. Optimáló eljárás az elõzõ játék automatikus megoldására 64. Szélsõérték keresése az aranymetszés módszerével 75. Aknamezõn biztonságos útvonalat keresõ eljárás 106. Pszeudo−véletlen számokat tartalmazó adatállomány készítése 167. Rendezési eljárások sebességének összehasonlítása 178. Adatsorok egyszerû statisztikái, valamint korrelációja 229. Egyszeû függvények illesztése 2810. Illesztések értékelése: variancia analízis, reziduumok elemzése 3211. Tetszõleges függvény illesztése optimáló eljárás segítségével 3912. Egy kiválasztott kör pontjainak koordinátái 4313. Kör illesztése a legkisebb négyzetek módszerével 4414. Kör illesztése a sugár irányú négyzetes eltérések minimálásával 4915. Klaszter analízis a dinamikus K−közép módszerével 5416. Osztályozás tanulóminta adatai alapján 58

Ajánlott irodalon 61

CD−ROM melléklet:

\TELEPITO Telepítõ készletekWIN MS−DOS / WindowsLINUX Linux

\FELADATOK Feladatok kidolgozása01 1. feladat állományai EXE MS−DOS / Windows bináris ELF Linux bináris02 2. feladat állományai EXE MS−DOS / Windows bináris ELF Linux bináris...16 16. feladat állományai EXE MS−DOS / Windows bináris ELF Linux bináris


Elõszó

Olyan feladatgyûjteményt tart kezében a kedves olvasó, amely elsõsorban a mûszaki képzésbenrésztvevõ egyetemi és fõiskolai hallgatók számára készült. A könyv azonban nem csupán nekikajánlható, hanem mindazoknak, akik mérési eredményeik kiértékelése érdekében nem riadnakvissza a számítógép programozásától.

A feladatgyûjtemény célja a mérnöki munka, kutatás során alkalmazható matematikai módszerekbemutatása. Ennek érdekében a közölt C és C++ forráskódok egyszerûek, sok megjegyzésselkiegészítve. A megértést a változók, eljárások beszédes nevei és a fenntartott szavak kiemelésetovább segíti. A feladatok megértését nagymértékben segíti Pascal vagy C, C++ programozásiismeret, optimálásban, operációkutatásban szerzett gyakorlat.

A CD−ROM mellékleten található telepítõ készletek segítségével a számítógépen létrehozható aszükséges fejlesztõi környezet. Ez a környezet magába foglalja a fordító programot (gcc) ésWindows, valamint MS−DOS alatt az RHIDE keretrendszert és az Emacs nevû szerkesztõt.Telepítés Windows / MS−DOS alatt:

1., másolja át [CD−ROM]\TELEPITO\WIN\ tartalmát egy ideiglenes könyvtárba2., indítsa el az INSTALL.EXE önkicsomagoló programot3., indítsa el a LBINSTDJ.EXE programot

Linux rendszerekben a GNU C fordító beépített elem. Ha frissíteni szeretné, a csomagot megtaláljaa [CD−ROM]\TELEPITO\LINUX\ könyvtárban. A telepítéshez szükséges tennivalókat tartalmazzaa csomag README állománya. Linux rendszerekben a C fordító csak része a GNU CommonCompilers csomagnak, ezért a mellékleten megtalálható a Java, Object C, Fortran 77 fordító is. HaLinux környezetben hibaüzenetet kap a matematikai függvények hiányára hivatkozva, használja akövetkezõ parancsot:

gcc f or r as. c −l m

ahol az "−lm" kapcsoló a matematikai könyvtár hozzáfûzését jelenti.

Amennyiben további információkra van szüksége a GNU C fejlesztõi környezetrõl (leírások,frissítések), a következõ két internet címet javasolhatom:

http://www.delorie.com/djgpphttp://gcc.gnu.org

2001. január

Jó munkát kívánok:

a szerzõ


[1a] Készítsünk programot, amely a képernyõre írja a Pascal−háromszög elsõ N sorát. Ha a programot késõbb bõvíteni szeretnénk, az értékeket célszerû egy mátrixba helyezni.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf * /

int main(void){ int * *H; /* H tartalmazza a háromszöget * / int i,j,n; /* segédváltozók * /

printf("A kovetkezo nevezetes szorzat egyutthatoit szamolja ki \n"); printf("ez a program: (a+b)^n \n");

/* beolvas egy 3 és 14 közötti számot * / do{ printf("n (3..14) = "); scanf("%d",&n); } while (n<3 || n>14);

/* megnöveljük "n" értékét, mert a legelsõ sor az n=0 kitevõ adatait tartalmazza * / n++;

/* memória foglalás; a háromszög minden sora csak a szükséges területet köti le. * / H = new int* [n]; for (i=0;i<n;i++) H[i] = new int[i+1];

/* feltöltés * / H[0][0]=1; H[1][0]=1; H[1][1]=1; for (i=2;i<n;i++) { H[i][0]=1; /* elsõ elem a sorban * / H[i][i]=1; /* utolsó elem a sorban * / for (j=1;j<i;j++) H[i][j]=H[i−1][j−1]+H[i−1][j]; }

/* Pascal−háromszög kiiratása * / for (i=0;i<n;i++) { printf("%2d: ",i); for (j=0;j<=i;j++) printf("%5d",H[i][j]); printf("\n"); }

/* memória felszabadítás * / for (i=0;i<n;i++) delete[] H[i]; delete[] H;

return(0);}


[1b] Az elõzõ feladat egyszerüsített megoldása, ha nem szükséges az adatok tárolása esetleges késõbbi felhasználásukhoz.


int main(void){ int *V; /* V vektorban tárolja az értékeket * / int i,j,n; /* segédváltozók * /

printf("A kovetkezo nevezetes szorzat egyutthatoit szamolja ki \n"); printf("ez a program: (a+b)^n \n");

do{ printf("n (3..14) = "); scanf("%d",&n); } while (n<3 || n>14);

/* memória foglalás * / V = new int[n+1];

for (i=0;i<=n;i++) { /* "i" azonosítja a Pascal−háromszög sorait * /

V[i]=1; /* a sor utolsó eleme * /

for (j=i−1;j>0;j−−) V[j]+=V[j−1];

printf("%3d.: ",i); for (j=0;j<=i;j++) printf("%5d",V[j]); printf("\n"); }

delete[] V;

return(0);}

[1a] és [1b] programok eredménye a képernyõn A kovet kezo nevezet es szor zat egyut t hat oi t szamol j a k iez a pr ogr am: ( a+b) ^nn ( 3. . 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


[2] Készítsünk játékprogramot, amely kitalál egy egész számot 1−tõl 100−ig. A felhasználó 10 alkalommal kérdezhet rá. A program csak annyit válaszolhat, hogy a beírt érték kisebb, vagy nagyobb, mint az általa választott, esetleg egyenlõek.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf * /#include <dos.h> /* pszeudo−véletlenszám elõállításához: gettime * /

int Hasonlit(int mit,int mivel) /* két számot hasonlít össze, visszatérési értékei: −1, 0, 1 * /{ if (mit>mivel) return(1); if (mivel>mit) return(−1); return(0);}

int Beallit(int maximum) /* pszeudo−véletlen szám elõállítása az aktuális idõ adataiból * /{ struct time T; int r;

gettime(&T); r = (T.ti_hund + T.ti_sec*T.ti_min)%maximum +1;

/* "r" értéke az 1..maximum tartományban van * / return(r);}

int main(void) /* fõprogram * /{ int Gep,Ember,N;

Gep=Beallit(100); printf("\n Kitalaltam egy szamot 1−tol 100−ig....");

N=0; /* számláló nullázása * / do{ printf("\n[%d] Mit tippel? ",N+1); scanf("%d",&Ember); switch(Hasonlit(Ember,Gep)) { case 1: printf("Tul sok. "); break; case −1: printf("Tul keves. "); break; case 0: printf("ELTALALTA!"); break; } N++; } while(Ember!=Gep && N<10);

printf("\n Probalkozasok szama: %d, keresett szam: %d\n",N,Gep);

return(0);}


[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.


int Hasonlit(int mit,int mivel) /* két számot hasonlít össze, visszatérési értékei: −1, 0, 1 * /{ if (mit>mivel) return(1); if (mivel>mit) return(−1); return(0);}

/* 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,Ember,N,Also,Felso;

/* beolvas egy egész számot 1−tõl 100−ig * / do{ printf("\n Kitalalt egy szamot 1−tol 100−ig? "); scanf("%d",&Ember); } while(Ember<1 || Ember>100);

N=0; Also=0; Felso=101; /* 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;

printf("%d. tippem: %d\n",N+1,Gep); switch(Hasonlit(Gep,Ember)) { case 1: printf("Tul sok.\n"); Felso=Gep; break; case −1: printf("Tul keves.\n"); Also=Gep; break; case 0: printf("ELTALALTAM!\n"); break; }

N++; } while(Ember!=Gep && N<10);

printf("\n Probalkozasok szama: %d, keresett szam: %d\n",N,Ember); printf("Utolso tipp: %d\n",Gep);

return(0);}

Teszt adatok

Ha a stratégián változtatni kíván, ezek a számok segítenek kipróbálni:

1, 7, 17, 28, 49, 51, 63, 75, 88, 99


[4] Határozzuk meg az Y=A*x^2 + B*x + C másodfokú egyenlet szélsõ értékét a [−50;50] intervallumon úgy, hogy az egyenlet együtthatóit a felhasználó adhassa meg.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf * /#include <math.h> /* matematikai rutinok: sqrt * /

double A,B,C; /* az egyenlet együtthatói * /

double fuggveny(double x) /* a parabola Y értékeit adja meg * /{ double d;

d = C + x*(B + A*x); /* d = A*x^2 + B*x + C * /

return(d);}

/* a következõ eljárás megvizsgálja, hogy valóban másodfokú−e az egyenlet és van−e tengelymetszete, ami alapján meghatározható a szélsõérték helye és a hozzá tartozó függvény érték. 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; double x1,x2;

d = B*B − 4*A*C; /* diszkrimináns * /

if (A==0) { printf("Ez nem masodfoku egyenlet! \n"); return; }

if (d<0) { printf("A fuggveny nem metszi az X tengelyt...\n"); return; }

if (d==0) { printf("A fuggveny erinti az X tengelyt: \n");

/* x számítható a másodfokú egyenlet megoldó képletével * / x1 = (−B)/(2*A); printf("zerushely: X = %lg\n",x1);

return; }


if (d>0) { printf("A fuggveny metszi az X tengelyt: \n");

/* a másodfokú egyenlet megoldó képletével * / x1 = (−B+sqrt(d))/(2*A); printf("zerushely: X(1) = %lg\n",x1); x2 = (−B−sqrt(d))/(2*A); printf("zerushely: X(2) = %lg\n",x2); x1=(x1+x2)/2; printf("szelsoertek helye: X = %lg\n erteke: Y = %lg\n",x1,fuggveny(x1));

/* ebben az utolsó feltételben elhagyható a return utasítás * / return; }

} /* vizsgálat vége * /

/* optimáló eljárás az aranymetszés módszerével: ekkor egy speciális arányszámot alkalmazunk,

amely értéke: a �3 � 5

2(kb. 0,3819) . Négy Y értéket kell kiszámítani, majd a középsõ

kettõ közül a kisebbik (maximum keresésekor) vagy nagyobbik (minimum keresésekor) helye lesz az új alsó, vagy felsõ határ. Az arányszám olyan különleges tulajdonságú, hogy ekkor elegendõ csupán egy új pontot kiszámítani, a másik három adott. A keresett x érték a két középsõ x koordináta átlaga. * /void optimalas(void){ double arany; /* arányszám * / double X[4]; /* a szükséges 4 x érték * / double Y[4]; /* a szükséges 4 f(x) érték * / int i,j,lepes; /* segédváltozók * /

/* konvex, vagy konkáv a parabola? * / if (A>0) printf("Minimumhely kereses...\n"); if (A<0) printf("Maximumhely kereses...\n"); if (A==0) { printf("A fuggveny nem parabola!\n"); return; }

printf("Kereses a [−50;50] tartomanyban...\n");

/* arányszám beállítása * / arany = ((double)3 − sqrt((double)5) )/2;

/* az intervallum két végpontja * / X[0]=−50; X[3]=50;

/* a közbülsõ értékek * / X[1]=X[0]+arany*(X[3]−X[0]); X[2]=X[3]−arany*(X[3]−X[0]);


/* az optimálás akkor áll le, amikor a szélsõértéket kellõ pontossággal megközelítettük . Esetünkben legyen a kívánt pontosság ±0,0005 * / lepes = 0; while (fabs(X[2]−X[1])>0.001) {

for (j=0;j<4;j++) Y[j]=fuggveny(X[j]); /* f(x) értékek kiszámítása * /

if (A>0) { /* x^2 együtthatója pozitív, tehát minimumhelyet keresünk * /

if (Y[1]>Y[2]) { X[0]=X[1]; X[1]=X[2]; X[2]=X[3]−arany*(X[3]−X[0]); } else { X[3]=X[2]; X[2]=X[1]; X[1]=X[0]+arany*(X[3]−X[0]); }

} else { /* x^2 együtthatója negatív, tehát maximumhelyet keresünk * /

if (Y[1]<Y[2]) { X[0]=X[1]; X[1]=X[2]; X[2]=X[3]−arany*(X[3]−X[0]); } else { X[3]=X[2]; X[2]=X[1]; X[1]=X[0]+arany*(X[3]−X[0]); }

} /* if (A...) vége * /

lepes++; } /* while (fabs()...) vége * /

printf("lepesek szama: %d\n",lepes); printf("x = %lg\n",(X[1]+X[2])/2); Y[0]=fuggveny((X[1]+X[2])/2); printf("f(x) = %lg\n",Y[0]);}

int main(void) /* fõprogram * /{ printf("A = "); scanf("%lf",&A); /* függvény együtthatóinak beolvasása * / printf("B = "); scanf("%lf",&B); printf("C = "); scanf("%lf",&C);

vizsgalat(); optimalas();

return(0);}


a [4] feladat üzenetei a képernyõn

A = 15B = −2C = −20A f uggveny met szi az X t engel yt :zer ushel y: X( 1) = 1. 22329zer ushel y: X( 2) = −1. 08996szel soer t ek hel ye: X = 0. 0666667er t eke: Y = −20. 0667Mi ni mumhel y ker eses. . .Ker eses a [ −50; 50] t ar t omanyban. . .l epesek szama: 21x = 0. 066703f ( x) = −20. 0667

[5] Készítsünk programot, amely egy 80x20 méretû mezõn véletlenszerûen elhelyez 70 aknát, majd írjuk meg azt az eljárást, amely a mezõ P1(1;10) pontjából indulva nagy valószínûséggel átjut a másik oldalra P2(80;?). Gondolni kell arra is, hogy az átjutás nem garantált az aknák véletlenszerû helyzete miatt.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: sprintf * /#include <conio.h> /* képernyõre írás: gotoxy, cputs * /#include <dos.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; /* aknamezõ * /int X,Y,Akna,Lepes; /* segédváltozók: pozíció, aknajelzõ, lépésszám * /int V1,V2,V3; /* 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;

r= (V1+V2*V3)%maximum; V1=V2; V2=V3; V3=r;

return(r);}

/* aknamezõ létrehozása, aknák elhelyezése és a képernyõre rajzolásuk */void Beallit(void){ int i,j,k; struct time T;

/* véletlenszámok generálásának beállítása * / gettime(&T); V1=T.ti_hund; V2=T.ti_sec; V3=T.ti_min;


/* memória foglalás: 80x20 mátrix, elemek nullázása * / Mezo = new int* [80]; for (i=0;i<80;i++) { Mezo[i] = new int[20]; for (j=0;j<20;j++) Mezo[i][j]=0; }

i=0; while (i<AKNAK) { /* aknák elhelyezése: az elsõ három oszlopba nem rakunk aknát * / j=Veletlen(76)+3; k=Veletlen(20); if (Mezo[j][k]==0) { Mezo[j][k]=1; i++; } else { /* ha ugyanoda már raktunk aknát, megváltoztatjuk a véletlenszámok generálását * / V1++; } }

/* aknamezõ megjelenítése * / clrscr(); for (j=2;j<22;j++) { gotoxy(1,j); for (i=0;i<80;i++) { switch(Mezo[i][j−2]) { case 0: cputs("."); break; case 1: cputs("A"); break; } } }

} /* Beallit() vége * /

/* aktuális pozíció kiértékelése: hány darab akna van a szomszédságban? * /void Ertekel(int x,int y){ int x1,x2,y1,y2,i,j;

if (Mezo[x][y]==1) { gotoxy(60,1); cputs("Aknara lepett!!"); Akna=−1; return; }

if (x>=79) { gotoxy(60,1); cputs("ATJUTOTT!!"); }


/* területhatárok kijelölése * / x1=x−1; x2=x+1; y1=y−1; y2=y+1; if (x1<0) x1=0; if (x2>79) x2=79; if (y1<0) y1=0; if (y2>19) y2=19;

/* aknák száma * / Akna=0; for (i=x1;i<=x2;i++) { for (j=y1;j<=y2;j++) if (Mezo[i][j]!=0) Akna=1; }

} /* Ertekel() vége * /

/* információk megjelenítése az elsõ sorban: X,Y koordináták, lépésszám * /void Cimsor(void){ char *Buff; /* buffer a kiiratáshoz * /

/* memória lefoglalása * / Buff = new char[50];

sprintf(Buff,"X= %2d Y= %2d | LEPES= %3d",X+1,Y+1,Lepes); gotoxy(1,1); cputs(Buff);

/* memória felszabadítása * / delete[] Buff;}

/* aktuális pozíció változtatása dx és dy alapján * /void Mozdit(int dx,int dy){ X+=dx; /* ellenõrzés * / if (X<0) X=0; if (X>79) X=79;

Y+=dy; /* ellenõrzés * / if (Y<0) Y=0; if (Y>19) Y=19;

Ertekel(X,Y); Lepes++; Cimsor();

gotoxy(X+1,Y+2); cputs("�");}

/* járható utat keresõ eljárás * /void Keres(void){ int dx,dy,dontes,valtas,lepes; /* segédváltozók * /


/* inicializálás, a Mozdit(0,0) segítségével kiértékeltetjük az aktuális pozíciót * / Lepes=0; X=0; Y=10; dx=1; dy=0; Mozdit(0,0);

/* addig folyik a keresés, ameddig át nem jutott, aknára lépett, 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; while (Akna==0 && X<79 && valtas<4 && Lepes<MAXLEPES) { Mozdit(dx,dy); /* vizszintesen halad * / if (dy==0) valtas=0; /* elsõ oszlopba lépett, vagy a szélére * / if (X<1 || (Y<1 && dx==0) || (Y>18 && dx==0)) valtas=4; /* 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, ezzel segítve, nehogy beszoruljon: nagyobb hurkokar ír le * / dontes=Veletlen(100); if (dontes>60*Lepes/MAXLEPES) valtas++; } }

if (Akna>0) { /* azért állt meg, mert akna van a közelben * /

Mozdit(−dx,−dy); /* vissza lép az elõzõ pozícióba * / if (dy==0) { /* vízszintesen haladt * / dx=0; dontes=Veletlen(100); /* az esetek 50%−ában felfelé, 50%−ában lefelé folytatja * / if (dontes<50) dy=−1; else dy=1; /* ha a szélén rossz irányt választott, korrigálni kell * / if (Y==0 && dy==−1) dy=1; if (Y==19 && dy==1) dy=−1; } else { /* függõlegesen haladt * / dy=0; /* az esetek 20%−ában balra, 80%−ban jobbra indul * / dontes=Veletlen(100); if (dontes<20) dx=−1; else dx=1; /* ha a szélén rossz irányt választott, korrigálni kell * / if (X==0 && dx==−1) dx=1; }

} else { /* azért állt meg, mert beszorult, aknára lépett, vagy irányt kell váltani * /

if (valtas>0) { /* kikényszerített irányváltás * /


if (dx==0) { /* függõlegesen haladt * / dy=0; dontes=Veletlen(100); /* az esetek 20%−ában balra, 80%−ában jobbra folytatja * / if (dontes<20) dx=−1; else dx=1; if (X==0 && dx==−1) dx=1; } else { dx=0; dontes=Veletlen(100); /* az esetek 50%−ában felfelé, 50%−ában lefelé folytatja * / if (dontes<50) dy=−1; else dy=1; /* ha a szélén rossz irányt választott, korrigálni kell * / if (Y==0 && dy==−1) dy=1; if (Y==19 && dy==1) dy=−1; }

} /* if (valtas...) vége * /

} /* if (Akna...) vége * /

} /* while() vége * /

if (Lepes>=MAXLEPES) { /* túllépte a megengedett lépésszámot, valószínûleg beszorult * / gotoxy(60,1); cputs("Nem sikerult."); }

} /* Keres() vége * /

/* memória felszabadítás * /void Vege(void){ int i; for (i=0;i<80;i++) delete[] Mezo[i]; delete[] Mezo;

/* kurzor pozíconálása a képernyõ alsó részére * / gotoxy(1,23);}

/* fõprogram * /void main(void){ Beallit(); Keres(); Vege();}


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ó, 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


[6] Készítsünk programot, amelyik 80000 pszeudo−véletlen számot ír egy szöveges állományba. A szöveges állományok használata kényelmes, mert könnyen importálhatóak táblázatokba és az elterjedt statisztikai programok is olvassák. Szerkesztésük, javításuk pedig egyszerû.


int A,B,C; /* 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;

r = (A + B*C)%maximum +1;

/* a paraméterek változtatása miatt az egymást követõ számok nem lesznek azonosak * / A = B; B = C; A = r;

/* "r" értéke 1 és maximum közötti egész szám * / return(r);}

int main(void) /* fõprogram * /{ FILE *T; /* szöveges állomány az adatoknak * / int i,j; /* segédváltozók * /

printf("Adja meg a parametereket (A,B,C): \n");

/* beolvasás * / printf("A = "); scanf("%d",&A); printf("B = "); scanf("%d",&B); printf("C = "); scanf("%d",&C);

/* állomány megnyitása * / T=fopen("ADAT.DAT","wt"); if (T!=NULL) {

/* csak akkor menti az adatokat, ha sikerült megnyitni az állományt * / for (i=0;i<80000;i++) { j=100+veletlen(500); /* "j" egy 101 és 600 közötti véletlenszerû szám * / fprintf(T,"%d\n",j); }

/* az fflush() utasítás a cache tartalmát lemezre menti. Biztos, ami biztos... * / fflush(T); fclose(T); }

return(0);}


[7] Az elõzõ programot felhasználva állítsunk elõ egy 80000 elemû egész számokból álló adatállományt, majd rendezzük az adatokat növekvõ számsorrendbe. Többféle rendezési eljárást alkalmazva összehasonlíthatjuk azok sebességét.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf * /#include <time.h> /* idõmérés * /

/* konstans, a maximálisan feldolgozható adatok számát tartalmazza * /#define MAXDATA 80000

int *A; /* Adatok vektora * /int darab; /* Adatok száma * /clock_t IDO; /* idõmérõ * /

void Beolvas(char *Neve) /* adatok beolvasása "Neve" állományból * /{ FILE *T; /* szöveges állomány az adatokkal * / int D; /* segédváltozók * /

darab=0; /* darabszám nullázása * /

A = new int[MAXDATA]; /* memória foglalás * / if (A==NULL) { printf("Nincsen elegendo memoria! \n"); return; }

printf("Allomany: %s\n",Neve); T=fopen(Neve,"rt"); if (T!=NULL) {

/* ha a megnyitás sikeres volt, olvassunk be adatokat, ameddig van adat az állományban és még nem haladtuk meg a megengedett maximumot (MAXDATA) * / while (!feof(T) && darab<MAXDATA) { fscanf(T,"%d\n",&D); A[darab++]=D; } fclose(T); printf("Adatok szama: %d\n",darab);

} else { /* sikertelen megnyitasi kiserlet * / printf("Nem olvashato.\n"); }

} /* beolvasás vége * /


/* egyszerû cserés rendezés: minden elemet összehasonlít az összes mögötte lévõvel és ha a sorrend nem megfelelõ, akkor kicseréli õket. Az adatsor elölrõl hátrafelé haladva − a nagyobb sorszám felé − válik rendezetté. * /void EgyszeruCsere(void){ int i,j,tmp;

printf("Egyszeru cseres rendezes...\n");

for (i=0;i<darab−1;i++) { for (j=i;j<darab;j++) { if (A[i]>A[j]) { tmp=A[i]; A[i]=A[j]; A[j]=tmp; } } }

} /* 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, ha a vizsgált szomszédok sorrendje nem megfelelõ. Az adatsor hátulról elõre haladva válik rendezetté. A nagyobb számok úgy haladnak hátrafelé, mint a buborékok a vízben felfelé. * /void Buborek(void){ int i,j,tmp,csere;

printf("Buborekos rendezes...\n");

for (i=darab−1;i>0;i−−) { csere=0; for (j=0;j<i;j++) { if (A[j]>A[j+1]) { tmp=A[j]; A[j]=A[j+1]; A[j+1]=tmp; csere=1; } } if (csere==0) i=0; /* 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, ott keresi meg azt a helyet, ahova beilleszthetõ. Az adatsor elölrõl hátrafelé haladva válik rendezetté. * /void Beszurasos(void){ int i,j,tmp;

printf("Beszurasos rendezes...\n");

for (i=1;i<darab;i++) { tmp=A[i]; /* aktuális elem mentése * /


j=i−1; while (j>=0 && A[j]>tmp) { A[j+1]=A[j]; /* elemek görgetése hátrafelé * / j−−; } A[j+1]=tmp; /* 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. Az adatsor elölrõl hátrafelé haladva válik rendezetté * /void MinimumKeres(void){ int i,j,min,tmp;

printf("Minimum kivalasztasos rendezes...\n");

for (i=0;i<darab−1;i++) { /* az "i" mögötti legkisebb keresése * / min=i; for (j=i+1;j<darab;j++) if (A[min]>A[j]) min=j;

if (min!=j) { tmp=A[min]; A[min]=A[i]; A[i]=tmp; } }

} /* minimumkeresés vége * /

/* a gyors rendezés nagyon hatékony eljárás, az adatsor két vége felõl közepe felé haladva rekurzívan vizsgálja az adatokat * /void Gyors(int bal,int jobb){ int i,j; int tmp1,tmp2;

i=bal; j=jobb; /* segédváltozók beállítása * / tmp1=A[(bal+jobb) / 2]; /* a középsõ elem értéke * /

do { while (A[i]<tmp1) i++; while (tmp1<A[j]) j−−;

if (i<=j) { tmp2=A[i]; A[i]=A[j]; A[j]=tmp2; i++; j−−; }

} while (j>i);


if (bal<j) Gyors(bal,j); if (i<jobb) Gyors(i,jobb);

} /* gyors rendezés vége * /

/* ez a rutin végzi el a gyors rendezést * /void GyorsRendez(void){ printf("Gyors rendezes...\n"); Gyors(0,darab−1);}

/* ellenörzõ eljárás, amely azt vizsgálja, hogy valóban monoton adatsor jött−e létre * /void Ellenor(void){ int i;

i=0; while (i<darab−1 && A[i]<=A[i+1]) i++; if (i<darab−1) { printf("Hiba a rendezesben a %d. adatnal! \n",i); printf("A[%d]=%d ; A[%d]=%d\n",i,A[i],i+1,A[i+1]); }

/* memória felszabadítás * / delete[] A;}

/* fõprogram * /int main(int argc, char *argv[]){ int i; double d; /* 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",argv[0]); printf("1 − Egyszeru cseres rendezes\n"); printf("2 − Buborekos rendezes\n"); printf("3 − Beszurasos rendezes\n"); printf("4 − Minimum kivalasztasos rendezes\n"); printf("5 − Gyors rendezes\n"); return(1); }

i=0; if (!sscanf(argv[2],"%d",& i) || i<1 || i>5) { /* nem sikerült beolvasni a számot a 2. paraméterbõl, vagy az értéke nincsen 1 és 5 között. * / printf("Ervenytelen parameter [1/2/3/4/5] : %s\n",argv[2]); return(2); }


Beolvas(argv[1]); /* adatok beolvasása * /

IDO=clock(); /* stopper indul * /

switch (i) { case 1: EgyszeruCsere(); break; case 2: Buborek(); break; case 3: Beszurasos(); break; case 4: MinimumKeres(); break; case 5: GyorsRendez(); break; }

/* szükséges másodpercek számítása * / d=(double)(clock()−IDO)/CLOCKS_PER_SEC; printf("Szukseges ido: %lg sec\n",d);

Ellenor();

return(0);}

a [7] feladat értékelése

Adat ok száma: 80000PC: I nt el Cel er on, 64MB RAMOS: Li nux Mandr ake 7. 2=========================================Módszer I dõ ( sec)−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−Egyszer ü cser és 184. 56Bubor ékos 293. 01Beszúr ásos 111. 42Mi ni mum ki vál aszt ásos 183. 09Gyor s 0. 10−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−


[8] Készítsünk programot, amely kiszámítja négy adatsor fontosabb statisztikai jellemzõit.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf * /#include <math.h> /* matematikai eljárások: sqrt * /

#define MAXDATA 3000 /* konstans: adatsorok maximális száma * /

double * *A; /* adatmátrix * /int darab; /* beolvasott adatok száma * /

void Beolvas(void) /* adatok beolvasása * /{ FILE *T; /* szöveges állomány * / double d; /* segédváltozó * / int i; /* segédváltozó * /

darab = 0;

/* memória foglalás * / A = new double* [4]; for (i=0;i<4;i++) A[i] = new double[MAXDATA];

/* adatállomány megnyitása és beolvasás * / T = fopen("adat.dat","rt"); if (T!=NULL) { while (!feof(T) && darab<MAXDATA) { for (i=0;i<3;i++) { fscanf(T,"%lf",&d); A[i][darab]=d; } fscanf(T,"%lf\n",&d); A[3][darab]=d; darab++; } fclose(T); }}

/* Leíró statisztika * /void Leiro(void){ double S,SS,min,max; /* segédváltozók * / int i,j,k; /* segédváltozók * /

/* ha nincs elegendõ számú adat, nincs értelme a statisztikának sem * / if (darab<2) return;

/* fejléc kiírása * / printf("Leiro statisztika\n"); for (i=0;i<40;i++) printf("="); printf("\n");


printf("# min. max. atlag szoras\n"); for (i=0;i<40;i++) printf("−"); printf("\n");

/* minimum, maximum, átlag, szórás számítása * / for (i=0;i<4;i++) { S=SS=0; min=max=A[i][0]; for (j=0;j<darab;j++) { S +=A[i][j]; /* összeg * / SS+=A[i][j]*A[i][j]; /* négyzetösszeg * / if (A[i][j]<min) min=A[i][j]; /* minimum * / if (A[i][j]>max) max=A[i][j]; /* maximum * / } SS = SS − S*S/darab; S/=darab; SS = sqrt(SS/(darab−1)); printf("%d %8.4lf %8.4lf %8.4lf %8.4lf\n",i+1,min,max,S,SS); }

/* elválasztó vonal * / for (i=0;i<40;i++) printf("−"); printf("\n");

/* monotonitás vizsgálata * / for (i=0;i<4;i++) { printf("%d : ",i+1); j=1; while (j<darab && A[i][j]>A[i][j−1]) j++; if (j>=darab) { printf("szigoruan monoton novekvo\n"); } else { j=1; while (j<darab && A[i][j]>=A[i][j−1]) j++; if (j>=darab) { printf("monoton novekvo\n"); } else { j=1; while (j<darab && A[i][j]<A[i][j−1]) j++; if (j>=darab) { printf("szigoruan monoton csokkeno\n"); } else { j=1; while (j<darab && A[i][j]<=A[i][j−1]) j++; if (j>=darab) { printf("monoton csokkeno\n"); } else { printf("nem monoton\n"); } } } } }


} /* Leiro() vége * /


/* kiugró értékek keresése: Dixon−próba * /void Kiugro(void){ double r,tmp; /* Dixon−féle r érték, segédváltozó * / int i,j,k; /* segédváltozó * / double *d; /* átmeneti tömb a rendezéshez * /

/* ha nincsen elegendõ számú adat, nincs értelme a statisztikának * / if (darab<2) return;

/* memória foglalás * / d = new double[darab];

/* fejléc kiírása * / printf("\nKiugro ertekek: Dixon−proba\n"); for (i=0;i<30;i++) printf("="); printf("\n"); printf("# min. [?] max. [?] \n"); for (i=0;i<30;i++) printf("−"); printf("\n");

/* a négy adatsorra külön−külön * / for (i=0;i<4;i++) {

/* adatok átmásolása A mátrixból d tömbbe * / for (j=0;j<darab;j++) d[j]=A[i][j];

/* egyszerû cserés rendezés * / for (j=0;j<darab−1;j++) { for (k=j+1;k<darab;k++) { if (d[j]>d[k]) { tmp=d[j]; d[j]=d[k]; d[k]=tmp; } } }

printf("%d ",i+1);

k = darab/10; /* 10 % meghatározása*/

/* Dixon−próba az elsõ (legkisebb) elemre * / r = d[0]−d[k]; r/= d[0]−d[darab−k]; printf("%8.4lf",r);

/* ha meghaladja a kritikus értéket, valószínûleg (p=95%) kiugró adatot talált * / if (r>0.35) printf(" [+] "); else printf(" [−] ");

/* Dixon−próba az utolsó (legnagyobb) elemre * / r = d[darab−1]−d[darab−k]; r/= d[darab−1]−d[k]; printf("%8.4lf",r);


/* ha meghaladja a kritikus értéket, valószínûleg (p=95%) kiugró adatot talált * / if (r>0.35) printf(" [+] "); else printf(" [−] ");

printf("\n"); }


/* memória felszabadítás * / delete[] d;

} /* Kiugro() vége * /

/* adatsorok közötti lineáris kapcsolat keresése * /void Korrelacio(void){ double M[4][4]; /* eredmény mátrix * / int i,j,l; /* segédváltozók * / double S1,S2,S3,S4,S5,k; /* segédváltozók * /

/* ha nincsen legendõ számú adat, nincs értelme a statisztikának * / if (darab<2) return;

/* fejléc kiírása * / printf("\nKorrelacios matrix (n=%d )\n",darab); for (i=0;i<38;i++) printf("−"); printf("\n");

for (i=0;i<4;i++) { for (j=0;j<4;j++) { S1=S2=S3=S4=S5=0; M[i][j]=0; for (l=0;l<darab;l++) { S1+=A[i][l]; S2+=A[i][l]*A[i][l]; S3+=A[j][l]; S4+=A[j][l]*A[j][l]; S5+=A[i][l]*A[j][l]; } k = S5 − S1*S3/darab; S2 −= S1*S1/darab; S4 −= S3*S3/darab;

/* nullával osztást kerüljük el * / if (S2*S4>0) { k /= sqrt(S2*S4); M[i][j]=k; }

} }


/* korrelációs mátrix kiiratása * / for (i=0;i<4;i++) { for (j=0;j<4;j++) printf(" %8.4lf",M[i][j]); printf("\n"); }


/* 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.f.=%d\n",darab−2); for (i=0;i<38;i++) printf("−"); printf("\n");

for (i=0;i<4;i++) { for (j=0;j<4;j++) {

/* 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); k/= 1 − M[i][j]*M[i][j]; M[i][j] = sqrt(k); printf(" %8.3lg",M[i][j]); } else printf("%9s","−−−−"); /* else ág jelenti a +1 vagy −1 −es korrelációt: t értéke végtelen * /

} printf("\n"); }


} /* Korrelacio() vége * /

/* memória felszabadítása * /void Vege(void){ int i;

for (i=0;i<4;i++) delete[] A[i]; delete[] A;}

/* fõprogram * /void main(void){ Beolvas(); Leiro(); Kiugro(); Korrelacio(); Vege();}


a [8] feladat eredménye a képernyõn

Lei r o st at i szt i ka========================================# mi n. max. at l ag szor as−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−1 0. 0000 9. 4169 4. 7084 2. 71982 10. 0000 29. 8196 25. 7886 4. 97983 28. 6353 43. 5000 31. 6585 3. 73494 7. 0000 33. 0000 22. 7601 8. 7721−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−1 : szi gor uan monot on novekvo2 : szi gor uan monot on novekvo3 : szi gor uan monot on csokkeno4 : nem monot on−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

Ki ugr o er t ekek: Di xon−pr oba==============================# mi n. [ ?] max. [ ?]−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−1 0. 1111 [ −] 0. 1108 [ −] 2 0. 3811 [ +] 0. 0088 [ −] 3 0. 0088 [ −] 0. 3801 [ +] 4 0. 0554 [ −] 0. 0145 [ −] −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

Kor r el aci os mat r i x ( n=3000)−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− 1. 0000 0. 8695 −0. 8695 0. 0005 0. 8695 1. 0000 −1. 0000 −0. 2440 −0. 8695 −1. 0000 1. 0000 0. 2440 0. 0005 −0. 2440 0. 2440 1. 0000−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

t −pr oba ( H: r ! =0) d. f . =2998−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− −−−− 96. 4 96. 4 0. 0248 96. 4 −−−− 7. 68e+07 13. 8 96. 4 7. 68e+07 −−−− 13. 8 0. 0248 13. 8 13. 8 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−


[9] Készítsünk programot, amely a mellékelt adatokra (ADAT.DAT) egyenest, vagy parabolát illeszt a felhasználó választásától függõen. Ezen alap típusok ismerete elegendõ lehet, mert az egyszerûbb függvények általában visszavezethetõek egyenes illesztésére.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf * /#include <math.h> /* matematikai függvények: sqrt * /


double *X; /* X értékek tömbje * /double *Y; /* Y értékek tömbje * /int darab; /* beolvasott adatok száma * /

/* adatok beolvasása * /void Beolvas(void){ FILE *T; /* szöveges állomány * / double a,b; /* segédváltozók * / int i; /* segédváltozó * /

darab=0;

/* memória foglalás * / X = new double[MAXDATA]; Y = new double[MAXDATA];

/* állomány megnyitása, beolvasás * / T=fopen("adat.dat","rt"); if (T!=NULL) { while (!feof(T) && darab<MAXDATA) { fscanf(T,"%lf %lf\n",&a,&b); X[darab]=a; Y[darab]=b; darab++; } fclose(T); }

}

/* egyenes illesztése: Y = a + b*X * /void Egyenes(void){ double S1,S2,S3,S4,S5; /* segédváltozók: négyzetösszegek * / double A,B,R; /* segédváltozók: együtthatók, r2 * / int i; /* segédváltozó * /


/* ha nincsen adat, kilép * / if (darab==0 || X==NULL || Y==NULL) return;

/* négyzetösszegek számítása * / S1=S2=S3=S4=S5=0; for (i=0;i<darab;i++) { S1+=X[i]; S3+=X[i]*X[i]; S2+=Y[i]; S4+=Y[i]*Y[i]; S5+=X[i]*Y[i]; }

S5−=S1*S2/darab; /* SQxy * / S3−=S1*S1/darab; /* SQx * / S4−=S2*S2/darab; /* SQy * /

/* R−négyzet számítása, ha lehetséges * / if (S3*S4==0) R=1; else R = S5*S5/(S3*S4);

if (S3==0) { printf("Nullaval osztas: fuggoleges egyenes\n"); darab=0; return; }

/* meredekség * / B = S5/S3;

S1=S2=0; for (i=0;i<darab;i++) { S1+=X[i]; S2+=Y[i]; } S1/=darab; S2/=darab;

/* tengelymetszet * / A = S2 − B*S1;

printf("Y = %lg + %lg * X\n",A,B); printf("R−negyzet: %lg (n=%d)\n",R,darab);

/* t−próba, nullhipotézis: r2 nem nulla* / if (R*R<1) { S1 = R*R*(darab−2); S1/= 1 − R*R; S1 = sqrt(S1); printf("t−proba (H: r!=0) : %lg (df=%d)\n",S1,darab−2); }

} /* Egyenes() vége * /


/* parabola illesztése: Y = a + b1*X + b2*X^2 * /void Parabola(void){ double S[8]; /* segédváltozók: négyzetösszegek * / double A,B1,B2,R; /* segédváltozók: együtthatók, r2 * / int i; /* segédváltozó * /


/* számlálók nullázása * / for (i=0;i<8;i++) S[i]=0;

/* négyzetösszegek számítása * / for (i=0;i<darab;i++) { S[0]+=X[i]; S[1]+=X[i]*X[i]; S[2]+=pow(X[i],4); S[3]+=Y[i]; S[4]+=Y[i]*Y[i]; S[5]+=X[i]*Y[i]; S[6]+=X[i]*X[i]*Y[i]; S[7]+=pow(X[i],3); }

S[7]−=S[0]*S[1]/darab; /* SP12 * / S[5]−=S[0]*S[3]/darab; /* SQxy * / S[6]−=S[1]*S[3]/darab; /* SQx2y * / S[2]−=S[1]*S[1]/darab; /* SQx2 * / S[1]−=S[0]*S[0]/darab; /* SQx * / S[4]−=S[3]*S[3]/darab; /* SQy * /

if (S[1]*S[2]−S[7]*S[7]==0 || S[4]==0) { printf("Nullaval osztas: varatlan hiba\n"); return; }

/* lineáris tag együtthatója * / B1 = S[2]*S[5] − S[7]*S[6]; B1/= S[1]*S[2] − S[7]*S[7];

/* négyzetes tag együtthatója * / B2 = S[1]*S[6] − S[7]*S[5]; B2/= S[1]*S[2] − S[7]*S[7];

/* determinációs együttható * / R = B1*S[5] + B2*S[6]; R/= S[4];

S[0]=S[1]=S[2]=0; for (i=0;i<darab;i++) { S[0]+=Y[i]; S[1]+=X[i];


S[2]+=X[i]*X[i]; } S[0]/=darab; S[1]/=darab; S[2]/=darab;

/* tengelymetszet számítása * / A = S[0] − B1*S[1] − B2*S[2];

printf("Y = %lg + %lg * X + %lg * X^2\n",A,B1,B2); printf("R−negyzet: %lg (n=%d)\n",R,darab);

/* t−próba, nullhipotézis: r2 nem nulla * / if (R*R<1) { B1 = R*R*(darab−2); B1/= 1 − R*R; B1 = sqrt(B1); printf("t−proba (H: r!=0) : %lg (df=%d)\n",B1,darab−2); }

} /* Parabola() vége * /

/* a felhasználó által választott függvényt illeszti * /void Illeszt(void){ int i; /* segédváltozó * /

printf("Melyik fuggvenyt illeszti?\n"); printf("1 − Y = a + b*X\n"); printf("2 − Y = a + b1*X + b2*X^2\n"); do{ printf("Valasszon: "); scanf("%d",& i); } while (i<1 || i>2);

switch(i) { case 1: Egyenes(); break; case 2: Parabola(); break; }}

/* memória felszabadítás * /void Vege(void){ delete[] X; delete[] Y;}


/* fõprogram * /void main(void){ Beolvas(); Illeszt(); Vege();}

a [9] program eredménye a képernyõn

Mel yi k f uggvenyt i l l eszt i ?1 − Y = a + b* X2 − Y = a + b1* X + b2* X^2Val asszon: 1Y = 103. 705 + −0. 431063 * XR−negyzet : 0. 933015 ( n=1000)t −pr oba ( H: r ! =0) : 117. 902 ( df =998)

Mel yi k f uggvenyt i l l eszt i ?1 − Y = a + b* X2 − Y = a + b1* X + b2* X^2Val asszon: 2Y = 90. 435 + 0. 257787 * X + −0. 00765332 * X^2R−negyzet : 0. 999522 ( n=1000)t −pr oba ( H: r ! =0) : 1444. 4 ( df =998)

[10] Végezzük el az elõzõ feladatban szereplõ függvények illesztését, valamint az illesztés jóságának és a reziduumok autokorrelációjának elemzését.

#include <stdio.h> /* hagyományos ki− és beviteli függvények: printf, fscanf * /#include <math.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; /* Y értékek tömbje * /int darab; /* beolvasott adatsorok száma * /

/* adatok beolvasása * /void Beolvas(void){ FILE *T; /* szöveges állomány * / double a,b; /* segédváltozók * / int i; /* segédváltozó * /

darab=0;



/* adatállomány megnyitása, beolvasás * / T=fopen("adat.dat","rt"); if (T!=NULL) { while (!feof(T) && darab<MAXDATA) { fscanf(T,"%lf %lf\n",&a,&b); X[darab]=a; Y[darab]=b; darab++; } fclose(T); }

} /* Beolvas() vége * /

/* egyenes illesztése: Y = a + b*X * /void Egyenes(void){ double S1,S2,S3,S4,S5; /* segédváltozók: négyzetösszegek * / double A,B1,R,tmp; /* segédváltozók: együtthatók, r2 * / int i; /* segédváltozó * /

/* ha nincs adat, kilép * / if (darab==0 || X==NULL || Y==NULL) return;

/* négyzetösszegek számítása * / S1=S2=S3=S4=S5=0; for (i=0;i<darab;i++) { S1+=X[i]; S3+=X[i]*X[i]; S2+=Y[i]; S4+=Y[i]*Y[i]; S5+=X[i]*Y[i]; }

S5−=S1*S2/darab; /* SQxy * / S3−=S1*S1/darab; /* SQx * / S4−=S2*S2/darab; /* SQy * /

/* determinációs együttható számítása * / if (S3*S4==0) R=1; else R = S5*S5/(S3*S4);

/* nullával osztást kerüljük el * / if (S3==0) { printf("Nullaval osztas: fuggoleges egyenes\n"); darab=0; return; }

/* meredekség számítása * / B1 = S5/S3;


S1=S2=0; for (i=0;i<darab;i++) { S1+=X[i]; S2+=Y[i]; } S1/=darab; S2/=darab;

/* tengelymetszet számítása * / A = S2 − B1*S1;

printf("Y = %lg + %lg * X\n",A,B1); printf("R−negyzet: %lg (n=%d)\n",R,darab);

/* t−próba, nullhipotézis: r2 nem nulla * / if (R<1) { tmp = R*(darab−2); tmp/= 1 − R; tmp = sqrt(tmp); printf("t−proba (H: r!=0) : %lg (df=%d)\n",tmp,darab−2); }

printf("\nVariancia tablazat\n"); if (S3==0) { printf("A tablazat nem keszitheto el nullaval osztas miatt.\n"); return; }

/* fejléc kiírása * / for (i=0;i<45;i++) printf("="); printf("\n"); printf("%s %10s %5s %10s %10s\n","Forras","SS","df","MS","F"); for (i=0;i<45;i++) printf("−"); printf("\n");

/* elsõ sor: a model által magyarázott eltérések * / tmp = S5*S5/S3; printf("Model %10.4lg %5d %10.4lg",tmp,1,tmp);

/* F−érték * / tmp/= (S4 − tmp)/(darab−2); printf(" %10.4lg\n",tmp);

/* második sor: a véletlen hibából adódó eltérések * / tmp = S4 − S5*S5/S3; printf("Hiba %10.4lg %5d %10.4lg\n",tmp,darab−2,tmp/(darab−2));

/* elválasztó * / for (i=0;i<45;i++) printf("−"); printf("\n");

/* összesen sor * / printf("Osszes %10.4lg %5d\n",S4,darab−1);


printf("Reziduumok autokorrelaciojanak elemzese\n");

S1=S2=0; for (i=0;i<darab;i++) { S3 = A + B1*X[i] − Y[i]; S1 += S3*S3; if (i>0) { S4 = A + B1*X[i−1] − Y[i−1]; S2 += (S3−S4)*(S3−S4); } } tmp = S2*darab; tmp/= S1*(darab−1);

/* 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, valószínû a reziduumok autokorrelációja, azaz nem sikerült a megtalálni a megfelelõ függvényt * / printf("Neumann−fele hanyados: %lg\n",tmp);

} /* Egyenes() vége * /

/* parabola illesztése: Y = a + b1*X + b2*X^2 * /void Parabola(void){ double S[8]; /* segédváltozók: négyzetösszegek számításához * / double A,B1,B2,R,tmp; /* segédváltozók: együtthatók, r2 * / int i; /* segédváltozó * /

/* ha nincs adat, kilép * / if (darab==0 || X==NULL || Y==NULL) return;

/* négyzetösszegek számítása * / for (i=0;i<8;i++) S[i]=0; for (i=0;i<darab;i++) { S[0]+=X[i]; S[1]+=X[i]*X[i]; S[2]+=pow(X[i],4); S[3]+=Y[i]; S[4]+=Y[i]*Y[i]; S[5]+=X[i]*Y[i]; S[6]+=X[i]*X[i]*Y[i]; S[7]+=pow(X[i],3); }

S[7]−=S[0]*S[1]/darab; /* SP12 * / S[5]−=S[0]*S[3]/darab; /* SQxy * / S[6]−=S[1]*S[3]/darab; /* SQx2y * / S[2]−=S[1]*S[1]/darab; /* SQx2 * / S[1]−=S[0]*S[0]/darab; /* SQx * / S[4]−=S[3]*S[3]/darab; /* SQy * /


if (S[1]*S[2]−S[7]*S[7]==0 || S[4]==0) { printf("Nullaval osztas: varatlan hiba\n"); return; }

/* lineáris tag együtthatója * / B1 = S[2]*S[5] − S[7]*S[6]; B1/= S[1]*S[2] − S[7]*S[7];

/* négyzetes tag együtthatója * / B2 = S[1]*S[6] − S[7]*S[5]; B2/= S[1]*S[2] − S[7]*S[7];

/* determinációs együttható * / R = B1*S[5] + B2*S[6]; R/= S[4];

S[0]=S[1]=S[2]=0; for (i=0;i<darab;i++) { S[0]+=Y[i]; S[1]+=X[i]; S[2]+=X[i]*X[i]; } S[0]/=darab; S[1]/=darab; S[2]/=darab;

/* tengelymetszet számítása * / A = S[0] − B1*S[1] − B2*S[2];

printf("Y = %lg + %lg * X + %lg * X^2\n",A,B1,B2); printf("R−negyzet: %lg (n=%d)\n",R,darab);

/* t−próba, nullhipotézis: r2 nem nulla * / if (R<1) { tmp = R*(darab−2); tmp/= 1 − R; tmp = sqrt(tmp); printf("t−proba (H: r!=0) : %lg (df=%d)\n",tmp,darab−2); }

printf("\nVariancia tablazat\n");

R = B1*S[5] + B2*S[6]; if (S[4]==R) { printf("A tablazat nem keszitheto el nullaval osztas miatt.\n"); return; }


/* fejléc kiírása * / for (i=0;i<45;i++) printf("="); printf("\n"); printf("%s %10s %5s %10s %10s\n","Forras","SS","df","MS","F"); for (i=0;i<45;i++) printf("−"); printf("\n");

/* elsõ sor: model által magyarázott eltérések, F−érték * / printf("Model %10.4lg %5d %10.4lg",R,2,R/2); tmp = R*(darab−3)/(S[4] − R); printf(" %10.4lg\n",tmp);

/* második sor: véletlenszerû eltérések * / tmp = S[4]−R; printf("Hiba %10.4lg %5d %10.4lg\n",tmp,darab−3,tmp/(darab−3));


/* összesen sor * / printf("Osszes %10.4lg %5d\n",S[4],darab−1);

printf("Reziduumok autokorrelaciojanak elemzese\n"); S[1]=S[2]=0; for (i=0;i<darab;i++) { S[3] = A + X[i]* (B1 + B2*X[i]) − Y[i]; S[1] += S[3]*S[3]; 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[2]*darab; tmp/= S[1]* (darab−1);

/* 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, valószínû a reziduumok autokorrelációja, azaz nem sikerült a megtalálni a megfelelõ függvényt * / printf("Neumann−fele hanyados: %lg\n",tmp);

} /* Parabola() vége * /

/* a felhasználó által választott illesztés elvégzése * /void Illeszt(void){ int i; /* segédváltozó * /

printf("Melyik fuggvenyt illeszti?\n"); printf("1 − Y = a + b*X\n"); printf("2 − Y = a + b1*X + b2*X^2\n");


do{ printf("Valasszon: "); scanf("%d",& i); } while (i<1 || i>2);

switch(i) { case 1: Egyenes(); break; case 2: Parabola(); break; }} /* Illeszt() vége * /

/* memória felszabadítás * /void Vege(void){ delete[] X; delete[] Y;}

/* fõprogram * /void main(void){ Beolvas(); Illeszt(); Vege();}


Mel yi k f uggvenyt i l l eszt i ?1 − Y = a + b* X2 − Y = a + b1* X + b2* X^2Val asszon: 2Y = 90. 435 + 0. 257787 * X + −0. 00765332 * X^2R−negyzet : 0. 999522 ( n=1000)t −pr oba ( H: r ! =0) : 1444. 4 ( df =998)

Var i anci a t abl azat=============================================For r as SS df MS F−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−Model 5. 782e+04 2 2. 891e+04 2. 084e+06Hi ba 27. 66 997 0. 02774−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−Osszes 5. 785e+04 999Rezi duumok aut okor r el aci oj anak el emzeseNeumann−f el e hanyados: 0. 000165689


[11] Illesszük az Y = A + B*sin( C*x + D ) függvényt az ADAT.DAT állományban tárolt adatsorra! A feladat megoldására írjunk optimáló eljárást.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, fscanf * /#include <math.h> /* matematikai függvények: sin * /


double *X; /* X értékek tömbje * /double *Y; /* Y értékek tömbje * /int darab; /* beolvasott adatok száma * /double PARAM[4]; /* a szinusz függvény együtthatói * /

/* adatok beolvasása * /void Beolvas(void){ FILE *T; /* szöveges adatállomány * / double a,b; /* segédváltozók * /

darab = 0;

/* állomány megnyitása * / T=fopen("adat.dat","rt"); if (T==NULL) { printf("Nem olvashato: ADAT.DAT\n"); return; }


while (!feof(T) && darab<MAXDATA) { fscanf(T,"%lf %lf\n",&a,&b); X[darab]=a; Y[darab]=b; darab++; } fclose(T);}

/* Y = f(x) számítása * /double Fuggveny(double x){ double d; /* segédváltozó * /

d = PARAM[0] + PARAM[1]*sin(PARAM[2]*x + PARAM[3]); return(d);}


/* eltérés négyzetösszegek számítása * /double Elteres(void){ double d,fx; /* segédváltozók * / int i; /* segédváltozó * /

d=0; for (i=0;i<darab;i++) { fx = Fuggveny(X[i]); d+= (Y[i]−fx)* (Y[i]−fx); }

return(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]; /* az optimálás induló lépéshosszai * / double E0,E1,atlag; /* segédváltozók * / int i,j; /* segédváltozók * /


/* kezdõ értékek meghatározása * / atlag=0; for (i=0;i<darab;i++) atlag+=Y[i]; atlag/=darab;

PARAM[0]=atlag; /* függõleges eltolás * / PARAM[1]=atlag/5; /* amplitudó * / PARAM[2]=2; /* periódus * / PARAM[3]=1; /* vízszintes eltolás * /

/* induló lépéshossz a paraméter értékének 10 %−a * / for (i=0;i<4;i++) LEPES[i]=PARAM[i]/10;

/* 15 iterációs ciklus * / for (i=0;i<15;i++) {

printf("%2d. iteracio: SS = %lg\n",i,Elteres());

/* paraméterenként külön−külön * / for (j=0;j<4;j++) {

/* irány meghatározása * / E0=Elteres(); PARAM[j]+=LEPES[j]; E1=Elteres();


/* sikeres volt a lépés? Ha nem: ellenkezõ irányba próbáljuk meg * / if (E0<E1) LEPES[j]*=−1;

/* addig változtatjuk a kívánt irányba, ameddig csökken az eltérés négyzetösszeg, vagy a csökkenés már nem számottevõ * / do{ E0=E1; PARAM[j]+=LEPES[j]; E1=Elteres(); } while (E0−E1>0.001);

/* lépéshossz csökkentése * / LEPES[j]/=2; }

} /* 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,fx,atlag,Fisher,R2; /* segédváltozók * / int i;

/* függvény kiírása * / printf("\nY=%lg+%lg*SIN(%lg*x+%lg)\n",PARAM[0],PARAM[1],PARAM[2],PARAM[3]);

atlag=0; for (i=0;i<darab;i++) atlag+=Y[i]; atlag/=darab;

/* variancia táblázat számítása * / Model=Hiba=0; for (i=0;i<darab;i++) { fx = Fuggveny(X[i]); Model+=(atlag−fx)* (atlag−fx); Hiba +=(Y[i]−fx)* (Y[i]−fx); }

/* fejléc kiírása * / for (i=0;i<60;i++) printf("="); printf("\n"); printf("Forras SS df"); printf(" MS Fisher\n"); for (i=0;i<60;i++) printf("−"); printf("\n");

/* adatok megjelenítése * / printf("Model %15.4lf %5d",Model,3);

Fisher = (Model* (darab−4))/(Hiba*3); printf("%15.4lf %15.4lf\n",Model/3,Fisher);


printf("Hiba %15.4lf %5d",Hiba,darab−4); printf("%15.4lf\n",Hiba/(darab−4));


printf("Ossz: %15.4lf %5d\n",Model+Hiba,darab−1);

/* determinációs együttható * / R2=Model/(Model+Hiba); printf("R−negyzet = %lg\n",R2);

/* memória felszabadítás * / delete[] X; delete[] Y; darab = 0;}

/* fõprogram * /void main(void){ Beolvas(); Kozelit(); Vege();}


0. i t er aci o: SS = 46026 1. i t er aci o: SS = 40657. 2 2. i t er aci o: SS = 15838. 3 3. i t er aci o: SS = 3289. 65 4. i t er aci o: SS = 776. 311 5. i t er aci o: SS = 167. 765 6. i t er aci o: SS = 88. 4581 7. i t er aci o: SS = 28. 802 8. i t er aci o: SS = 15. 1177 9. i t er aci o: SS = 7. 1364510. i t er aci o: SS = 3. 4891711. i t er aci o: SS = 1. 9623612. i t er aci o: SS = 1. 143913. i t er aci o: SS = 0. 71327614. i t er aci o: SS = 0. 54384

Y = 10. 5041 + −4. 60239 * SI N( 2. 99807 * x + −2. 03383 )============================================================For r as SS df MS Fi sher−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−Model 38113. 1541 3 12704. 3847 87033604. 7028Hi ba 0. 5249 3596 0. 0001−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−Ossz: 38113. 6790 3599R−negyzet = 0. 999986


[12] Készítsünk programot, amely a felhasználó által megadott paraméterekkel rendelkezõ körív 1000 pontjának X és Y koordinátáit ADAT.DAT állományba menti.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf, fprintf * /#include <math.h> /* matematikai függvények: sin, cos * /

/* fõprogram * /void main(void){ FILE *T; /* szöveges állomány az adatoknak * / double a,b,x,y,r,X,Y; /* segédváltozók * / int i; /* segédváltozó * /

/* adatok beolvasása * / printf("Adja meg a kor kozeppontjat\n"); printf("X = "); scanf("%lf",&x); printf("Y = "); scanf("%lf",&y); printf("Sugar = "); scanf("%lf",&r); printf("Adja meg a korivet hatarolo szogeket\n"); do{ printf("Alfa (0..360)= "); scanf("%lf",&a); } while (a<0 || a>360); do{ printf("Beta (%lg..360)= ",a); scanf("%lf",&b); } while (b<a || b>360);

/* az 1000 adat lépésközének kiszámítása * / b −= a; b /= 1000;

/* állomány megnyitása * / T=fopen("adat.dat","wt"); if (T==NULL) { printf("Nem nyithato meg az allomany: ADAT.DAT\n"); return; }

/* koordináták számítása * / for (i=0;i<1000;i++) { X = x + r*cos((a+i*b)*3.14/180); Y = y + r*sin((a+i*b)*3.14/180); fprintf(T,"%lf %lf\n",X,Y); }

/* cache ürítése, állomány lezárása * / fflush(T); fclose(T);}


[13] Készítsünk programot, amelyik a 12. feladatban létrehozott adatokra kört illeszt. Használjuk ismét a legkisebb négyzetek módszerét (figyelemmel arra, hogy egy X értékhez két Y is tartozhat). A kör egyenlete: (x−u)^2 + (y−v)^2 = r^2

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf, fscanf * /#include <math.h> /* matematikai függvények: sqrt * /


double *X; /* X koordináták tömbje * /double *Y; /* Y koordináták tömbje * /int darab; /* beolvasott adatok száma * /double PARAM[3]; /* a kör paraméterei * /

/* adatok beolvasása * /void Beolvas(void){ FILE *T; /* adatállomány * / double a,b; /* segédváltozók * /

darab = 0;




/* Y érték számításaa megadott X koordinátához * /double Fuggveny(double x){ double d;


d=PARAM[2]*PARAM[2]−(x−PARAM[0])* (x−PARAM[0]);

/* a paraméterek változtatása során elõfordulhat, hogy d értéke negatív, ekkor gyököt sem vonhatunk belõle. * / d=sqrt(fabs(d))+PARAM[1];

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]);

/* az X[i] −hez tartozó megfelelõ Y érték keresése * / if (Y[i]<PARAM[1]) { fx = 2*PARAM[1] − fx; }

d+= (Y[i]−fx)* (Y[i]−fx); }

return(d);}

/* optimáló eljárás: célja 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 nincs adat, kilépünk * / if (darab==0 || X==NULL || Y==NULL) return;

/* közelítés stratégiája: körívet, vagy majdnem teljes kört illeszthetünk * / 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);


/* kezdeti paraméterek beállítása a választásnak megfelelõen * / 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; } /* 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);

/* kezdeti 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]);

/* iterációs közelítés, 15 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(); /* sikertelen próbálkozás esetén az 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 csökkentése * / }

}



/* egyenlet kiírása, R−négyzet kiszámítása, memória felszabadítás * /void Vege(void){ double Model,Hiba,fx,atlag,R2; /* segédváltozók * / int i;

/* egyenlet megjelenítése * / printf("\n(X − %lg)^2 ",PARAM[0]); printf("+ (Y − %lg)^2 = %lg^2\n",PARAM[1],PARAM[2]);

/* statisztika * / atlag=0; for (i=0;i<darab;i++) atlag+=Y[i]; atlag/=darab;

Model=Hiba=0; for (i=0;i<darab;i++) { fx = Fuggveny(X[i]);

/* 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);





Az opt i mal as kezdet i beal l i t asa:1 − or i go kozeppont bol i ndul2 − adat ok sul ypont j abol i ndulVal asszon: 1

Kozeppont : X= 0, Y= 0Sugar : R= 22. 9721

0. i t er aci o: SS = 60979. 4 1. i t er aci o: SS = 28435. 8 2. i t er aci o: SS = 5612. 84 3. i t er aci o: SS = 2924. 37 4. i t er aci o: SS = 345. 262 5. i t er aci o: SS = 219. 258 6. i t er aci o: SS = 146. 115 7. i t er aci o: SS = 58. 0139 8. i t er aci o: SS = 15. 807 9. i t er aci o: SS = 2. 1311210. i t er aci o: SS = 0. 99283911. i t er aci o: SS = 0. 21367112. i t er aci o: SS = 0. 21667313. i t er aci o: SS = 0. 076689414. i t er aci o: SS = 0. 0231675

( X − 2. 00002) ^2 + ( Y − 3. 99982) ^2 = 18. 4998^2R−negyzet = 1 ( n=1000)


Kozeppont : X= 1. 99062, Y= 4. 00004Sugar : R= 18. 5094

0. i t er aci o: SS = 6. 54863 1. i t er aci o: SS = 12117. 7 2. i t er aci o: SS = 4789. 11 3. i t er aci o: SS = 1565. 73 4. i t er aci o: SS = 614. 085 5. i t er aci o: SS = 177. 137 6. i t er aci o: SS = 89. 2038 7. i t er aci o: SS = 14. 1009 8. i t er aci o: SS = 4. 64429 9. i t er aci o: SS = 1. 8596510. i t er aci o: SS = 0. 72337311. i t er aci o: SS = 0. 3152712. i t er aci o: SS = 0. 24848513. i t er aci o: SS = 0. 072636914. i t er aci o: SS = 0. 0144445

( X − 2. 00006) ^2 + ( Y − 3. 99964) ^2 = 18. 4999^2R−negyzet = 1 ( n=1000)


[14] Készítsünk programot, amely a 12. feladat felhasználásával létrehozott adatokra kört illeszt. 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.

#include <stdio.h> /* hagyományos ki− és bemeneti függvények: printf, scanf, fscanf * /#include <math.h> /* matematikai függvények: sqrt * /


double *X; /* X koordináták tömbje * /double *Y; /* Y koordináták tömbje * /int darab; /* beolvasott adatok száma * /double PARAM[3]; /* a kör paraméterei * /

/* adatok beolvasása * /void Beolvas(void){ FILE *T; /* adatállomány * / double a,b; /* segédváltozók * /

darab = 0;




/* sugár érték számítása a megadott X és Y koordinátákhoz * /double Fuggveny(double x,double y){ double d;

d = (x−PARAM[0])* (x−PARAM[0]) + (y−PARAM[1])* (y−PARAM[1]);


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; }


/* 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 * / }

}


/* 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]);


/* 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);






Kozeppont : X= 0, Y= 0Sugar : R= 22. 9721

0. i t er aci o: SS = 27548. 3 1. i t er aci o: SS = 6104. 52 2. i t er aci o: SS = 1115. 64 3. i t er aci o: SS = 497. 118 4. i t er aci o: SS = 28. 9866 5. i t er aci o: SS = 15. 9215 6. i t er aci o: SS = 8. 87305 7. i t er aci o: SS = 2. 61902 8. i t er aci o: SS = 0. 474628 9. i t er aci o: SS = 0. 032491710. i t er aci o: SS = 0. 011195411. i t er aci o: SS = 0. 0014841212. i t er aci o: SS = 0. 0013373913. i t er aci o: SS = 0. 00032228714. i t er aci o: SS = 1. 78156e−05

( X − 2. 00002) ^2 + ( Y − 3. 99988) ^2 = 18. 5^2R−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


[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.


#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);}


/* klaszter közepeinek becslése a legtávolabbi értékekkel * /void Centrum(void){ int i,j,k,c1,c2; /* segédváltozók * / long d,dmax; /* távolságok * /

if (darab==0) return;

printf("Klaszter kozepek becslese...\n");

/* minden tizediket kiválasztva megkeresi a legtávolabbiakat => gyorsabb * / dmax=0; for (i=0;i<SOR−11;i+=10) { for (j=i+10;j<SOR−11;j+=10) { d=0; for (k=0;k<OSZLOP;k++) d+=(A[k][i]−A[k][j])* (A[k][i]−A[k][j]); if (d>dmax) { dmax=d; c1=i; c2=j; } } }

/* memória foglalás * / C1 = new int[OSZLOP]; C2 = new int[OSZLOP];

/* centrumok adatainak mentése * / for (k=0;k<OSZLOP;k++) { C1[k]=A[k][c1]; C2[k]=A[k][c2]; }

/* képernyõre kiiratás * / printf("K#1: "); for (i=0;i<OSZLOP;i++) printf(" %3d",C1[i]); printf("\n"); printf("K#2: "); for (i=0;i<OSZLOP;i++) printf(" %3d",C2[i]); printf("\n");}

/* dinamikus K−közép módszere: minden iterációval újraszámolja a középpontot * /void Klaszter(void){ double *K1; /* 1. klaszter középpontja * / double *K2; /* 2. klaszter középpontja * / long N1; /* 1. klaszter adatainak száma * / long N2; /* 2. klaszter adatainak száma * / int i,j; /* segédváltozók * / double d1,d2; /* távolságok * / FILE *T; /* eredmények szöveges állománya * /


/* adatállomány megnyitása * / T=fopen("KLASZTER.DAT","wt"); if (T==NULL) { printf("Hiba a megnyitasnal...\n"); return; }

/* memória foglalás * / K1 = new double[OSZLOP]; K2 = new double[OSZLOP]; /* inicializálás * / for (i=0;i<OSZLOP;i++) { K1[i]=(double)C1[i]; K2[i]=(double)C2[i]; }

printf("Klaszterezes...\n");

N1=N2=1; for (i=0;i<darab;i++) { d1=0; /* távolság az 1. klaszter középpontjától * / d2=0; /* távolság a 2. klaszter középpontjától * / for (j=0;j<OSZLOP;j++) { d1+=(K1[j]−A[j][i])* (K1[j]−A[j][i]); d2+=(K2[j]−A[j][i])* (K2[j]−A[j][i]); } if (d1<d2) { /* középpont újraszámolása * / for (j=0;j<OSZLOP;j++) K1[j]=(N1*K1[j]+A[j][i])/(N1+1); N1++; fprintf(T,"1 %lg\n",d1); } else { /* középpont újraszámolása * / for (j=0;j<OSZLOP;j++) K2[j]=(N2*K2[j]+A[j][i])/(N2+1); N2++; fprintf(T,"2 %lg\n",d2); } }

/* cache ürítése, állomány lezárása * / fflush(T); fclose(T);

/* számított középpontok megjelenítése, elemszámokkal együtt * / printf("K#1 [N=%8d] : ",N1); for (i=0;i<OSZLOP;i++) printf(" %6.2lf",K1[i]); printf("\n"); printf("K#2 [N=%8d] : ",N2); for (i=0;i<OSZLOP;i++) printf(" %6.2lf",K2[i]); printf("\n");}


/* memória felszabadítás * /void Vege(void){ int i;

delete[] C1; delete[] C2;

for (i=0;i<OSZLOP;i++) delete[] A[i]; delete[] A;}

/* fõprogram * /void main(void){ Beolvas(); Centrum(); Klaszter(); Vege();}

a [15] feladat eredményei

[ MI NTA. DAT]N = 30000Kl aszt er kozepek becsl ese. . .K#1: 8 23 9K#2: 207 218 184Kl aszt er ezes. . .K#1 [ N= 11208] : 95. 62 93. 75 17. 55K#2 [ N= 18794] : 69. 16 137. 34 188. 62

MINTA.DAT adatait a BMP2DAT programmal hoztuk létre. Az adatok így soronként egy képpontvörös, zöld és kék színkomponenseit jelentik. Az alábbi képek bemutatják a klaszter analíziserdeményét:

VIRAG_A.BMP VIRAG_B.BMP


[16] Osztályozzuk MINTA.DAT adatait (az állomány soronként három egész számot tartalmaz). Az osztályozáshoz szükséges adatokat INIT.DAT tartalmazza. Az eredményt mentsük el EREDMENY.DAT állományba (osztály és távolság adatokat).


#define SOR 30000 /* adatsorok maximális száma * /#define OSZLOP 3 /* adatok száma egy sorban * /#define OSZTALY 3 /* osztályok maximális száma * /

int * *O; /* osztályok adatai * /int * *A; /* adatmátrix * /int db0; /* osztályok száma * /int db1; /* adatsorok száma * /

void Beolvas(void) /* adatok beolvasása * /{ FILE *T; /* szöveges állomány * / int i,a; /* segédváltozók * /

db0=db1=0;

T=fopen("INIT.DAT","rt"); /* a tanulóminta statisztikai adatai * / if (T==NULL) { printf("Nem megnyithato! \n"); return; }

/* memória foglalás * / O = new int* [OSZLOP]; for (i=0;i<OSZLOP;i++) O[i]=new int[OSZTALY];

/* beolvasás az adatállományból * / while (!feof(T) && db0<OSZTALY) { for (i=0;i<OSZLOP−1;i++) { fscanf(T,"%d",&a); O[i][db0]=a; } fscanf(T,"%d\n",&a); O[OSZLOP−1][db0]=a; db0++; } fclose(T);

T=fopen("MINTA.DAT","rt"); /* adatállomány * / if (T==NULL) { printf("Nem megnyithato! \n"); return; }


/* memória foglalás * / A = new int* [OSZLOP]; for (i=0;i<OSZLOP;i++) A[i]=new int[SOR];

/* beolvasás az adatállományból * / while (!feof(T) && db1<SOR) { for (i=0;i<OSZLOP−1;i++) { fscanf(T,"%d",&a); A[i][db1]=a; } fscanf(T,"%d\n",&a); A[OSZLOP−1][db1]=a; db1++; } fclose(T);

} /* 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.DAT állományba. * /void Osztalyoz(void){ FILE *T; /* szöveges állomány * / int i,j,k,o; /* segédváltozók * / long d,d2; /* távolságok * /

T=fopen("EREDMENY.DAT","wt"); if (T==NULL) { printf("Nem megnyithato! \n"); return; }

for (i=0;i<db1;i++) { d2=999999; /* távolság kezdõértéke * / o=0; for (j=0;j<db0;j++) { d=0; for (k=0;k<OSZLOP;k++) d+=(A[k][i]−O[k][j])* (A[k][i]−O[k][j]); if (d<d2) { d2=d; o=j; /* a legközelebbi osztály kiválasztása * / } } fprintf(T,"%d %d\n",o,d2); }

fflush(T); fclose(T);}

/* memória felszabadítás * /void Vege(void){ int i;


for (i=0;i<OSZLOP;i++) { delete[] O[i]; delete[] A[i]; } delete[] O; delete[] A;}

/* fõprogram * /void main(void){ Beolvas(); Osztalyoz(); Vege();}

a [16] feladat eredménye

INIT.DAT adatai a következõ színeket azonosítják soronként: kék (0;0;255), sárga (255;255;0),zöld (0;255;0). Az osztályozás eredényét az alábbi képek mutatják be:

VIRAG_A.BMP VIRAG_C.BMP


Ajánlott irodalom

1. Bodor L., Bérczi N. (2000):C/C++ programozás. LSI Oktatóközpont, Budapest.

2. A.I. Bojarinov, V.V. Kafarov (1973):Optimalizálás a vegyiparban. Mûszaki Könyvkiadó, Budapest.

3. A.E. Bryson, Y.C. Ho (1981):Applied optimal control: optimization, estimation and control. Hemisphere PublishingCorporation

4. D.E. Goldberg, (1998):Genetic algorithms in search, optimization and machine learning. Addison WesleyLongman Inc.

5. Hillier, Lieberman (1999):Bevezetés az operációkutatásba. LSI Oktatóközpont, Budapest.

6. Kemény S., Deák A. (1993):Mérések tervezése és eredményeik értékelése. Mûszaki Könyvkiadó, Budapest.

7. J. Nocedal, S.J. Wright (1999):Numerical optimization. Springer−Verlag, New York.

8. Obádovics Gy. (1997):Numerikus módszerek I.−II. LSI Oktatóközpont, Budapest.

9. J.R. Piggott (1986):Statistical procedures in food research. Elsevier Applied Science Publishers Ltd., Essex UK.

10.Popper Gy., Csizmás F. (1993):Numerikus módszerek mérnököknek. Akadémiai Kiadó, Budapest.

11.Sváb J. (1981):Biometriai módszerek a kutatásban. Mezõgazdasági Kiadó, Budapest.

bodor lászló, bérci norbert, baranyai lászló - c, c++ programozás feladatokkal, cd...

Documents