Transcript
  • GNU C/C++ pldaprogramok 1

    Mrnki szmtsok C/C++ nyelven16 feladat a GNU C hasznlinak

    Tartalom

    1. (a+b)^n egytthatinak kiszmtsa a Pascal hromszg segtsgvel 32. Jtk pszeudovletlen szmokkal 53. Optiml eljrs az elz jtk automatikus megoldsra 64. Szlsrtk keresse az aranymetszs mdszervel 75. Aknamezn biztonsgos tvonalat keres eljrs 106. Pszeudovletlen szmokat tartalmaz adatllomny ksztse 167. Rendezsi eljrsok sebessgnek sszehasonltsa 178. Adatsorok egyszer statisztiki, valamint korrelcija 229. Egysze fggvnyek illesztse 2810. Illesztsek rtkelse: variancia analzis, reziduumok elemzse 3211. Tetszleges fggvny illesztse optiml eljrs segtsgvel 3912. Egy kivlasztott kr pontjainak koordinti 4313. Kr illesztse a legkisebb ngyzetek mdszervel 4414. Kr illesztse a sugr irny ngyzetes eltrsek minimlsval 4915. Klaszter analzis a dinamikus Kkzp mdszervel 5416. Osztlyozs tanulminta adatai alapjn 58Ajnlott irodalon 61

    CDROM mellklet:

    \TELEPITO Telept kszletekWIN MSDOS / WindowsLINUX Linux

    \FELADATOK Feladatok kidolgozsa01 1. feladat llomnyai EXE MSDOS / Windows binris ELF Linux binris02 2. feladat llomnyai EXE MSDOS / Windows binris ELF Linux binris...

    16 16. feladat llomnyai EXE MSDOS / Windows binris ELF Linux binris

  • GNU C/C++ pldaprogramok 2

    Elsz

    Olyan feladatgyjtemnyt tart kezben a kedves olvas, amely elssorban a mszaki kpzsbenrsztvev egyetemi s fiskolai hallgatk szmra kszlt. A knyv azonban nem csupn nekikajnlhat, hanem mindazoknak, akik mrsi eredmnyeik kirtkelse rdekben nem riadnakvissza a szmtgp programozstl.

    A feladatgyjtemny clja a mrnki munka, kutats sorn alkalmazhat matematikai mdszerekbemutatsa. Ennek rdekben a kzlt C s C++ forrskdok egyszerek, sok megjegyzsselkiegsztve. A megrtst a vltozk, eljrsok beszdes nevei s a fenntartott szavak kiemelsetovbb segti. A feladatok megrtst nagymrtkben segti Pascal vagy C, C++ programozsiismeret, optimlsban, opercikutatsban szerzett gyakorlat.

    A CDROM mellkleten tallhat telept kszletek segtsgvel a szmtgpen ltrehozhat aszksges fejleszti krnyezet. Ez a krnyezet magba foglalja a fordt programot (gcc) sWindows, valamint MSDOS alatt az RHIDE keretrendszert s az Emacs nev szerkesztt.Telepts Windows / MSDOS alatt:

    1., msolja t [CDROM]\TELEPITO\WIN\ tartalmt egy ideiglenes knyvtrba2., indtsa el az INSTALL.EXE nkicsomagol programot3., indtsa el a LBINSTDJ.EXE programot

    Linux rendszerekben a GNU C fordt beptett elem. Ha frissteni szeretn, a csomagot megtalljaa [CDROM]\TELEPITO\LINUX\ knyvtrban. A teleptshez szksges tennivalkat tartalmazzaa csomag README llomnya. Linux rendszerekben a C fordt csak rsze a GNU CommonCompilers csomagnak, ezrt a mellkleten megtallhat a Java, Object C, Fortran 77 fordt is. HaLinux krnyezetben hibazenetet kap a matematikai fggvnyek hinyra hivatkozva, hasznlja akvetkez parancsot:

    gcc forras.c lm

    ahol az "lm" kapcsol a matematikai knyvtr hozzfzst jelenti.Amennyiben tovbbi informcikra van szksge a GNU C fejleszti krnyezetrl (lersok,frisstsek), a kvetkez kt internet cmet javasolhatom:

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

    2001. janurJ munkt kvnok:

    a szerz

  • GNU C/C++ pldaprogramok 3

    [1a] Ksztsnk programot, amely a kpernyre rja a Pascalhromszg els N sort. Ha a programot ksbb bvteni szeretnnk, az rtkeket clszer egy mtrixba helyezni.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */

    int main(void){ int **H; /* H tartalmazza a hromszget */ int i,j,n; /* segdvltozk */ printf("A kovetkezo nevezetes szorzat egyutthatoit szamolja ki \n"); printf("ez a program: (a+b)^n \n");

    /* beolvas egy 3 s 14 kztti szmot */ do{ printf("n (3..14) = "); scanf("%d",&n); }while (n14); /* megnveljk "n" rtkt, mert a legels sor az n=0 kitev adatait tartalmazza */ n++;

    /* memria foglals; a hromszg minden sora csak a szksges terletet kti le. */ H = new int*[n]; for (i=0;i

  • GNU C/C++ pldaprogramok 4

    [1b] Az elz feladat egyszerstett megoldsa, ha nem szksges az adatok trolsa esetleges ksbbi felhasznlsukhoz.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */

    int main(void){ int *V; /* V vektorban trolja az rtkeket */ int i,j,n; /* segdvltozk */ 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 (n14); /* memria foglals */ V = new int[n+1];

    for (i=0;i0;j) V[j]+=V[j1]; printf("%3d.: ",i); for (j=0;j

  • GNU C/C++ pldaprogramok 5

    [2] Ksztsnk jtkprogramot, amely kitall egy egsz szmot 1tl 100ig. A felhasznl 10 alkalommal krdezhet r. A program csak annyit vlaszolhat, hogy a bert rtk kisebb, vagy nagyobb, mint az ltala vlasztott, esetleg egyenlek.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */#include /* pszeudovletlenszm ellltshoz: gettime */

    int Hasonlit(int mit,int mivel) /* kt szmot hasonlt ssze, visszatrsi rtkei: 1, 0, 1 */{ if (mit>mivel) return(1); if (mivel>mit) return(1); return(0);}

    int Beallit(int maximum) /* pszeudovletlen szm ellltsa az aktulis id adataibl */{ struct time T; int r;

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

    /* "r" rtke az 1..maximum tartomnyban van */ return(r);}

    int main(void) /* fprogram */{ int Gep,Ember,N;

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

    N=0; /* szmll nullzsa */ 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

  • GNU C/C++ pldaprogramok 6

    [3] Az elz feladatban ismertetett jtk szerepeit cserljk fel! A szmtgp legfeljebb 10 lpsben tallja ki az ltalunk vlasztott 1 s 100 kztti egsz szmot.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */

    int Hasonlit(int mit,int mivel) /* kt szmot hasonlt ssze, visszatrsi rtkei: 1, 0, 1 */{ if (mit>mivel) return(1); if (mivel>mit) return(1); return(0);}

    /* a felezses eljrst alkalmazva biztosan ki lehet tallni minden szmot legfeljebb 8 lpsbl */int main(void){ int Gep,Ember,N,Also,Felso;

    /* beolvas egy egsz szmot 1tl 100ig */ do{ printf("\n Kitalalt egy szamot 1tol 100ig? "); scanf("%d",&Ember); }while(Ember100); N=0; Also=0; Felso=101; /* segdvltozk belltsa */

    do{ /* a szmtgp az als s a fels hatr tlagt 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

  • GNU C/C++ pldaprogramok 7

    [4] Hatrozzuk meg az Y=A*x^2 + B*x + C msodfok egyenlet szls rtkt a [50;50] intervallumon gy, hogy az egyenlet egytthatit a felhasznl adhassa meg.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */#include /* matematikai rutinok: sqrt */

    double A,B,C; /* az egyenlet egytthati */

    double fuggveny(double x) /* a parabola Y rtkeit adja meg */{ double d;

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

    return(d);}

    /* a kvetkez eljrs megvizsglja, hogy valban msodfoke az egyenlet s vane tengelymetszete, ami alapjn meghatrozhat a szlsrtk helye s a hozz tartoz fggvny rtk. Az itt kiszmtott s kirt rtkek segtenek az optimls rtkelsben */void vizsgalat(void){ double d; double x1,x2;

    d = B*B 4*A*C; /* diszkriminns */

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

    if (d

  • GNU C/C++ pldaprogramok 8

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

    /* a msodfok egyenlet megold kpletvel */ x1 = (B+sqrt(d))/(2*A); printf("zerushely: X(1) = %lg\n",x1); x2 = (Bsqrt(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 felttelben elhagyhat a return utasts */ return; }

    } /* vizsglat vge */

    /* optiml eljrs az aranymetszs mdszervel: ekkor egy specilis arnyszmot alkalmazunk, amely rtke: a 3

    52

    (kb. 0,3819) . Ngy Y rtket kell kiszmtani, majd a kzps kett kzl a kisebbik (maximum keressekor) vagy nagyobbik (minimum keressekor) helye lesz az j als, vagy fels hatr. Az arnyszm olyan klnleges tulajdonsg, hogy ekkor elegend csupn egy j pontot kiszmtani, a msik hrom adott. A keresett x rtk a kt kzps x koordinta tlaga. */void optimalas(void){ double arany; /* arnyszm */ double X[4]; /* a szksges 4 x rtk */ double Y[4]; /* a szksges 4 f(x) rtk */ int i,j,lepes; /* segdvltozk */ /* konvex, vagy konkv a parabola? */ if (A>0) printf("Minimumhely kereses...\n"); if (A

  • GNU C/C++ pldaprogramok 9

    /* az optimls akkor ll le, amikor a szlsrtket kell pontossggal megkzeltettk . Esetnkben legyen a kvnt pontossg 0,0005 */ lepes = 0; while (fabs(X[2]X[1])>0.001) {

    for (j=0;j0) { /* x^2 egytthatja pozitv, teht minimumhelyet keresnk */

    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 egytthatja negatv, teht maximumhelyet keresnk */

    if (Y[1]

  • GNU C/C++ pldaprogramok 10

    a [4] feladat zenetei a kpernyn A = 15B = 2C = 20A fuggveny metszi az X tengelyt:zerushely: X(1) = 1.22329zerushely: X(2) = 1.08996szelsoertek helye: X = 0.0666667erteke: Y = 20.0667Minimumhely kereses...Kereses a [50;50] tartomanyban...lepesek szama: 21x = 0.066703f(x) = 20.0667

    [5] Ksztsnk programot, amely egy 80x20 mret mezn vletlenszeren elhelyez 70 aknt, majd rjuk meg azt az eljrst, amely a mez P1(1;10) pontjbl indulva nagy valsznsggel tjut a msik oldalra P2(80;?). Gondolni kell arra is, hogy az tjuts nem garantlt az aknk vletlenszer helyzete miatt.

    #include /* hagyomnyos ki s bemeneti fggvnyek: sprintf */#include /* kpernyre rs: gotoxy, cputs */#include /* id lekrdezse a vletlenszm ellltshoz: gettime */

    #define MAXLEPES 15000 /* maximlis lpsszm */#define AKNAK 70 /* aknk szma */

    int **Mezo; /* aknamez */int X,Y,Akna,Lepes; /* segdvltozk: pozci, aknajelz, lpsszm */int V1,V2,V3; /* vltozk a vletlenszm generlshoz */

    int Veletlen(int maximum) /* vletlenszm ellltsa 0tl "maximum"ig */{ int r;

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

    return(r);}

    /* aknamez ltrehozsa, aknk elhelyezse s a kpernyre rajzolsuk */void Beallit(void){ int i,j,k; struct time T;

    /* vletlenszmok generlsnak belltsa */ gettime(&T); V1=T.ti_hund; V2=T.ti_sec; V3=T.ti_min;

  • GNU C/C++ pldaprogramok 11

    /* memria foglals: 80x20 mtrix, elemek nullzsa */ Mezo = new int*[80]; for (i=0;i

  • GNU C/C++ pldaprogramok 12

    /* terlethatrok kijellse */ x1=x1; x2=x+1; y1=y1; y2=y+1; if (x179) x2=79; if (y119) y2=19;

    /* aknk szma */ Akna=0; for (i=x1;i

  • GNU C/C++ pldaprogramok 13

    /* inicializls, a Mozdit(0,0) segtsgvel kirtkeltetjk az aktulis pozcit */ Lepes=0; X=0; Y=10; dx=1; dy=0; Mozdit(0,0);

    /* addig folyik a keress, ameddig t nem jutott, aknra lpett, vagy beszorult valahova */ while (X

  • GNU C/C++ pldaprogramok 14

    if (dx==0) { /* fgglegesen haladt */ dy=0; dontes=Veletlen(100); /* az esetek 20%ban balra, 80%ban jobbra folytatja */ if (dontes

  • GNU C/C++ pldaprogramok 15

    az [5] feladat a kpernyn

    A keres eljrs a kvetkez paramterekkel llthat: MAXLEPES : maximlis megengedett lpsszm irnyvlts kiknyszertsre hasznlt valszinsg : vltoz, 100% > 40% Y irny elmozduls valsznsgei: 1 : 50% +1 : 50% X irny elmozduls valsznsgei: 1 : 20% +1 : 80% vletlenszm generlsa ms fggvnnyel

  • GNU C/C++ pldaprogramok 16

    [6] Ksztsnk programot, amelyik 80000 pszeudovletlen szmot r egy szveges llomnyba. A szveges llomnyok hasznlata knyelmes, mert knnyen importlhatak tblzatokba s az elterjedt statisztikai programok is olvassk. Szerkesztsk, javtsuk pedig egyszer.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */

    int A,B,C; /* kezd rtkek a pszeudovletlen szmok generlshoz */

    int veletlen(int maximum) /* vletlenszer szmokat elllt eljrs */{ int r;

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

    /* a paramterek vltoztatsa miatt az egymst kvet szmok nem lesznek azonosak */ A = B; B = C; A = r;

    /* "r" rtke 1 s maximum kztti egsz szm */ return(r);}

    int main(void) /* fprogram */{ FILE *T; /* szveges llomny az adatoknak */ int i,j; /* segdvltozk */ printf("Adja meg a parametereket (A,B,C): \n");

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

    /* llomny megnyitsa */ T=fopen("ADAT.DAT","wt"); if (T!=NULL) {

    /* csak akkor menti az adatokat, ha sikerlt megnyitni az llomnyt */ for (i=0;i

  • GNU C/C++ pldaprogramok 17

    [7] Az elz programot felhasznlva lltsunk el egy 80000 elem egsz szmokbl ll adatllomnyt, majd rendezzk az adatokat nvekv szmsorrendbe. Tbbfle rendezsi eljrst alkalmazva sszehasonlthatjuk azok sebessgt.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */#include /* idmrs */

    /* konstans, a maximlisan feldolgozhat adatok szmt tartalmazza */#define MAXDATA 80000

    int *A; /* Adatok vektora */int darab; /* Adatok szma */clock_t IDO; /* idmr */

    void Beolvas(char *Neve) /* adatok beolvassa "Neve" llomnybl */{ FILE *T; /* szveges llomny az adatokkal */ int D; /* segdvltozk */

    darab=0; /* darabszm nullzsa */

    A = new int[MAXDATA]; /* memria foglals */ if (A==NULL) { printf("Nincsen elegendo memoria! \n"); return; }

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

    /* ha a megnyits sikeres volt, olvassunk be adatokat, ameddig van adat az llomnyban s mg nem haladtuk meg a megengedett maximumot (MAXDATA) */ while (!feof(T) && darab

  • GNU C/C++ pldaprogramok 18

    /* egyszer csers rendezs: minden elemet sszehasonlt az sszes mgtte lvvel s ha a sorrend nem megfelel, akkor kicserli ket. Az adatsor ellrl htrafel haladva a nagyobb sorszm fel vlik rendezett. */void EgyszeruCsere(void){ int i,j,tmp; printf("Egyszeru cseres rendezes...\n");

    for (i=0;i0;i) { csere=0; for (j=0;jA[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 = mr rendezett */ }

    } /* buborkos rendezs vge */

    /* beszrsos rendezs: minden elemet az eltte levkkel hasonlt ssze, ott keresi meg azt a helyet, ahova beilleszthet. Az adatsor ellrl htrafel haladva vlik rendezett. */void Beszurasos(void){ int i,j,tmp; printf("Beszurasos rendezes...\n");

    for (i=1;i

  • GNU C/C++ pldaprogramok 19

    j=i1; while (j>=0 && A[j]>tmp) { A[j+1]=A[j]; /* elemek grgetse htrafel */ j; } A[j+1]=tmp; /* beilleszts a megfelel pozciba */ }

    } /* beszrsos rendezs vge */

    /* minimumkeress: minden elemet a mgtte lev elemek legisebbikvel hasonlt ssze. Az adatsor ellrl htrafel haladva vlik rendezett */void MinimumKeres(void){ int i,j,min,tmp; printf("Minimum kivalasztasos rendezes...\n");

    for (i=0;i

  • GNU C/C++ pldaprogramok 20

    if (bal

  • GNU C/C++ pldaprogramok 21

    Beolvas(argv[1]); /* adatok beolvassa */

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

    /* szksges msodpercek szmtsa */ d=(double)(clock()IDO)/CLOCKS_PER_SEC; printf("Szukseges ido: %lg sec\n",d);

    Ellenor();

    return(0);}

    a [7] feladat rtkelse Adatok szma: 80000PC: Intel Celeron, 64MB RAMOS: Linux Mandrake 7.2=========================================

    Mdszer Id (sec)

    Egyszer csers 184.56Buborkos 293.01Beszrsos 111.42Minimum kivlasztsos 183.09Gyors 0.10

  • GNU C/C++ pldaprogramok 22

    [8] Ksztsnk programot, amely kiszmtja ngy adatsor fontosabb statisztikai jellemzit.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */#include /* matematikai eljrsok: sqrt */

    #define MAXDATA 3000 /* konstans: adatsorok maximlis szma */

    double **A; /* adatmtrix */int darab; /* beolvasott adatok szma */

    void Beolvas(void) /* adatok beolvassa */{ FILE *T; /* szveges llomny */ double d; /* segdvltoz */ int i; /* segdvltoz */

    darab = 0;

    /* memria foglals */ A = new double*[4]; for (i=0;i

  • GNU C/C++ pldaprogramok 23

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

  • GNU C/C++ pldaprogramok 24

    /* kiugr rtkek keresse: Dixonprba */void Kiugro(void){ double r,tmp; /* Dixonfle r rtk, segdvltoz */ int i,j,k; /* segdvltoz */ double *d; /* tmeneti tmb a rendezshez */

    /* ha nincsen elegend szm adat, nincs rtelme a statisztiknak */ if (darab

  • GNU C/C++ pldaprogramok 25

    /* ha meghaladja a kritikus rtket, valsznleg (p=95%) kiugr adatot tallt */ if (r>0.35) printf(" [+] "); else printf(" [] ");

    printf("\n"); }

    /* elvlaszt vonal */ for (i=0;i

  • GNU C/C++ pldaprogramok 26

    /* korrelcis mtrix kiiratsa */ for (i=0;i

  • GNU C/C++ pldaprogramok 27

    a [8] feladat eredmnye a kpernyn

    Leiro statisztika========================================

    # min. max. atlag szoras

    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 : szigoruan monoton novekvo2 : szigoruan monoton novekvo3 : szigoruan monoton csokkeno4 : nem monoton

    Kiugro ertekek: Dixonproba==============================

    # min. [?] max. [?]

    1 0.1111 [] 0.1108 [] 2 0.3811 [+] 0.0088 [] 3 0.0088 [] 0.3801 [+] 4 0.0554 [] 0.0145 []

    Korrelacios matrix (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

    tproba (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

  • GNU C/C++ pldaprogramok 28

    [9] Ksztsnk programot, amely a mellkelt adatokra (ADAT.DAT) egyenest, vagy parabolt illeszt a felhasznl vlasztstl fggen. Ezen alap tpusok ismerete elegend lehet, mert az egyszerbb fggvnyek ltalban visszavezethetek egyenes illesztsre.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */#include /* matematikai fggvnyek: sqrt */

    #define MAXDATA 1000 /* konstans: adatsorok maximlis szma */

    double *X; /* X rtkek tmbje */double *Y; /* Y rtkek tmbje */int darab; /* beolvasott adatok szma */

    /* adatok beolvassa */void Beolvas(void){ FILE *T; /* szveges llomny */ double a,b; /* segdvltozk */ int i; /* segdvltoz */

    darab=0;

    /* memria foglals */ X = new double[MAXDATA]; Y = new double[MAXDATA];

    /* llomny megnyitsa, beolvass */ T=fopen("adat.dat","rt"); if (T!=NULL) { while (!feof(T) && darab

  • GNU C/C++ pldaprogramok 29

    /* ha nincsen adat, kilp */ if (darab==0 || X==NULL || Y==NULL) return; /* ngyzetsszegek szmtsa */ S1=S2=S3=S4=S5=0; for (i=0;i

  • GNU C/C++ pldaprogramok 30

    /* parabola illesztse: Y = a + b1*X + b2*X^2 */void Parabola(void){ double S[8]; /* segdvltozk: ngyzetsszegek */ double A,B1,B2,R; /* segdvltozk: egytthatk, r2 */ int i; /* segdvltoz */

    /* ha nincsen adat, kilp */ if (darab==0 || X==NULL || Y==NULL) return; /* szmllk nullzsa */ for (i=0;i

  • GNU C/C++ pldaprogramok 31

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

    /* tengelymetszet szmtsa */ A = S[0] B1*S[1] B2*S[2];

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

    /* tprba, nullhipotzis: r2 nem nulla */ if (R*R

  • GNU C/C++ pldaprogramok 32

    /* fprogram */void main(void){ Beolvas(); Illeszt(); Vege();}

    a [9] program eredmnye a kpernyn Melyik fuggvenyt illeszti?1 Y = a + b*X2 Y = a + b1*X + b2*X^2Valasszon: 1Y = 103.705 + 0.431063 * XRnegyzet: 0.933015 (n=1000)tproba (H: r!=0) : 117.902 (df=998)

    Melyik fuggvenyt illeszti?1 Y = a + b*X2 Y = a + b1*X + b2*X^2Valasszon: 2Y = 90.435 + 0.257787 * X + 0.00765332 * X^2Rnegyzet: 0.999522 (n=1000)tproba (H: r!=0) : 1444.4 (df=998)

    [10] Vgezzk el az elz feladatban szerepl fggvnyek illesztst, valamint az illeszts jsgnak s a reziduumok autokorrelcijnak elemzst.

    #include /* hagyomnyos ki s beviteli fggvnyek: printf, fscanf */#include /* matematikai fggvnyek: sqrt */

    #define MAXDATA 1000 /* konstans: adatprok maximlis szma */

    double *X; /* X rtkek tmbje */double *Y; /* Y rtkek tmbje */int darab; /* beolvasott adatsorok szma */

    /* adatok beolvassa */void Beolvas(void){ FILE *T; /* szveges llomny */ double a,b; /* segdvltozk */ int i; /* segdvltoz */

    darab=0;

    /* memria foglals */ X = new double[MAXDATA]; Y = new double[MAXDATA];

  • GNU C/C++ pldaprogramok 33

    /* adatllomny megnyitsa, beolvass */ T=fopen("adat.dat","rt"); if (T!=NULL) { while (!feof(T) && darab

  • GNU C/C++ pldaprogramok 34

    S1=S2=0; for (i=0;i

  • GNU C/C++ pldaprogramok 35

    printf("Reziduumok autokorrelaciojanak elemzese\n");

    S1=S2=0; for (i=0;i0) { S4 = A + B1*X[i1] Y[i1]; S2 += (S3S4)*(S3S4); } } tmp = S2*darab; tmp/= S1*(darab1);

    /* a Neumannfle hnyados vrhat rtke idelis esetben 2 krli amennyiben az rtk ketttl tvol esik, valszn a reziduumok autokorrelcija, azaz nem sikerlt a megtallni a megfelel fggvnyt */ printf("Neumannfele hanyados: %lg\n",tmp);

    } /* Egyenes() vge */

    /* parabola illesztse: Y = a + b1*X + b2*X^2 */void Parabola(void){ double S[8]; /* segdvltozk: ngyzetsszegek szmtshoz */ double A,B1,B2,R,tmp; /* segdvltozk: egytthatk, r2 */ int i; /* segdvltoz */

    /* ha nincs adat, kilp */ if (darab==0 || X==NULL || Y==NULL) return; /* ngyzetsszegek szmtsa */ for (i=0;i

  • GNU C/C++ pldaprogramok 36

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

    /* lineris tag egytthatja */ B1 = S[2]*S[5] S[7]*S[6]; B1/= S[1]*S[2] S[7]*S[7];

    /* ngyzetes tag egytthatja */ B2 = S[1]*S[6] S[7]*S[5]; B2/= S[1]*S[2] S[7]*S[7];

    /* determincis egytthat */ R = B1*S[5] + B2*S[6]; R/= S[4];

    S[0]=S[1]=S[2]=0; for (i=0;i

  • GNU C/C++ pldaprogramok 37

    /* fejlc kirsa */ for (i=0;i

  • GNU C/C++ pldaprogramok 38

    do{ printf("Valasszon: "); scanf("%d",&i); }while (i2); switch(i) { case 1: Egyenes(); break; case 2: Parabola(); break; }} /* Illeszt() vge */

    /* memria felszabadts */void Vege(void){ delete[] X; delete[] Y;}

    /* fprogram */void main(void){ Beolvas(); Illeszt(); Vege();}

    a [10] program eredmnye a kpernyn

    Melyik fuggvenyt illeszti?1 Y = a + b*X2 Y = a + b1*X + b2*X^2Valasszon: 2Y = 90.435 + 0.257787 * X + 0.00765332 * X^2Rnegyzet: 0.999522 (n=1000)tproba (H: r!=0) : 1444.4 (df=998)

    Variancia tablazat=============================================

    Forras SS df MS F

    Model 5.782e+04 2 2.891e+04 2.084e+06Hiba 27.66 997 0.02774

    Osszes 5.785e+04 999Reziduumok autokorrelaciojanak elemzeseNeumannfele hanyados: 0.000165689

  • GNU C/C++ pldaprogramok 39

    [11] Illesszk az Y = A + B*sin( C*x + D ) fggvnyt az ADAT.DAT llomnyban trolt adatsorra! A feladat megoldsra rjunk optiml eljrst.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, fscanf */#include /* matematikai fggvnyek: sin */

    #define MAXDATA 4000 /* konstans: adatsorok maximlis szma */

    double *X; /* X rtkek tmbje */double *Y; /* Y rtkek tmbje */int darab; /* beolvasott adatok szma */double PARAM[4]; /* a szinusz fggvny egytthati */

    /* adatok beolvassa */void Beolvas(void){ FILE *T; /* szveges adatllomny */ double a,b; /* segdvltozk */

    darab = 0;

    /* llomny megnyitsa */ T=fopen("adat.dat","rt"); if (T==NULL) { printf("Nem olvashato: ADAT.DAT\n"); return; }

    /* memria foglals */ X = new double[MAXDATA]; Y = new double[MAXDATA];

    while (!feof(T) && darab

  • GNU C/C++ pldaprogramok 40

    /* eltrs ngyzetsszegek szmtsa */double Elteres(void){ double d,fx; /* segdvltozk */ int i; /* segdvltoz */

    d=0; for (i=0;i

  • GNU C/C++ pldaprogramok 41

    /* sikeres volt a lps? Ha nem: ellenkez irnyba prbljuk meg */ if (E00.001);

    /* lpshossz cskkentse */ LEPES[j]/=2; }

    } /* itercis ciklus vge */

    } /* Kozelit() vge */

    /* memria felszabadts s statisztika ksztse */void Vege(void){ double Model,Hiba,fx,atlag,Fisher,R2; /* segdvltozk */ int i;

    /* fggvny kirsa */ printf("\nY=%lg+%lg*SIN(%lg*x+%lg)\n",PARAM[0],PARAM[1],PARAM[2],PARAM[3]);

    atlag=0; for (i=0;i

  • GNU C/C++ pldaprogramok 42

    printf("Hiba %15.4lf %5d",Hiba,darab4); printf("%15.4lf\n",Hiba/(darab4));

    /* elvlaszt vonal */ for (i=0;i

  • GNU C/C++ pldaprogramok 43

    [12] Ksztsnk programot, amely a felhasznl ltal megadott paramterekkel rendelkez krv 1000 pontjnak X s Y koordintit ADAT.DAT llomnyba menti.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf, fprintf */#include /* matematikai fggvnyek: sin, cos */

    /* fprogram */void main(void){ FILE *T; /* szveges llomny az adatoknak */ double a,b,x,y,r,X,Y; /* segdvltozk */ int i; /* segdvltoz */

    /* adatok beolvassa */ 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 (a360); do{ printf("Beta (%lg..360)= ",a); scanf("%lf",&b); }while (b360); /* az 1000 adat lpskznek kiszmtsa */ b = a; b /= 1000;

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

    /* koordintk szmtsa */ for (i=0;i

  • GNU C/C++ pldaprogramok 44

    [13] Ksztsnk programot, amelyik a 12. feladatban ltrehozott adatokra krt illeszt. Hasznljuk ismt a legkisebb ngyzetek mdszert (figyelemmel arra, hogy egy X rtkhez kt Y is tartozhat). A kr egyenlete: (xu)^2 + (yv)^2 = r^2

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf, fscanf */#include /* matematikai fggvnyek: sqrt */

    #define MAXDATA 1000 /* konstans: adatsorok maximlis szma */

    double *X; /* X koordintk tmbje */double *Y; /* Y koordintk tmbje */int darab; /* beolvasott adatok szma */double PARAM[3]; /* a kr paramterei */

    /* adatok beolvassa */void Beolvas(void){ FILE *T; /* adatllomny */ double a,b; /* segdvltozk */

    darab = 0;

    /* llomny megnyitsa */ T=fopen("adat.dat","rt"); if (T==NULL) { printf("Nem olvashato: ADAT.DAT\n"); return; }

    /* memria foglals */ X = new double[MAXDATA]; Y = new double[MAXDATA];

    while (!feof(T) && darab

  • GNU C/C++ pldaprogramok 45

    d=PARAM[2]*PARAM[2](xPARAM[0])*(xPARAM[0]);

    /* a paramterek vltoztatsa sorn elfordulhat, hogy d rtke negatv, ekkor gykt sem vonhatunk belle. */ d=sqrt(fabs(d))+PARAM[1];

    return(d);

    } /* Fuggveny() vge */

    /* eltrs ngyzetsszeg szmtsa */double Elteres(void){ double d,fx; /* segdvltozk */ int i;

    d=0; for (i=0;i

  • GNU C/C++ pldaprogramok 46

    /* kezdeti paramterek belltsa a vlasztsnak megfelelen */ if (i==1) { PARAM[0]=0; PARAM[1]=0; } else { E0=E1=0; for (i=0;i

  • GNU C/C++ pldaprogramok 47

    /* egyenlet kirsa, Rngyzet kiszmtsa, memria felszabadts */void Vege(void){ double Model,Hiba,fx,atlag,R2; /* segdvltozk */ int i;

    /* egyenlet megjelentse */ 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

  • GNU C/C++ pldaprogramok 48

    a [13] feladat eredmnye a kpernyn

    Az optimalas kezdeti beallitasa:1 origo kozeppontbol indul2 adatok sulypontjabol indulValasszon: 1

    Kozeppont: X= 0, Y= 0Sugar: R= 22.9721

    0. iteracio: SS = 60979.4 1. iteracio: SS = 28435.8 2. iteracio: SS = 5612.84 3. iteracio: SS = 2924.37 4. iteracio: SS = 345.262 5. iteracio: SS = 219.258 6. iteracio: SS = 146.115 7. iteracio: SS = 58.0139 8. iteracio: SS = 15.807 9. iteracio: SS = 2.1311210. iteracio: SS = 0.99283911. iteracio: SS = 0.21367112. iteracio: SS = 0.21667313. iteracio: SS = 0.076689414. iteracio: SS = 0.0231675

    (X 2.00002)^2 + (Y 3.99982)^2 = 18.4998^2Rnegyzet = 1 (n=1000)

    Az optimalas kezdeti beallitasa:1 origo kozeppontbol indul2 adatok sulypontjabol indulValasszon: 2

    Kozeppont: X= 1.99062, Y= 4.00004Sugar: R= 18.5094

    0. iteracio: SS = 6.54863 1. iteracio: SS = 12117.7 2. iteracio: SS = 4789.11 3. iteracio: SS = 1565.73 4. iteracio: SS = 614.085 5. iteracio: SS = 177.137 6. iteracio: SS = 89.2038 7. iteracio: SS = 14.1009 8. iteracio: SS = 4.64429 9. iteracio: SS = 1.8596510. iteracio: SS = 0.72337311. iteracio: SS = 0.3152712. iteracio: SS = 0.24848513. iteracio: SS = 0.072636914. iteracio: SS = 0.0144445

    (X 2.00006)^2 + (Y 3.99964)^2 = 18.4999^2Rnegyzet = 1 (n=1000)

  • GNU C/C++ pldaprogramok 49

    [14] Ksztsnk programot, amely a 12. feladat felhasznlsval ltrehozott adatokra krt illeszt. A ngyzetes eltrseket szmoljuk sugr irnyba! Figyeljk meg, hogy az elz feladathoz kpest csupn nhny rszletet kell mdostani.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf, fscanf */#include /* matematikai fggvnyek: sqrt */

    #define MAXDATA 1000 /* konstans: adatsorok maximlis szma */

    double *X; /* X koordintk tmbje */double *Y; /* Y koordintk tmbje */int darab; /* beolvasott adatok szma */double PARAM[3]; /* a kr paramterei */

    /* adatok beolvassa */void Beolvas(void){ FILE *T; /* adatllomny */ double a,b; /* segdvltozk */

    darab = 0;

    /* llomny megnyitsa */ T=fopen("adat.dat","rt"); if (T==NULL) { printf("Nem olvashato: ADAT.DAT\n"); return; }

    /* memria foglals */ X = new double[MAXDATA]; Y = new double[MAXDATA];

    while (!feof(T) && darab

  • GNU C/C++ pldaprogramok 50

    d = sqrt(d);

    return(d);} /* Fuggveny() vge */

    /* eltrs ngyzetsszeg szmtsa */double Elteres(void){ double d,fx; /* segdvltozk */ int i;

    d=0; for (i=0;i

  • GNU C/C++ pldaprogramok 51

    /* sugr becslse */ E0=0; for (i=0;i

  • GNU C/C++ pldaprogramok 52

    /* statisztika */ atlag=0; for (i=0;i

  • GNU C/C++ pldaprogramok 53

    a [14] feladat eredmnye a kpernyn

    Az optimalas kezdeti beallitasa:1 origo kozeppontbol indul2 adatok sulypontjabol indulValasszon: 1

    Kozeppont: X= 0, Y= 0Sugar: R= 22.9721

    0. iteracio: SS = 27548.3 1. iteracio: SS = 6104.52 2. iteracio: SS = 1115.64 3. iteracio: SS = 497.118 4. iteracio: SS = 28.9866 5. iteracio: SS = 15.9215 6. iteracio: SS = 8.87305 7. iteracio: SS = 2.61902 8. iteracio: SS = 0.474628 9. iteracio: SS = 0.032491710. iteracio: SS = 0.011195411. iteracio: SS = 0.0014841212. iteracio: SS = 0.0013373913. iteracio: SS = 0.00032228714. iteracio: SS = 1.78156e05

    (X 2.00002)^2 + (Y 3.99988)^2 = 18.5^2Rnegyzet = 1 (n=1000)

    A CDROM mellkleten tallhat adatok valdi egyenlete a kvetkez:

    (x2)2 + (y4)2 = 18,52

    azaz a kzppontja O(2;4) s sugara R = 18,5

  • GNU C/C++ pldaprogramok 54

    [15] A mellkletben tallhat MINTA.DAT adatait (soronknt 3 egsz szm) vlassza kt osztlyra a dinamikus Kkzp mdszervel. A klaszter analzis kiindul adatait automatikusan hatrozza meg! A hozzrendels eredmnyt mentse a KLASZTER.DAT szveges llomnyba.

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */

    #define SOR 30000 /* konstans: adatsorok maximlis szma*/#define OSZLOP 3 /* konstans: adatok szma egy sorban */

    int **A; /* adatmtrix */int darab; /* adatok szma */

    int *C1; /* 1. klaszter centruma */int *C2; /* 2. klaszter centruma */

    /* adatok beolvassa */void Beolvas(void){ FILE *T; /* szveges llomny az adatokkal */ int i,a; /* segdvltozk */

    darab=0;

    T=fopen("minta.dat","rt"); if (T==NULL) { printf("Hiba a megnyitas soran! \n"); return; }

    /* memria foglals: OSZLOP x SOR mtrix */ A = new int*[OSZLOP]; for (i=0;i

  • GNU C/C++ pldaprogramok 55

    /* klaszter kzepeinek becslse a legtvolabbi rtkekkel */void Centrum(void){ int i,j,k,c1,c2; /* segdvltozk */ long d,dmax; /* tvolsgok */

    if (darab==0) return;

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

    /* minden tizediket kivlasztva megkeresi a legtvolabbiakat => gyorsabb */ dmax=0; for (i=0;i

  • GNU C/C++ pldaprogramok 56

    /* adatllomny megnyitsa */ T=fopen("KLASZTER.DAT","wt"); if (T==NULL) { printf("Hiba a megnyitasnal...\n"); return; }

    /* memria foglals */ K1 = new double[OSZLOP]; K2 = new double[OSZLOP]; /* inicializls */ for (i=0;i

  • GNU C/C++ pldaprogramok 57

    /* memria felszabadts */void Vege(void){ int i;

    delete[] C1; delete[] C2;

    for (i=0;i

  • GNU C/C++ pldaprogramok 58

    [16] Osztlyozzuk MINTA.DAT adatait (az llomny soronknt hrom egsz szmot tartalmaz). Az osztlyozshoz szksges adatokat INIT.DAT tartalmazza. Az eredmnyt mentsk el EREDMENY.DAT llomnyba (osztly s tvolsg adatokat).

    #include /* hagyomnyos ki s bemeneti fggvnyek: printf, scanf */

    #define SOR 30000 /* adatsorok maximlis szma */#define OSZLOP 3 /* adatok szma egy sorban */#define OSZTALY 3 /* osztlyok maximlis szma */

    int **O; /* osztlyok adatai */int **A; /* adatmtrix */int db0; /* osztlyok szma */int db1; /* adatsorok szma */

    void Beolvas(void) /* adatok beolvassa */{ FILE *T; /* szveges llomny */ int i,a; /* segdvltozk */

    db0=db1=0;

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

    /* memria foglals */ O = new int*[OSZLOP]; for (i=0;i

  • GNU C/C++ pldaprogramok 59

    /* memria foglals */ A = new int*[OSZLOP]; for (i=0;i

  • GNU C/C++ pldaprogramok 60

    for (i=0;i

  • GNU C/C++ pldaprogramok 61

    Ajnlott irodalom1. Bodor L., Brczi N. (2000):

    C/C++ programozs. LSI Oktatkzpont, Budapest.

    2. A.I. Bojarinov, V.V. Kafarov (1973):Optimalizls a vegyiparban. Mszaki Knyvkiad, 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):Bevezets az opercikutatsba. LSI Oktatkzpont, Budapest.

    6. Kemny S., Dek A. (1993):Mrsek tervezse s eredmnyeik rtkelse. Mszaki Knyvkiad, Budapest.

    7. J. Nocedal, S.J. Wright (1999):Numerical optimization. SpringerVerlag, New York.

    8. Obdovics Gy. (1997):Numerikus mdszerek I.II. LSI Oktatkzpont, Budapest.

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

    10.Popper Gy., Csizms F. (1993):Numerikus mdszerek mrnkknek. Akadmiai Kiad, Budapest.

    11.Svb J. (1981):Biometriai mdszerek a kutatsban. Mezgazdasgi Kiad, Budapest.


Recommended