b'\n_START_ARTICLE_\nBitvis operation\n_START_PARAGRAPH_\nInom digital datorprogrammering opererar en bitvis operation p\xc3\xa5 ett eller flera bitm\xc3\xb6nster eller bin\xc3\xa4ra tal p\xc3\xa5 bitniv\xc3\xa5. Det \xc3\xa4r snabba primitiva operationer som st\xc3\xb6ds direkt av processorn och anv\xc3\xa4nds f\xc3\xb6r att manipulera v\xc3\xa4rden f\xc3\xb6r j\xc3\xa4mf\xc3\xb6relser och ber\xc3\xa4kningar._NEWLINE_P\xc3\xa5 enkla l\xc3\xa5gkostnadsprocessorer \xc3\xa4r bitvisa operationer markant snabbare \xc3\xa4n division, flera g\xc3\xa5nger snabbare \xc3\xa4n multiplikation och ibland m\xc3\xa4rkbart snabbare \xc3\xa4n addition. Medan moderna processorer vanligen adderar och multiplicerar lika snabbt som de utf\xc3\xb6r bitvisa operationer p\xc3\xa5 grund av sina l\xc3\xa4ngre pipelines och andra arkitekturer anv\xc3\xa4nder bitvisa operationer ofta mindre kraft p\xc3\xa5 grund av ett reducerat anv\xc3\xa4ndande av resurser.\n_START_SECTION_\nBitvisa operatorer\n_START_PARAGRAPH_\nI f\xc3\xb6rklaringarna nedan r\xc3\xa4knas bitarnas position fr\xc3\xa5n h\xc3\xb6ger (den minst signifikanta sidan) till v\xc3\xa4nster. Det bin\xc3\xa4ra v\xc3\xa4rdet 0001 (decimalt 1) har nollor p\xc3\xa5 alla positioner utom den f\xc3\xb6rsta.\n_START_SECTION_\nOch (AND)\n_START_PARAGRAPH_\nDet bitvisa AND tar tv\xc3\xa5 bin\xc3\xa4ra str\xc3\xa4ngar av samma l\xc3\xa4ngd och genomf\xc3\xb6r en logisk AND-operation p\xc3\xa5 varje par av motsvarande bitar genom att multiplicera dem. S\xc3\xa5, om b\xc3\xa5da bitarna har v\xc3\xa4rdet 1, blir resultatet 1 (1\xc2\xa0\xc3\x97\xc2\xa01\xc2\xa0=\xc2\xa01), annars 0 (1\xc2\xa0\xc3\x97\xc2\xa00\xc2\xa0=\xc2\xa00). Till exempel_NEWLINE_    0101 (decimalt 5)_NEWLINE_AND 0011 (decimalt 3)_NEWLINE_  = 0001 (decimalt 1)_NEWLINE_Operationen kan anv\xc3\xa4ndas f\xc3\xb6r att avg\xc3\xb6ra om en viss bit \xc3\xa4r satt (1) eller ej (0). Till exempel: F\xc3\xb6r att avg\xc3\xb6ra om den andra biten i 0011 (decimalt 3) \xc3\xa4r satt anv\xc3\xa4nder vi ett bitvist AND med ett tal som bara inneh\xc3\xa5ller en etta i andra biten:_NEWLINE_    0011 (decimalt 3)_NEWLINE_AND 0010 (decimalt 2)_NEWLINE_  = 0010 (decimalt 2)_NEWLINE_Eftersom resultatet 0010 inte \xc3\xa4r noll vet vi att den andra biten i 0011 \xc3\xa4r satt. Detta kallas ofta "bitmaskning". (En analogi \xc3\xa4r maskeringstejp som t\xc3\xa4cker (maskerar) de bitar som inte skall \xc3\xa4ndras eller delar som \xc3\xa4r ointressanta. I detta fallet maskerar 0 de bitar vi inte \xc3\xa4r intresserade av.)_NEWLINE_Om vi lagrar resultatet kan det anv\xc3\xa4ndas f\xc3\xb6r att nollst\xc3\xa4lla valda bitar i ett register. Om vi exempelvis har 0110 (decimalt 6) kan vi nollst\xc3\xa4lla den andra biten genom att anv\xc3\xa4nda ett bitvist AND med ett m\xc3\xb6nster som har en nolla bara i den andra biten:_NEWLINE_    0110 (decimalt 6)_NEWLINE_AND 1101 (decimalt 13)_NEWLINE_  = 0100 (decimalt 4)_NEWLINE_P\xc3\xa5 grund av denna egenskapen \xc3\xa4r det l\xc3\xa4tt att kontrollera ett bin\xc3\xa4rt tals paritet genom  att testa v\xc3\xa4rdet hos den minst signifikanta biten. Till exempel:_NEWLINE_    0110 (decimalt 6)_NEWLINE_AND 0001 (decimalt 1)_NEWLINE_  = 0000 (decimalt 0)_NEWLINE_Allts\xc3\xa5 \xc3\xa4r 0110 (6) j\xc3\xa4mnt delbart med 2 och allts\xc3\xa5 j\xc3\xa4mnt.\n_START_SECTION_\nEller (OR)\n_START_PARAGRAPH_\nEtt bitvist OR tar tv\xc3\xa5 bin\xc3\xa4ra str\xc3\xa4ngar av samma l\xc3\xa4ngd och utf\xc3\xb6r en logisk OR-operation p\xc3\xa5 varje par av motsvarande bitar. Resultatet f\xc3\xb6r varje position \xc3\xa4r 0 om samma bit i de b\xc3\xa5da talen \xc3\xa4r 0, annars 1. Till exempel:_NEWLINE_   0101 (decimalt 5)_NEWLINE_OR 0011 (decimalt 3)_NEWLINE_ = 0111 (decimalt 7)_NEWLINE_Ett bitvist OR kan anv\xc3\xa4ndas f\xc3\xb6r att s\xc3\xa4tta de valda bitarna till v\xc3\xa4rdet 1. Till exempel kan det anv\xc3\xa4ndas f\xc3\xb6r att s\xc3\xa4tta en specifik bit (eller flagga) i ett register, d\xc3\xa4r varje bit representerar ett individuellt booleskt v\xc3\xa4rde i ett register. S\xc3\xa5 kan 0010 (decimalt 2) betraktas som en upps\xc3\xa4ttning p\xc3\xa5 fyra flaggor, d\xc3\xa4r bara den andra \xc3\xa4r satt. F\xc3\xb6r att s\xc3\xa4tta den fj\xc3\xa4rde flaggan utan att r\xc3\xb6ra de andra g\xc3\xb6r vi en bitvis OR med 1000 (decimalt 8):_NEWLINE_   0010 (decimalt 2)_NEWLINE_OR 1000 (decimalt 8)_NEWLINE_ = 1010 (decimalt 10)_NEWLINE_Den h\xc3\xa4r tekniken \xc3\xa4r ett effektivt s\xc3\xa4tt att lagra ett antal booleska v\xc3\xa4rden i s\xc3\xa5 lite minne som m\xc3\xb6jligt.\n_START_SECTION_\nExklusivt eller (XOR)\n_START_PARAGRAPH_\nEtt bitvist XOR tar tv\xc3\xa5 bin\xc3\xa4ra str\xc3\xa4ngar av samma l\xc3\xa4ngd och utf\xc3\xb6r en logisk XOR-operation p\xc3\xa5 varje par av motsvarande bitar. Resultatet blir 1 om den ena biten \xc3\xa4r 1 och den andra 0, men 0 om b\xc3\xa5da bitarna \xc3\xa4r lika. Till exempel:_NEWLINE_    0101 (decimalt 5)_NEWLINE_XOR 0011 (decimalt 3)_NEWLINE_  = 0110 (decimalt 6)_NEWLINE_Bitvist XOR kan anv\xc3\xa4ndas f\xc3\xb6r att invertera ("sl\xc3\xa5 om", som om de vore str\xc3\xb6mbrytare) valda bitar i ett register, genom att utf\xc3\xb6ra en bitvis XOR med en str\xc3\xa4ng inneh\xc3\xa5llande 1 p\xc3\xa5 de positioner man vill invertera. Till exempel om man har 0010 (decimalt 2) kan man sl\xc3\xa5 om positionerna tv\xc3\xa5 och fyra genom en XOR med 1010:_NEWLINE_    0010 (decimalt 2)_NEWLINE_XOR 1010 (decimalt 10)_NEWLINE_  = 1000 (decimalt 8)_NEWLINE_Den h\xc3\xa4r tekninken kan anv\xc3\xa4ndas f\xc3\xb6r att manipulera bitm\xc3\xb6nster som representerar booleska tillst\xc3\xa5nd._NEWLINE_Assemblerprogrammerare anv\xc3\xa4nder ibland XOR som en genv\xc3\xa4g f\xc3\xb6r att s\xc3\xa4tta v\xc3\xa4rdet p\xc3\xa5 ett register till noll, eftersom detta resultat blir f\xc3\xb6ljden om man genomf\xc3\xb6r en XOR p\xc3\xa5 ett tal med sig sj\xc3\xa4lv, a XOR a = 0. M\xc3\xa5nga processorer \xc3\xa4r byggda s\xc3\xa5 att XOR anv\xc3\xa4nder f\xc3\xa4rre klockcykler eller mindre minne \xc3\xa4n att ladda v\xc3\xa4rdet noll och spara det till registret.\n_START_SECTION_\nMatematiska ekvivalenser\n_START_PARAGRAPH_\nOm x > y f\xc3\xb6r icke-negativa heltal, kan de bitvisa operationerna skrivas som:_NEWLINE_D\xc3\xa4r  \xc3\xa4r antalet bitar i  f\xc3\xb6r alla .\n_START_SECTION_\nAtom\xc3\xa4ra booleska funktioner\n_START_PARAGRAPH_\nInom satslogiken anv\xc3\xa4nds 3 och 5 (bin\xc3\xa4rt 0011 och 0101) som ing\xc3\xa5ngsv\xc3\xa4rden, eftersom de motsvarar de m\xc3\xb6jliga sanningsv\xc3\xa4rdena hos tv\xc3\xa5 atom\xc3\xa4ra satser som skall f\xc3\xb6rbindas med konnektiv. Exempel 0101 AND 0011 = 0001 s\xc3\xa4ger att uttrycket \xc3\xa4r sant bara n\xc3\xa4r motsvarande bit i de b\xc3\xa5da talen \xc3\xa4r 1 (d.v.s. n\xc3\xa4r b\xc3\xa5da satserna \xc3\xa4r sanna). F\xc3\xb6r tre satser anv\xc3\xa4nder man 15, 51 och 85 (00001111, 00110011 och 01010101). Dessa tal \xc3\xa5terfinns i taltriangeln \xe2\x80\x8aA211344:_NEWLINE_           1                                  01_NEWLINE_        3     5                       0011          0101_NEWLINE_    15    51     85          00001111      00110011      01010101\n_START_SECTION_\nBitvis skiftning\n_START_PARAGRAPH_\nBitskifte betraktas ibland som en bitvis operation, eftersom de behandlar ett v\xc3\xa4rde som en serie bitar snarare \xc3\xa4n en numerisk storhet. Vid dessa operationer flyttas bitarna (skiftas) \xc3\xa5t h\xc3\xb6ger eller v\xc3\xa4nster._NEWLINE_Registerna i en datorprocessor har en fast bredd, s\xc3\xa5 vissa bitar kommer att "skiftas ut" fr\xc3\xa5n registrets ena \xc3\xa4nde, medan samma antal bitar "skiftas in" i den andra. Skillnaden mellan olika skiftoperatorer ligger i vad som skiftas in.\n_START_SECTION_\nAritmetiskt skift\n_START_PARAGRAPH_\nVid ett aritmetiskt skift tas bitarna som skiftas ut bort. Vid ett aritmetiskt v\xc3\xa4nsterskift fyller man p\xc3\xa5 med nollor i h\xc3\xb6ger\xc3\xa4nden, vid ett aritmetiskt h\xc3\xb6gerskift fyller man p\xc3\xa5 med teckenbiten i v\xc3\xa4nster\xc3\xa4nden, s\xc3\xa5 att operandens tecken bevaras._NEWLINE_Exemplet nedan anv\xc3\xa4nder ett \xc3\xa5ttabitarsregister:_NEWLINE_   00010111 (decimalt +23) V\xc3\x84NSTERSKIFT_NEWLINE_=  00101110 (decimalt +46)_NEWLINE_   10010111 (decimalt \xe2\x88\x92105) H\xc3\x96GERSKIFT_NEWLINE_=  11001011 (decimalt \xe2\x88\x9253)_NEWLINE_I f\xc3\xb6rsta fallet skiftades siffran l\xc3\xa4ngst till v\xc3\xa4nster ut och en nolla skiftades in l\xc3\xa4ngst till h\xc3\xb6ger. I andra fallet skiftades ettan l\xc3\xa4ngst till h\xc3\xb6ger ut (kanske in i carry-flaggan) och en ny etta kopierades in till h\xc3\xb6ger s\xc3\xa5 att tecknet bevarades. Multipla skift f\xc3\xb6rkortas ibland till en operation med angivande av antal steg. Till exempel:_NEWLINE_   00010111 (decimalt +23) V\xc3\x84NSTERSKIFT-MED-TV\xc3\x85_NEWLINE_=  01011100 (decimalt +92)_NEWLINE_Ett aritmetiskt v\xc3\xa4nsterskift med n steg \xc3\xa4r detsamma som att multiplicera med 2\xe2\x81\xbf (f\xc3\xb6rutsatt att overflow ej intr\xc3\xa4ffar), medan ett aritmetiskt h\xc3\xb6gerskift med n steg \xc3\xa4r detsamma som att dividera med 2\xe2\x81\xbf och runda av mot noll.'