Bit Düzeyinde Mantıksal Operatörler

BİT DÜZEYİNDE MANTIKSAL OPERATÖRLER

Bu operatörler esas itibariyle mantıksal operatörler gibi işlem görürler; bit düzeyine uyarlanırsa aşağıdaki tablolar elde edilir. AND (&) operatörü için,

a	b	a&b(and b)
1	1	1
1	0	1
0	1	0

tablosu oluşturulabilir.

ÖRNEK: ONLUK SİSTEMDEKİ BİR SAYININ İKİLİK SİSTEME DÖNÜŞTÜRÜLMESİ

var n, c, k:Int

n = 128

print("\(n) DESİMAL SAYISININ İKİLİ SİSTEMDEKİ KARŞILIĞI")

for c in 0 ..< 31 {
    
    k = n >> c;
    
    let r = k & 1
    
    if r%2 != 0
        
    { print("1") }
        
    else
        
    { print("0") }
    
}


print("\n")

 

PROGRAMIN ÇIKTISI

 

128 DESİMAL SAYISININ İKİLİ SİSTEMDEKİ KARŞILIĞI

00000000000000000000000010000000

İKİLİK SİSTEMDEKİ BİR SAYIYI ONLUK SİSTEME ÇEVİREN SWIFT PROGRAMI

import Foundation

func ikili_onlu( nn:Int )
    
{
    
    var r,s,p:Int
    
    r=0;s=0;p=0;
    
    var n:Int=nn
    
    var k:Int=0
    
    while( n > 0)
        
    {
        
        print("n=\(n)")
        
        r = n % 10;
        
        n = n / 10;
        
        var t:Int=1
        
        for i in 0...p
        {
            t = t * 2
        }
        
        print("t=\(t)")
        
        k=t
        
        s += r * k
        
        p += 1;
        
    }
    
    print("ONLUK SAYI...\(s)")
    
}



var say:Int

say = 11101

print("İKİLİK SAYI......\(say)")

ikili_onlu(nn: say);

 

PROGRAMIN ÇIKTISI

İKİLİK SAYI......11101

n=11101

n=11101

t=1

n=1110

t=2

n=111

t=4

n=11

t=8

n=1

t=16

ONLUK SAYI...29

ONLUK SAYIYI ONALTILIK SAYIYA ÇEVİREN SWIFT KODU

import Foundation

func on_onalti(n:Int)
    
{ var nn:Int
    
    var r:[Int]=[0,0,0,0,0,0,0,0,0,0,0]
    
    var i:Int=0
    
    var l:Int=0;
    
    nn=n
    
    while( nn > 0)
        
    {
        
        r[i] = nn % 16
        
        nn = nn / 16
        
        i += 1
        
        l += 1;
        
    }
    
    
    for i in stride(from:l-1, to: 0, by: -1) {
        
        switch(r[i])
            
        {
            
        case 10:
            
            print("A");
            
        case 11:
            
            print("B");
            
        case 12:
            
            print("C");
            
        case 13:
            
            print("D");
            
        case 14:
            
            print("E");
            
        case 15:
            
            print("F");
            
        default :
            
            print(r[i]);
            
        }
        
    }
    
}

var nn:Int;


nn = 500

print("ONLUK SAYI..\(nn)")

on_onalti(n:nn)

 

PROGRAMIN ÇIKTISI

ONLUK SAYI..500

ONALTILIK SAYI... : 1F4

 

ONLUK SAYIYI SEKİZLİK SAYIYA ÇEVİREN SWIFT PROGRAMI

import Foundation

func on_sekiz(n:Int)
    
{
    
    var r:[Int]=[0,0,0,0,0,0,0,0]
    
    var i:Int=0
    
    var l:Int=0
    
    var nn:Int
    
    nn=n
    
    while(nn>0)
        
    {
        
        r[i] = nn % 8
        
        nn = nn / 8
        
        i += 1
        
        l += 1;
        
    }
    
    print("SEKİZLİK SAYI... : ");
    
    for i in stride(from:l-1, to: 0, by: -1) {
        
        print("\(r[i])") }
    
}

//================================================

var say:Int

say=100

print("ONLUK SAYI....\(say)")

on_sekiz(n:say)

PROGRAMIN ÇIKTISI

ONLUK SAYI....100

SEKİZLİK SAYI... : 144

 

OR (|) operatörü içinse aşağıdaki tablo geçerlidir:

a	b	a|b (a or b)
1	1	1
1	0	1
0	1	1
0	0	0

Bu operatörlerin mantıksal işlem operatörlerine göre tek farkları data üzerinde bit düzeyinde işlem yapmalarıdır. Aşağıdaki Swift programında, bit düzeyinde AND (&) ve bit düzeyinde OR ( | ) sembollerinin kullanılışı ile ilişkili örnek sunulmaktadır:

 

print("\n214|112=\( 214|112) \n\n 13 & 25=\(13 & 25)");

 

SONUÇ:

214|112=246



13 & 25=9

AÇIKLAMA:

13 ve 25 ikili sayı sisteminde dolayısı ile bit mertebesinde aşağıdaki gibi temsil edilirler:

 

13=00001101

25=00011001

 

Bu durumda, 00001101&00011001 işleminde karşılıklı dijitler arasında & işlemi yapılacak ve bu işlemde 0&1=0, 1&0=0, 0&0=0 ve 1&1=1 kuralına göre,

00001101&00011001=00001001 sonucu bulunur, ki bu da onluk sistemdeki 9 sayısına eşittir.

 

Aynı şekilde,

 

214=11010110

112=01110000

 

şeklinde temsil edilebilir. | (OR) işleminde, 1|1=1, 1|0=1, 0|1=1 ve 0|0=0 şeklinde belirlendiğinden,

 

11010110 | 01110000 = 11110110 sonucu bulunur; ki bu da onluk sistemdeki 246 sayısına denktir.

 

Aşağıdaki tablo ise onluk, onaltılık, sekizlik ve ikilik sistemler arasında dönüşümü vermektedir; ve okuyucunun ifadeleri daha hızlı incelemesini sağlamak amacı ile konulmuştur.

 

Onluk	Onaltılık	ikilik	Sekizlik
0	0	0000	0
1	1	0001	1
2	2	0010	2
3	3	0011	3
4	4	0100	4
5	5	0101	5
6	6	0110	6
7	7	0111	7
8	8	1000	10
9	9	1001	11
10	A	1010	12
11	B	1011	13
12	C	1100	14
13	D	1101	15
14	E	1110	16
15	F	1111	17

Aşağıdaki Swift programı ise exclusive OR (XOR) operatörü ^ ve bit düzeyinde tamamlama (complement) operatörü (∼) ile ilişkili örnekler sunmaktadır:

let a:UInt8=0b00000011

let b:UInt8=0b00000111

print("a=\(a)")

print("b=\(b)")

print("not a=\(~a)")

print("a^b=\(a^b)")

 

PROGRAMIN ÇIKTISI

 

a=3

b=7

not a=252

a^b=4

AÇIKLAMA

 

Bit düzeyinde not operatörü olan ~, bitin değerini değiştirir 1 ise 0; 0 ise 1 yapar:

Bit	~Bit
0	1
1	0

XOR operatörü olan ^ operatörü ise aşağıdaki tablo ile verilen işlemi gerçekleştirir:

a	b	a^b
1	1	0
0	1	1
1	0	1
0	0	0

 

Bu durumda a=0011=3 ve b=0111=7 ise aşağıdaki tabloya göre:

a	b	a^b
0	0	0
0	1	1
1	1	0
1	1	0

 

Olacak ve a^b=0100 olarak elde edilecektir. Bu da onluk sistemde 4 sayısıdır.

a=00000011 olduğu için, ~a=11111100 olacaktır ve bu da onluk sistemde 252 sayısıdır.