sciencetalk

Ik programmeer al een tijdje in C en Java maar heb altijd gebruik gemaakt van standaard natuurlijke operatoren zoals toewijzingsoperatoren ( x = a !=b || !b == 3^a%2 || a = 33) , wiskundige operatoren (+,-,*,/,\,%), logische operatoren (and, or, not, xor,..) en vergelijkingsoperatoren (>,<,<=,>=,==,!=,..) maar bitoperatoren?? wa voor iets is dit en waarom gebruiken en waar en hoe toe te passen ?

Mischien iemand die op een very low-level programming language programmeert dit voor mij uitleggen zonder links a.u.b en toegelicht me een paar voorbeeldjes?

merciekes

Beste Bchaib,

Wij mensen werken met getallen uit het tientallig stelsel (0 t/m 9), maar computers werken alleen met 0 en 1 (het tweetallig stelsel). Daarom worden alle getallen die je in je programma's gebruikt achter de schermen omgezet naar enen en nullen (bits). De bits worden in groepjes van acht opgeslagen (bytes), zodat je met één byte 256 verschillende waarden kan opslaan: De bits '00000000' komen overeen met de waarde 0, '00000001' met 1, '00000010' met 2, enzovoort, tot en met '11111111' die overeenkomen met 255. Overigens worden bytes nog verder gegroepeerd maar dat doet hier niet terzake. Met bitoperators kun je de bits in een getal manipuleren. Als je bijvoorbeeld 255 AND 3 gebruikt, dan is het resultaat 3, omdat hier eigenlijk '11111111' AND '00000011' wordt uitgerekend, wat '00000011' oplevert, oftewel 3. Met die bits heb je in de dagelijkse praktijk meestal niets te maken; je kan in je programma's werken met gewone getallen. Het omrekenen van de getallen naar bits gebeurt achter de schermen.

Rekenen met bits wordt handig wanneer je meerdere waarden tegelijk in één byte wilt opslaan. Dat kan bijvoorbeeld wanneer je alleen maar de waarden 0 en 1 gebruikt. Een voorbeeld is de muisknop-byte. Ik weet niet precies hoe dit in elke programmeertaal werkt, maar ik ben gewend dat de toestand van alle muisknoppen in 1 byte verstopt zitten. Elke knop is dan 1 bit. Zo kan '00000001' (waarde 1) betekenen 'linkermuisknop ingedrukt' en '00000110' (waarde 6) 'middelste en rechter muisknop ingedrukt'. (Overigens, de precieze waarden zou je even op moeten zoeken; het gaat om het idee.) Als je wil testen of de middelste muisknop is ingedrukt, moet je dus zoiets doen: 'if (muisknoppen AND 2) ...'. Dit werkt ook zo met de toetsen Alt, Shift en Control.

Een ander voorbeeld van een toepassing van bitoperators is wanneer je een zwartwitplaatje in een bestand op wilt slaan. Zo'n plaatje bestaat uit beeldpunten die zwart (0) of wit (1) zijn. Het zou zonde zijn om voor elk beeldpunt een hele byte te gebruiken. Je kan acht beeldpunten tegelijk in een byte opslaan, dat scheelt een factor 8 in ruimtegebruik. Wanneer je dit soort dingen aan de slag gaat is het dus in zekere zin onhandig dat bits altijd gegroepeerd worden tot bytes, want dan moet je trucs uithalen met bitoperators. Er zijn overigens ook nog de bitoperators '<<' en '>>', de 'bit shift'-operators, waarmee je bits kan verschuiven.

Ik hoop dat dit je vraag beantwoordt.

Met vriendelijke groet,

Axel Brink.

Nut: Bit operatoren worden toegepast bij het genereren van zetten en dergelijke in bitboardbased schaak computers

AxelBrink schreef:..

Rekenen met bits wordt handig wanneer je meerdere waarden tegelijk in één byte wilt opslaan. Dat kan bijvoorbeeld wanneer je alleen maar de waarden 0 en 1 gebruikt. Een voorbeeld is de muisknop-byte. Ik weet niet precies hoe dit in elke programmeertaal werkt, maar ik ben gewend dat de toestand van alle muisknoppen in 1 byte verstopt zitten. Elke knop is dan 1 bit. Zo kan '00000001' (waarde 1) betekenen 'linkermuisknop ingedrukt' en '00000110' (waarde 6) 'middelste en rechter muisknop ingedrukt'. (Overigens, de precieze waarden zou je even op moeten zoeken; het gaat om het idee.) Als je wil testen of de middelste muisknop is ingedrukt, moet je dus zoiets doen: 'if (muisknoppen AND 2) ...'. Dit werkt ook zo met de toetsen Alt, Shift en Control.

..

Ja, ik geloof da u da wel geantwoord hebt. Dank u wel maar als ik dit nu heel goed begrijp dan heeft een high level (C, Algol, Cobol, Oberon, ..) programmeur deze bitoperatoren helemaal niet nodig en hoef ze niet te begrijpen aangezien men niet op een machinetaal niveau moet gaan programmeren en volgens mij is het ook zo dat elk fabricant hun eigen machinetaal voor hun hardware producten ontwikkelen.

Thanks

Mvg

Nut: Bit operatoren worden toegepast bij het genereren van zetten en dergelijke in bitboardbased schaak computers

Dit voorbeeld hier begrijp ik echt niet soory maar toch bedankt voor u reactie.

Groetjes

Stel, je moet een zwart-wit plaatje inlezen. In het bestandsformaat staan de pixels met 8 tegelijk in een byte, iedere bit representeert één pixel. Stel dat je dit plaatje wilt weergeven, of het aantal witte pixels tellen, of wat dan ook. Hoe ga je daar nu (in C, Algol, Cobol, ongeacht welke taal) de individuele pixels uit lezen?

bchaib schreef:Dit voorbeeld hier begrijp ik echt niet soory maar toch bedankt voor u reactie.

Groetjes

zie hier bv

http://en.wikipedia.org/wiki/Bitboard

Hallo

Bitoperatoren worden er veel gebruikt in assembleertaal programma's voor het bij voorbeeld sturen van de hardware poorten, bvb een LED laten knipperen samen met een timer. Ander voorbeeld is een input sturen naar een poort,

AND wordt gebruikt om bits te resetten

OR wordt gebruikt om bits te setten

XOR wordt gebruikt om bits te toggelen (gelijk een FF)

NOT om een toestand om te keren

Wordt erg veel toegepast in de elektronica, als je wilt ik heb heel veel assembler programma's liggen

The art of assembly language daar wordt echt alles uitgelegd ook over:

bitwise operators

shift operators

rotate operators

In mijn compiler worden bit operatoren zoal voor het volgende toegepast.

:

Efficient opslaan van 8 statussen.

Wat anders zeg 8 bytes kost , kost dan 1 byte.

Bij 2000*8 is toch weer wat bespaard.

Snelheidswinst: je zet alle 8 statussen met 1 set met 0 uit.

Ook behoeft het geheugen minder vrije blokken te zoeken bij geheugen vergroting.

Controle getallen: hiervoor wordt XOR toegepast en SHL.

Ik heb voor het opzoeken van commandos ook xor nodig en and.

==================

Verdere toepassingen

In zoekmachines kan met het ook toepassen door het bepalen van een code getal.

Bij een longint als codegetal heeft men een 2 miljard ttrefkans.

==================

In games voor het beheren van eguipment die een speler bij zich heeft.

Men kan bij een longint praktisch 31 aan/uit zaken onderbrengen:)

Bit 1: hamer

Bit 2: bijl

Bit 3: pistool etc

je kunt met 1 and test zoals bij (speler_equipment and 7)<>0 dan zien dat de speler iets van deze spullen heeft.



Bij gebruik van een int64 kan men al 63 zaken kwijt.

Men kan met 1 set dan 63 dingen tegelijkertijd resetten.

Bij een int64 processor is dat ook een luttele stap.

Soms gebruik je ook pointers om een byte van een longint te halen en deze dan te bewerken met or en and.

En daarna weer terugzetten.

Even een stukje uit die software voor het bepalen van de code voor het opzoeken van het commando:

PROCEDURE qu_SCORPIUS_COM_REFCODE_DO;

VAR X,Y,B,R,L,L2:longint;

VAR P,P2:longint;

BEGIN

qu_SCORPIUS_COM_REFCODE:=0;

P:=1;

|aflopen van de commando opgaven |

FOR X:=1 to qu_SCORPIUS_com_length do begin

|aflopen van de tekens van de naam met maximaal 7 letters.|

P2:=P;

r:=0;

L:=qu_SCORPIUS_com_mele[x];

L2:=L;

IF L2>7 then begin L2:=7;end;

FOR Y:=1 TO L2 do begin

b:=qu_SCORPIUS_com_mestr[P2];

INC( p2);

r:=r SHL 1; r:=r XOR b;

END;

qu_SCORPIUS_COM_REFCODE:=qu_SCORPIUS_COM_REFCODE XOR r;

|optellen van positie op mestr| INC(P,L+1);

END;

qu_SCORPIUS_COM_REFCODE:=(qu_SCORPIUS_COM_REFCODE AND 4095)+1;

END;

Men ziet een XOR een SHL en een AND in toepassing.

(...) als ik dit nu heel goed begrijp dan heeft een high level (C, Algol, Cobol, Oberon, ..) programmeur deze bitoperatoren helemaal niet nodig en hoef ze niet te begrijpen aangezien men niet op een machinetaal niveau moet gaan programmeren en volgens mij is het ook zo dat elk fabricant hun eigen machinetaal voor hun hardware producten ontwikkelen.

Als je graag wil weten welke muisknop is ingedrukt, of iets anders van de genoemde voorbeelden, dan heb je het nodig.

Je kunt met XOR 2 variabelen omwisselen zonder gebruik van een lokale.

Is wel langzamer dan met een lokale maar ja:

In pascal (omwisselen van a en b):

Normaal met lokale:

Var M:longint;

BEGIN

M:=A;

A:=B;

B:=M;

Nu met XOR:

A:=A XOR B;

B:=A XOR B;

A:=A XOR B;

Ik vind vooral de constructie grappig...