Bitler için 'bool' türünün uygun olduğundan emin değilim. bool mantıksal ifade türü olduğundan ancak dizi "bitler 1 mi dizisi" olarak düşünüldüğünde uygun geliyor. Yoksa "bit dizisi" kavramı için ubyte daha uygun.

Çünkü zaten bilgisayarda adreslenebilen en küçük veri yapısı 8 bit olduğundan bool da perde arkasında bir bayt olarak gerçekleştirilmiştir. Yani bellek kazancı da yok.

Ali

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

Merhaba,

Sabahleyin (bir kaç saat önce), en son tartıştığımız şu işlevi (Zafer sayesinde öğrendiğim yöntemi), ilk 50 milyon asal sayının bulunmasında (n<982451653) denedim. Karşılaştırmanız için ikisini birden aşağıda alıntılıyorum:

Alıntı:

> /* <--- aşağıdaki işlevi açmak için, başa / ekleyin...
> bool bitTest(uint k) {
>     ubyte a = veriler[k >> 3];
>     for (uint i = 0; i < (k % 8); i++) a >>= 1;
>     if (a % 2 == 1) return true;
>     return false;
> }/*/
>
> bool bitTest(uint k) {
>     ubyte bits = veriler[k >> 3];
>     if ((bits & (1 << k % 8)) != 0) return true;
>     return false;
> }//*/
> ```

Bu zorlu bir testi ve elde ettiğim sonuç %7 hız kazancıydı. Zafer hocama teşekkür ederim; sayesinde Eratosten Kalburu (<http://ddili.org/forum/thread/745>)'nu biraz daha hızlandırdım. Gerçi bitTest() işlevinde almış olmam bir kaç saniye (return'lerden dolayı git, gel) yavaşlığa neden oldu. Ama istenirse bir kaç küçük değişiklikle bu kodlar, ana yordama dahil edilebilir.

Şimdi bir sonraki aşamaya geçme zamanı...:)

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

Elinize sağlık Erdem ve Salih böyle güzel mesajlarla yine dolu dolu bir konu oluşmuş.

Ali'nin bool hakkındaki düşüncesini açmasını bekliyorum sonrasında burada bir iki metod üzerinde karar verip BitOkuyucu sınıfını geliştirmeye çalışırız diye düşünüyorum. Başlangıcı yapmak adına benim sınıfta bulunmasını düşündüğüm metot şöyle;

public string CevirString(ubyte byteDizisi, int pozisyon)

Bu metot bir byte dizisini aldığı pozisyon değerine kadar okuyup bu kısmı string olarak vermeli, doğru mu yanlış mı olur bilemiyorum. Amacım bir başlangıç olsun.

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

Sanırım Zafer'in bir başka amacı (gerçi en başta değinmiş) bilgi ve tecrübesini arttırmak. Eğer bir süre sonra sınıf gereksiz gibi görünürse, dış kabuğu sıyırıp bunları algoritma kütüphanemize dahil edeceğimiz işlevler zinciri olarak düşünebiliriz. Ancak mümkünse Türkçe karakter içeren kelimeler kullanmamaya gayret edelim çünkü tarzancadan nefret ediyorum. Bende her kalıba uyacak sözcük var merak etmeyin...:)

Elbette D'de (UTF destekli diğer dillerde olduğu gibi) Türkçe karakter sorunu yok. Ancak elimizden geldiğince İngilizce ifadeler (zaten kullandığımız standart şeylerin %90'nı bu dilde) kullanırsak ve/veya Türkçe karakter içermeyen kelimeler seçersek sanırım herkes için (yabancılar da kolay okuyacak) iyi olacak. Örneğin Ali hocamın bulduğu "uzunluk" iyi ve bunun başka uzunluk ifadeleri ile karışmaması için "bUzunluk" veya "bitUzunluk" '(*)' şeklinde benzersiz (unique) yapabiliriz.

Zafer, şimdi 'ÇevirString()' dışında başka ne işlevler düşünüyorsun? Aslında şöyle de yapabiliriz; aynı isimden ve veri kaynağından (istersen bu basit bir dizi olsun sonra dosyaya bağlarız) istenilen uzunlukta değeri alıp döndüren (fetch) işlevler yapalım. Sanırım dizi döndüren (sanırım dilim diyorsunuz?) olay hazır gibi. Bir de bunu dizgeye çeviren ikinci bir bitOku olur ki dönüş değer string ise zaten bunu derleyici bilecek ve hangi işlevin adresine bağlayacağını bilecek. Ayrıca bitUzunluk, eğer boş ise tamamını döndürme gibi bir şey yapabiliriz. Böylece kısmen döndürülen veri için ayrı bir işlev kurmayıp tek bir sorgu 'if()' ile işi bitirebiliriz; ne dersin?

Bu arada benim de önerim (hatta düşünmeye başladım bile) kısaca şu: Bir nevi bul değiştir! Yani verinin (baytlardan oluşan öbeğin) neresinde aradığımız veri (örn. 0b_1100 1010 değeri) varsa verdiğimiz ikinci bir veriyle (bu iki bayt arasında bir yerde olsa dahi) değiştirsin. Yani kuramsal açıdan 2 ila 10 bit arası veri iki bayta birden denk gelebilir. Bu aralık daha büyükse 3, 4, 5 ... bayt diye uzayabilir. Bir de parçalı arayıp bulma (partial seek) var tabi ama o işleri karıştıracağı gibi aynı işlevi kullanan başka bir yapı ile halledebilriz. O yüzden bu 'araBul()' işlevi çok temel parametrelere sahip olursa birden fazla görevi icra edebilir.

**'(*) '**Sözcüklerin illaki Türkçe yazım kuralına uyması (örn. bitUzunluğu) gerekmez. Geleneğe bağlı kalarak ilk harfleri küçük başlayıp çok güzel bileşik isimler üretebiliriz. Türkçe aslında çok zengin bir dil. Arapça ve Farsça'dan bile gelen çok şey var ama dile oturduysa ve aramızda yaşıyorsa kullanmaya devam. Kullandığımız renk isimlerinin çoğu yabancı dillerden geldiğini biliyor muydunuz? Yani temel renklerden bahsediyorum yoksa özel renkler halkın uydurduğu şeyler dahil türlü zenginlikte...:)

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

Alıntı (zafer):

Yalnızca iki değeri olabildiği için tek bitle ifade edilen bir bilgiyi bool'da yalnızca iki değer taşıyabildiği için bool olarak ifade etmek istediğini düşündüm.

bool mantıksal ifade türü olduğundan yani "acaba böyle midir" gibi sorulara yanıt verdiğinden, eğer ifade etmek istediğin bilgi "acaba bu indekse karşılık gelen bitin değeri 1 midir" ise bool dizisi uygun.

Yok eğer bu dizi "bitlerin değerlerini taşıyan dizi" ise, bool türü bit değeri taşımaya uygun gelmedi. Evet, tabii ki kullanılabilir ama anlamsal açıdan doğru değil.

İki değerli olduğu için C++'ın bool'unun tek bitlik bir tür olduğunu düşünenlere rastlamıştım. Ek olarak onu da belirttim. bool dahil, en küçük değişken en azından bir bayt olmak zorundadır. Hatta, hiç üyesi olmadığı için uzunluğu sıfır olması gereken türlerin değişkenleri bile bir baytlıktırlar:

struct BoşYapı
{}

void main()
{
   assert(BoşYapı.sizeof == 1);
}

Bu, her değişkenin kendi yeri olabilsin diyedir. Eğer uzunluğu sıfır olsaydı, örneğin on elemanlı bir BoşYapı dizisinin on elemanı da aynı adreste bulunurlardı. Oysa hepsinin farklı kişiliklerinin olması gerekir. Bu da farklı adresleriyle sağlanır.

Alıntı (zafer):

Sınıf mı olmalı yoksa bitlerle ilgili olan bir grup işlev mi? Çünkü sınıf (veya yapı) denince üyeleri olan ve işlemler sırasında o üyeleri kullanan türler düşünüyorum.

Alıntı:

> public string CevirString(ubyte byteDizisi, int pozisyon)
> ```


İşte şimdi oradaki "pozisyon"u görünce sınıf olabileceğini görüyorum ama pozisyon parametre olarak mı verilmeli, yoksa sınıfın bir üyesi mi olmalı. Örneğin File yapısı da dosyanın belirli bir yerinden okur ama pozisyon biz readf()'i kullandıkça otomatik olarak artar. (Evet, okuma pozisyonunu değiştirebiliyoruz da ama bunu farklı bir işlevle yapıyoruz.)

Alıntı:
> Bu metot bir byte dizisini aldığı pozisyon değerine kadar

Yanlış anlamışım bile. :) Parametre listesinde pozisyon görünce o pozisyondaki bilgi okunuyor sanmışım. Parametrenin adı "uzunluk" olsa "başından başlayarak şu uzunlukta" diye anlayabilirdim belki.

Ali

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

Alıntı (Salih Dinçer):

Kesinlikle! Hiçbir biçimde baltalamak istemiyorum. :) Benimkini yalnızca dile getirilmiş bir gözlem olarak alın lütfen.

Ali

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

Alıntı (acehreli):

Evet, aslında yapmak sitediğim buydu yani 8 adet biti byte paketinin içinden çıkarıp hepsine ayrı ayrı ulaşabilmek ve her bir biti özelleştirmek istemiştim.

Alıntı:

Aslında haklısın sınıf deyince insanın aklına bunlar geliyor. Ben bu konuda biraz daha esnek düşünüyorum sanırım, bana göre class anahtar sözcüğü ile işaretlenmiş kodlar bir sınıftır. Mutlaka üyeleri veya işlemleri olmak zorunda değil sadece nitelikleri (property) içeren bir kod parçasıda olabilir. Burada benim kafamdaki BitOkuyucu sınıfı static olarak işaretlenmiş bir sınıftır ve dolayısıyla bir örneği oluşturulmadan içindeki metotlar kullanılabilir. Aslında bu hali ile seninde belirttiğin gibi bir grup işlev haline geliyor :)

Alıntı:

Bu konuda biraz daha dikkatli davranmalıyım sanırım :)

Alıntı:

Bence bu çok güzel bir fikir Salih, BitOkuyucu gibi bir proje için bence en anlamlı metot bu olur herhalde, ancak bu iş umduğumdan çok daha karışık açıkcası, belki biraz daha alt yapı çalışması gerekiyor diye düşünmeye başladım. Yada nasıl diyeyim D dili ve olanaklarını biraz daha detaylı tanımak belki bu işlemleri yapabilmek için ihtiyacımız olan öncelikli konumuz olmalı.

Alıntı:

Kesinlikle Ali! Senin her türlü yazını çok çok severek okuyorum ve hepsinden çok güzel bilgiler elde ediyorum. O sebeple lütfen yaz, hatta konuya cevap verilmiş olsa bile yinede yaz. Senin birikimin ve bakış tarzın eminim ki ben dahil burda yazan arkadaşlara daha yeni ve farklı bakış açısı kazandırıyor.

Diğer taraftan baltalamak gerekiyorsa baltalamaktak çekinme :) Eğer buna karşı ben projemi güçlü argümanlarla savunamıyorsam zaten orada bir sıkıntı var demektir.

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

Alıntı (zafer):

(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.

Benim aklıma Phobos geliyor: algotirmalar Algorithm diye bir sınıfın üyeleri değiller.

Öte yandan, BitOkuyucu bir sınıf da olabilir tabii. Örneğin son durumunu koruyordur, nereden okumakta olduğunu hatırlıyordur, vs. O zaman bence de çok normal.

Alıntı:

Uygun isimler bulmak çok önemli ve bazen çok zor. Benim de her gün başımda. :)

Ali

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

Sanırım Ali hocam bizi baltalamaktan çok NLP'de güçlü klorik kişilerde olan şekilde tabiri caizse adeta gazlıyor. O yüzden Ali hocamın görüşlerine önem veriyorum. Özellikle işlev veya değişken ismi bulma konusunda...:)

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...

Bunun için ikinci bir işlev yazmamız gerekecek. Sanırım 10 gibi buralarda oluyorsun ki o zamana kadar buraya bir şeyler yapıştırabileceğimi ümit ediyorum. Görüşmek üzere...:)

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

Günaydın...

Önceki sayfalarda yer alan işlevi değiştirdiğim için kodun tamamını aşağıya yapıştırıyorum...

/*
bitOku.d (14.03.2012)
*/
import core.stdc.stdio: printf;/*
import std.stdio;//*/

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

bool bitTest(ref ubyte[] veri, uint bit) {
   const sonBit = 2 ^^ (veriBitleri - 1);
   ubyte aranan = veri[bit / veriBitleri];
   if ((aranan & (sonBit >> bit % veriBitleri)) != 0) return true;
   return false;
}

void binaryPrint(ushort b) {
   const sonBit = 2 ^^ (araBitleri - 1);
   for (uint i = 0; i < araBitleri; i++) {
       if ((i != 0) && (i % 4 == 0)) printf("_");
       if ((b & (sonBit >> i)) != 0) printf("1");
       else printf("0");
   }
}

void main() {
   ubyte[] veriler = [ 137, 1, 0]; // 0000_0000_1000_1001_0000_0001_0000_0000
   ushort kafa = 0,                  aranan = 0b1000_1001_0000_0001;
   // kafa ~ buffer, stack finder // aranan ~ keyword bits

   for (uint i = 0; i < (veriler.length * veriBitleri); i++) {
       kafa <<= 1; // kafa, veri üzerinde bir bit kaydırılıyor...
       if (bitTest(veriler, i)) kafa |= 1; // boşalan yere yeni veri geldi!
       binaryPrint(kafa); // kafadaki verinin şu an ki durumu göster
       if (kafa == aranan) printf("<--"); // aranan ile kafa arasında
       printf("- (%d == %d) ?\n", kafa, aranan); // bir eşleşme var mı?
   }
}

Buradaki 'binaryPrint()' çalışıp çalışmadığını görmek için ve bize lazım olan işlev değil! Aslında, önceki iletimde bahsettiğim işlev 'main()' içinde bir yerlerde ve olgunlaşınca kendi dairesine geçecek...:)

Ancak burada basit bir sorun var; o da aramanın 8, 16, 32, 64 bitler (kafanın genişiliği) olması. Yani aranan değişkeni, örneğin 9 biti geçmeyen bir değerde olsaydı başındaki sıfırlar (10-15. bitler) eşleşmeyi bozacaktı. O yüzden aranan verinin genişliği kadar veriden parça alınıp AND maskesi (örn. 9 bit için 0000_0001_1111_1111) yapmamız gerekiyor; bir de kaçıncı bitte (segment => offset convert) olduğunu döndürmesi...

İşte bu sorun ve özellik halledildiğinde 'wordSearch()' isminde nurtopu gibi bir işlevimiz olacak. Hemen ardından da pratik bir şekilde (belki XOR kullanarak?) bitleri değiştireceğiz. Buraya kadar anlaşılmayan bir şey var mı?

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