March 14, 2012

Unutmuşum...

sonBit sabiti de gereksiz! Çünkü biz yazıyı soldan sağa yazdığımız için ikilik sistem tıpkı Arapça gibi tersimize geliyor. Eee doğal olarak kavramak güç oluyor ve sanki her şey çorba olmuş gibi geliyor...:)

Açıkçası bugün bir an için öyle bir şeyler oldu. N'oluyor, ne bitiyor anlayamadım! Bu kod çalışması lazım diyorum ama hiç bir şey ile eşleşmiyor. Sonra elektron dünyasını yaşadığımız dünyaya adapte edince her şey düzeldi. Bunun için kaydırılan biti (yoklayıcı bit) sona alıp sağa kaydırdım. Dolayısıyla işlev yerine oturduğunda bu sabiti kaldıracağız.

Özetle aslında yukarıda çok bir şey yapmış değiliz. Halen senin ilk iletindeki gibi bir tarama olayı gerçekleşmekte. Bir tek kafa (buffer) kavramı ortaya koydum ve böyle bant yüzeyine (veriye) eski pikaplar gibi tek iğne (bir bit) değil bir sözcük (word) dokunmakta. Biz de bunu aradığımız veriyle eşleşip eşleşmediğini sorgulamaktayız. Tabi basit olması için ushort, uint, ulong gibi değişkenler kullanacağız. Sonra işi struct boyutuna ve belki sınıfa taşımalıyız.

Başarılar...

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

March 14, 2012

Estağfurullah, ne gereksizi altın bunlar...:)

Bu arada dışarıya çıkmadan evvel (yarına unutmadan) malum işleve Bismillah dedim. Yaptığım sadece puzzle birleştirmek gibi. Eğer Zafer devam derse hemen bunu bugün hatim eder, yarın da değiştirme olayına geçeriz inşaallah...

int bitBul(int bitUzunluk, uint arananBitler, ref ubyte[] veri) {
   int i, uzunluk = bitUzunluk;
   if (bitUzunluk == 0) uzunluk = 32;
   else if (bitUzunluk >32) return 0;

// Maske oluşturuyoruz...
   uint maske = 1;
   for (i = 0; i < uzunluk; i++) {
       maske <<= 1; // sola bir bit kaydır
       maske |= 1;  // açılan yere 1 bitini yerleştir: 0 => 1
   }

// Verileri alırken maskeliyoruz...
   ushort kafa = 0;
   for (i = 0; i < (veri.length * veriBitleri); i++) {
       kafa <<= 1;
       if (bitTest(veri, i)) kafa |= 1;
       kafa &= maske;
       if (kafa == arananBitler) return i * veriBitleri;
   }
   return 0;
}

Eminim hatalar vardır ama derleyici hata vermiyor. Tabi önemli olan doğru bulması ve konumunu geri döndürmesi. Kullanmak için ise sanırım (denemedim) kısaca şu şekilde çalışması lazım...:)

void main() {
   ubyte[] veriler = [ 137, 1, 0]; // 0000_0000_1000_1001_0000_0001_0000_0000
   //ushort aranan = 0b1000_1001_0000_0001; // dec(35073)
   ushort aranan = 0b1001_0000_0001; // dec(2305)
   printf("Aranan %d, şurada bulundu: %d", aranan, bitBul (12, aranan, veriler));
}

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

March 14, 2012

Alıntı (acehreli):

>

(Galiba bunu daha önce de konuşmuştuk. (?)) Bu bir arkadaşımla da yaşadığımız bir tartışma. Ben önce işlev yazma taraftarıyım. Ancak o işlevlerin paylaştıkları bir veri oluşunca onları bir sınıfın üyeleri yaparım. "Her şey sınıftır" diyenler de var.

Ali'yi çok sevdiğimi ve görüşlerini çok değerli bulduğumu önceki yazımda belirtmiştim ve cevap vermeden duramayacağımı da söyleyip yazıyorum :-D .Ben daha önce konuştuğumuzu hatırlamıyorum ama emin değilim neyse. Bu bence tamamen farklı bakış açısından kaynaklanan bir durum. Belki sürekli nesnelerle ve sınıflarla boğuştuğum için işlerimi analiz ederken öncelikle bir sınıf çerçevesi oluşturup onun içinde çözümü geliştirmeyi alışkanlık edinmişim. Yada çalıştığınız herşeyin sınıf olduğu bir dünyada yazılan işlevinde aslında bir sınıfın içerisinde olduğu gerçeğinden dolayı böyle bir bakış açısına sahibim.

Neyse sorun değil, farklı bakış açıları olmalı ki zenginlik ve farklı çözümler oluşsun, aksini düşünmek bile istemem :)

Alıntı:

>

Zafer yazdıklarını hiç okumadım farz ediyorum. Zor bir şey yok, (zafer bizimdir!) yapacağız inşaallah. Hatta bunu yaparken çok şey öğreneceğimize eminim. Zaten tek yapmamız gereken veriyi taramak. Bunu eski bantlı kasetlerdeki gibi düşünebilirsin. Bantı okuyan bir kafa var ve bu kafa veri üzerinde bir yöne hareket ediyor. Ancak kafa tıpkı DNA'ları kopyalayan, değiştirip düzelten ve/veya hatalarını bulan üstün moleküller gibi bir yandan eşleşip eşlemediğini kontrol edecek, hepsi o kadar...

Ben senin kadar iyimser olamıyorum Salih, bence zor olan bir çok şey vardır. Ancak mühim olan zor veya kolay olmasından ziyade o işi yapmak için ne kadar azim olduğudur. Bu azim zorlukları aşmayada yeterli olacaktır. Benim zorluktan kastım bu tür alt seviye işlemlerle daha önce böyle detaylı çalışmamış olmamdan kaynaklanıyor. Dolayısıyla şu an tabir yerinde ise kafamdaki bilgilerin hepsi her yerde gibi bir durum oluştu bu durumda bu biligleri düzenleyip analiz etmeme engel oluyor.

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

March 14, 2012

Biliyorum, yazılan kodlar zaten güzel ve amacına uygun olduğu sürece bunlar çok anlamsız ama ben yine gereksiz bazı yorumlar yapacağım. :)

Alıntı (Salih Dinçer):

>
> const uint veriBitleri = 8;     // ubyte 8 bit olduğu için...
> const uint araBitleri = 16;     // ushort 16 bit olduğu için...
> ```


Onlar tam da enum olmaya uygun sabitler. Hem kesinlikle değişmeyecek olan büyüklükler, hem de derleme zamanında bile biliniyorlar:


enum uint veriBitleri = 8; // ubyte 8 bit olduğu için...
enum uint araBitleri = 16; // ushort 16 bit olduğu için...




Alıntı:
>
>
if ((aranan & (sonBit >> bit % veriBitleri)) != 0) return true;
return false;

}

Orada "bu mantıksal ifade true ise true döndür, değilse false döndür" gibi bir anlam olduğu için doğrudan mantıksal ifadenin değerini de döndürebiliriz:

   return (aranan & (sonBit >> bit % veriBitleri)) != 0;

Alıntı:

>
>     for (uint i = 0; i < araBitleri; i++) {
> ```


O da tam foreach'e uygun bir döngü (öyle başka bir döngü daha var):


foreach (i; 0 .. araBitleri) {



Ali

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

Notlar:

  1. İşlev nerede bulduğu bilgisini döndürdüğüne göre 'return 0' yanıltıcı olacaktır. Bulunmadığında uint.max özel değeri döndürülebilir.

1.5) Konum gibi bilgiler için size_t daha uygun oluyor çünkü .length gibi nitelikler de o türdeler. uint veya int kullanmak istediğimizde hep öyle tür uyumsuzluklarıyla karşılaşıyoruz. O yüzden dönüş türü size_t olabilir.

  1. Eğer bitUzunluk'un 32'den uzun olması bir hata ise işlev onu hata atarak baştan reddetmelidir. Bu tam std.exception.enforce'a göre bir denetim.

  2. bitUzunluk'un denetimi uzunluk denetiminden önce uzunluk'un değerinin ayarlanması gibi bazı işlemler de var. Bence işlevin giriş koşullarının en başta yapılması daha temiz olur. (Hem de aslında sıfır kabul edilse de uzunluk'a yapılan iki atama işleminin masrafından kurtulunmuş olunur.)

  3. Dilimleri 'ref' olarak geçirme konusunu konuşmuştuk. İşlev ancak çağıran taraftaki dilimde yapısal bir değişiklik yapacaksa 'ref' olarak almalıdır. (Burada "yapısal değişiklik" derken dilime eleman ekleme, eleman çıkartma, veya yepyeni elemanlara eriştirme gibi işlemleri kastediyorum. Yoksa asıl elemanları dilimler yoluyla değiştirebileceğimizi biliyoruz.)

Bunun dışındaki durumlarda dilimler rahatça değer olarak geçirilmelidirler. Hem zaten yalnızca iki üyeden oluşurlar (elemanları gösteren gösterge ve eleman adedi) hem de aslında değer olarak gönderildiklerinde işlev içindeki kullanımları 'ref' daha hızlı olur! :) (Çünkü 'ref' parametreler perde arkasında gösterge olduklarından dilim kullanılırken o gösterge üzerinden zıplanır.)

  1. Aldığı dilimde değişiklik yapmayacağı için parametreyi 'const' olarak işaretleyebilir. Böylece değişebilen 'immutable' olan dilimlerle de çağrılabilir.

  2. Yine for yerine foreach öneririm. Böylece i gibi değişken de gerekmemiş olur.

7)Bir grup kodun '// Maske oluşturuyoruz...' gibi açıklamalarla açıklanma gereği duyulmuşsa, o kodun maskeOluştur() gibi bir işleve taşınmalarının zamanı gelmiş demektir.

Bu konu "İşlevler" bölümünde ayrı bir başlık halinde de var:

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

  1. printf güvensizdir (programcı düzen belirteçlerini yanlış verebilir) ve yeteneksizdir (yalnızca temel türleri destekler).

  2. Sonunda etkin kullanımını anladığımızı düşündüğümüz immutable anahtar sözcüğünü de serpiştirebiliriz. (Doğrusu çok uzun olduğu için beni biraz rahatsız ediyor. :( )

Bütün bunlara uygun olarak ve kendi sevdiğim gibi bol boşluklu olarak :):

import std.exception;

uint maskeOluştur(size_t uzunluk)
{
   uint maske = 1;
   foreach (i; 0 .. uzunluk) {
       maske <<= 1; // sola bir bit kaydır
       maske |= 1;  // açılan yere 1 bitini yerleştir: 0 => 1
   }
   return maske;
}

size_t bitBul(int bitUzunluk, uint arananBitler, const ubyte[] veri) {
   enforce (bitUzunluk <= 32, "Bit uzunluğu 32'den fazla olamaz");

   immutable int uzunluk = (bitUzunluk == 0
                            ? 32
                            : bitUzunluk);

   immutable uint maske = maskeOluştur(uzunluk);

// Verileri alırken maskeliyoruz...
   ushort kafa = 0;
   foreach (i; 0 .. (veri.length * veriBitleri)) {
       kafa <<= 1;

       // [Ali] bitTest() size_t olarak alsaydı bu cast'e gerek kalmazdı.
       //       size_t türü ile ilgili söylediklerim bu gibi durumlarda
       //       ortaya çıkıyor.
       if (bitTest(veri, cast(uint)i)) kafa |= 1;
       kafa &= maske;
       if (kafa == arananBitler) return i * veriBitleri;
   }
   return 0;
}

void main() {
   ubyte[] veriler = [ 137, 1, 0]; // 0000_0000_1000_1001_0000_0001_0000_0000
   //ushort aranan = 0b1000_1001_0000_0001; // dec(35073)
   ushort aranan = 0b1001_0000_0001; // dec(2305)
   writefln("Aranan %d, şurada bulundu: %d", aranan, bitBul (12, aranan, veriler));
}

Ali

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

March 15, 2012

Alıntı (zafer):

>

Benim zorluktan kastım bu tür alt seviye işlemlerle daha önce böyle detaylı çalışmamış olmamdan kaynaklanıyor. Dolayısıyla şu an tabir yerinde ise kafamdaki bilgilerin hepsi her yerde gibi bir durum oluştu bu durumda bu biligleri düzenleyip analiz etmeme engel oluyor.
Peki, sen bilirsin Zafer. Bu ortak çalışmayı başlatan sensin ve uygun gördüğün zamanda yine devam edebiliriz. Ama ben, genelde zor bir şey olmadığından çok, ikilik sistemde arama algoritmasının kolay olduğunu ve isminden esinlenecek (zafer bizim...) şeklinde renklendirmek istemiştim. Biraz hızlı gitmiş olabilirim, kusura bakma. Sen de haklısın çünkü bu konular daha çok elektronikçi arladaşlarımızın aşina olduğu şeyler. Bu arada meslek neydi?:)

İstersen senin başlattığın yerden devam edelim. Mesela baştan itibaren değil de verilen iki değer aralığı (başlayacağı bit hariç sonraki falanca bite kadar) döndürsün. Bunun da çok faydalı olacağını düşünemekteyim.

Görselleştirirsem:
' 0_________1_________2_________3________ bytes
| 0123 4567 0123 4567 0123 4567 0123 4567 | bits
Verimiz (*) şu olacak: | 0000_0000_1000_1001_0000_0001_0000_0000 |
-------------------------------------------'

Çekip alacağımız aralık ise 7-12 ama yarım bayt değil! İlginç değil mi; şöyle ki: işlev bize 7. bit hariç (dikkat 0 da bir bittir) 8. bitten itibaren toplam 12 biti döndürecek. Yani gönderilen veri şu olmalı: '0b1001_0000_0001 d(2305)'

Değişkenler ise örneğin: bKonum (bOffset), bUzunluk (bLength);
İşlev ismi olarak: uint bitGetir(bitFetch), olabilir...

Eğer bunu dizi üzerinden gönderirsek kolay gibi görünüyor. Peki 16 bit (uint) değişken üzerinden, başına bir nibble bit (bayt'ın yarısı) ekleyerek şunu gönderse nasıl olur: '0b0000_1001_0000_0001'

'(*)' Aslında ikilik sistemde sayılar (1 ve 0) sağdan sola doğru yazılır. Anlayışı kolaylaştırmak için tersi şeklinde ifade edilmiştir.

Kolay gelsin...

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

March 15, 2012

Merhaba Ali Hocam,

Notlar için teşekkür ederim, böyle çok daha eğitici oluyor. Öyleyse madde madde devam edelim ve Zafer'in de katılmasını beklediğimi belirtirim...:)

Alıntı (acehreli):

>
  1. İşlev nerede bulduğu bilgisini döndürdüğüne göre 'return 0' yanıltıcı olacaktır. Bulunmadığında uint.max özel değeri döndürülebilir.
    Doğru söylüyorsun, yazarken özellike dönüşü int türünde tanımladım; belki -1 döndürebiliriz diye...

Alıntı (acehreli):

>

1.5) Konum gibi bilgiler için size_t daha uygun oluyor çünkü .length gibi nitelikler de o türdeler. uint veya int kullanmak istediğimizde hep öyle tür uyumsuzluklarıyla karşılaşıyoruz. O yüzden dönüş türü size_t olabilir.

1.6) bitTest() size_t olarak alsaydı bu cast'e gerek kalmazdı. size_t türü ile ilgili söylediklerim bu gibi durumlarda ortaya çıkıyor.
Henüz size_t olayına alışamadım ve belirsiz şeylerden hoşlanmıyorum. Ama tam da bu iş için uygun görünüyor. Çünkü aranan değer ubyte sınırları içindeyse ulong kullanmak gereksiz olur. Yazdığın kodu denedim 'bitTest()''de ref yerine const yazmam gerekti. Ancak 'cast()''i kaldırdığımda hata vermedi. Peki, 'foreach()' uint döndürdüğü için böyle olmuş olabilir mi?

Alıntı (acehreli):

>
  1. Eğer bitUzunluk'un 32'den uzun olması bir hata ise işlev onu hata atarak baştan reddetmelidir. Bu tam std.exception.enforce'a göre bir denetim.

  2. bitUzunluk'un denetimi uzunluk denetiminden önce uzunluk'un değerinin ayarlanması gibi bazı işlemler de var. Bence işlevin giriş koşullarının en başta yapılması daha temiz olur. (Hem de aslında sıfır kabul edilse de uzunluk'a yapılan iki atama işleminin masrafından kurtulunmuş olunur.)
    Bu bölüm için daha farklı bir şey düşünüyorum. Çok amatörce olduğunun farkındayım ve işlev adayı olacak şekilde not alayım dedim. Oysa daha akıllıca bir şey yapılabilir. Sanırım 'bitBul()' işlevinde gereksiz çok şey var.

Alıntı (acehreli):

>
  1. Dilimleri 'ref' olarak geçirme konusunu konuşmuştuk. İşlev ancak çağıran taraftaki dilimde yapısal bir değişiklik yapacaksa 'ref' olarak almalıdır. (Burada "yapısal değişiklik" derken dilime eleman ekleme, eleman çıkartma, veya yepyeni elemanlara eriştirme gibi işlemleri kastediyorum. Yoksa asıl elemanları dilimler yoluyla değiştirebileceğimizi biliyoruz.)
    ...
  2. Aldığı dilimde değişiklik yapmayacağı için parametreyi 'const' olarak işaretleyebilir. Böylece değişebilen 'immutable' olan dilimlerle de çağrılabilir.
    Özellikle ref kullandım çünkü amacım 'bulDeğiştir()' benzeri bir işleve ulaşmak. Dolayısıyla işlev içerisinde gösterge (pointer) yardımıyla veya 'main()' dışında (global) tanımlayarak diziye müdahale etmeyi düşünüyorum.

Alıntı (acehreli):

>
  1. Yine for yerine foreach öneririm. Böylece i gibi değişken de gerekmemiş olur.

7)Bir grup kodun '// Maske oluşturuyoruz...' gibi açıklamalarla açıklanma gereği duyulmuşsa, o kodun maskeOluştur() gibi bir işleve taşınmalarının zamanı gelmiş demektir...
Yukarıda dediğim gibi bu döngü henüz taslak. Ancak ayrı bir işleve taşımak (başka yerde kullanımı) gerekirse bunu düşünebiliriz. Aslında 1.6'daki 'foreach()' burada hangi değeri gönderdiği sanki belirsiz. Açıkçası geleneksel olarak dizilerin elemanların aktarma dışında kullanımını 'for()''a pek yeğlemiyorum...:)

Alıntı (acehreli):

>
  1. printf güvensizdir (programcı düzen belirteçlerini yanlış verebilir) ve yeteneksizdir (yalnızca temel türleri destekler).
    Haklısın, çok çok güvensiz! Ama bu C'de böyle değil, sanki bu dilde özellikle hatalı çalışıyor. Örneğin tırnak içinde %d şeklinde bir anahtar atıp virgülden sonra değişkene bağlamazsanız kafasına göre ekrana veri basıyor. Bazı zaman da ilginç hallerine tanık oldum. En iyisi kendi işlevimizi 'biçimliYaz()' gibi bir şey yapmalı. Çünkü ekrana bir yazı yazmak için std.stdio kullanmamaya çalışıyorum. Bu şu başlıkta dile getirmiştim: http://ddili.org/forum/thread/742

Sevgiler, saygılar...

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

March 15, 2012

Evvvvett...:)

D'de yazdığım ilk çocuğum (işlev) doğdu. Tamam, ilk değil ama diğerleri hep öğrenme nitelikliydi. Ali hocam ve Zafer'e çok teşekkür ediyorum. Onlar sayesinde (ve sonunda) mesleğim ile alakalı küçük de olsa bir şey yaptım...

Arkadaşlar nasıl, sizce 10 numara kod olmadı? Bir de konsol'dan arguman aldımı... :-O
Alıntı:

>
> import core.stdc.stdio: printf;
>
> int bitBul(size_t arananBitler, ref ubyte[] veri) {
>     int uzunluk = cast(int)arananBitler;
>     size_t kafa, maske = 1;
>
>     for(int i = 1; i <= 64; i++) {
>         maske |= maske << 1;
>         uzunluk >>= 1;
>         if(uzunluk == 0) {
>             maske >>= 1;
>             uzunluk = i;
>             break;
>         } // MSB bitleri 0 olana kadar devam et, önceki duruma dön ve çık
>     } // maske'yi doldur ve uzunluk'tan bir bit çıkar
>
>     for(ubyte b = 0; b < (veri.length * veri.sizeof); b++) {
>         kafa <<= 1;
>     	if((veri[b / veri.sizeof] & (128 >> b % veri.sizeof))!=0) kafa |= 1;
>         kafa &= maske;
>         if (kafa == arananBitler) return b - uzunluk;
>     }
>     return -1;
> }
>
> int main() {
>     // bit >>           8  16  24   32   40   48   56   64 <--ulong
>     ubyte[] veriler = [ 1, 1, 137, 137, 137, 137, 137, 137, 9, 1 ];
>     size_t xKelime = 0b1000_1001; // decimal 137
>     int xKonum = bitBul(xKelime, veriler);
>
>     printf("%lu verisi arandı ", xKelime);
>
>     if(xKonum == -1) {
>         printf("ama bulunamadı!");
>     } else {
>         printf("ve %d numaralı bitden sonra başladığı tespit edildi...:)", xKonum);
>     }
>     printf("\n\nHoşça kalın...\n");
>
>     return 1;
> }
> ```

>

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

Alıntı (Ali Çehreli):

>

Alıntı (Salih Dinçer):

>

Özellikle ref kullandım çünkü amacım 'bulDeğiştir()' benzeri bir işleve ulaşmak.

Yani bitBul değişecek ve bulDeğiştir mi olacak? O zamam tamam. Yoksa bu haliyle şu kodun derlenemiyor olması kısıtlayıcı oluyor:

>     immutable ubyte[] veriler = /* ... */
> ```

Aslında henüz emin değilim çünkü değiştirmek istediğimiz verinin konumunu biliyorsak (veri uygulamanın kendi içinde üretildiyse ~ stack register gibi) bu durumda bulmak için zaman harcamasına gerek yok. Öyleyse bir Bit sınıfı oluşturup şu işlevleri geliştirmeye bakalım:
* Bit.oku (immutable: veri[]) ~ read, fetch
* Bit.bul (immutable: veri[], size_t: kelime) ~ find, search
* Bit.kes (ref: veri[], uint: konum) ~ cut, delete
* Bit.koy (...) ~ change, swap (yerine koy)

Bu son işlevde üç defa XOR kullanarak veriye (ayrıca maske ile) müdahale edebileceğimi düşünüyorum. Nasıl olsa değişecek veri parametre ile alınacak. Hatta bu parametre aynen geri döndürülüp verinin ne ile değiştiği ve/veya değişip değişmediği anlaşılabilir. Eğer bunu yapabilirsek bir çok uygulamada kullanılabilir ve bence çok faydalı. Özellikle benim için...:)

Alıntı (Ali Çehreli):
> D'de değişkenler için immutable'un const'tan daha kullanışlı olduğunu kabul ediyoruz. Buna rağmen birisi herhangi bir nedenle şöyle tanımlamış olsa, o da derlenemiyor:
>
>
>
const ubyte[] veriler = /* ... */
>

Eğer bitBul olarak kalacaksa çok kısıtlayıcı, çünkü immutable değişkenlerin içinde de bit vardır. "Neden bulamıyoruz?" diye düşündürüyor. :)
:)

Ben bu 'bit yeniği'ni (immutable) hala çözemedim. İlgili dersi (http://ddili.org/ders/d/const_ve_immutable.html) okudum ama bir kaç deneme yapmalıyım. Fark ettiniz mi; yukarıda yazdığım kodların birinde (işlevlerin içindekiler), const ifadesini de tek başına kullanmışım ve derleme hatası almamışım! D'ye bazen çok farklı (sade) bakıyorum. Derleme zamanında bilinen ve yerine koyulan bir çok özelliğin (enumerator, overloading, template, structs vb.) çalışma zamanında orada var olmadıklarını, her şeyin bir büyü olduğunu düşünüyorum! <-- The Matrix göndermesi...:)

"Aslında bir kaşık yok!"

Sevgiler, saygılar...

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

March 15, 2012

Bit işlemleri ile ilgili ders çok güzel ve kapsamlı. Sanırım hiç bir ders konusunda (yani internette) bu tür bilgiler bulunmaz. Altın değerinde bunlar ki Google Amca bol bol sayfaya referans gösterir inşaallah...:)

'maskeYap()' da güzelmiş ama benim işleve uygun değil. Çünkü döngü içinde aynı zamanda gönderilen verinin uzunluğunu (MSB'deki sıfırları) hesaplatıyorum. Aynı anda da maske kuruluyor ve bir taşla iki kuş vurmuş oluyorum. Zaten bu döngüler çok kısa ve önemsiz olsa gerek.

Görüşlerine katılıyor ve daha iyi hale getirmek için çabalayacağıma söz veriyorum...

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