Programmerarkalkylator & bitkalkylator

Skriv ett enda uttryck med hexadecimala litteraler 0x, binära 0b och oktala 0o, bitvisa operatorer & | ^ ~, skift << >> >>>, rotationer och vanlig aritmetik — resultatet uppdateras direkt som decimal, hexadecimal, oktal och binär vid en ordstorlek på 8, 16, 32 eller 64 bitar, signerat eller osignerat. Nedan finns ett klickbart bitrutnät, en bitvis panel med två operander (AND / OR / XOR / NAND / NOR / NOT / skift / ROL / ROR) och enskild bit sätt / rensa / växla. För enkel basomvandling utan bitlogik, se Matematikomvandlaren; för statistik, Statistikkalkylatorn.
1. Uttryck
Ordstorlek   Vy   Operatorer: & | ^ ~ << >> >>> + - * / % ( ) — endast heltalsmatematik, resultaten vikts vid ordstorleken.
2. Resultat i alla fyra baser (redigera valfri rad)
DEC
HEX
OCT
BIN
3. Bitrutnät — klicka på en bit för att vända den
Bitarna visas med den mest signifikanta först; nedtonade celler ligger utanför den aktuella ordstorleken.
4. Enskild bit — sätt / rensa / växla
bitindex (0 = minst signifikant)
5. Bitvis panel med två operander
A =    B =  A och B accepterar hela uttryck (t.ex. 1 << 12).
Resultattabellen visas när både A och B kan tolkas. Skift och rotationer tar antalet från B.
Prova ett exempel:
Så beter sig skift: << maskar tillbaka till ordstorleken (bitar som faller av toppen försvinner). >>> är alltid ett logiskt (osignerat) skift. >> följer väljaren Vy: aritmetiskt i signerat läge, logiskt i osignerat läge. Integritet: hela kalkylatorn körs i denna flik — ingen server, ingen lagring.

Vad är en programmerarkalkylator?

En programmerarkalkylator gör aritmetik på det sätt datorer lagrar den: i ord med fast bredd av bitar. I stället för en oändlig tallinje är ett 8-bitarsord en cirkel med 256 värden, ett 32-bitarsord en cirkel med 4 294 967 296. Varje resultat vikts tillbaka in i den cirkeln, och samma bitar kan läsas antingen som ett osignerat tal (0 … 255) eller som ett signerat tvåkomplementvärde (-128 … 127). De fyra baserader ovan är samma bitar återgivna på fyra sätt — ändra en så följer de tre andra.

Varför programmerare lever i hexadecimalt

En hexsiffra är exakt fyra bitar, så en byte är alltid två hexsiffror och ett 32-bitarsord alltid åtta. Hex är binärt med nollorna omgrupperade för mänskliga ögon:

BinärtHexDecimal
1111 11110xFF255
0001 01100x1622
1000 00000x80128 (eller -128 signerat)

Tvåkomplement på ett stycke

För att läsa ett ord som signerat, titta på den översta biten. Om den är 0 är värdet bara det osignerade talet. Om den är 1, subtrahera cirkelns storlek: en 8-bitars 0xFF är 255 − 256 = −1. Det är hela tricket — -x och 0 - x ger identiska bitar, vilket är varför samma adderarhårdvara fungerar för båda. Teckenväxlingen är "invertera varje bit, addera 1": NOT(0x01) = 0xFE, +1 = 0xFF = −1.

Skiftoperatorerna i korthet

OperatorNamn8-bitarsexempel (a = 0xF0)
a << 1vänsterskift0xE0 — översta biten faller bort, nolla kommer in nedtill
a >> 1 (osignerat)logiskt högerskift0x78 — nollor kommer in upptill
a >> 1 (signerat, a = −16)aritmetiskt högerskift0xF8 = −8 — teckenbiten kopieras
a >>> 1alltid logiskt0x78 oavsett vyväljaren
rol(a, 1)rotera vänster0xE1 — den bortfallna översta biten kommer tillbaka nedtill

Vanliga misstag som den här sidan hjälper till att undvika

Aritmetiskt skift kontra logiskt skift: att kopiera teckenbiten (aritmetiskt) och fylla med nollor (logiskt) skiljer sig när den översta biten är satt — byt vyväljaren och se 0xF0 >> 1 ändras mellan 0x78 och 0xF8.
Överraskningen med 53 bitar: JavaScripts vanliga Number-typ är ett 64-bitars flyttal med endast 53 säkra heltalsbitar, så 0xFFFFFFFFFFFFFFFF kan inte representeras exakt — denna sida använder exakt 64-bitars heltalsaritmetik internt, så varje hexsiffra som visas är tillförlitlig.
Flyttalsfällor: 0.1 + 0.2 ger i flyttal berömt 0.30000000000000004; denna kalkylator är endast för heltal med avsikt — division trunkerar mot noll, precis som C:s / på heltal.
Inledande nollor: i gammal C betydde en litteral som 052 oktalt. Här är decimal vanliga siffror och oktal kräver prefixet 0o, så inget är tvetydigt.

Vanliga frågor

Vilket är det största talet? — 64-bitars osignerat: 18 446 744 073 709 551 615 (0xFFFFFFFFFFFFFFFF); signerat: ±9 223 372 036 854 775 808.
Varför blev 1 << 8 0? — ordstorleken är 8 bitar; bit 8 finns inte, och masken tar bort den. Byt till 16/32/64 bitar för att behålla den.
Vad gör ~? — bitvis NOT: varje bit vänds inom den aktuella ordstorleken, så ~0 är alla ettor (255 / 65535 / −1 …).
Finns det flyttal? — nej, endast heltal; använd den vetenskapliga kalkylatorn för flyttal, trigonometri och funktioner.
Lämnar något min dator? — nej: ingen server, ingen lagring, ingen analys; stäng fliken så är allt borta.

Självtest