Merhaba,

Uzun uzadıya değinilebilir! Sanırım kısa kısa örnekler ile devam edersek daha çok şey anlayacağız...:)

Aralıkları ilk gördüğümde bana garip geliyorlardı ve pek anlamıyordum. Bunun sebebi, aralıkları(range) ilk olarak D'de tanımam olabilir. Bilmiyorum, başka dillerde kullanılmaya başlandı mı?

Belki fikir sahibi olmak için, ilk önce D.ershane'deki şu başlığı okumalısız:

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

Şimdi anladığımı yazacağım, bu örnek ile doğrulamaya çalışacağım. Ancak bu örnekler belden aşağı olacak! Yani farklı örnekler olacak. Maksat uçlarda gezip işin doğasını, sınırını gözlemlemek. Güncel olduğu için aklıma ilk gelen örnek:

   struct Foo
   {
     int i;

     bool empty() {
       return i == 16;
     }

     int front() {
       return i;
     }

     void popFront() {
       i++;
     }
   }

   import std.stdio;

void main() {

 Foo foo;
 foreach(f; foo)
 {

   f.write("-", foo.front, " ");

 }
 writeln;
}

Yukarıda basit bir aralık örneği görüyoruz. Sayaç vazifesi gören i değişkeni ile 3 tane özelleştirilmiş işlevlerimiz var. Yaptıkları gerçekten çok basit öyle değil mi? Sayalım, i'nin:

• 16'ya eşit olup olmadığını sorguluyor
• içerdiği değeri gönderiyor
• değerini bir arttırıyor

Sonuçta 0'dan 15'e kadar ekrana sayıları yazıyoruz. Çünü empty()'den true onayı gelmediği müddetçe döngü dönmeye ve front()'dan aldığı veriyi ekrana yazmaya devam ediyor. Yani bütün olay yukarıda maddelediğim sırada devam ediyor...

Peki f değişkeni döngü tarafından alınan front()'un bir kopyası ise aynı anda front()'u yazdırdığımızda ne olmasını beklersiniz? Aşağıdaki gibi bir sonuç olabilir mi?

Alıntı:

Evet, sonuç gerçekten böyle çıkıyor. Yani her zaman aralığın en başındaki elemanı veriyor. Bu bana garip geliyor ve niye olduğunu anlamaya çalışıyorum. Belki de henüz aralıkları tam olarak anlayabilmiş değilimdir...:)

Başarılar...

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

Alıntı (acehreli):

> >   Foo foo;
> >   foreach(f; foo)
> > ```

>
> foreach'in içinde tüketilen Foo, foo'nun bir kopyası. popFront() hep o kopya üzerinde çağrıldığı için foo.front() hep 0 döndürüyor.
>
Bunu bilmiyordum, gerçekten ilginç ve bir de şu şekilde denediğimde kopyasını çıkaramadığı için beklediğim sonucu aldım...

auto foo = new Foo();
foreach(f; foo) {
: : :

Bunu öğrendiğim iyi oldu. Zaten yapılar ve sınıflar arasındaki kopya çıkarma olayını biliyorduk. Bunu aralıklar ile perçilendiğimiz harika oldu.

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

Alıntı (Salih Dinçer):

Aslında Boost kütüphanelerinde de çok benzer yapılar varmış. Boost kütüphanelerini kullanan C++ projeleri de yararlanabilirler ama C++'ın kendi standart kütüphanesinde aralık yok.

Alıntı:

>   Foo foo;
>   foreach(f; foo)
> ```


foreach'in içinde tüketilen Foo, foo'nun bir kopyası. popFront() hep o kopya üzerinde çağrıldığı için foo.front() hep 0 döndürüyor.

Bu konu D forumlarında da açılmıştı. Andrei'nin yanıtı da "sırf elemanlarını yazdırdığımız için aralık tükenmesin diye" demişti. Özetle, foo foreach'ten sonra bile kullanılmamış durumda.

(Böylece, benim diğer konuda front()'un çağrılmasıyla ilgili olarak altını çizdiğim sakınca aslında foreach aralığını değil, yerel aralığı etkiler.)

Alıntı:
> aralıkları tam olarak anlayabilmiş

Aralıkların gariplikleri oluyor. Örneğin, File.byLine()'ın döndürdüğü string'in de .dup ile kopyalanması gerekir çünkü okunan her satır perde arkasında aynı string'e yazılır.

Ali

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

Merhaba,

Zombi olmuş bir başlığı tekrar hortlattığım için kusura bakmayın. Bütün çabam InputRange işlevlerini (_r.back; _r.front; _r.empty; _r.popBack():void; _r.popFront():void;) daha iyi anlamak ve anlatmak. Bunun için bugün Çift Yönlü ve Erişimli Aralık döndüren bir yığıt yaptım. Bunu zaten geçmişte TriBit başlığı ile gerçeklemiştim. Tabi orada özel bir bool veri türü kullanıyordum: https://forum.dlang.org/post/1030.8280@ddili.org

Aşağıdaki kodun türü, foreach_reverse()'ü kullanarak FIFO mantığı ile çalışan bir yığıt. Aynı şekilde true parametresi gönderilmezse geleneksel LIFO (Son Giren İlk Çıkar) işletiliyor. Çıktısı, sırasıyla 2 kere ACGT ve tersi 2 kere TGCA yazmak :)

Tabi çıktının yarısında while(!empty) kullanılmasını ve InputRange ile mükemmel uyumlu olmasını dikkatinize sunarım! En önemli fark, foreach() aralığı tüketmezken diğer öyle değil!

/* DNAstack.d by dbey
 * 02.07.2021
 *
 * https://github.com/dlang/phobos/pull/4010
 *
 */
import std.stdio;

enum DNA { A,  // [ 0, 0 ]
           C,  // [ 0, 1 ]
           G,  // [ 1, 0 ]
           T   // [ 1, 1 ]
         }/****** [ L, R ] ******/

struct DNAstack {
  bool FIFO;
  bool[] data;
  size_t index;

  void init (DNA[] customData = [], bool stackType = false )
  {
    FIFO = stackType;
    foreach (dna; customData)
    {
      data ~= this.decode (dna);
    }
    if (FIFO)
    {
      index = 0;
    } else {
        index = data.length/2;
    }
  }

  private bool[] decode (DNA n)
  {
    bool left, right;
    if(n == DNA.G || n == DNA.T) left = true;
    if(n == DNA.C || n == DNA.T) right = true;

    return [ left, right];
  }

  private DNA encode (bool[] code)
  {
    int result;
    if (code[0]) result += 2;
    if (code[1]) result += 1;

    return cast(DNA)result;
  }

  void push (DNA veri) @property
  {
    if(!FIFO) index += 2;
    data ~= this.decode(veri);
  }

  DNA pop () @property
  {
    bool left, right;
    if(FIFO)
    {
      index += 2;
      left = data[index-2];
      right = data[index-1];
    } else {
      index -= 2;
      left = data[index];
      right = data[index+1];
    }
    return encode([ left, right]);
  }

  void popBack () @property
  {
    index += 2;
  }

  DNA back () @property
  {
    auto left = data[index];
    auto right = data[index+1];
    return encode([ left, right]);
  }

  void popFront () @property
  {
    index -= 2;
  }

  DNA front () @property
  {
    auto left = data[index-2];
    auto right = data[index-1];
    return encode([ left, right]);
  }

  bool empty () @property
  {
    if(FIFO) {
      return index == data.length ;
    } else {
      return index == 0;
    }
  }
}

void main()
{
  DNAstack s;
  with(DNA)
  {
    s.init(     [A, C, G, T], true     );

    foreach_reverse(n; s) n.write;
    writeln(": ", s.index);

    while(!s.empty) s.pop.write;
    writeln(": ", s.index);

    s.init(     [A, C, G, T]           );

    foreach(n; s) n.write;
    writeln(": ", s.index);

    while(!s.empty) s.pop.write;
    writeln(": ", s.index);
  }
} /* ÇIKTISI:
rdmd DNAstack.d

ACGT: 0
ACGT: 8
TGCA: 8
TGCA: 0

https://tour.dlang.org/ */

Başarılar...

On Friday, 2 July 2021 at 21:54:10 UTC, Ali Çehreli wrote:

Dlang Community içinde bir DM sistemi mi var?

Açtım: https://forum.dlang.org/post/zsxlwlqwbkwkysdbzckw@forum.dlang.org

ve...

Bu sefer Rosalind Project ile ilişkilendirdim. Çünkü şaşırtıcı şekilde, sadece bir invertData()'a sayesinde ilgili soruyu çözebilme yeteneği olduğunu fark ettim. Eminim, sitedeki diğer birçok soru bu şekilde çözülebilir! Boş bir vakitte XP almak için deneyeceğim...

Maalesef yabancı dildeki bu terimleri karıştırıyorum. Benim için front neyse back de aynı kefede. Sadece foreach'in diğer türüyle de uyumlu şekilde kullanabildiğimi görmek beni heyecanlandırıyor. Ekstra olanaklar olsa iyi olur mu diye o tartışmaya girmiyorum; zaten şurada yeterince tartışılmış ve evet, Andrei'ye hak veriyorum:

https://github.com/dlang/phobos/pull/4010
(Kapanmış ve başka hata ile ilişkilendirilmiş konu!

Aslında foreach(), bu BidirectionalRange'i kullanırken yapının bir kopyasını alması ve topluluğun üyelerini kullanıp orijinaline dokunmaması benim için yeterli. Dilim kullanmak konusuna gelince: Evet, daha sık kullanmalıyım...

Kesinlikle haklısın hocam! Bu konuda FIFO_is() @property'si ile sayenizde yeni bir yaklaşım ürettim. Çünkü benim için daha anlaşılır: FIFO, true değilse o koşula girilmez veya false olarak işaretliyse LIFO olarak çalışacaktır:

      public void FIFO_is (bool FIFO) @property {
        this.FIFO = FIFO;
        if (FIFO) this.index = 0;
      }

Nasıl çözüm?

Kesinlikle hayır! Çünkü odak noktamda anlaşılma kolaylığı ve etkili öğrenme hızı var. Ama bir gün, BitArray ile benzer yüklemeleri (opOpAssign) icra edersem birebir hız karşılaştırması yapmak istiyorum; özellikle kendi geliştirdiğim BitDerle sınıfı ile...

Evet, hatırlatınca denedim. Sadece 3 satırı (biri tanımlandığı yapının başı) değiştirerek kolayca kullanılabildiğini gördüm. Özellikle gerçek DNA transkriptleri (büyük yapılarda GB'larca veri) ile bir deneme yapmak zorlayıcı bir örnek olabilir.

Örneğin, sevgili Damla'nın ilgisini çekebilecek Mitokondriyal DNA (mtDNA)'dan kısa bir dizi (1859 byte):

ACADS (NM_000017.4): https://www.ncbi.nlm.nih.gov/nuccore/1518494109/

Şimdiki gelişen nesil, programlama dillerini kullanarak bu veriler üzerinde çalışma yapıyorlar. Sanırım daha çok Python kullanılıyor ama D'yi düşünsünler derim!

     index = data.length/2;

O nereden geldi! Sanırım hızlıca kod geliştirmekten kaynaklı. Tekrar düzenlediğimde 2 katını aldığımı fark ettim. Demek ki kafamda bir şeyler karışmış olacak :)

S.Dinçer

Merhaba Ali hocam,

Aslında bu soru senin çünkü kitaptaki şu örnekten yola çıkmış; "InputRange example" başlığı....

On Thursday, 4 August 2022 at 13:08:21 UTC, pascal111 wrote:

Aktif Başlık:
https://forum.dlang.org/post/pmjvguvrswlzqrgyusoo@forum.dlang.org

Aslında cevap belli de yıllar geçse de hala aralıkları anlamak için çabalayan insanlar var 😀

Bir köşede dursun.

Sevgiler...