Pato1111 2011.05.03 18:27:52

(ÉLES) Qt Konvenciók 1

#include "frakszal.h"

FrakSzal::FrakSzal(double A, double B, double C, double D,
int szelesseg, int magassag, int IteraciosHatar, FrakAblak *FrakAblak)
{
this->A = A;
this->B = B;
this->C = C;
this->D = D;
this->szelesseg = szelesseg;
this->IteraciosHatar = IteraciosHatar;
this->FrakAblak = FrakAblak;
this->magassag = magassag;

EgySor = new int[szelesseg];
}

FrakSzal::~FrakSzal()
{
delete[] EgySor;
}

// A szál kódját a Javát tanítokhoz írt Java kódomból vettem át
// www.tankonyvtar.hu/informatika/javat-tanitok-2-2-080904-1
// mivel itt az algoritmust is leírtam/lerajzoltam, így meghagytam
// a kommenteket, hogy a hallgató könnyen hozzáolvashassa az "elméletet",
// ha érdekli.
void FrakSzal::run()
{
// A [a,b]x[c,d] tartományon milyen sûrû a
// megadott szélesség, magasság háló:
double dx = (B-A)/szelesseg;
double dy = (D-C)/magassag;
double reC, imC, reZ, imZ, ujreZ, ujimZ;
// Hány iterációt csináltunk?
int iteracio = 0;
// Végigzongorázzuk a szélesség x magasság hálót:
for(int j=0; j<magassag; ++j) {
//sor = j;
for(int k=0; k<szelesseg; ++k) {
// c = (reC, imC) a háló rácspontjainak
// megfelelõ komplex szám
reC = a+k*dx;
imC = d-j*dy;
// z_0 = 0 = (reZ, imZ)
reZ = 0;
imZ = 0;
iteracio = 0;
// z_{n+1} = z_n * z_n + c iterációk
// számítása, amíg |z_n| < 2 vagy még
// nem értük el a 255 iterációt, ha
// viszont elértük, akkor úgy vesszük,
// hogy a kiinduláci c komplex számra
// az iteráció konvergens, azaz a c a
// Mandelbrot halmaz eleme
while(reZ*reZ + imZ*imZ < 4 && iteracio < IteraciosHatar) {
// z_{n+1} = z_n * z_n + c

ujreZ = reZ*reZ - imZ*imZ + reC;
ujimZ = 2*reZ*imZ + imC;

reZ = ujreZ;
imZ = ujimZ;

++iteracio;

}
// ha a < 4 feltétel nem teljesült és a
// iteráció < iterációsHatár sérülésével lépett ki, azaz
// feltesszük a c-rõl, hogy itt a z_{n+1} = z_n * z_n + c
// sorozat konvergens, azaz iteráció = iterációsHatár
// ekkor az iteráció %= 256 egyenlõ 255, mert az esetleges
// nagyítasok során az iteráció = valahány * 256 + 255

iteracio %= 256;

//a színezést viszont már majd a FrakAblak osztályban lesz
EgySor[k] = iteracio;
}
// Ábrázolásra átadjuk a kiszámolt sort a FrakAblak-nak.
FrakAblak->vissza(j, egySor, szelesseg);
}
FrakAblak->vissza();

}

Pato1111 2011.05.03 12:36:12

data.hu/get/3787675/KJ_beadando.cpp

Pato1111 2011.03.29 20:22:18

imagerz.com/QFdDXA8BAlQ
Elkészítettem a rajz programot itt a kép róla.

Pato1111 2011.04.04 19:00:30

(ÉLES) P-szálak ismétlő: írj olyan C programot (a 4. ea. mintájára, illetve PP 67) amiben 100 szál cserélgeti 2 globális változó értékét. Mutasd meg, hogy mutex nélkül elromlik, mutexxel nem.

Alap helyzetben a=42, b=55.

Mutex nélkül:
Szal: 20, a értéke: 55, b értéke: 42
Szal: 20, a értéke: 42, b értéke: 55
Szal: 76, a értéke: 42, b értéke: 55
Szal: 76, a értéke: 42, b értéke: 55
Szal: 76, a értéke: 55, b értéke: 42
Szal: 76, a értéke: 42, b értéke: 55
Szal: 76, a értéke: 55, b értéke: 42
A szamlalo vegul: -1

Mutexxel:
Szal: 94, a értéke:55 b értéke:42
Szal: 94, a értéke:42 b értéke:55
Szal: 94, a értéke:55 b értéke:42
Szal: 94, a értéke:42 b értéke:55
Szal: 94, a értéke:55 b értéke:42
Szal: 94, a értéke:42 b értéke:55
Szal: 34, a értéke:42 b értéke:55
A szamlalo vegul: 0

Pato1111 2011.04.05 15:31:14

@nb: Újra gondoltam a dolgot kicsit javítgattam és most valóban úgy jött ki ahogy Tanár úr írja.

Mutex zárak nélkül:
Indításkor egy darabig még cserélgeti a 2 változót:
Szal: 1, A: 55, B: 42
Szal: 0, A: 42, B: 55
Szal: 1, A: 42, B: 55
Szal: 4, A: 55, B: 42
Szal: 9, A: 55, B: 42
Szal: 6, A: 42, B: 55

Aztán körülbelül a futás felénél megtörténik a hiba és a kimenet a következő:
Szal: 81, A: 55, B: 55
Szal: 81, A: 55, B: 55
Szal: 81, A: 55, B: 55
Szal: 81, A: 55, B: 55
Szal: 81, A: 55, B: 55
Szal: 81, A: 55, B: 55
A értéke: 55 B értéke: 55

Mutex zárakkal:
Program futásának kezdete:
Szal: 1, A: 42, B: 55
Szal: 2, A: 55, B: 42
Szal: 3, A: 42, B: 55
Szal: 4, A: 55, B: 42

Program futásának vége:
Szal: 91, A: 55, B: 42
Szal: 91, A: 42, B: 55
Szal: 91, A: 55, B: 42
Szal: 91, A: 42, B: 55
A értéke: 42 B értéke: 55

Hibátlanul cserélgette végig a 2 változó értékét zárak segítségével.

Pato1111 2011.03.14 15:04:05

@nb:
kallo@kallo-K52Jr:~/Asztal/szam$ wc fa2.txt
0 1 280 fa2.txt
kallo@kallo-K52Jr:~/Asztal/szam$ wc fa.txt
1 1 560 fa.txt

fa2 a kimenet elmentve. fele annyi.

Pato1111 2011.03.14 15:25:58

@nb: nincs sok pontom, de mehet a vadászok közé is

Pato1111 2011.03.23 22:34:26

Az 5. ea. utolsó robotfocis fáliájának (cout-ra a módosításos copyright üzenet) ...

kepfeltoltes.hu/110323/foci_www.kepfeltoltes.hu_.png

Pato1111 2011.03.08 16:46:42

@nb:
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define ENG 0000
int
main()
{
int f;
f = creat("Olyan_fajl", ENG);
return 0;
}

Pato1111 2011.03.10 20:29:29

Nekem ezt hiányolja valamiért a complearn.
** ERROR **: Error loading module libmod_lzmax.so.0.0.0
Ez miért lehet?

Pato1111 2011.03.10 22:02:38

Elkészítettem én is ezt a feladatot kicsit más jött ki hátha ez a megoldás :D

kepfeltoltes.hu/110310/random_www.kepfeltoltes.hu_.png

Én így csináltam a hexa random számokat:
#include <stdio.h>
#include <stdlib.h>
int
main (void)
{
int i, r;
int tomb[500];
int hexa[500];
for (i = 0; i < 500; ++i)
{
r = 1 + (int) (15.0 * rand () / (RAND_MAX + 1.0));
tomb[i] = r;
}
for (i = 0; i < 500; ++i)
{
switch (tomb[i])
{
case 0:
hexa[i] = '0';
break;
case 1:
hexa[i] = '1';
break;
case 2:
hexa[i] = '2';
break;
case 3:
hexa[i] = '3';
break;
case 4:
hexa[i] = '4';
break;
case 5:
hexa[i] = '5';
break;
case 6:
hexa[i] = '6';
break;
case 7:
hexa[i] = '7';
break;
case 8:
hexa[i] = '8';
break;
case 9:
hexa[i] = '9';
break;
case 10:
hexa[i] = 'A';
break;
case 11:
hexa[i] = 'B';
break;
case 12:
hexa[i] = 'C';
break;
case 13:
hexa[i] = 'D';
break;
case 14:
hexa[i] = 'E';
break;
case 15:
hexa[i] = 'F';
break;
}
}

for (i = 0; i < 500; ++i)
printf ("%c", hexa[i]);
printf ("\n");
return 0;
}