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

Aslında tam yeni değil: eski "Dilimler ve Aralıklar" dersinin genişletilmiş hali...

Ali

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

Çok güzel olmuş. Bu arada eşleme tablosuda genişletilmeli. Onuda belki ilk ben genişletmeyi denerim. Ancak bunu en erken yarından sonraki gün yapabilirim.

Bu arada notlar aldım:

Alıntı:

Ben destekliyor sanıyordum ancak denedim desteklemiyor. Ancak belki bile bile desteklenmiyor olabilir mi? Çünkü dinamik dizide kullanılacak ise kullanılan dizilerin uzunluklarının eşit olması ve sağında eşlenen dizininde eşit olması gerekir yoksa range violation hatası almamıza neden olmaz mı? Belki programcı uzunlukla uğraşıp hata yapmasın diye eklenmiyordur?

Derste "Uzunluğun artması paylaşımı sonlandırır" denmiş ve bir örnek verilmiş:

import std.stdio;

void main()
{
   int[] dizi = [ 1, 3, 5, 7, 9, 11, 13, 15 ];
   int[] yarısı = dizi[0 .. $ / 2];
   int[] çeyreği = dizi[0 .. $ / 4];

   çeyreği[1] = 0;

   writeln(çeyreği);
   writeln(yarısı);
   writeln(dizi);
}

Ancak uzunluğun azaltılmasıda paylaşımı sonlandırmaz mı? Eğer öyle olursa "Uzunluğun değişmesi paylaşımı sonlandırır." denmesi daha doğru olur.

Azalmaya örnek:

import std.stdio;

void main()
{
   int[] dizi = [ 1, 3, 5, 7, 9, 11, 13, 15 ];
   int[] yarısı = dizi[0 .. $ / 2];
   int[] çeyreği = dizi[0 .. $ / 4];
   dizi.length=dizi.length-4;
   çeyreği[1] = 0;

   writeln(çeyreği);
   writeln(yarısı);
   writeln(dizi);
}

Bu arada array-wise hakkında düşündüklerimi paylaşacağım bir yazı yazmak istiyorum. Onun üzerinde tartışarak bence array-wise'in kullanılmamasını düşünebiliriz. Eğer yazacağım yazıya bende inanırsam paylaşırım. Yoksa rezil olmamak için paylaşmam. :-D

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

Alıntı:

Kasten bende öyle isterim :-)

Bence büyütülmesi gereken alanlar:

• çok boyutlu diziler gibi çok boyutlu eşleme tabloları tanımlama öğreten bir paragraf eklenmeli.
• göstergelerden sonra eşleme tablosundaki in gerçeğini anlatmadınız diye hatırlıyorum ve anlatmanız gerektiğini düşünüyorum.
• birde şuan o kadar aramama rağmen bulamadığım getValue mi ne öyle işlemleri tanıtan yazı yazılması gerekiyor. şimdi buldum bu konu: http://ddili.org/forum/thread/320 eklenmesi gerekiyor.

(eşleme tablosu doğru bir kullanım mı?)

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

Alıntı (acehreli):

Ancak uzunluğun azaltılmasıda paylaşımı sonlandırmaz mı?

Ben eğer dizinin uzunluğu azaltılırsa arttırıldığı gibi yine paylaşımı sonlandırır bunu eklemek gerek diye düşünnmüştüm. Örneğin okuyan kişi bak uzunluk arttırılınca paylaşım sonlandırılıyormuş ancak azaltma hakkında bir şey söylememiş acaba paylaşım sonlanır mı sonlanmaz mı diye sormasın diye dedim. Daha da kötüsü benim sizi o mesajı yazarken ki gibi yok acaba sadece arttırınca paylaşım sonlanıyor azaltınca bir şey olmuyor halen dilimi olarak kalıyor demesin diye söylemek istedim.

Alıntı (acehreli):

Bu arada array-wise hakkında düşündüklerimi paylaşacağım bir yazı yazmak istiyorum.

Böyle deyince heyecanlandım :-) Ben sadece konu hakkında ortak fikir oluşturmak adına dedim. Eğer en azından oraya konmasa bile bir makale tarzında olacaksa array-wiseleri iyice bir inceleyerek konuşmak gerekir.

Ben array-wise e diğerlerinin farklarını şöyle bir kod deneyerek inceledim:

import std.stdio;

void main()
{
/* int[] dizi = [ 1, 3, 5, 7, 9, 11, 13, 15 ];
   int[] yarısı = dizi[0 .. $ / 2];
   int[] çeyreği = dizi[0 .. $ / 4];
   dizi.length=dizi.length-4;
   çeyreği[10] = 0;

   writeln(çeyreği);
   writeln(yarısı);
   writeln(dizi);*/
   double[] dilim1 = [ 1, 1, 1 ];
   double[] dilim2 = [ 2, 2, 2 ];
   double[] dilim3 = [ 3, 3, 3 ];

   dilim2 = dilim1;              // (1)  dilim2'yi dilim1'in referansı yapıyor.
   dilim3[] = dilim1;            // (2)  dilim3'ü dilim1'in referansı yapmıyor. .dup ile
   //aynı işe yarıyor.
   //dilim3[] = dilim1; yerine dilim3[] = dilim1[]; kullanımını anlamca daha doğru
   //buluyorum.
   //çünkü dilim1 dediğimizde aklımıza dilim1'in bellek adresi ve eleman sayısı
   //aklıma geliyor.
   //ancak dilim[]1 dediğimizde foreach'te kullanmışızcasına
   //tek tek elemanları eriştiğimizi anlatıyor.

   dilim1[2] = 54; //Tek tek atarsak eleman değişiyor. dilim2 dilim1'in referansı

   writeln("dilim1: ", dilim1);
   writeln("dilim2: ", dilim2);
   writeln("dilim3: ", dilim3);
   dilim1[1..3]=[27,32]; //aralık belirterek atarsak elemanyine değişiyor.
   //dilim2 dilim1'in referansı

   writeln("dilim1: ", dilim1);
   writeln("dilim2: ", dilim2);
   writeln("dilim3: ", dilim3);

   dilim1[0..3]=[22,27,32];//aralıkta tüm elemanları belirterek atarsak eleman
   //yine değişiyor. dilim2 dilim1'in referansı

   writeln("dilim1: ", dilim1);
   writeln("dilim2: ", dilim2);
   writeln("dilim3: ", dilim3);

   dilim1[]=[66,55,55];//yine dilim2 dilim1'in referansı. Ama(1) numaralı yerde tam
   //zıttına referans olmamasını
   //sağlamıştı. Burada ise referans olmasını sağladı.
   writeln("dilim1: ", dilim1);
   writeln("dilim2: ", dilim2);
   writeln("dilim3: ", dilim3);

   dilim1=[97,100,100];//artık dilim2 dilim1'in referansı değil. Ama(2) numaralı yerde
   //tam zıttına referans olmasını
   //sağlamıştı. Burada ise referans olmamasını sağladı.
   writeln("dilim1: ", dilim1);
   writeln("dilim2: ", dilim2);
   writeln("dilim3: ", dilim3);

}

Ve şu önermeleri savundum:

Bu kod üzerinde [] kullanımın anlamı açık olsa bile ne yapacağını bilemezsek veya karıştırırsak programımızın hatasının nerede olduğunu bulunması zor bir durumda kalacağımızı söylemek istiyorum.

Örneğin kodun bu satırında "dilim1[]=[66,55,55];"referans olmasını sağlıyor.
ancak "dilim1=[97,100,100];" burada ise referans olmamasını sağlıyor.

Ancak kodun ilk başlarında ise tam zıttını sağlıyordu. Tasarımı belki hatasız mantıklı ayrıca kolaylaştırıcı. Ancak her durumda farklı sonuçlar çıkarması kafamızı karıştıracaktır ve programımızı hatalara sürükleyecektir. Ayrıca programımızın kodlarını değiştirdiğimizde örneğin referans olmasını sağlıyorken artık sağlamıyor olacak. Belki de tam zıttı. Ancak hep beklediğimizden farklı çalışacak.

Eğer yinede kullanılmak istenilirse "dilim1[]=dilim5[]" ve "dilim1[]=dilim5" kullanımın aynı sonuçları doğurduğunu var sayarak ilk kullanımdaki gibi kullanılmasının koddaki anlamın daha rahat anlaşılmasını ve kodun daha kolay anlaşılacağını savunuyorum.

Ancak asla array-wise'ye onun karmaşıklılığı yüzünden ihtiyacımız olmadığını bunu zaten foreach anlaşılabilir bir biçimde kolayca açıkça ve belki biraz uzunca kodlanabileceğini söylüyorum. Array-wise ile yapmak istediğimiz her şey foreachle yapılır. Örn andreinin kitabından:

auto a = [1.0, 2.5, 3.6];
auto b = [4.5, 5.5, 1.4];
auto c = new double[3];

array wish ile

c[] += 4 * a[] + b[];

aynı biçimde ne yaptığımızı daha açık bir biçimde göstererek:

foreach (i; 0..length) {
   c[i] += 4 * a[i] + b[i];
}

array-wise ile ilgili bir uyarıda andreinin kitabında var onuda eklerim. Ayrıca şunu örnek olarak eklerim(Ali Bey'in diziler konsunun dershane problemindeki çözümü. bunu foreach ile yazıp hadi bunu array-wise ile yazın deyip çok çok güçlü bir olanak olmadığını gösteririm.(Sanırım andreinin uyarısıda bu döngüler ile ilgili idi.)):

import std.stdio;
import std.cstream;

void main()
{
   double[] dizi = [ 1, 20, 2, 30, 7, 11 ];

   double[] dilim = dizi;     // dizinin bütün elemanlarına
                              // erişim sağlayan bir dilimle
                              // başlıyoruz

   while (dilim.length) {     // o dilimde eleman olduğu
                              // sürece ...

       if (dilim[0] > 10) {   // yalnızca ilk elemanla
           dilim[0] /= 2;     // ilgileniyoruz
       }

       dilim = dilim[1 .. $]; // dilimi başından kısaltıyoruz
   }

   writeln(dizi);             // asıl dizi değişmiş oluyor
}

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

Alıntı:

Teşekkürler. Bende onu demek istemiştim. orada eşleme sözcüğü geçmediğinden bende eşleme diye aradığımdan dakikalarca konuyu bulamadımda :-)

Doğruymuş bende kendimin neden bu hataya düştüğünü not alayımda bir daha aynı hataya düşmeyeyim.

   int[] dizi = [ 1, 3, 5, 7, 9, 11, 13, 15 ];
   int[] yarısı = dizi[0 .. $ / 2];
   int[] çeyreği = dizi[0 .. $ / 4];
   dizi.length=dizi.length-4;
   çeyreği[1] = 0;
   writeln(çeyreği);
   writeln(yarısı);
   writeln(dizi);

dizi'den elemanlar silindiği halde yarısı dizisinde o elemanlar silinmedi. Bende ondan karıştırmışım. Şimdi açıklamayı buldum. Dizi göstergesindeki eleman silmek sadece elemanların bellekte boş boş oturmalarını sağlıyor. Ancak çeyreği ile yarısı dizisi ise yeni eski alanlarına erişiyor. Ben ise artık kalan dizinin uzunluğuun yarısını alacağını sandım. Yani şöyle bir çıktı bekledim:

[1]
[1, 0]
[1, 0, 5, 7]

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

Teşekkürler :-)

Bu arada rastgele mi yazılacak rasgele mi yazılacak bir kararsızlık yaşıyorsunuz sanırım. Çünkü tdk'nin sözlüğünde rasgele yokken terimler sözlüğünde var. Ancak oraya yine rastgele konulmuş. Bence doğrusu rastgele iken en kestirme yoluda "gelişigüzel" sözcüğünü kullanmak. Ancak her türlü anlaşılır zorlamamak lazım sözcükleri :-)

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

Alıntı (canalpay):

Çok iyi fikir ama diğer tarafları tek kişinin ağzından olunca ikinci yazarın tarzı uymayabilir. Eğer eksiklikleri bilirsem kendi ağzımla yazmak isterim.

Başlardaki dersleri özellikle genel bırakmaya çalışmıştım. Dizilerin iki derse ayrılmış olmasının nedeni de oydu.

Aslında forumun çok daha canlı olacağını da bekliyordum. Yazıdan genel bir şeyler anlaşılmalı ve akla gelen sorular "peki şunu nasıl yaparız" diye forumda sorulmalı. Kendi öğrenme tarzıma en güzel bu yöntem uyuyor.

Alıntı:

O yüzden olduğunu sanmıyorum. Programcının yanlışlıkla dizi dışına taşabileceği başka işlemler de var. Örneğin dizi indekslemek.

Dinamik dizilerin de uzunlukları olduğu için bence işlevsel olarak bir sorun yok. Zaten dmd'nin verdiği hata da bunun yasal olmadığını söylemiyor. Derleyici hatası gibi bir hata veriyor.

Hatta bütün diziyi etkileyen bazı işlemler çalışıyor; bazıları çalışmıyor.

Alıntı:

O zaman çok kısıtlayıcı olurdu. Diziler en azından Andrei'nin aralık (range) kavramına uymamış olurlardı. Oysa dilin temel olanakları olarak dizilerin de aralıkları desteklemeleri çok yararlı.

Burada aklımda olan kullanım, dilimin baş tarafından kısaltılarak ilerletilmesi. (Yani std.array modülünde tanımlanan popFront()'un kullanımı.)

Ve uzunluğu değiştikçe bütün elemanların kopyalanmaları da yavaşlık getirirdi.

Alıntı:

Makaleler bölümüne koyalım. :)

Ben daha önce konuştuğumuz tehlikeli durumu digitalmars.D forumunda da sordum:

http://thread.gmane.org/gmane.comp.lang.d.general/48828

Tabii ki oranın en verimli kişisi olan bearophile tarafından daha önce dile getirilmiş ve hangi kullanımların yasal olmalarının mantıklı olduğu küçük tablolarda irdelenmiş:

http://d.puremagic.com/issues/show_bug.cgi?id=3971

Ali

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

Alıntı (canalpay):

Tamam: böylece her türün kullanılabildiği pekiştirilmiş olur.

Alıntı:

Göstergeler dersine eklemişim. "Eşleme tablolarının in işleci" başlığı altında:

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

Alıntı:

Tamam; eklenebilir.

Aslında dizileri anlatırken std.array'i de gözardı etmiştim. Onda da bazı yararlı olanaklar var ama onu forum sohbetlerine bırakacağım. :)

Alıntı:

Eğer "erişim tablosu" demek istediysen; hayır, doğru değil. :) O konuyu şimdi "eşleme tablosu" olarak düzelttim.

Ali

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

Alıntı (canalpay):

O doğru işte: uzunluk arttırılınca paylaşım sonlanır ama azaltılınca sonlanmaz. Tamam, bunun böyle olduğunu daha açık ifade edeceğim.

void main()
{
   int[] a = [ 1, 11, 111 ];
   int[] d = a;

   assert(&d[0] == &a[0]);  // başları aynı

   d = d[1 .. $];           // başından kısalınca
   assert(&d[0] == &a[1]);  // 0, 1'e denk geliyor

   d = d[0 .. $ - 1];       // sonundan kısalınca da ...
   assert(&d[0] == &a[1]);  // ... paylaşım devam ediyor

   // Bir de .length'i değiştirerek deneyelim

   d = a;                   // yeniden başlıyoruz
   --d.length;              // sonundan kısalttık
   assert(&d[0] == &a[0]);  // paylaşım devam ediyor

   d.length = d.length - 1; // yine sonundan kısalttık
   assert(&d[0] == &a[0]);  // paylaşım yine devam ediyor
}

Ali

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

Alıntı (canalpay):

Doğru. O elemanların sahibi çöp toplayıcısı. Ancak o, başka erişim sağlayan kalmadığını bildiği zaman o elemanların bellekteki yerlerini başka işler için kullanıyor.

Ben o yüzden dilimlerin kendi elemanları olmadığı kavramının altını çizmeye çalışıyorum. Şunun bile kendi elemanları yok:

   int[] a = [ 1, 11, 111 ];

a, çöp toplayıcının sahip olduğu elemanlara erişim sağlayan tek dilim ama kendisi sahip değil.

Ali

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