Bu yazının amacı, bilgisayar programlama dillerinde kullanılan bir yaklaşım olan geri çağırım (call back) kavramını açıklamaktır.

Bir programlama dilinin, yapısal programlama dili (structured programming language) olabilmesi için aşağıdaki üç özelliğe haiz olması gerekir:

• Kod bloğunun koşula bağlı olabilmesi : Klasik programlama dillerindeki if/else yapısı
• Kod bloğunun tekrar ettirilebilir olması : Klasik programlama dillerindeki döngü (loop) yapısı
• Kod bloğunun parametrize edilebilir olması: Klasik programlama dillerindeki fonksiyon (function) yapısı

Yukarıdaki bu üç özelliği günümüz programlama dillerinin hemen hepsi bünyelerinde barındırmaktadır ve günümüzdeki çoğu dil, yapısal programlama dili olma özelliğini taşır.

Geri çağırım ismi verilen özellik ise, yukarıdaki özelliklerden üçüncüsünün parametre olarak bir kod bloğunu alabilmesidir. Diğer bir deyişle, çalıştırılacak olan kod bloğunun, parametre olarak basit sayılar veya değişkenler yerine, farklı bir kod bloğunu alması ve bu kod bloğunu çalıştırması, hatta diğer iki özelliği de kullanarak, alınan parametredeki kod bloklarını tekrar etmesi veya koşullu olarak sçmesi anlamına gelir

Geri çağırım özelliği (call back), bir programlama dilinde, aşağıdakine benzer bir yapı kazandırır:

Yukarıdaki temsili resimde, klasik bir geri çağırımda, bir ana fonksiyonun (örneğin C gibi dillerdeki main fonksiyonu olabilir), herhangi bir kütüphanede bulunan fonksiyonu çağırması ve ardından bu kütüphanenin de ana programdaki bir fonksiyonu geri çağırması ifade edilmiştir.

Bu gösterimden anlaşıldığı üzere kütüphane fonksiyonu, basitçe kendisine gelen çağırımı, ana programdan aldığı bir parametreye geri yönlendirmektedir. Bu kullanım ise C gibi dillerde ancak fonksiyon göstericisi (function pointer) yapısı ile mümkündür. Yani gelen bir çağrının, ana programdaki hangi fonksiyona yönlendirileceği (geri çağrılacağı , callback), gelen kütüphane fonksiyonuna verilmiş bir parametre olan ikinci bir fonksiyon ile yapılabilir ki bu parametrede ancak ikinci bir fonksiyon olabilir.

Bu durumu örnek bir kod ile anlatmaya çalışalım:

#include <stdio.h>
int func(int);
void PassPtr(int (*pt2Func)(int))
{
   int sonuc = (*pt2Func)(12);
   printf("%d",sonuc);
}

main(){
      int (*fp)(int);
      fp = func;
      PassPtr(fp);

}
int
func(int arg){
     return ++arg;
}

Yukarıdaki kodda bulunan main fonksiyonu, öncelikle fp isminde bir fonksiyon göstericisi tanımlamış ve bu fonksiyon göstericisini, PassPtr ismi verilen fonkisyona parametre olarak geçirmiştir. Yukarıdaki yapıda, PassPtr isimli fonkisyon, daha alt seviyede olan bir kütüphane fonksiyonu ve func ismi verilen ve main fonkisyonunda fp isimli gösterici ile ifade edilen fonksiyon ise geri çağırım yapılan fonksiyon olarak düşünülebilir.

Bu durumda, bizim tasarım yapımız aşağıdaki şekilde görülebilir

Yukarıdaki yaklaşımın faydası, bize alt seviye fonksiyonunun hiç bilgisi olmadan üst seviyedeki herhangi bir fonksiyona geri dönüş imkanı vermesidir. Bu anlamada, programda soyutlama (abstraction) yakalanmasında veya geçirilen parametreler sayesinde bilgi gizlenmesi (inforation hiding) özelliği kazandırmaktadır.

Özet olarak geri çağırım özelliği, bir programlama yaklaşımında kullanılan tasarım yöntemlerinden birisidir ve nesne yönelimli olmayan programlama dillerinde, yukarıda bahsedilen durumlarda sıklıkla kullanılan bir çözümdür. Nesne yönelimli programlama dillerinin gelişimi ile birlikte, tasarım kalıpları (design patterns) önem kazanmış ve bu kalıplardan gözlemci kalıbı (observer patter) yukarıda açıklanan özelliklerin tamamını bir nesne yönelimli programlama dilinde çözmeye yöenlik olarak programcıların hizmetine sunulmuştur.

174 views

Özellikle bilgisayar programlama dillerinde kullanılan bir terimdir. Buna göre dillerde bulunan özelliklerin birbirine dik olması, yani birbirinden bağımsız olması kast edilir. Kelime olarak, yöneylerin (vectors) dikliğinden esinlenilmiştir. Vektörlerin birbirine dik olması, aralarında ilişki bulunmaması (birbirine iz düşümünün sıfır olması) anlamına gelmektedir. Şayet bir dilde bulunan özellikler arasında da ilişki bulunmuyorsa, dilin özelliklerinin genişlemiş olduğu düşünülebilir.

Örneğin değişken tipleri olarak tamsayı (integer) ve küsurlu sayının (float) bulunduğu bir dil ve işlem(operator) olarak dizi (array) ve işaretçi (pointer) bulunduğu bir dili ele alalım. Bu dildeki 2 değişken tipi ve iki işlem şekli, şayet kaime arz ediyorsa, bu durumda bir işaretçi, tamsayı veya küsurlu sayıyı gösterebilmektedir. Benzer şekilde dizinin elemanları işaretçi olabilmekte ve işaretçi de diziye işaret edebilmektedir.

Şayet dilde, kaime bulunmasaydı, örneğin dizi işlemi, sadece küsurlu sayılar üzerinde çalışıyor olsaydı, bu durumda dildeki esneklik büyük ölçüde kaybedilmiş olacak ve örneğin tam sayı dizisi bulunmayacağı gibi, tam sayı dizisine işaret eden bir işaretçi veya her elemanı işaretçi olan bir tamsayı dizisi de kullanılamayacaktı.

C dilinde toplama işlemi (+) bulunmakta ve lisan-ı kaime gereği mümkün olduğunca değişken yapısından bağımsız tutulmaktadır.

Örneğin,

a+b şeklindeki bir işlemde, C dili, a ve b değişken değerlerini alıp hafızaya yükledikten sonra toplama işlemini yine hafızada tutmaktadır.

Yukarıdaki bu örnekte, a ve b değerleri, herhangi bir değişken tipinde olabilir. Örneğin tam sayı (int) veya karakter (char) yapısında olmasının bir mahsuru yoktur.

Ayrıca yukarıdaki a ve b değerleri birer işaretçi (pointer) da olabilir.

Örneğin;

int *a ;
int x[10];
a = x;
int b = 4;
a = a + b;

şeklindeki kodun anlamı, a işaretçisinin gösterdiği mevcut yerin 4 sonraki adresini göstermesidir. Buna göre, x dizisinin 4. elemanına işaret etmektedir. Yukarıdaki bu özellik, C dilinde bulunan ve işaretçi ile dizi ve değişken tipleri arasında bulunan diklik özelliğine istinat edilebilir.

Bir dilde diklik özelliğinin fazla olması, dildeki kodlamayı kolaylaştırır ve dilin öğrenilmesini basit hale getirir. Örneğin işaretçi kullanmayı öğrenen birisi yukarıdaki bu işlemleri ilave bir kural öğrenmeksizin kodlayabilir. Şayet diklik özelliği az olsaydı, bu durumda dili öğrenen veya kodlayan kişilerin istisna kurallarını da öğrenmesi gerekecekti. Örneğin ingilizce öğrenen birisi, fiillerin sonuna –ed eki getirerek geçmiş zaman yapılacağını öğrenir, ancak bunun istisnası olan kelimeleri de öğrenmek zorundadır. Şayet istisnası hiç olmasaydı, dili öğrenmek ve kullanmak çok daha kolay olacaktı.

Bir dildeki diklik özelliğinin çok fazla olması da sakıncalıdır. Aşırı derecede diklik içerilmesi halinde, dili çalıştıracak bir derleyicinin (compiler) geliştirilmesi imkansızlaştığı gibi kodu kullanan kişilerinde hata yapma ihtimali artar.

Örneğin C dilinde iki tip veri birliktelik ilişkisi bulunmaktadır (data associativity). Bunlar diziler (array) ve kayıtlardır (records, C dilinde özel olarak yapı (struct) ismi ile geçer). C dilinde bulunan fonksiyonlar, iki tipte de parametre alırken, sadece kayıt tipinde veri döndürebilmektedir. Dizi tipinde döndürmesi mümkün değildir. Bu durum dilin diklik özelliğine uymadığı gibi, dilde bulunan bu özelliklere de diklik eklenmesi halinde, hafıza yönetimi (Dizi boyutunun kestirilmesi) ve hafızanın ihalili gibi pek çok problemi, kodu yazan kişinin kontrol etmesi gerekecekti. Çözüm olarak, C dilinin tasarımı sırasında, bu özelliklere diklik getirilmemiştir.

211 views

Bilgisayar bilimlerinde, özellikle özyineli (recursive) problemlerde, problemin bir kısmının tekrar edilmesi durumudur. Örneğin, klasik bir problem olan fibonacci sayıları örneğinde, örtüşen altproblem bulunmaktadır.

Fibonacci serisinin 4. terimini hesaplamak isteyelim ve bunun için aşağıdaki fonksiyonu yazmış olalım:

Matematiksel olarak : fib(0) = 1, fib(1) = 1 ve fib(n) = fib(n-1)+fib(n-2)

Programlama dillerinde:

fib(int n){
   if(n==0||n==1)
      return 1;
   return fib(n-1)+fib(n-2);
}

Yukarıdaki bu fonksiyonun çalışması sırasında çağırdığı alt fonksiyonları bir ağaç şeklinde çizecek olursak:

Yukarıdaki ağaçta, görüldüğü üzere, bazı terimler birden fazla kere hesaplanmaktadır. Örneğin fib(2) fonksiyonu, hem fib(4) hesaplanırken, hem de fib(3) hesaplanırken hesaplanmaktadır. Bu anlamda, problemin bir alt grubunun (subproblem) örtüştüğünden (overlap) bahsedebiliriz. Genelde bu tip örtüşmelerde, hız kazandırmak ve problemin sadece bir kere çözülmesini saplamak için dinamik programlama (dynamic programming) yöntemi kullanılır.

192 views

Yazan : Şadi Evren ŞEKER

Bilgisayar bilimleri de dahil olmak üzere pek çok mühendislik ve istatistiksel uygulamada kullanılan bir dağılımdır. İsmini, kendi olasılık teorisini yayınlayan Sim`eon Denis Poisson’un soy isminden almaktadır ve Türkçede, “pvasson” kelimesinin okunması şeklinde telaffuz edilmektedir. (neden bilmiyorum ama ben de dahil pek çok kişi bilmeden bu dağılımı İngilizcedeki “poison” gibi telaffuz etmekte ısrar ediyoruz, oysaki kelime Fransızca )

İlginç bir şekilde doğal olaylardaki dağılımlar oluşturulduğunda Poisson dağılımına yakın karakterde çıkmaktadır. Örneğin bir telefon santraline dakikada gelen aramaların dağılımı, bir web sunucusunda yapılan dakika başına sayfa talepleri veya sabit bir radyasyon altında bir DNA diziliminde meydana gelen mutasyon sayıları gibi değerlerin dağılımı hep Poisson dağılımına uymaktadır.

Karakteristik denklemi ile hesaplanmaktadır. Formüldeki k, gerçekleşen olayların sayısını λ i se beklenen değeri (expected value) vermektedir .

Yukarıdaki şekilde farklı λ değerleri için çizilmiş farklı dağılım grafikleri görülmektedir. (şekildeki yatay eksen k değerlerini ifade etmektedir).

Yukarıda verdiğimiz fonksiyonu C dilinde kodlayalım:

Poisson dağılımı yukarıdaki kodda görüldüğü üzere basit bir fonksiyon ile hesaplanabilir. Bu fonksiyondaki e değeri kabulü yine kodda verilmiştir, hassasiyeti arttırmak için hane sayısı arttırılabilir.

Yukarıdaki kodun ekran çıktısı aşağıda verilmiştir:

Yukarıdaki değerleri grafik üzerine yerleştirecek olursak:

Şekilde görüldüğü üzere dağılım fonksiyonu, yazının başında verilen dağılım şeklindedir. 

450 views

Yazan : Şadi Evren ŞEKER

Bu yazının amacı, bilgisayar bilimlerinde, çeşitli konularda geçen normal dağılımı anlatmaktır. Literatürde, normal dağılım (normal distribution) veya Gauss dağılımı (Gauss distribution) olarak da geçen konu kabaca çan eğrisi olarak tanımlanabilir (bell curve).

Yukarıdaki şekil, normal dağılımın grafiğidir ve aşağıdaki formülle hesaplanır (Gauss fonksiyonu):

Yukarıdaki formül, aynı zamanda gauss dağılımının, olasılık yoğunluk fonksiyonu (probability dense function, pdf) olarak geçmektedir. Formülde kullanılan ve çan eğrisinin şeklini belirleyen en önemli değişken σ değeridir. Bu değer dağılımın üzerinde uygulandığı olasılıksal sürecin (stochastic process) veya topluluğun (population) standart sapmasıdır (standard deviation). Dikkat edilirse formülde kullanıldığı iki yerde de karesi alınmıştır. Bu anlamda değişme (varyans, variance) değeri olarak kabul edilebilir (E = σ ² olduğunu hatırlayınız).

Ayrıca formülümüzde bulunan μ değeri, ortalama değerdir (mean) ve çan eğrisinin tepe noktasının hangi x değeri için olduğunu belirler. Örneğin yukarıdaki şekilde 3.6 noktasında tepe yapmıştır. Bu durumda μ=3.6 olmuş denilebilir.

Bütün dağılım fonksiyonlarının ortak özelliği olarak, çizilen eğrinin altında kalan alanın toplam değeri 1 olmalıdır (olasılıkların toplamının 1 olduğunu hatırlayınız).

Bu değerleri hesaplayan programı C++ dilinde yazmaya çalışalım:

Kodda basitçe anlatılan fonksiyon kodlanmıştır. Fonksiyonu kodlarken math.h kütüphanesinden faydalandık ve PI ve e sabitlerini kodda görüldüğü şekilde tanımladık. Hassas sonuçlar için bu değerler daha hassas hale getirilebilir.

Kodun çalışan hali aşağıdaki şekildedir:

Yukarıdaki kod üç değer almaktadır. Buna göre hesaplanması istenen x, dağılımın ortalama değeri ve standart sapması girilmelidir. Dağılımın nasıl bir yapıda olduğunu görebilmek için bir döngü halinde bazı değerleri hesaplatalım:

Yukarıdaki kodda, bir döngü içerisinde x=3.2 ile 4.0 arasındaki değerleri otomatik olarak hesaplatıyoruz. Kodun çıktısı aşağıdaki şekildedir:

Yukarıdaki sonuçlardan anlaşılacağı üzere değerler bir çan eğrisi şeklinde yükselip 3.6 değerinde tepe yaptıktan sonra tekrar alçalmaktadır. Bu durumu, yukarıdaki değerleri, aşağıdaki şekilde işaretleyerek göstermeye çalışalım:

Yukarıdaki şekilde kesikli olarak (discrete) elde edilen sonuç bir gauss dağılımıdır ve yazının başında verilen grafiğin kodlanarak ulaşılmış halidir. Grafiği daha iyi görebilmek için daha sık aralıklar verilerek deneme yapılabilir.

Ayrıca konunun bilgisayar bilimleri ile ilgili bir uygulaması için, resim işleme (image processing) konusunda kullanılan düzleştirme filitresi (gauss filter) başlıklı yazıyı okuyabilirsiniz.

519 views

Yazan : Şadi Evren ŞEKER

İyileştirme problemleri açısından klasik bir örnektir (optimisation problems). Problem basitçe bir kutunun içerisine en az boş alan bırakarak, eşyaların en iyi şekilde nasıl yerleştireceği olarak düşünülebilir.

Aslında problemi boyutlara göre incelersek aşağıdaki şekilde bir liste yapılabilir:

Tek boyutlu kutulama (1D bin packing) :Bu problemde amaç bir çizgi veya hat gibi görülebilecek yapının içerisine farklı boyutlardaki çizgileri yerleştirmek olarak düşünülebilir.

Örneğin zaman çizelgelemesinde, bir kişinin yapacağı işleri, zaman çizgisinin üzerine yerleştirmesi (ve her işin farklı miktarda zaman gerektirdiğini ve kişinin çalışma saatlerinin sınırlı olduğunu düşünürsek en fazla işi en az zamanda (örneğin 8 saatlik mesailer içinde) yapması ) bir problemdir. Buradaki hem kişinin yapacağı işler hem de bu işlerin yerleştirileceği zaman çizgisi tek boyutludur.

Daha basit olması açısından örneğin 100m uzunluğundaki bir ipi 7 ve 9m uzunluğundaki parçalara en az fire ile bölmek istiyoruz, en verimli bölme işleminde kaç adet 7 ve kaç adet 9 uzunluğunda ipimiz olur gibi soruları düşünebiliriz. Bu tip sorular tek boyutlu kutulama problemleridir.

İki boyutlu kutulama problemleri (2D bin packing optimization): Bu grupta bir tablodan ve iki boyuttan bahsedilebilir. Örneğin kot pantolon üreten bir tekstil firmasında farklı boyutlardaki Pantolon kalıplarının en az fire ile 5x5m büyüklüğündeki bir kare kumaştan kesilmesi isteniyor olsun. Bu problem iki boyutlu (x ve y boyutları) bir kutulama problemidir. Benzer bir problem, bir gazetedeki seri ilanların, en az fire ile sayfaya yerleştirilmesi olarak da düşünülebilir.

3 boyutlu kutulama (3D bin packing) problemin en zor şekli olarak tanımlanır ve 3 boyutlu bir kutunun içerisine konulan her şeklin farklı x,y ve z boyutlarında şekiller olması olarak düşünülebilir. Problemin genel tanımını yaptığımız için belirteyim, örneğin ev taşıma sırasında çıkan eşyaların kutulanması olarak düşünebilirsiniz. Bu durumu daha da karmaşık yapmaktadır çünkü kutular farklı boyut ve şekillerdedir (örneğin silindir bir varil veya küp veya dikdörtgenler prizması gibi kutuların içerisine yerleştirme yapılmakta) ve kutulanan şekillerde farklıdır ve hatta girintilidir (concave , non-convex) (örneğin avize, koltuk, sandalye gibi birbirinin içine girebilen nesneleri düşününüz). 2 ve 3 boyutlu paketleme, paketlenen nesnelerin girintili olup olmamasına göre ikiye ayrılmaktadır. Dış bükey nesnelerin paketlenmesi nispeten daha basit bir problemdir. Ancak nesnelerin iç bükey olması halinde problem biraz daha karmaşıklaşır.

Hatta literatürdeki kısıtlı aramalarım sonucunda ulaşabildiğim kadarıyla tam olarak iç bükey nesnelerin paketlenebildiği bir sonuç ne yazık ki bulamadım. Örneğin iki vidanın en verimlim paketlenmesi sırasında vidaların girinti çıkıntılarının üstüste gelmesi gerektiğini tecrübi olarak biliyoruz. N adet vida için bu durum birbirini tekrar eden bir hal alır. Gerçekten farklı boylarda ve adım sıklığında ve çaplarda vidalar verilse bu durumda en verimli paketlemeyi yapabilen bir algoritma henüz görmedim.

Paketlenen nesnelere göre problemin sınıflandırılması:

Paketlenen nesne çeşitlerinin sabit olması ve ön tanımlı olması halinde problem homojen olarak tanımlanır. Örneğin tek boyutlu kutulama probleminin tanımı sırasında verilen ve “100m uzunluğundaki bir ipi 7 ve 9m uzunluğundaki parçalara en az fire ile bölmek” şeklinde geçen örnek bu tip homojen (homogenous) bir yapıdadır. Buna karşılık heterojen bir problemde, paketlenecek nesnelerin tipleri ya tamamen birbirlerinden farklıdır ya da aynı tipte çok az tekrar vardır. Yine tek boyutlu problem örneğinde verilen zaman çizgisi üzerinde farklı uzunluklardaki randevuların yerleştirilmesi bu tiptendir.

Bu anlamda aşağıdaki problemler, kutulama probleminin birer özel hali olarak düşünülebilir:

• kamyon yükleme problemi (truck loading),

• konteyner yükleme problemi (Container loading problem, CLP)

• şerit paketleme problemi (Strip Packing problem, SPP)

Yukarıda, problemin tanımını yaptıktan sonra çözümlere bir göz atalım:

Homojen tek boyutlu problem çözümü

Şayet problem tek boyutlu ise ve homojen nesnelerin paketlenmesi olarak problemin çözülmesi isteniyorsa problem oldukça basit demektir ve basit matematiksel hesaplamalar ile problemi çözebiliriz.

Örneğin tek nesne ve tek paket varsa işlem basitçe paketin nesneye bölümü olarak bulunur (zaten burada zor Bir şey de yok):

Örneğin 100m uzunluğundaki bir ipten kaç tane 5m uzunluğunda ip kesilebilir:

100 / 5 = 20

biraz daha zorlaştırıp ip sayısını 2 çeşide veya 3 çeşide çıkarırsak problem np-tam (np-complete) bir hal alır. Örneğin aşağıdaki kodu inceleyelim:

Kodda görüldüğü üzere bütün ihtimaller denenmektedir. Basitçe herhangi bir k değeri için, k-a ve k-b değerlerini denemekte ve denenen duruma göre a veya b değerini bir arttırmaktadır. Aslında kodumuz basit bir ikili ağaç (binary tree) oluşturmaktadır:

Önce 9 veya 7 ile başlanması ihtimalleri:

Sonra bu ihtimallerin de 7 veya 9 azalma ihtimalleri:

Yukarıda gösterildiği gibi her düğümden yine ikişer ihtimal indirerek bir alt seviyeye geçilebilir. Neticede 0 olana kadar yapılan bir aramadır ve 0 sonucuna birden farklı yoldan ulaşılabilir.

Kodumuz çalıştırıldığında çözüm olarak aşağıdaki sonuçları üretmektedir:

cozum : 7*4 + 9*8

cozum : 7*13 + 9*1

Gerçekten de problemin iki farklı çözümü bulunmaktadır.

Yukarıdaki kod basit bir hesaplama ile, 2′nin üstlerinin toplamı kadar adım hesaplamaktadır.

Bu değer yukarıdaki ağaçtan çıkarılabilir:

ilk düğüm için tek ihtimal 2 ⁰

ikinci seviye için iki ihtimal: 2 ¹

üçüncü seviye için dört ihtimal 2 ²

şeklinde gitmektedir ve örneğin problemimiz üçüncü seviyede çözülseydi (sonuç 0 olsaydı) o zaman karmaşıklığımız bu değerlerin toplamı olacaktı ve 2 ⁰ + 2 ¹ + 2 ² şeklinde hesaplanacaktı.

Bu değer, ikili ağaçlardan bilindiği üzere 2 ⁿ-1 şeklinde hesaplanabilir.

Görüldüğü üzere yukarıdaki algoritma O(2 ⁿ) değerinde bir karmaşıklığa sahiptir ve bu değer bir çok terimli (polynom) değildir yani algoritmanın karmaşıklık sınıfı np-tam (NP-Complete) olarak belirtilebilir. Ayrıca yukarıdaki k değeri için bir çözüm bulunmuştur ancak çözüm bulunamasaydı bu değer k terim için denenecekti. Yani 100 için çözüm yoksa bir yaklaşığı olan 99 için ardından iki yaklaşığı 98 için … Bu işlem hiç çözüm bulunamaması halinde k terim için denenecekti.

Yukarıdaki problem, dinamik programlama (dynamic programming) kullanılarak iyileştirilebilir. Bunun sebebi arama işlemi sırasında bazı sonuçların tekrar etmesidir. Örneğin yukarıdaki ikili ağacı aşağıdaki şekilde çizebiliriz:

Farka dikkat ederseniz, 93 – 9 = 84 ve aynı zamanda 91-7 = 84 olduğu görülür. Bu durumda aslında 84 değeri bir önceki kodda iki farklı durum için aranmaktayken şimdi tek bir durum için aransın istiyoruz. Elbette 84 sadece bir örnektir ve buna bağlı olarak çok sayıda tekrar eden değer bulunmaktadır.

Hesaplanan bu değerleri bir dizi (array) içerisinde tutup tekrar hesaplanmasını engellemek istiyoruz:

Yukarıdaki yeni kodda, bir dizi içerisinde tek döngü ile sonucu hesaplattık. Buna göre algoritmamız iki elemanlı bir diziyi kullanmakta, dizinin 0. elemanları 7lerin sayısını ve 1. elemanları ile 9ların sayısını saymaktadır.

Kodumuz ilk başta 0 için 0 tane 7 ve 0 tane 9 gerektiği gerçeği ile çalışmaya başlıyor. 14-23. satırlar arasındaki döngü basitçe i. terim için i-a ve i-b değerlerine bakıyor. Şayet i. terim için i-a veya i-b değerinde bir çözüm varsa (nereden geldiğini önemsemeksizin) bu çözüme bulduğu koşulu ilave ederek mevcut i değeri için çözümü kaydediyor. Şayet bu iki terim de bulunmuyorsa o zaman bir sonraki i değerine geçiyor.

Ekran çıktısı aşağıdaki şekildedir:

Son 20 satır görülmekle birlikte daha önceki satılar alıntılanmamıştır. Ayrıca son 20 satırda görüldüğü üzere, tamamına ait bir çözüm bulunmaktadır. Örneğin 88 sayısı için 7*10 + 9*2 = 88 sonucuna ulaşılmıştır. En son satırda ise 100 için 7*13 + 9*1 sonucu görülmektedir.

Görüldüğü üzere birden fazla sonuç olsa bile tek bir sonucu görmekteyiz bunun sebebi veri yapısının bir sonuç üretmek üzere tasarlanmış olmasıdır. Elbette daha farklı veri yapıları kullanılarak diğer çözümleri de gösteren sonuçlar elde edilebilir.

Yukarıdaki algoritmanın karmaşıklığı ise bir öncekine göre oldukça iyi sayılabilecek O(n) olarak bulunur. Bunun sebebi dizideki her elemanın üzerinden tek bir kere geçiyor olması ve dolayısıyla tek bir döngünün (koddaki 14-21 satırlar arası) çalışıyor olmasıdır.

569 views

Bu yazının amacı C kütüphanelerinden ctype.h kütüphanesini açıklamaktır. Kütüphane kabaca C dilinde bulunan karakterler (char) üzerinde işlem yapmaya imkan sağlar. Kütüphane ismi de buradan gelmektedir ( char + type = ctype) Amacı bir karakterin tipini algılama veya değiştirmektir. Kütüphane karakterler üzerinde işlem imkanı sağladığı için dizgiler (string) üzerinde yapılan işlemler açısından avantaj sağlar.

Kütüphane herhangi bir C kodunda aşağıdaki şekilde eklenir.

#include <ctype.h>

Eklemenin ardından aşağıdaki fonksiyonlar çağırılabilir:

Örnek olarak klavyeden bir dizgi (string) alan ve bu dizgi içerisindeki büyük harfleri küçüğe ve küçük harfleri büyüğe çeviren kodu aşağıdaki şekilde kodlayabiliriz:

Kodun örnek çıktısı aşağıda verilmiştir:

181 views

Gelen bir soru üzerine, C dilinde bir dosyanın içeriğini tersten ekrana basan kodu yazıp sitede yayınlıyorum.

Öncelikle algoritmamızı inşa edelim.

Ters almak gibi işlemler yapı olarak özyineli (recursive) fonksiyonlara çok uygundur. Genelde stack (yığın) yapısının kullanıldığı özyineli fonksiyonlar bilgiyi tutma ve ters çevirme (son giren ilk çıkar (LIFO) algoritması) için elverişli olurlar. Bu yüzden biz de bir özyineli fonksiyon kullanarak dosyamızdan karakter karakter değerleri okuyacak sonra da bunları ekrana basacağız.

Kodu aşağıda veriyorum:

Kodumuzdaki main fonksiyonu sadece dosyayı açmakta ve sonra ters fonksiyonunu çağırmaktadır. Dosya ters fonksiyonunda işlendikten sonra (ki bu işleme dosyayı tersten basmak olacak) dosya kapatılmakta ve program sonlandırılmaktadır.

Gelelim ters fonksiyonuna. Bu fonksiyon, dosya göstericisini (file pointer) parametre olarak alıp, dosya sonu olup olmadığını kontrol ediyor. Feof fonksiyonu, şayet dosyanın sonuna ulaştıysa, return; satırını çalıştıracak ve dolayısıyla fonksiyondan çıkılacak. Aslında bu durum bizim dosyamızın sonu ve dolayısıyla fonksiyonumuzun sonu ve dolayısıyla özyineleme yığınımızın (recursion stack) sonu olmaktadır.

Fonksiyonun geri kalanında işlem gayet basit bir şekilde fscanf ile dosyadan okumak ve ardından tekrar ters fonksiyonunu çağırmak ve sonra da okunan karakteri ekrana basmak şekline ilerler.

Buradaki kritik nokta, ters fonksiyonunu, ekrana karakter basmadan çağırmaktır. Şayet kodun 11. ve 12. satırları yer değiştirecek olsaydı, yani önce ekrana basıp sonra ters fonksiyonunu çağıracak olsaydık, bu durumda dosyanın içeriği olduğu gibi ekrana basılacaktır. Biz bunun yerine o andaki okunan karakteri bekletiyoruz ve sonraki karakteri basması ve ters çevirmesi için yeniden fonksiyona veriyoruz. Bu işlem dosya sonuna kadar gidiyor. Nihayet dosya sonuna erişilince özyineli yığınımız (recursion stack) toparlanmaya başlıyor ve bu toparlanma sırasında ekrana karakterleri basarak ilerliyor.

Yukarıdaki kod, Dev-CPP ile test edilmiş ve çalışmaktadır. Örneğin girdi.txt dosyası olarak aşağıdaki içerikte bir dosyayı verirsek:

Programın çıktısı aşağıdaki şekilde olur:

533 views

Robert Floyd tarafından tasarlanan bir sayı üçgenidir. Üçgen, her satırda, o satır kadar elemandan oluşan ve ardışık sayma sayılarının satırlara dağıtılması ile şekillenen, sağa yaslı bir dik üçgen olarak tanımlanabilir:

1

2  3

4  5  6

7  8  9 10

11 12 13 14 15

Yukarıdaki şekilde üçgenin ilk 5 satırı görülebilir.

Üçgenin en solundaki sütunda bulunan sayıları listeleyecek olursak:

1, 2, 4, 7, 11 şeklindeki sayılara, merkezi poligon sayıları ismi verilir. Bu sayılar, verilen doğru sayısına göre, bir daireyi kaç farklı şekle böldüğünü gösterir.

Örneğin yukarıdaki sayı serisini eksi olmayan tam sayılar ile birebir eşleştirirsek

Yukarıdaki gibi bir tablo elde ederiz. Bu tablodaki ilk satır kaç doğru kullandığımız, ikinci satır ise kaç parça elde ettiğimizdir. Örneğin ilk sütunda 0 doğru kullanılmış ve daire en fazla tek parçaya ayrılabilmiştir. İkinci sütunda tek bir doğru ile daire iki parçaya ayrılmıştır. 3 doğru kullanarak daire en fazla 7 parçaya ayrılabilir. Bu durumu aşağıdaki şekilde görebilirsiniz:

Yukarıdaki şekilde görüldüğü üzere daire 7 farklı parçaya bölünmüştür.

Kısacası, Floyd üçgeninin ilk sütununda bulunan sayılara, merkezi poligon sayıları (central polygon numbers) veya tembel pizzacı serileri (lazy caterer’s sequence) isimleri verilir. Bu ikinci isimlendirme, bir pizzacının, pizzasını en az bıçak darbesi ile en çok parçaya ayırma hevesinden gelmektedir

Floyd üçgeninin ilk sütununu oluşturan bu seri, aşağıdaki formül ile hesaplanabilir:

k = (n² + n + 2) / 2 , bu denklemdeki n satır sayısı, k ise bu satırdaki ilk elemandır (veya aynı formül merkezi poligon sayılarını bulmak için de kullanılır)

Floyd üçgeninin diğer bir özelliği ise, herhangi bir satırdaki sayıların toplamının aşağıdaki formül ile bulunabilmesidir:

n(n² + 1)/2

312 views

Bilgisayar mühendisliğinde, birbirinde ayrı işlerin kontrolü için kullanılır. Aynı anda çalışan işlerin birbirinden tamamen ayrı olması için (mutually exclusive), bazı kontrollerin yapılması gerekmektedir. Algoritma bu problemi aşağıdaki şekilde çözer.

Yukarıdaki kodda görüldüğü üzere, kod üç kısımdan oluşmaktadır:

1. Bariyer
2. Kritik alan
3. Bitiş

Bariyer kodunda, işlem (process), diğer çalışmakta olan ve o anda kritik bir koda erişen işlemleri bekler. Kendi önündeki bariyerin kalkmasıyla kritik alana girer. Bu alana o anda giren tek işlemdir çünkü kendi önündeki bariyerin kalkması ancak diğer işlemin bitiş kodunu çalıştırması ile mümkündür. Kritik alandaki görevini yerine getirdikten sonra bitiş kodunu çalıştırır ve beklemeden olan diğer işlemin bariyerlerini kaldırır.

Yukarıdaki kodda kullanılan flag dizisi (array), boolean tipinde olup o anda hangi işlemin çalıştığını tutmaktadır. Örneğin yukarıdaki kodun simetriği olarak diğer işlemin kodu aşağıdaki şekilde verilebilir:

İkinci kod ile ilk kod karşılaştırılırsa, flag[] ve turn değişkenlerine göre kimin çalışacağı belirlenmektedir.

Kodlarda bulunan 7. Satırdaki while döngüsü, aslında bekleme işlemini sağlar. Bu döngü turn değişkenine göre sonsuza kadar beklemektedir. Ancak diğer işlem tarafından değeri değiştirilince işlem çalışmasına devam edebilir.

Burada kullanılan turn değişkeni, iki işlem de aynı anda kritik alana girmek istiyorsa, anlık olarak bir tanesinin girmesini sağlar. Flag değişkeni ise o anda kritik alan girmek isteyen diğer işlem olup olmadığını kontrol eder.

Örneğin P1 işlemi, kritik alana girmek istemiyorsa, P2 işleminin kritik alana girerken turn değişkenine bakmasının bir anlamı yoktur. Benzer şekilde P2 işleminin kritik alan ihtiyacı yoksa, P1 de turn değişkenine bakmaz. Ancak iki işlem (yani P1 ve P2) aynı anda kritik alana girmek istiyorlarsa turn değişkeni anlamlı olur.

Bu tip beklemelere meşgul bekleme (busy wait) ismi verilir. Bu ismin verilme sebebi, işlemin sürekli olarak değişkenin değerine bakarak değeri değişene kadar beklemesidir. Bu bekleme işleminin sürekli bir kontrol yapıyor olması, işlemci üzerinde bir yük getirmektedir.

Algoritmanın diğer bir özelliği ise kilitlenme (deadlock) ve kıtlık (starvation) konularına karşı dayanıklı olmasıdır. Algoritmamızda kilitlenme (deadlock) olmayacağı, turn değişkeninin kullanılmasından anlaşılabilir. Bu değişkenin sistemde anlık olarak tek değeri bulunacak (1 veya 0) ve bu değere göre sistem iki işlemden bir tanesini çalıştıracaktır.

Kıtlık (starvation) problemini görmek için ise bir ihtimalin daha hesaplanması gerekir. Buna göre örneğin P1 çalışıyor ve P0 bekliyorken, P1 işini bitirip P0′ın kilidini kaldırdığında P0 henüz çalışmaya başlamadan P1 yeniden çalışıyor mu diye algoritmaya bakmalıyız. Diğer bir deyişle, sürekli olarak kritik alana erişmeye çalışan P1 ve P0 işlemlerinden örneğin P1 işini bitirip kritik alandan çıktından sonra henüz P0 kritik alana girmeden yeniden P1 kritik alana giriyorsa kıtlık (starvation) oluşuyor demektir.

Algoritmada böyle bir durum yaşanmaz. Bunun sebebi algoritmanın kullandığı flag değişkenidir. P1 işlemi, kritik alandan çıkarken, beklemede olan P0 işleminin bariyerini kaldırır ve bu kaldırma sonucunda P0 işlemi çalışırken P1′in yeniden çalışmasını engelleyici biçimde, diğer tarafın flag değişkenini atar.

Kısaca algoritma kilitlenme (deadlock) ve kıtlık (starvation) ihtimallerine karşı başarılı bir şekilde çalışır.

249 views