Binär kalkylator

Den binära kalkylatorn adderar, subtraherar, multiplicerar och dividerar tal skrivna i bas 2, konverterar mellan binär och decimal och tillämpar bitvis OCH, ELLER, XOR, NOT och skiftar. Varje resultat inkluderar motsvarande decimal och en kolumnuppdelning så att bär och lån kan kontrolleras för hand. Bitbredd kan ställas in för tvås komplementarbete, eller lämnas obegränsad för exakt aritmetik utan registeromslutning.

All beräkning körs i din webbläsare. Inget du anger skickas till en server.

Addera, subtrahera, multiplicera och dividera binära tal

Binär aritmetik använder samma kolumnregler som decimal, men varje plats håller bara 0 eller 1 och bärtröskeln är 2 istället för 10. Ange två binära strängar, välj operationen och räknaren returnerar resultatet i binärt med decimalkontrollen bredvid. Inledande nollor tas bort från utgången om inte en bitbredd har valts.

Addering sker när en kolumn summerar till 2 eller fler. Subtraktion lånar från nästa högre bit när minuändsiffran är mindre. Multiplikation och division följer samma långformade mönster som lärs ut för decimaler, byggda av skiftningar och tillägg. Ogiltiga siffror som "2" eller "A" avvisas omedelbart eftersom de inte är lagliga i bas 2.

Konvertera binär till decimal

Positionell notation förvandlar en binär sträng till ett decimalt heltal genom att summera varje bit multiplicerad med dess potens av två. Biten längst till höger är 2⁰ (värde 1), nästa är 2¹ (värde 2), sedan 4, 8, 16 och så vidare. Ange "10111" och expansionen är 16 + 0 + 4 + 2 + 1 = 23.

1 0 1 1 1
│ │ │ │ └─ 1 × 2⁰ = 1
│ │ │ └─── 1 × 2¹ = 2
│ │ └───── 1 × 2² = 4
│ └─────── 0 × 2³ = 0
└───────── 1 × 2⁴ = 16
                   = 23

Alla binära strängar som räknaren accepterar konverteras på detta sätt. Gruppering i nibbles av fyra bitar gör platserna lättare att läsa högt: 1010 1010 är tydligare än åtta obrutna siffror när man kontrollerar en subnätmask eller ett behörighetsbitfält.

Konvertera decimal till binär

Upprepad division med 2 ger binära siffror som rester. Dividera decimalvärdet med 2, registrera resten (0 eller 1), dividera kvoten igen och fortsätt tills kvoten är noll. Att läsa resten från sist till första ger den binära formen.

För 23:

Step	Quotient	Remainder
23 ÷ 2	11	1
11 ÷ 2	5	1
5 ÷ 2	2	1
2 ÷ 2	1	0
1 ÷ 2	0	1

Läser rester uppåt ger "10111". Kalkylatorn utför denna omvandling i endera riktningen och visar båda formerna tillsammans så att en felskriven siffra är uppenbar före det aritmetiska steget.

Lägg till 10101010 och 11001100

Att lägga till 10101010 och 11001100 är den arbetade fixturen för kolumntillägg med bär. I decimal är operanderna 170 och 204, och summan är 374, vilket är 101110110 i binärt format. Äldre konturnoteringar som listade 110001110 var fel; aritmetiken nedan är det korrekta resultatet.

1 1 1 1 1 0 0 0     carries
            1 0 1 0 1 0 1 0   170
          + 1 1 0 0 1 1 0 0   204
          -----------------
          1 0 1 1 1 0 1 1 0   374

Kolumn för kolumn från höger: 0+0=0, 1+0=1, 0+1=1, 1+1=0 bär 1, 0+0+bär=1, 1+0=1, 0+1=1, 1+1=0 bär 1, och den sista bära skriver en nionde bit. Niobitarsresultatet 101110110 matchar 256 + 0 + 64 + 32 + 16 + 0 + 4 + 2 + 0 = 374. Den binära kalkylatorn visar denna bärrad för varje addition så att handkontrollen stämmer överens med utdata.

Subtrahera binära tal med lån

Binär subtraktion lånar när en kolumn behöver ta 1 från en 0. Att låna från nästa högre bit förvandlar den nuvarande 0:an till 2 (binär 10), och långivaren förlorar 1. Om den långivaren också är 0, fortplantar sig lånet tills det hittar en 1:a.

Exempel: "1000" minus "0001".

1 0 0 0
- 0 0 0 1
---------
  0 1 1 1

Kolumnen längst till höger lånar över tre nollor. Efter att kedjan avgjorts blir varje lånad kolumn 1, och den utlånade biten längst till vänster blir 0, vilket lämnar "0111" (decimal 7). När en bitbredd är inställd och resultatet skulle bli negativt, kan kalkylatorn visa de tvås komplementomslag istället för en obegränsad negativ magnitud. Obegränsat läge håller det signerade heltal exakt utan radbrytning.

Använd bitvisa operationer

Bitvisa operatorer agerar på varje bit oberoende snarare än på strängen som ett heltal. AND returnerar endast 1 där båda ingångarna är 1. ELLER returnerar 1 där endera ingången är 1. XOR returnerar 1 där bitar skiljer sig åt. INTE vänder varje bit i den valda bredden. Skiftar flyttar bitar och fyller nollor, eller teckenbiten för aritmetisk högerförskjutning.

A	B	AND	OR	XOR
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

En bitmask rensar eller behåller valda fält. value AND mask nollställer varje bit där masken är 0. value OR flag ställer in bitar. value XOR toggle vänder valda bitar utan att störa resten. Dessa mönster visas i behörighetsflaggor, statusregister och nätverksdelen av en IPv4-adress när en subnätmask tillämpas.

Representerar negativa tal i tvås komplement

Tvås komplement är det vanliga sättet att binärt med fast bredd lagrar negativa heltal. För ett n-bitarsregister, negera ett värde genom att invertera varje bit och lägga till en. Den höga biten är teckenbiten: 0 för icke-negativ, 1 för negativ. Det representerbara området för n bitar är −2ⁿ⁻¹ till 2ⁿ⁻¹ − 1.

I 8 bitar är +5 "00000101". Invertera till 11111010, lägg till en för att få 11111011, vilket är -5. Att lägga till 00000101 och 11111011 ger 00000000 med ett överflödesutförande av registret, vilket är hur negation checkar ut. Utan en bredd finns det ingen fast teckenbit och tvåans komplement är odefinierat; räknaren kräver därför en bredd (8, 16, 32 eller 64) innan den visar komplementformulär.

Overflow inträffar när det sanna matematiska resultatet inte passar den valda bredden. Binärkalkylator-flaggorna lindas så att ett tyst trunkerat svar inte misstas för ett exakt svar.

Läs tabellen för binära platsvärden

Placera värden fördubblas vid varje steg till vänster om den binära punkten. Att memorera de första åtta räcker för de flesta arbeten på bytenivå: 1, 2, 4, 8, 16, 32, 64, 128. Fyra bitar gör en nibble; åtta bitar gör en byte. Sexton bitar gör ett ord om många arkitekturer; 32 och 64 är vanliga registerstorlekar idag.

Bit index	Power	Value
0	2⁰	1
1	2¹	2
2	2²	4
3	2³	8
4	2⁴	16
5	2⁵	32
6	2⁶	64
7	2⁷	128

En full byte av ettor, 11111111, är 255. Enbart den höga biten, 10000000, är 128. Att läsa ett värde som summan av dess inställda platsvärden är snabbare än att konvertera siffra för siffra när tabellen väl är bekant, och räknarens expansionsvy matchar den mentala kontrollen.

Använd binär i praktiken

Binär dyker upp varhelst hårdvara eller protokoll exponerar bitfält. Subnätmasker är 32-bitars mönster av ledande. Unix-fillägen packar läs-, skriv- och exekveringsbitar i nio behörighetsbitar. Färgkanaler är ofta åttabitarsvärden. CPU-flaggor och enhetsregister packar booleskt tillstånd i enstaka bitar så att en mask kan testa eller rensa dem utan att vidröra grannar.

Minnesadresser och maskininstruktioner är binära under varje hex-dump. Vid felsökning går det vanligtvis snabbare att konvertera ett misstänkt flaggord till binärt och ställa det mot databladet än att gissa från decimalformen. Kalkylatorn håller binär- och decimalvyerna länkade så att tur och retur förblir ärlig.

Vanliga frågor

Sammanfattning

Den binära kalkylatorn utför bas-2 aritmetik, konverterar till och från decimaler till två potenser och tillämpar bitvis OCH, ELLER, XELLER, INTE och skiftar med en valfri registerbredd. Att lägga till "10101010" och "11001100" ger "101110110" (170 + 204 = 374), med överföringar som visas kolumn för kolumn.

Tvås komplement negation och bitvis kräver INTE en bit bredd; obegränsat läge håller resultaten matematiskt exakta. Platsvärden, nibbles och bytes listas så att binära strängar som används i masker, behörigheter och flaggor kan läsas utan att gissa.

Relaterade miniräknare

Hexkalkylator · IP-subnätskalkylator · Stortalskalkylator