Mp3, ID3v1, ID3v2 derken bit işlemlerine iyice bulaştıktan sonra birazda .Net çatısında bulunan BinaryReader (http://msdn.microsoft.com/en-us/library/system.io.binaryreader.aspx) sınıfından etkilenerek BitOkuyucu adında bir sınıf hazırlamayı denedim.

Sınıfın amacı bit işlemlerini biraz daha üst düzeyde gerçekleştirmemizi sağlamak ancak bilgi ve tecrübem çok yeterli değil. Yinede neden olmasın dedim ve denemeye karar verdim. Sonuçta ortaya şöyle bir sınıf çıktı

class BitOku
{
   public this()
   {
       //
   }

   public static bool[] CevirBool(byte byteDegeri)
   {
       int sayi = cast(int)byteDegeri;

       bool[] dizi = new bool[8];

       for (int i = 0; i < 8; ++i)
       {
           if ((sayi & (1 << 7 - i)) != 0)
           {
               dizi[i] = true;
           }
       }

       return dizi;
   }
   unittest
   {
       bool[8] testDizi = [0, 0, 1, 1, 1, 0, 0, 0];

       assert(CevirBool(0b_00111000) == testDizi, "Sorun var!");
   }
}

Henüz sınıfımızın tek bir metodu var. Onun görevi ise kendisine gönderilen byte değerini bir (1) ve sıfırlardan (0) oluşan bir bool[] dizisi olarak geriye vermek.

Belki biraz garip gelecek, yaptım ama tam olarak anlamadığım şu kısım var.

if ((sayi & (1 << 7 - i)) != 0)

Burada sola kaydırmayı tam olarak anlamadım. Yani direk (sayi & i) gibi bir yazımla "ve" işlemini neden yapamıyorum? Sanırım buradaki mantığı tam anlayamadım.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Eline sağlık Zafer, şu an kodu deneyemiyorum ama katkı sağlamak isterim. Çünkü faydalı bir çalışma ve rahatlıkla geliştirebiliriz. Sadece daha önce kullandığım kaydırma yöntemini (aslında bölme, kağıt üzerinde yaptığımız gibi) kısaca ifade edeyim:

bool bitOku(uint k) {
   ubyte a = veriler[k >> 3];// Düzeltme 1: Veri ubyte'da işlenmeli
   for (uint i = 0; i < (k % 8); i++) a >>= 1;// Düzeltme 2: Bölen 8'den kalan
   if (a % 2 == 1) return true;// Düzeltme 3: Eşitlik 1 ise
   return false;
}

Belki kodda yanlışlık olabilir, aklımdan yazdım. Bu benim sonsuza giden dinamik bir dizideki verinin (Turing Machine gibi) herhangi bir yerindeki bit'in 1 (true) veya 0 (false) olduğunu göndüren alt yordamım. İşine yaraması ümidiyle.

Başarılar...

'Düzenleme: Bu alt yordam, 'döndür()' (eskisi) çalışmadığı için düzenlenmiştir. Ayrıca dileseydik kaydırma işleçleri yerine 8 ile 2'ye bölme kullanabilirdik. Hiç işte, artistlik olsun diye oradalar...:)'

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bahsetmek istediğim kodu çalıştırdım (hata vardı, 3 düzenleme de yaptım!) ve bunu deneyebilirsin:

/*
bitOkuyucu.d (10.03.2012)
*/
import core.stdc.stdio: putchar;/*
import std.stdio;//*/

ubyte [] veriler = [ 128,     // 1000 0000 [] = 0-7. bitler
                      1,     // 0000 0001 [] = 8-15. bitler
                    255,     // 1111 1111 [] = 16-31. bitler
                     15,     // 0000 1111 [] = 32-47. bitler
                    240      // 1111 0000 [] = 48-63. bitler
   ];

void writeln(string harfler) {
   foreach(ubyte harf; harfler) putchar (harf);
   putchar(10);    // printf("\n");
}

bool bitOku(uint k) {
   ubyte a = veriler[k >> 3];// Düzeltme 1: Veri ubyte'da işlenmeli
   for (uint i = 0; i < (k % 8); i++) a >>= 1;// Düzeltme 2: Bölen 8'den kalan
   if (a % 2 == 1) return true;// Düzeltme 3: Eşitlik 1 ise
   return false;
}

void main() {
   bool boolean = 0;
   //uint xVeri = 8; /* örn. 8. bit 1'dir, 15. 0 (yanlış'dır!)...

   for(uint xVeri = 0; xVeri < (veriler.length * 8); xVeri++)//*/
       writeln(bitOku(xVeri)? "doğru" : "yanlış");
       //putchar(bitOku(xVeri) ? 49 : 48);
}

Dip Not: Sanırım kodda hata yok, fazla denemedim ama iki, bilemedin üç deneme yapabilirsin. Örneğin '//uint xVeri''nin başındaki imleri kaldırırsan elle tekli, 'putchar()''ı devreye sokarsan bir bütün halinde çoklu (verinin tüm haritasıyla) deneme yapabilirsin. Bu uygulama bitWise Kalburu (http://code.google.com/p/bitwise-sieve/)'nun çekirdeğini oluşturmaktadır.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (Zafer Çelenk):

> if ((sayi & (1 << 7 - i)) != 0)
> ```

> Burada sola kaydırmayı tam olarak anlamadım. Yani direk (sayi & i) gibi bir yazımla "ve" işlemini neden yapamıyorum? Sanırım buradaki mantığı tam anlayamadım.
Bu arada senin sınıfın çekirdek bölümüne baktım da sanırım maskeleme işlemi kullanılmış. Hangi yöntem daha hızlıdır bilmiyorum ama sonuçta sen mod (%) işlemi yapmamış oluyorsun! Hem de ben 16 defa yapıyorum...:)

Burada ise sayı AND'lemeden önce (eğer 1/1 ise çıkış 1 olur) sırasıyla 1, 2, 4, 8, 16, 32, 64 ve 128 sayıları oluşturuluyor. Sonuçta bir nevi o biti alıp çıkarıyorsun. Ben ise elektronikçilerin (hatta matematikçilerin) yaptığı sürekli taban değerine bölme işlemini uygulamışım. Acaba hangisi hızlı?

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Salih çok hızlı gidiyorsun malesef ben bu konularda senin kadar bilgiye sahip değilim :) Ama güzel durmak yok, sen devam et ben bir şekilde sana yetişmeye çalışırım.

Alıntı:

Tamam Ali bu kısmı anladım. Peki (1 << (7 - i)) ile yaptığımız tam olarak nedir? Yani bunun altındaki mantık nedir? İşlem olarak sormuyorum buradaki düşünceyi fikri anlamaya çalışıyorum.

Alıntı:

İlk konudada belirttiğim gibi bu konuda çok bilgisizim amacım bit işlemlerini biraz daha üst düzeyde yapabilecek metodlar içeren bir sınıf oluşturmak CevirBool() sadece böyle bir fikri hayata geçirmek adına hazırlanmış bir yapı, anladığım kadarıyla Salih' te bu işe sıcak bakıyor. İsterseniz küçük bir yol haritası belirleyip uzak çaplı bir şey yapabiliriz. Örneğin verilen byte dizisini belli bir pozisyona kadar okuyup char dizisi veya string olarak döndürmek olabilir mi mesela?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Estağfurullah, Zafer...

Biliyorsun araç kullanırken hız ölüm demek. D dili de bizim için bir araç olduğuna göre yavaş yavaş...:)

Gerçi ben de uzun yol almak istiyorum ve de planım bu ay ortaya bir şeyler çıkarmak. Ancak senin hedeflerin çok güzel. Küçük küçük yol almak istiyorsun. Ne dersen onu yapalım...

Alıntı (Zafer Çelenk):

• i, sırasıyla 0'dan 7'e kadar 8 değer alıyor,
• Dolayısıyla ilk parantez aslında 7'den 0'a kadar geri sayıyor; belki döngüyü o şekilde kurabilirdik,
• Sonra bir maske sayı (0000_0001) üzerinden kaydırma işleçi (shift operator) uygulanıyor,
• Gelen işlev parametresi (sayi) ile de AND'lenerek sorgulanıyor...

Şimdi, bu şu demek değil mi; her seferinde yukarıdaki 3. maddenin parantez içinde yazdığım sayı (1 rakamı) sola kayacak. Ancak şöyle bir durum da var. Her defasında (AND'lendiği için), sayının 8 olasılıktan biri olup olmadığı sorgulanıyor. Sanırım o sorgunun bir karşılığı da şu olmalı: (gerçi D'de, bu tür switch kullanımının assembly kodu if'lerden üretiliyor!)

final switch(sayi) case 1, 2, 4, 8, 16, 32, 64, 128: dizi[i] = true;

Bence burada AND'lemek yerine OR'lamalı. Böylece 0 olan bölüm kesilmiş olacak. Şimdilik ekleyebileceklerim bu kadar ama dikkatimden başka şeyler kaçmış olabilir. Ali hocam tamamlayacaktır...:)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (acehreli):

Ali beyin söylediklerine ek olarak aslında bunlar Boole cebrinden geliyor. VE çarpma işlemi, VEYA ise toplama.

Ve işlemi

http://farm8.staticflickr.com/7194/6823798490_45095f384e_m.jpg (http://www.flickr.com/photos/elektronikhobi/6823798490/)

Çarpma aynı bildiğimiz gibidir. Bunların devre karşılığına bakacak olursak:

http://farm8.staticflickr.com/7197/6823798542_fd9cfe5a66.jpg (http://www.flickr.com/photos/elektronikhobi/6823798542/)

http://farm8.staticflickr.com/7062/6969921913_4ac83187b9.jpg (http://www.flickr.com/photos/elektronikhobi/6969921913/)

http://farm8.staticflickr.com/7048/6969921943_b3995dbedc.jpg (http://www.flickr.com/photos/elektronikhobi/6969921943/)

http://farm8.staticflickr.com/7208/6969921983_b6e6d39236.jpg (http://www.flickr.com/photos/elektronikhobi/6969921983/)

Veya işlemi

Toplamada Boole cebrinde ufak bir fark var. 1 + 1 gene bir oluyor. Bunu devre ile gösterimde daha iyi görebiliriz:

http://farm8.staticflickr.com/7069/6969922009_036eefce01_m.jpg (http://www.flickr.com/photos/elektronikhobi/6969922009/)

http://farm8.staticflickr.com/7051/6969922039_dff577268f.jpg (http://www.flickr.com/photos/elektronikhobi/6969922039/)

http://farm8.staticflickr.com/7060/6969922081_76e3aa4530.jpg (http://www.flickr.com/photos/elektronikhobi/6969922081/)

http://farm8.staticflickr.com/7048/6823798808_d2763c632a.jpg (http://www.flickr.com/photos/elektronikhobi/6823798808/)

http://farm8.staticflickr.com/7056/6823798870_1ff4a5a46d.jpg (http://www.flickr.com/photos/elektronikhobi/6823798870/)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (Salih Dinçer):

'SAYI => 0000 00011 \ AND'lenirse,
MASK => 0000 00001 / değer 1 olur

SAYI => 0000 00011 \ AND'lenirse,
MASK => 0000 00010 / değer 2 olur

SAYI => 0000 00011 \ AND'lenirse,
MASK => 0000 00100 / değer 0 olur
: : : >diğerleri de aynı olur...'

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (zafer):

& işleci, iki ifadenin karşılıklı bitlerini teker teker VE işleminden geçirir. Sonuç ifadede birden fazla 1 olabilir. Şurada "Ve işleci &" başlığının altındaki örnekte var:

http://ddili.org/ders/d/bit_islemleri.html

Hem 'sayi'da hem de i'de birden fazla 1 olabileceğinden '(sayi & i)[' yanlış olur. Çünkü o ifadeki if ile kullandığında "bütün ifade 0 değilse" demiş oluyorsun. O da "sonucun herhangi biti 1 ise" anlamına geliyor.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (Salih Dinçer):

Bölme işlemi en yavaş işlemlerdendir. Eğer bölen 8 gibi ikinin bir katı ise derleyici onları yine de >> işlecine çevirebilir ama olabildiğince kaçınmak gerek. Şurlada "Sağa kaydırmak ikiye bölmektir" başlığında tam da 8'e bölen bir örnek kullanmışım:

http://ddili.org/ders/d/bit_islemleri.html

Bu arada çok haklısın, özel bir nedeni yoksa bit işlemlerinde işaretsiz türleri kullanmak gerek. (Bu konu da orada var. ;))

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]