« előző következő »
Oldalak: [1]   Le

Szerző Téma: Bitmûveletek a gyakorlatban.  (Megtekintve 2791 alkalommal)

Nem elérhető Zsolesszka

  • 2317
    • Profil megtekintése
Bitmûveletek a gyakorlatban.
« Dátum: 2013. július 14. - 01:23:07 »
+9 Show voters
Mivel látom hogy elég kevesen alkalmazzák ezen dolgokat sa-mp szkriptelés terén ezért megpróbálok pár példát írni alkalmazásukra természetesen ahogy sikerül valami újabb hasznos gyakorlati alkalmazást kitalálnom vagy találnom, frissíteni fogom ezen leírásszerûséget.
Itt nem fogok kitérni a bitmûveletek mûködésre arra ott van Anthony által írt leírás: Bitmûveletek, valamint gyakorlati alkalmazás a SA:MP-ban
Az egyik segítség kérés témában felmerült problémára való megoldásként jött az ötlet, mivel ott említettem hogy egyszerûbb lenne bitmûveletekkel megvalósítani a dolgot miszerint szeretnénk egy játékosnak egyszerre több munkát is engedélyezni, úgy hogy minél kevesebb memóriát használunk fel, természetesen egyszerûen törölni akár az összes meglévõ munkát.
Ennyit az elõzményrõl.

A kiegészítõ szövegek után szereplõ bináris értékek a bitmûveletek után történt változás eredményét szemléltetik!
 
enum 
(<<= 1)
{
MUNKA_NONE,   // 0b00000000000000000000000000000000
MUNKA_1 = 1,   // 0b00000000000000000000000000000001
MUNKA_2,   // 0b00000000000000000000000000000010
MUNKA_3,   // 0b00000000000000000000000000000100
MUNKA_4,   // 0b00000000000000000000000000001000
MUNKA_5,   // 0b00000000000000000000000000010000
MUNKA_6,   // 0b00000000000000000000000000100000
MUNKA_7,   // 0b00000000000000000000000001000000
MUNKA_8,   // 0b00000000000000000000000010000000
MUNKA_9,   // 0b00000000000000000000000100000000
MUNKA_10,   // 0b00000000000000000000001000000000
MUNKA_11,   // 0b00000000000000000000010000000000
MUNKA_12,   // 0b00000000000000000000100000000000
MUNKA_13,   // 0b00000000000000000001000000000000
MUNKA_14,   // 0b00000000000000000010000000000000
MUNKA_15,   // 0b00000000000000000100000000000000
MUNKA_16,   // 0b00000000000000001000000000000000
MUNKA_17,   // 0b00000000000000010000000000000000
MUNKA_18,   // 0b00000000000000100000000000000000
MUNKA_19,   // 0b00000000000001000000000000000000
MUNKA_20,   // 0b00000000000010000000000000000000
MUNKA_21,   // 0b00000000000100000000000000000000
MUNKA_22,   // 0b00000000001000000000000000000000
MUNKA_23,   // 0b00000000010000000000000000000000
MUNKA_24,   // 0b00000000100000000000000000000000
MUNKA_25,   // 0b00000001000000000000000000000000
MUNKA_26,   // 0b00000010000000000000000000000000
MUNKA_27,   // 0b00000100000000000000000000000000
MUNKA_28,   // 0b00001000000000000000000000000000
MUNKA_29,   // 0b00010000000000000000000000000000
MUNKA_30,   // 0b00100000000000000000000000000000
MUNKA_31,   // 0b01000000000000000000000000000000
MUNKA_32   // 0b10000000000000000000000000000000
}

 
Megjegyzés: Nem véletlenül szerepel a MUNKA_32 mivel ennyi a maximálisan állítható bit érték egy változóba 32 bit esetén.
Több munka egyszerre történõ megadása:
 
   Job[playerid] |= MUNKA_2;  // Ez az érték megadása a következõ sor szemléltetése végett szerepel. // 0b00000000000000000000000000000010
Job[playerid] = MUNKA_1 | MUNKA_4 | MUNKA_3; // Ez a megoldás töröl minden korábban beállított munkát!! // // 0b00000000000000000000000000001101

 
Munkák egyesével történõ hozzáadása:
 
   Job[playerid] |= MUNKA_5;   // 0b00000000000000000000000000011101
Job[playerid] |= MUNKA_10;   // 0b00000000000000000000001000011101
Job[playerid] |= MUNKA_15;   // 0b00000000000000000100001000011101
Job[playerid] |= MUNKA_20;   // 0b00000000000010000100001000011101
Job[playerid] |= MUNKA_25;   // 0b00000001000010000100001000011101
Job[playerid] |= MUNKA_30;   // 0b00100001000010000100001000011101
Job[playerid] |= MUNKA_32;   // 0b10100001000010000100001000011101

 
Egy munka törlése:
 
   Job[playerid] &= ~MUNKA_5;   // 0b10100001000010000100001000001101

 
Egy munka törlése ha aktív, vagy aktiválása ha nincs beállítva:
 
   Job[playerid] ^= MUNKA_20; // Ez esetben törlés mivel már aktiválva van.   // 0b10100001000000000100001000001101
Job[playerid] ^= MUNKA_21; // Ez esetben aktiválás mivel nincs hozzáadva.   // 0b10100001000100000100001000001101

 
Több munka egyszerre történõ megadása régi értékek megtartása mellett:
 
   Job[playerid] |= MUNKA_11 | MUNKA_31 | MUNKA_22;   // 0b11100001001100000100011000001101   <--Ez az érték kerül egy kis ellenõrzésre a példában. (printf(\"%d - %d -> %b\")

 
Az elvállalt munka lehetõség kilistázása for ciklussal:
 
   static const
M_name[][] = 
{
\"MUNKA_1\", \"MUNKA_2\", \"MUNKA_3\", \"MUNKA_4\", \"MUNKA_5\", \"MUNKA_6\", \"MUNKA_7\", \"MUNKA_8\", \"MUNKA_9\", \"MUNKA_10\", 
\"MUNKA_11\", \"MUNKA_12\", \"MUNKA_13\", \"MUNKA_14\", \"MUNKA_15\", \"MUNKA_16\", \"MUNKA_17\", \"MUNKA_18\", \"MUNKA_19\", \"MUNKA_20\", 
\"MUNKA_21\", \"MUNKA_22\", \"MUNKA_23\", \"MUNKA_24\", \"MUNKA_25\", \"MUNKA_26\", \"MUNKA_27\", \"MUNKA_28\", \"MUNKA_29\", \"MUNKA_30\", \"MUNKA_31\", \"MUNKA_32\"
};
for(new i; i < cellbits; i++)
{
if(Job[playerid] & (1 << i)) printf(\"Vállalt: %s\", M_name);
}

 
A beállított munkák számlálása:
 
stock
bitcount(num) // Ezt természetesen valahova máshova kell másolni a módban, szkriptben.
{
new 
count = 0 ;
while(num) 
{
num &= (num - 1) ;
printf(\"--- %b\", num);
count++;
}
return count ;
}
printf(\"%d elvállalt munkád van.\", bitcount(Job[playerid]));

 
Ellenõrzés hogy melyik munkát vállalta a játékos:
 
   if(Job[playerid] == MUNKA_NONE)    printf(\"Nincs egy munka sem: MUNKA_NONE\");
if(Job[playerid] & MUNKA_1)       printf(\"Vállalt munka: MUNKA_1\");
if(Job[playerid] & MUNKA_2)       printf(\"Vállalt munka: MUNKA_2\");
if(Job[playerid] & MUNKA_3)       printf(\"Vállalt munka: MUNKA_3\");
if(Job[playerid] & MUNKA_4)       printf(\"Vállalt munka: MUNKA_4\");
if(Job[playerid] & MUNKA_5)       printf(\"Vállalt munka: MUNKA_5\");
if(Job[playerid] & MUNKA_6)       printf(\"Vállalt munka: MUNKA_6\");
if(Job[playerid] & MUNKA_7)       printf(\"Vállalt munka: MUNKA_7\");
if(Job[playerid] & MUNKA_8)       printf(\"Vállalt munka: MUNKA_8\");
if(Job[playerid] & MUNKA_9)       printf(\"Vállalt munka: MUNKA_9\");
if(Job[playerid] & MUNKA_10)       printf(\"Vállalt munka: MUNKA_10\");
if(Job[playerid] & MUNKA_11)       printf(\"Vállalt munka: MUNKA_11\");
if(Job[playerid] & MUNKA_12)       printf(\"Vállalt munka: MUNKA_12\");
if(Job[playerid] & MUNKA_13)       printf(\"Vállalt munka: MUNKA_13\");
if(Job[playerid] & MUNKA_14)       printf(\"Vállalt munka: MUNKA_14\");
if(Job[playerid] & MUNKA_15)       printf(\"Vállalt munka: MUNKA_15\");
if(Job[playerid] & MUNKA_16)       printf(\"Vállalt munka: MUNKA_16\");
if(Job[playerid] & MUNKA_17)       printf(\"Vállalt munka: MUNKA_17\");
if(Job[playerid] & MUNKA_18)       printf(\"Vállalt munka: MUNKA_18\");
if(Job[playerid] & MUNKA_19)       printf(\"Vállalt munka: MUNKA_19\");
if(Job[playerid] & MUNKA_20)       printf(\"Vállalt munka: MUNKA_20\");
if(Job[playerid] & MUNKA_21)       printf(\"Vállalt munka: MUNKA_21\");
if(Job[playerid] & MUNKA_22)       printf(\"Vállalt munka: MUNKA_22\");
if(Job[playerid] & MUNKA_23)       printf(\"Vállalt munka: MUNKA_23\");
if(Job[playerid] & MUNKA_24)       printf(\"Vállalt munka: MUNKA_24\");
if(Job[playerid] & MUNKA_25)       printf(\"Vállalt munka: MUNKA_25\");
if(Job[playerid] & MUNKA_26)       printf(\"Vállalt munka: MUNKA_26\");
if(Job[playerid] & MUNKA_27)       printf(\"Vállalt munka: MUNKA_27\");
if(Job[playerid] & MUNKA_28)       printf(\"Vállalt munka: MUNKA_28\");
if(Job[playerid] & MUNKA_29)       printf(\"Vállalt munka: MUNKA_29\");
if(Job[playerid] & MUNKA_30)       printf(\"Vállalt munka: MUNKA_30\");
if(Job[playerid] & MUNKA_31)       printf(\"Vállalt munka: MUNKA_31\");
if(Job[playerid] & MUNKA_32)       printf(\"Vállalt munka: MUNKA_32\");

 
Összes munka törlése.   Pl.: OnPlayerConnect-hez
 
   printf(\"%d - %d -> %b\", 0b11100001001100000100011000001101, Job[playerid], Job[playerid]); // Egy kis ellenõrzés tényleg jók-e a bitmûveletek.
Job[playerid] = MUNKA_NONE; // 0b00000000000000000000000000000000

 
Példa szkript gyors tesztelésre:



#include <a_samp>
 
enum 
(<<= 1)
{
MUNKA_NONE,   // 0b00000000000000000000000000000000
MUNKA_1 = 1,   // 0b00000000000000000000000000000001
MUNKA_2,   // 0b00000000000000000000000000000010
MUNKA_3,   // 0b00000000000000000000000000000100
MUNKA_4,   // 0b00000000000000000000000000001000
MUNKA_5,   // 0b00000000000000000000000000010000
MUNKA_6,   // 0b00000000000000000000000000100000
MUNKA_7,   // 0b00000000000000000000000001000000
MUNKA_8,   // 0b00000000000000000000000010000000
MUNKA_9,   // 0b00000000000000000000000100000000
MUNKA_10,   // 0b00000000000000000000001000000000
MUNKA_11,   // 0b00000000000000000000010000000000
MUNKA_12,   // 0b00000000000000000000100000000000
MUNKA_13,   // 0b00000000000000000001000000000000
MUNKA_14,   // 0b00000000000000000010000000000000
MUNKA_15,   // 0b00000000000000000100000000000000
MUNKA_16,   // 0b00000000000000001000000000000000
MUNKA_17,   // 0b00000000000000010000000000000000
MUNKA_18,   // 0b00000000000000100000000000000000
MUNKA_19,   // 0b00000000000001000000000000000000
MUNKA_20,   // 0b00000000000010000000000000000000
MUNKA_21,   // 0b00000000000100000000000000000000
MUNKA_22,   // 0b00000000001000000000000000000000
MUNKA_23,   // 0b00000000010000000000000000000000
MUNKA_24,   // 0b00000000100000000000000000000000
MUNKA_25,   // 0b00000001000000000000000000000000
MUNKA_26,   // 0b00000010000000000000000000000000
MUNKA_27,   // 0b00000100000000000000000000000000
MUNKA_28,   // 0b00001000000000000000000000000000
MUNKA_29,   // 0b00010000000000000000000000000000
MUNKA_30,   // 0b00100000000000000000000000000000
MUNKA_31,   // 0b01000000000000000000000000000000
MUNKA_32   // 0b10000000000000000000000000000000
}
new
Job[MAX_PLAYERS];
public
OnFilterScriptInit()
{
// Több munka egyszerre történõ megadása:
Job[0] |= MUNKA_2;  // Ez az érték megadása a következõ sor szemléltetése végett szerepel. // 0b00000000000000000000000000000010
Job[0] = MUNKA_1 | MUNKA_4 | MUNKA_3; // Ez a megoldás töröl minden korábban beállított munkát!! // // 0b00000000000000000000000000001101
// Munkák egyesével történû hozzáadása:
Job[0] |= MUNKA_5;   // 0b00000000000000000000000000011101
Job[0] |= MUNKA_10;   // 0b00000000000000000000001000011101
Job[0] |= MUNKA_15;   // 0b00000000000000000100001000011101
Job[0] |= MUNKA_20;   // 0b00000000000010000100001000011101
Job[0] |= MUNKA_25;   // 0b00000001000010000100001000011101
Job[0] |= MUNKA_30;   // 0b00100001000010000100001000011101
Job[0] |= MUNKA_32;   // 0b10100001000010000100001000011101
// Egy munka törlése:
Job[0] &= ~MUNKA_5;   // 0b10100001000010000100001000001101
// Egy munka törlése ha aktív, vagy aktiválása ha nincs beállítva:
Job[0] ^= MUNKA_20; // Ez esetben törlés mivel már aktiválva van.      // 0b10100001000000000100001000001101
Job[0] ^= MUNKA_21; // Ez esetben aktiválás mivel nincs hozzáadva.   // 0b10100001000100000100001000001101
// Több munka egyszerre történõ megadása régi értékek megtartása mellett:
Job[0] |= MUNKA_11 | MUNKA_31 | MUNKA_22;   // 0b11100001001100000100011000001101
// Ellenõrzés hogy melyik munkát vállalta a játékos:
if(Job[0] == MUNKA_NONE)    printf(\"Nincs egy munka sem: MUNKA_NONE\");
if(Job[0] & MUNKA_1)          printf(\"Vállalt munka: MUNKA_1\");
if(Job[0] & MUNKA_2)          printf(\"Vállalt munka: MUNKA_2\");
if(Job[0] & MUNKA_3)          printf(\"Vállalt munka: MUNKA_3\");
if(Job[0] & MUNKA_4)          printf(\"Vállalt munka: MUNKA_4\");
if(Job[0] & MUNKA_5)          printf(\"Vállalt munka: MUNKA_5\");
if(Job[0] & MUNKA_6)          printf(\"Vállalt munka: MUNKA_6\");
if(Job[0] & MUNKA_7)          printf(\"Vállalt munka: MUNKA_7\");
if(Job[0] & MUNKA_8)          printf(\"Vállalt munka: MUNKA_8\");
if(Job[0] & MUNKA_9)          printf(\"Vállalt munka: MUNKA_9\");
if(Job[0] & MUNKA_10)       printf(\"Vállalt munka: MUNKA_10\");
if(Job[0] & MUNKA_11)       printf(\"Vállalt munka: MUNKA_11\");
if(Job[0] & MUNKA_12)       printf(\"Vállalt munka: MUNKA_12\");
if(Job[0] & MUNKA_13)       printf(\"Vállalt munka: MUNKA_13\");
if(Job[0] & MUNKA_14)       printf(\"Vállalt munka: MUNKA_14\");
if(Job[0] & MUNKA_15)       printf(\"Vállalt munka: MUNKA_15\");
if(Job[0] & MUNKA_16)       printf(\"Vállalt munka: MUNKA_16\");
if(Job[0] & MUNKA_17)       printf(\"Vállalt munka: MUNKA_17\");
if(Job[0] & MUNKA_18)       printf(\"Vállalt munka: MUNKA_18\");
if(Job[0] & MUNKA_19)       printf(\"Vállalt munka: MUNKA_19\");
if(Job[0] & MUNKA_20)       printf(\"Vállalt munka: MUNKA_20\");
if(Job[0] & MUNKA_21)       printf(\"Vállalt munka: MUNKA_21\");
if(Job[0] & MUNKA_22)       printf(\"Vállalt munka: MUNKA_22\");
if(Job[0] & MUNKA_23)       printf(\"Vállalt munka: MUNKA_23\");
if(Job[0] & MUNKA_24)       printf(\"Vállalt munka: MUNKA_24\");
if(Job[0] & MUNKA_25)       printf(\"Vállalt munka: MUNKA_25\");
if(Job[0] & MUNKA_26)       printf(\"Vállalt munka: MUNKA_26\");
if(Job[0] & MUNKA_27)       printf(\"Vállalt munka: MUNKA_27\");
if(Job[0] & MUNKA_28)       printf(\"Vállalt munka: MUNKA_28\");
if(Job[0] & MUNKA_29)       printf(\"Vállalt munka: MUNKA_29\");
if(Job[0] & MUNKA_30)       printf(\"Vállalt munka: MUNKA_30\");
if(Job[0] & MUNKA_31)       printf(\"Vállalt munka: MUNKA_31\");
if(Job[0] & MUNKA_32)       printf(\"Vállalt munka: MUNKA_32\");
// Összes munka törlése.   Pl.: OnPlayerConnect-hez
printf(\"%d - %d -> %b\", 0b11100001001100000100011000001101, Job[0], Job[0]); // Egy kis ellenõrzés tényleg jók-e a bitmûveletek.
Job[0] = MUNKA_NONE; // 0b00000000000000000000000000000000
printf(\"%b\", Job[0]);
// Tényleg törölt minden munkát? :D
if(Job[0] == MUNKA_NONE)    printf(\"Nincs egy munka sem: MUNKA_NONE\");
if(Job[0] & MUNKA_1)          printf(\"Vállalt munka: MUNKA_1\");
if(Job[0] & MUNKA_2)          printf(\"Vállalt munka: MUNKA_2\");
if(Job[0] & MUNKA_3)          printf(\"Vállalt munka: MUNKA_3\");
if(Job[0] & MUNKA_4)          printf(\"Vállalt munka: MUNKA_4\");
if(Job[0] & MUNKA_5)          printf(\"Vállalt munka: MUNKA_5\");
if(Job[0] & MUNKA_6)          printf(\"Vállalt munka: MUNKA_6\");
if(Job[0] & MUNKA_7)          printf(\"Vállalt munka: MUNKA_7\");
if(Job[0] & MUNKA_8)          printf(\"Vállalt munka: MUNKA_8\");
if(Job[0] & MUNKA_9)          printf(\"Vállalt munka: MUNKA_9\");
if(Job[0] & MUNKA_10)       printf(\"Vállalt munka: MUNKA_10\");
if(Job[0] & MUNKA_11)       printf(\"Vállalt munka: MUNKA_11\");
if(Job[0] & MUNKA_12)       printf(\"Vállalt munka: MUNKA_12\");
if(Job[0] & MUNKA_13)       printf(\"Vállalt munka: MUNKA_13\");
if(Job[0] & MUNKA_14)       printf(\"Vállalt munka: MUNKA_14\");
if(Job[0] & MUNKA_15)       printf(\"Vállalt munka: MUNKA_15\");
if(Job[0] & MUNKA_16)       printf(\"Vállalt munka: MUNKA_16\");
if(Job[0] & MUNKA_17)       printf(\"Vállalt munka: MUNKA_17\");
if(Job[0] & MUNKA_18)       printf(\"Vállalt munka: MUNKA_18\");
if(Job[0] & MUNKA_19)       printf(\"Vállalt munka: MUNKA_19\");
if(Job[0] & MUNKA_20)       printf(\"Vállalt munka: MUNKA_20\");
if(Job[0] & MUNKA_21)       printf(\"Vállalt munka: MUNKA_21\");
if(Job[0] & MUNKA_22)       printf(\"Vállalt munka: MUNKA_22\");
if(Job[0] & MUNKA_23)       printf(\"Vállalt munka: MUNKA_23\");
if(Job[0] & MUNKA_24)       printf(\"Vállalt munka: MUNKA_24\");
if(Job[0] & MUNKA_25)       printf(\"Vállalt munka: MUNKA_25\");
if(Job[0] & MUNKA_26)       printf(\"Vállalt munka: MUNKA_26\");
if(Job[0] & MUNKA_27)       printf(\"Vállalt munka: MUNKA_27\");
if(Job[0] & MUNKA_28)       printf(\"Vállalt munka: MUNKA_28\");
if(Job[0] & MUNKA_29)       printf(\"Vállalt munka: MUNKA_29\");
if(Job[0] & MUNKA_30)       printf(\"Vállalt munka: MUNKA_30\");
if(Job[0] & MUNKA_31)       printf(\"Vállalt munka: MUNKA_31\");
if(Job[0] & MUNKA_32)       printf(\"Vállalt munka: MUNKA_32\");
return 1;
}
« Utoljára szerkesztve: 2013. július 18. - 08:25:15 írta ɐʞzssǝlosz »
Naplózva

Nem elérhető krisk

  • 2380
    • Profil megtekintése
Bitmûveletek a gyakorlatban.
« Válasz #1 Dátum: 2013. július 21. - 10:32:12 »
0 Show voters
Na ez az enumos megoldás a maszkokra nekem nagyon tetszik, az életben nem jutott volna eszembe.
Aminek én örültem volna, ha elmagyarázod, hogy a bwise OR miért hozzáadásra való, bwise AND miért a lekérésre, meg ugye a XOR/NOT-nak mi köze van az állítgatáshoz.
Mert szerintem a legtöbb ember azért nem használja a mûveleteket, mert túl bonyorultnak vélik, nem feltétlen azért, mert effektíve nem tudják, hogy kell használni.
Egyébként remek leírás lett, szóval gratulálok.
« Utoljára szerkesztve: 2013. július 21. - 10:40:29 írta krisk »
Naplózva

Nem elérhető kurta999

  • 2759
  • Éllő fédisznó
    • Profil megtekintése
Bitmûveletek a gyakorlatban.
« Válasz #2 Dátum: 2013. július 21. - 11:53:25 »
+1 Show voters
Szerintem aki nem érti miért, az olvassa el a másik Bit Mûveletek témát, abban ez nagyon szépen le van írva minden operátor mit csinál, ha nem érti meg elsõre, akkor egy 3-4x átkell olvasni. Énsem voltam elõször másképp.
Deha már annyira valaki lusta, akkor ittvan :D
Bitwise OR akkor ad igazat, ha az egyik érték igaz.
Tehát ha a jelenlegi változó értéke 0101110001 és itt be akarjuk \"kapcsolni\" a feketével jelzett bitet, akkor 0101110001 VAGY 0000000100 (remélem jól írtam a darabszámot, könnyen elveszek ennyi 01 között ha csak így hasra csapva írom le xd), és ebbõl adódóan 1 lesz a bitbõl, mivel ahol már az egyik értéke 1, ott a VAGY 1el tér vissza, nem kell, hogy mind a kettõ 1 legyen.
Az ÉS pedig csak akkor tér vissza 1el, ha mind a kettõ érték IGAZ. 0101110001 Tehát ha itt ki akarjuk a befeketített bitet kapcsolni, akkor 0101110001 ÉS 11111111111111111111111111011111. (Mint leírtam, akkor ad 1et, ha mind a kettõ érték igaz, ha csak a 6. bitet akarjuk kikapcsolni, akkor csak a 6. biten lévõ értékre rakunk 0-t, többire 1et és csak ezt fogja kikapcsolni, többit nem bántja)
Amúgy bitek megszámlálására ittvan egy funkció, ez sokkal gyorsabb mind az összes többi. Nincs benne ciklus.
 

stock CountSetBits(i)
{
i = i - ((i >> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}
« Utoljára szerkesztve: 2013. július 21. - 12:02:34 írta kurta999 »
Naplózva

Nem elérhető Zsolesszka

  • 2317
    • Profil megtekintése
Bitmûveletek a gyakorlatban.
« Válasz #3 Dátum: 2013. július 21. - 12:48:33 »
0 Show voters
Köszönöm.
Direkt nem tértem ki a mûködésre, arra linkeltem a másik leírást, gyakorlati példákkal szeretném még bõvíteni, hogyan alkalmazzák, ha már így elkezdenek vele foglalkozni könnyebben megfogják érteni mûködését. Mivel a mûvelet után csak egybõl az eredményt tüntettem fel, nem kell azzal törõdni hogy lett az, ha kíváncsi rá akkor meg már az elsõ olvasás után érteni fogja a mûveletek igazság tábláját és akkor világossá válik számára mûködésük.
Sok leírást is olvastam itt ott, sose volt bennünk kezdetleges (alap) mûveletek példában leírva, hanem csak egybõl valami pawn terén stock funkció hogy  (Bit_Set, Bit_Get, Bit_Clear), na szerintem ezért nem használják, ha csak a mûveleti jelekkel lenne szemléltetve pár leírás hamarabb alkalmaznák.
Az összeadás, kivonás, szorzás, jeleket meg leírhatnák úgyis hogy (Add_, Sub_, Mul_) hogy kicsit érthetetlenebb legyen. :D
@kurta999 Végeztél sebesség tesztet? Amúgy megtaláltam én is azt a verziót csak bonyolultsága miatt nem írtam ki, arra gondolva hogy megérteni is nehéz a mûködését, még meg se próbáltam rájönni milyen logikai menettel jött rá a készítõje, de briliáns ha minden számnál pontos eredményt ad az biztos. :D
Naplózva

Nem elérhető kurta999

  • 2759
  • Éllő fédisznó
    • Profil megtekintése
Bitmûveletek a gyakorlatban.
« Válasz #4 Dátum: 2013. július 21. - 17:25:02 »
0 Show voters
Végeztem, mondjuk én azzal a for ciklusos megoldással oldottam eleinte meg, hogy megnézni mind az összes bitet, hogy melyik igaz és ahhoz képest sokkal gyorsabb volt. Aztán hivatalos fórumon láttam egy témát és úgyemléxek, hogy ott még ettõl a negálós módszertõl is gyorsabb volt. Y_Less is igen ezt javasolta, úgyhogy valószinû ez a leggyorsabb megoldás rá :D
Amúgy hamár szóba kerültek az összeadások, arra nemtudsz egy leírást neten, ahol levan írva binárisan hogy történik? Angol is megfelel.
Naplózva

Nem elérhető Zsolesszka

  • 2317
    • Profil megtekintése
Bitmûveletek a gyakorlatban.
« Válasz #5 Dátum: 2013. július 21. - 19:37:34 »
+1 Show voters
Végeztem sebesség tesztet én is és valóban gyorsabb, sõt több mint kétszeres sebesség különbség van. :D
http://hu.wikipedia.org/wiki/Kettes_sz%C3%A1mrendszer
Naplózva
Oldalak: [1]   Fel
« előző következő »
 
SimplePortal 2.3.7 © 2008-2024, SimplePortal