FEN B ĐLĐMLER Đ ENST ĐTÜSÜtez.sdu.edu.tr/Tezler/TF01311.pdf · Algoritmalar ve Đşlemler ......
Transcript of FEN B ĐLĐMLER Đ ENST ĐTÜSÜtez.sdu.edu.tr/Tezler/TF01311.pdf · Algoritmalar ve Đşlemler ......
T.C.
SÜLEYMAN DEMĐREL ÜNĐVERSĐTESĐ
FEN BĐLĐMLERĐ ENSTĐTÜSÜ
HEMŞĐRE ÇĐZELGELEME PROBLEMLERĐNĐN GENETĐK ALGORĐTMA ĐLE ÇÖZÜMÜ
Hanife ÇĐVRĐL
Danışman: Yrd.Doç.Dr.Mehmet UZUNKAVAK
YÜKSEK LĐSANS TEZĐ ELEKTRONĐK BĐLGĐSAYAR EĞĐTĐMĐ ANABĐLĐMDALI
ISPARTA-2009
Fen Bilimleri Enstitüsü Müdürlüğüne
Bu çalışma jürimiz tarafından Elektronik Bilgisayar Eğitimi ANABĐLĐM DALI'nda
oybirliği/oyçokluğu ile YÜKSEK LĐSANS TEZĐ olarak kabul edilmiştir.
Başkan : Yrd. Doç. Dr. Tuncay YĐĞĐT (Đmza)
SDÜ Müh. Mim. Fak. Bilgisayar Müh. Bölümü
Üye : Yrd. Doç. Dr. Mehmet UZUNKAVAK (Đmza)
SDÜ Tek. Eğt. Fak. Elektrik Eğitimi Bölümü
Üye : Yrd. Doç. Dr. Ecir Uğur KÜÇÜKSĐLLE (Đmza)
SDÜ Tek. Eğt. Fak. Elektronik Bilgisayar Eğitimi Bölümü
ONAY
Bu tez .../.../20.. tarihinde yapılan tez savunma sınavı sonucunda, yukarıdaki jüri
üyeleri tarafından kabul edilmiştir.
..../...../20...
Prof. Dr. Mustafa KUŞÇU
Enstitü Müdürü
i
ĐÇĐNDEKĐLER
Sayfa ĐÇĐNDEKĐLER ......................................................................................................... i
ÖZET ..................................................................................................................... iii
ABSTRACT ........................................................................................................... iv
TEŞEKKÜR .............................................................................................................v
ŞEKĐLLER DĐZĐNĐ ................................................................................................ vi
ÇĐZELGELER DĐZĐNĐ .......................................................................................... vii
SĐMGELER VE KISALTMALAR ....................................................................... viii
1. GĐRĐŞ ...................................................................................................................1
2. KAYNAK ÖZETLERĐ .........................................................................................4
3. MATERYAL VE YÖNTEM ................................................................................8
3.1. Yapay Sinir Ağları .............................................................................................9
3.2. Tabu Arama Algoritmaları ............................................................................... 11
3.3. Tavlama Benzetimi .......................................................................................... 13
3.4. Karınca Kolonileri Đyilemesi ............................................................................ 14
3.5. Yapay Bağışıklık Sistemleri ............................................................................. 17
3.5.1. Bağışık Hücre, Molekül ve Bunların Etkileşiminin Soyut Modelleri .............. 18
3.5.2. Algoritmalar ve Đşlemler................................................................................ 18
3.5.2.1. Kemik Đliği Modelleri ................................................................................. 18
3.5.2.2. Timus Modelleri ......................................................................................... 19
3.5.2.3. Klonal Seçim Algoritmaları ........................................................................ 20
3.5.2.4. Bağışık Ağ Modelleri ................................................................................. 21
3.6. Genetik Algoritmalar ....................................................................................... 21
3.6.1. Genetik Algoritmanın Diğer yöntemlerden farkı ............................................ 24
3.6.2. Genetik Algoritma Tekniği ............................................................................ 24
3.6.2.1. Gen ............................................................................................................ 25
3.6.2.2. Kromozom ................................................................................................. 25
3.6.2.3. Popülasyon ................................................................................................. 25
3.6.2.4. Allel (Allele) .............................................................................................. 25
3.6.2.5. Locus ......................................................................................................... 25
3.6.2.6. Genotip (Genotype) .................................................................................... 26
ii
3.6.2.7. Fenotip (Phenotype) ................................................................................... 26
3.6.3. Genetik Algoritmada Kullanılan Operatörler ................................................. 26
3.6.3.1. Kodlama ..................................................................................................... 26
3.6.3.2. Seçim ......................................................................................................... 28
3.6.3.3. Çaprazlama ................................................................................................ 29
3.6.3.4. Mutasyon ................................................................................................... 31
3.6.4. Genetik Algoritmanın Çalışma Prensibi ......................................................... 33
3.6.5. Örnek Uygulama ........................................................................................... 36
4. ARAŞTIRMA BULGULARI ............................................................................. 40
4.1. Aylık Hemşire Nöbet Çizelgesi Hazırlama Đşlemi............................................. 40
4.1.1. Gün Kapama ................................................................................................. 40
4.1.2. Kısıtlar .......................................................................................................... 40
4.2. Aylık Hemşire Nöbet Çizelgeleme Đçin Genetik Algoritmalar .......................... 41
4.2.1. Kromozomların Kodlanması ......................................................................... 43
4.2.2. Başlangıç Popülasyonun Oluşturulması ......................................................... 44
4.2.3. Uygunluk Fonksiyonu ................................................................................... 44
4.2.4. Rulet Çarkı .................................................................................................... 46
4.2.5. Çaprazlama ................................................................................................... 46
4.2.6. Mutasyon ...................................................................................................... 46
4.2.7. Yeni Popülasyon ........................................................................................... 47
4.2.8. Đyileştirme ve En Đyi Birey ............................................................................ 47
4.3. Genetik Algoritma Kullanılarak Hazırlanan Programın Tanıtılması .................. 47
4.3.1. Kayıt ............................................................................................................. 48
4.3.2. Çizelge .......................................................................................................... 49
4.3.3. Đzinler............................................................................................................ 50
4.3.4. Đstekler .......................................................................................................... 51
4.3.5. Raporlar ........................................................................................................ 52
5. TARTIŞMA VE SONUÇ .................................................................................... 55
6. KAYNAKLAR .................................................................................................. 57
EK .......................................................................................................................... 61
ÖZGEÇMĐŞ............................................................................................................ 87
iii
ÖZET
Yüksek Lisans Tezi
HEMŞĐRE ÇĐZELGELEME PROBLEMLERĐNĐN
GENETĐK ALGORĐTMA ĐLE ÇÖZÜMÜ
Hanife ÇĐVRĐL
Süleyman Demirel Üniversitesi Fen Bilimleri Enstitüsü Elektronik Bilgisayar Eğitimi Anabilim Dalı
Juri: Yrd.Doç.Dr. Mehmet UZUNKAVAK (Danışman) Yrd.Doç.Dr. Tuncay YĐĞĐT Yrd.Doç.Dr. Ecir Uğur KÜÇÜKSĐLLE
Hemşire çizelgeleme problemleri, belirli kısıtlar altında vardiyaların (gece vardiyası,
gündüz vardiyası, tatil vs.) aylık olarak hemşirelere nasıl dağıtılacağı sorusu ile
ilgilenir. Hastanelerde hemşirelere verilen çalışma saatleri genellikle yine bu işten
sorumlu hemşireler tarafından ayarlanmaktadır. Bu tez çalışmasında, belli hastaneler
bünyesinde çizelgelemeyi hazırlayan hemşirelerle görüşülerek ve bu konu üzerinde
daha önceden hazırlanmış çalışmalar incelenerek problemimize uygun kısıtlar
belirlenmiş ve bu kısıtlar göz önünde bulundurularak vardiyalı sistemle çalışan söz
konusu hastanelerin nöbet çizelgelemelerini hesaplamak için bir program
hazırlanmıştır. Bu program C# programlama dilinde Genetik Algoritma kullanılarak
geliştirilmiştir ve kullanıcı etkileşimli bir arayüze sahiptir. Giriş verileri ile çıkış
raporları için bu arayüz kullanılabilir. Çalışmalar sonucunda geliştirilen algoritma ile
uygun aylık hemşire çizelgesinin hazırlanabileceği gösterilmiştir.
Anahtar Kelimeler: Optimizasyon, Genetik Algoritma, Hemşire Çizelgeleme.
2009, 87 sayfa
iv
ABSTRACT
M.Sc. Thesis
GENETIC ALGORITHMS FOR NURSE SCHEDULING PROBLEMS
Hanife ÇĐVRĐL
Süleyman Demirel University Graduate School of Applied and Natural Sciences Department of Electronics Computer Education
Thesis Committee: Asst. Prof. Mehmet UZUNKAVAK (Supervisor)
Asst. Prof. Tuncay YĐĞĐT Asst. Prof. Ecir Uğur KÜÇÜKSĐLLE
Nurse scheduling problems ask for a distribution of shifts (night shift, day shift, vacation
etc.) to a set of given nurse under some certain constraints. Working hours assigned to
the nurses are also generally arranged by a few nurses who are responsible to do so. In
this thesis, we have interviewed nurses in certain hospitals who prepare such schedulings
and having reviewed the previous work done, we have defined a set of constraints
specific to our problem. Having these constraints, we have written a program which
computes schedulings for these hospitals. The program was written with the C#
programming language using a Genetic Algorithm and it has an interactive interface. The
interface can be used for the input data and output results. As a result of our work, we
have seen that the developed algorithm can produce a suitable monthly scheduling.
Key Words: Optimization, Genetic Algorithm, Nurse Sheduling.
2009, 87 pages
v
TEŞEKKÜR
Çalışmalarımda beni yönlendiren, karşılaştığım zorluklarda her zaman yanımda olan
değerli danışman hocam Yrd. Doç. Dr. Mehmet UZUNKAVAK’a; fikir, bilgi ve
tecrübesiyle yardımını esirgemeyen değerli hocam Yrd.Doç.Dr. Ecir Uğur
KÜÇÜKSĐLLE’ye ve çalışmalarım sırasında beni maddi açıdan destekleyen
TÜBĐTAK Bilim Đnsanı Destekleme Daire Başkanlığı’na teşekkür ederim.
Isparta Devlet Hastanesi Bevliye Servisinde görev yapmakta iken çalışmalarımın
başlangıç aşamasında bana yardımcı olan hemşire Meral KAPLAN’a teşekkür
ederim.
Tezimin her aşamasında beni yalnız bırakmayan ve tecrübesiyle destekleyen
ağabeyim Ali ÇĐVRĐL’e, iş ve akademik çalışmalarımda başarılı olmamı sevgi,
destek ve tecrübeleriyle sağlayan anneme, babama ve tüm dostlarıma sonsuz sevgi ve
saygılarımı sunarım.
Hanife ÇĐVRĐL
ISPARTA, 2009
vi
ŞEKĐLLER DĐZĐNĐ
Şekil 3.1. Klasik Tabu Arama Algoritmasının Akış Diyagramı ............................... 13
Şekil 3.10. Genetik algoritmanın akış diyagramı ..................................................... 35
Şekil 3.11. Rulet çarkı dağılımı ............................................................................... 37
Şekil 3.2. Karıncaların yuvaları ile yiyecek kaynağı arasındaki hareketleri .............. 15
Şekil 3.3. Karıncaların yuvaları ile yiyecekleri arasına bıraktıkları feromenler ........ 16
Şekil 3.4. Klonal seçim algoritması ......................................................................... 21
Şekil 3.5. De Castro ve Von Zuben’in ağ modeli ..................................................... 21
Şekil 3.6. Tek noktalı çaprazlama ........................................................................... 30
Şekil 3.7. Çift noktalı çaprazlama ........................................................................... 30
Şekil 3.8. Uniform çaprazlama ................................................................................ 31
Şekil 3.9. Aritmetik çaprazlama .............................................................................. 31
Şekil 4.1. Aylık hemşire nöbet çizelgeleme için GA akıl şeması ............................. 42
Şekil 4.2. Kromozomların kodlanması için temsili gösterim .................................... 44
Şekil 4.3. Program genel akış şeması ...................................................................... 48
Şekil 4.4. Kayıt Sekmesi ......................................................................................... 49
Şekil 4.5. Çizelge Sekmesi ...................................................................................... 50
Şekil 4.6. Đzinler Sekmesi........................................................................................ 51
Şekil 4.7. Đstekler Sekmesi ...................................................................................... 52
Şekil 4.8. Cildiye Servisine Ait Örnek Aylık Hemşire Çizelgesi.............................. 54
Şekil 5.1. Zorunlu Kısıtların Ceza Toplamlarının Nesillere Göre Değişim Grafiği.. 55
Şekil 5.2. Zorunlu ve Esnek Kısıtların Ceza Toplamlarının Nesillere Göre Değişim Grafiği ........................................................................................................ 56
vii
ÇĐZELGELER DĐZĐNĐ
Çizelge 3.1. Đkili sayı sisteminde kodlanmış örnek kromozomlar ............................ 26
Çizelge 3.2. Permutasyon kodlama sistemi ile kodlanmış örnek kromozomlar ........ 27
Çizelge 3.3. Değer kodlama sistemi ile kodlanmış örnek kromozomlar ................... 28
Çizelge 3.4. Ters Çevirme Mutasyonu .................................................................... 32
Çizelge 3.5. Ekleme Mutasyonu .............................................................................. 32
Çizelge 4.1. Kromozomların Kodlanması ................................................................ 43
Çizelge 4.2. Nöbet çizelgesi için sağlanmaya çalışılan kısıtlar ve ceza değerleri ...... 45
viii
SĐMGELER VE KISALTMALAR Cmax Tamamlanma zamanı F Ceza fonksiyonu f Uygunluk fonksiyonu GA Genetik Algoritmalar MA Memetik Algoritmalar NP Polinomal olmayan NP-hard Polinomal olmayan-zor P Polinomal r Rastgele bir sayı SA Tavlama Benzetimi SSGA Kararlı Hal Genetik Algoritması T Popülasyondaki tüm bireylerin uygunluk toplamı t 0’dan itibaren popülasyondaki bireylerin uygunluklarının
toplamı TS Tabu Search TTML Zaman Çizelgeleme Biçimleme Dili YBS Yapay Bağışıklık Sistemleri YSA Yapay Sinir Ağları
1
1. GĐRĐŞ
Çizelgeleme, işlerin belirlenen bir sırada gerçekleşmesi için program yapılması ve bu
programın çeşitli kriterler altında çeşitli performans ölçütlerini iyilemesi faaliyetidir.
Çizelgeleme problemleri, belirli zaman aralıklarının kullanıcılara kısıtlar göz önünde
bulundurularak makul bir şekilde atanmasını gerektirir.
Problemin zorluk derecesinin bilinmesi problemin çözümü için en iyi yöntemin
uygulanmasını sağlar. Polinomal(P) olan denklemler çözümlenmesi, incelenmesi
kolay olan denklemlerdir ve kısa sürede sorunu çözen yöntemleri mevcuttur. Eğer bir
denklem ya da sistem polinomal değilse(NP) çözümlenmesi zor sistemlerdir. Ancak
NP(polinomal olmayan, kesin çözümü olmayan) problemler için ise kısa sürede
gerçek çözümü bulan yöntemler mevcut değildir. Bu nedenle NP problemleri için
gerçek çözüme en yakın sonucu bulmak amacıyla yaklaşık çözüm algoritmaları
geliştirilmiştir (Biroğul, 2005).
Yaklaşık çözüm algoritmaları, problemin gerçek olmayan ancak geçerli bir
çözümünü(gerçek sonuca yakın olan) kısa sürede bulabilirler. Pratikte karşılaşılan
problemlerin çoğu için kesin çözümden ziyade kısa sürede yaklaşık bir çözümün
bulunması istenmektedir. Bu nedenle pratikte karşılaşılan NP problemlerin
çözümünde probleme özgü olarak sezgisel yöntemler yardımıyla geliştirilen
algoritmalar kullanılır. Problemlerin çözümü için kullanılan algoritmaların sonuca
kısa sürede ulaşması esastır. Bir algoritmanın en yaygın performans ölçütü,
algoritmanın sonucu bulana kadarki geçen süredir (Biroğul, 2005).
Polinomal algoritmalar pratikteki problemlerin çözümünde iyi performans
gösterirler. NP problemlerinde kullanılan polinomal algoritmalar ise sorunu
çözememektedir. NP olarak adlandırılan problemlerin çözümünde kesin sonuç yerine
yakın çözümler tercih edilir (Biroğul, 2005).
NP kapsamına giren optimizasyon problemlerinin çözümünde çeşitli sezgisel arama
metodları geliştirilmiştir. Genetik Algoritmalar(GA), Tavlama Benzetimi(SA) ve
2
Tabu Araştırmaları(TS) bu metotlar içerisinde başarı ile uygulanan ve en popüler
olan üç tanesidir. Genetik algoritmalar biyolojiden, tavlama benzetimi fizikten, tabu
araştırmaları ise zekâ tekniklerinden esinlenerek geliştirilmiş arama teknikleridir
(Gen, 1996).
Genetik algoritmalar, doğal seçim ilkelerine dayanan bir arama ve optimizasyon
yöntemidir. Karmaşık çok boyutlu arama uzayında en iyinin hayatta kalması ilkesine
göre bütünsel en iyi çözümü arar. Temel ilkeleri John Holland tarafından ortaya
atılmıştır. Genetik algoritmaların, fonksiyon optimizasyonu, çizelgeleme, mekanik
öğrenme, tasarım, hücresel üretim gibi alanlarda başarılı uygulamaları
bulunmaktadır. Geleneksel optimizasyon yöntemlerine göre farklılıkları olan genetik
algoritmalar, parametre kümesini değil kodlanmış biçimlerini kullanırlar. Olasılık
kurallarına göre çalışan genetik algoritmalar, yalnızca amaç fonksiyonuna
gereksinim duyar. Çözüm uzayının tamamını değil belirli bir kısmını tararlar.
Böylece, etkin arama yaparak çok daha kısa bir sürede çözüme ulaşırlar (Goldberg,
1989).
Genetik algoritmalar problemlere tek bir çözüm üretmek yerine farklı çözümlerden
oluşan bir çözüm kümesi üretir. Böylelikle, arama uzayında aynı anda birçok nokta
değerlendirilmekte ve sonuçta bütünsel çözüme ulaşma olasılığı yükselmektedir.
Çözüm kümesindeki çözümler birbirinden tamamen bağımsızdır. Her biri çok
boyutlu uzay üzerinde bir vektördür. Genetik algoritmalar problemlerin çözümü için
evrimsel süreci bilgisayar ortamında taklit ederler.
Hemşire çizelgeleme problemleri NP problemlerdir. Bu çalışmada, genetik algoritma
kullanılarak aylık hemşire nöbet çizelgesi yazılımı hazırlanmıştır. Bu yazılım için C#
programı ve veritabanı olarak Microsoft Access 2007 programı kullanılmıştır. Bu
yazılım kullanıcı etkileşimli bir arayüze sahip olup girilen verilerin ışığında tüm
servislere ait aylık nöbet çizelgesi oluşturmaktadır.
Bu tezde, önce konu ile ilgili olarak daha önceden yapılmış olan çalışmalar
özetlenmiştir. Sonra Genetik Algoritmanın adımları ayrıntılı olarak ele alınmıştır.
3
Daha sonra aylık hemşire çizelgeleme yazılımı oluşturulurken kullanılan genetik
algoritmanın adımları tek tek ele alınarak açıklanmıştır.
4
2. KAYNAK ÖZETLERĐ
Jan vd. (2000) tarafından yapılan çalışmada, hemşire çizelgeleme problemleri için
evrimsel algoritmalar kullanılmıştır. Bu çalışmada, genetik algoritmalarda bilinen
operatörlerin kullanılması sonucu çözümün yerel minimumda kalma problemini
çözmek için “kaçış operatörü” tanımlanmıştır.
Kawanaka vd. (2001) tarafından yapılan çalışmada, hemşire çizelgeleme problemleri,
kısıtları da göz önünde bulundurarak genetik algoritma yardımıyla çözülmüştür. Bu
çalışmada problem için genetik algoritma çalıştırıldıktan sonra keskin kısıtları
sağlamayan kromozomlar genetik algoritma dışında düzeltilerek sonuca ulaşılmıştır.
Emel ve Taşkın (2002) tarafından yapılan çalışmada, bir arama ve optimizasyon
yöntemi olan genetik algoritma ve uygulama alanları incelenmiştir. Çalışmada ilk
olarak genetik algoritma kavramı ve temel teoremi hakkında bilgi verilmiştir. Daha
sonra, basit genetik algoritmanın çalışma adımları ve parametre seçimi incelenmiş ve
fonksiyon optimizasyonu için bir çözüm örneği verilmiştir.
Engin ve Fığlalı (2002) tarafından yapılan çalışmada, tamamlanma zamanı (Cmax)
kriterli akış tipi çizelgeleme problemlerinin Genetik algoritma yardımı ile
çözümünde uygun çaprazlama operatörünün belirlenmesine çalışılmıştır.
Özcan ve Alpay (2002) tarafından yapılan çalışmada, çok kısıtlı üniversite ders
programı hazırlamaya yönelik kararlı hal genetik algoritması (SSGA) geliştirilmiştir.
Yeni melezleme mutasyon uzmanları ile paralel genetik algoritmalardan
esinlenilerek çok nüfuslu SSGA denenmiştir.
Inoue vd. (2003) tarafından yapılan çalışmada, hemşire çizelgeleme problemlerinin
çözümü için evrimsel algoritma ve sezgisel algoritmalar birleştirilmiştir.
Aickelin ve Dowsland (2004) tarafından yapılan çalışmada, genetik algoritma
kullanılarak hemşire çizelgeleme programı hazırlanmıştır. Bu çalışmada iterasyonları
5
bir çözüm bulmak için zorlayan ceza fonksiyonu ve değişen yapıyı korumak ve
kısıtları sağlamayan kromozomları düzeltmek için tamir operatörü kullanmanın
dezavantajlı olabileceği belirtilmiştir ve bu iki fonksiyonu kullanmadan basit bir
genetik algoritma kullanılmıştır. Genetik algoritma sonucunda oluşan çözüm ise
probleme özgü başka bir algoritma (kombinatoryal greedy algoritması) tarafından
kullanılarak sonuca ulaşılmıştır.
Daban ve Özdemir (2004) tarafından yapılan çalışmada, eğitimde zamanlama
konusunun alt bölümü sayılabilecek ders programlarının verimliliğinin arttırılması
için yapay zeka yöntemlerinden biri olan Genetik Algoritma kullanılarak, öğretim
elemanı ve öğrenci verimliliklerine göre ders ağırlıkları alınarak daha etkin bir eğitim
öğretim sağlamak için, ders programı hazırlayan ve optimize eden bir program
geliştirilmiştir. Yapılan simülasyon sonuçlarında pedagojik esaslara göre, ders
ağırlıkları dikkate alınarak hazırlanan ders programlarında, ele alınan kriterlerde
başlangıca göre %35-40 oranında iyileşme sağlanmıştır.
Ersoy (2004) tarafından yapılan çalışmada, zaman çizelgeleme problemlerinin bir alt
sınıfı olan, final sınavı zaman çizelgeleme verilerini zaman çizelgeleme biçimleme
dili (TTML)’ne çeviren bir aracın ve Memetik Algoritmalara (MA) dayanan, TTML
girdisini kullanarak final sınavı zaman çizelgelemesini çözen başka bir aracın
geliştirilmesi amaçlanmıştır.
Kakmacı ve Hasgül (2004) tarafından yapılan çalışmada eğitim-öğretimin düzeninin
sağlanması amacıyla hazırlanan öğretmen nöbet çizelgeleri probleminin gösteriminde
karar modellerinden yararlanılmış, modellerin çözümünde ise Lingo paket
programının MS-Excel ve MS-Access programlarıyla bütünleşik çalışması
sağlanmıştır.
Özcan (2005) tarafından yapılan çalışmada, hemşire çizelgeleri için memetic
algoritmalar kullanılmıştır. Bu çalışmada, rastgele veriler üzerinde çeşitli
operatörlerin çözüm üzerindeki etkisi deneysel olarak incelenmiştir.
6
Özdemir (2005) tarafından yapılan çalışmada, makine ve zaman çizelgeleme, ders
çizelgeleme, araç rotalama ve kesme problemleri gibi kaynak atama problemlerin bir
çeşit çok ölçütlü problemler olduğu belirtilerek söz konusu problemlere ilişkin
yapılacak çalışmalara bir girdi teşkil etmesi açısından bir literatür taraması
yapılmıştır. Öncelikle problem türleri ve özellikleri tanıtılmış ardından mevcut
çalışmalar yıllarına, uygulandıkları sektöre, amaç fonksiyonlarına ve kullandıkları
çözüm yaklaşımlarına göre sınıflandırılmıştır. Böylece, çok ölçütlü problemlerde
gelinen noktalar değerlendirilmiş, açık kalan noktalar irdelenmiştir.
Biroğul (2005) tarafından yapılan çalışmada, atölye çizelgeleme probleminin genetik
algoritma ile çözümü gerçekleştirilmiştir. Girilen atölye bilgilerine göre gant şeması
çizimi yapılmıştır.
Tuncel (2005) tarafından yapılan çalışmada, genetik algoritma kullanılarak
geliştirilmiş bir yazılım ile çok zaman alan askeri nöbet çizelgesi hazırlama
işlemlerinin; harcanan süre sağlanan doğruluk yönü ile eniyilenmesi amaçlanmıştır.
Kaya (2006) tarafından yapılan çalışmada, polinomal olmayan-zor (NP-hard)
operasyonel sabit iş çizelgeleme problemlerinin genetik algoritma ile çözüm
performansının artırılmasına yönelik bir uygulama yapılmıştır.
Ohki vd. (2006) tarafından yapılan çalışmada, etkili mutasyon ve hill climbing
yöntemleri kullanılarak genetik algoritma ile hemşire çizelgeleme problemleri
çözülmüştür.
Yiğit (2006) tarafından yapılan çalışmada, meslek liseleri için haftalık ders
çizelgelerinin genetik algoritmalar yardımıyla oluşturulması sağlanmıştır. Bu
çalışmada genetik algoritmada kullanılan mutasyon operatöründen sonra
kromozomların yapısında oluşan bozuklukların giderilmesi için “tamir operatörü”
kullanılmıştır.
7
Kalender (2007) tarafından yapılan çalışmada üst-sezgisel algoritmalar ile Yeditepe
Üniversitesi Bilgisayar mühendisliğinde kullanılmak üzere çözümlerin üretilebildiği,
değiştirebildiği ve bilgilerin saklanabildiği otomatik ders çizelgeleme programı
hazırlayan bir uygulama geliştirilmiştir.
Çetin vd. (2008) tarafından yapılan çalışmada havayolu taşımacılığında uçuş ekibi
maliyetlerini minimize etmek amacıyla çözüm aranmıştır. Bu çalışmada ekip
eşleştirme ve ekip atama problemleri bütünleşik bir yapıda ele alınmıştır. Küme
bölme modeli formunda ifade edilen ekip eşleştirme probleminin tamsayılı
programlama ile çözümü MATLAB bilgisayar programından faydalanılarak
gerçekleştirilmiştir. Uygulamanın ikinci kısmını oluşturan ve ekip eşleştirme
sonuçlarının girdi olarak kullanıldığı ekip atama problemi yine küme bölme
modeline dönüştürülmüş ve tamsayılı programlama yöntemiyle çözümü aranmıştır.
Çalışmadan elde edilen atama planıyla maliyetler açısından tasarruflar
sağlanabileceği görülmüştür.
8
3. MATERYAL VE YÖNTEM
Çift vardiya sistemine göre çalışan hastaneler, 7 gün 24 saat açık olan, günlük
mesailerin 8:00-16:00 ve 16:00-8:00 saatleri arasında yapıldığı hastanelerdir. 08:00-
16:00 saatleri arası “Gündüz Vardiyası”, 16:00-08:00 saatleri arası “Gece Vardiyası”
olarak isimlendirilir. Aylık hemşire nöbet çizelgeleri, sorumlu hemşireler tarafından
belirli kıstaslar göz önünde bulundurularak en uygun şekilde hazırlanmaya çalışılır.
Süleyman Demirel Üniversitesi Araştırma ve Uygulama Hastanesi’nde çalışan
hemşirelerle yapılan ön görüşmelere göre, hemşirelerin aşağıda belirtilen koşullara
uygun şekilde çalışmaları gerekmektedir.
1. Hastanelerde hemşire hizmeti günün 24 saatinde devam eder.
2. Bir hemşire haftada en az 40 saat çalışmalıdır.
3. Günün ya 08:00-16:00 saatleri arasında ya da 16:00-08:00 saatleri arasında
çalışmalıdır.
4. Haftada en az bir kere ardışık iki tam gün (bir tam gün 00:00-24:00 saatleri
arasındaki süre) tatil kullanmalıdır.
5. Haftada ardışık 72 saat veya daha fazla izin kullanmamalıdır.
6. Ardışık iki gün 16:00-08:00 saatleri arasında çalışmamalıdır.
7. Ardışık olarak 16 saatten fazla çalışmamalıdır.
8. Bir hemşire haftada ardışık 16 saat çalışmayı olabildiğince az yapmalıdır.
9. Her servisin sorumlu hemşiresi gündüz vardiyasında çalışmalıdır.
Đkinci ve üçüncü koşullar göz önünde bulundurulduğunda uygulanabilecek haftalık
nöbet çizelgeleri 3 grupta toplanabilir.
a) Haftada 5 kez sadece gündüz vardiyasında çalışılması: Bu grupta çalışan bir
hemşire 08:00-16:00 saatleri arasında, 5 gün 8’er saat çalışarak 40 saatlik
çalışma süresini tamamlamış olur.
9
b) Haftada 2 kez gece 1 kez gündüz vardiyasında çalışılması: Bu grupta çalışan bir
hemşire iki kez 16:00-08:00 saatleri arasında, bir kez 08:00-16:00 saatleri
arasında çalışarak 40 saatlik çalışma süresini tamamlamış olur.
c) Haftada 1 kez gece vardiyasında ve 3 kez gündüz vardiyasında çalışılması: Bu
grupta çalışan bir hemşire bir kez 16:00-08:00 saatleri arasında, 3 kez 08:00-
16:00 saatleri arasında çalışarak 40 saatlik çalışma süresini tamamlamış olur.
Hemşire çizelgeleme problemleri NP problemleridir. Temelde NP problemlerinin
çözümünde kullanılan metotlar;
• Yapay sinir ağları
• Tabu arama algoritmaları
• Tavlama benzetimi
• Karınca kolonileri optimizasyonu
• Yapay bağışıklık sistemleri
• Genetik algoritmalardır.
3.1. Yapay Sinir Ağları
Yapay sinir ağları, insan beyninin özelliklerinden olan öğrenme yolu ile yeni bilgiler
türetebilme, yeni bilgiler oluşturabilme ve keşfedebilme gibi yetenekleri herhangi bir
yardım almadan otomatik olarak gerçekleştirmek amacı ile geliştirilen bilgisayar
sistemleridir (Öztemel, 2003). YSA, insan beyninin çalışma şekli benzetilerek
tasarlanan programlama yaklaşımıdır. Benzetilen sinir hücreleri nöronlar içerirler ve
bu nöronlar çeşitli şekillerde birbirlerine bağlanarak ağı oluştururlar. Bu ağlar
öğrenme, hafızaya alma ve veriler arasındaki bağlantıyı ortaya çıkarma yetisine
sahiptirler. Diğer bir ifadeyle, YSA'lar, normalde bir insanın düşünme ve
gözlemlemeye yönelik doğal yeteneklerini gerektiren problemlere çözüm
üretmektedir. Bir insanın, düşünme ve gözlemleme yeteneklerini gerektiren
problemlere yönelik çözümler üretebilmesinin temel sebebi ise insan beyninin ve
dolayısıyla insanın sahip olduğu yaşayarak veya deneyerek öğrenme yeteneğidir
(Yurtoğlu, 2005).
10
Biyolojik sistemlerde öğrenme, nöronlar arasındaki sinaptik (synaptic) bağlantıların
ayarlanması ile olur. Yani, insanlar doğumlarından itibaren bir yaşayarak öğrenme
süreci içerisine girdiklerinden beyin sürekli bir gelişme göstermektedir. Yaşayıp
tecrübe ettikçe sinaptik bağlantılar oluşur ve bu sayede öğrenme gerçekleşir. Bu
durum YSA için de geçerlidir. Öğrenme, eğitme yoluyla örnekler kullanarak olur;
başka bir deyişle, gerçekleşme girdi/çıktı verilerinin işlenmesiyle, yani eğitme
algoritmasının bu verileri kullanarak bağlantı ağırlıklarını (weights of the synapses)
bir yakınsama sağlanana kadar, tekrar tekrar ayarlamasıyla olur (Yurtoğlu, 2005).
YSA'lar, ağırlıklandırılmış şekilde birbirlerine bağlanmış birçok işlem biriminden
(nöronlar) oluşan matematiksel sistemlerdir. Bir işlem birimi, transfer fonksiyonu
olarak anılan bir denklemdir. Bu işlem birimi, diğer nöronlardan sinyalleri alır;
bunları birleştirir, dönüştürür ve sayısal bir sonuç ortaya çıkartır. Genelde, işlem
birimleri kabaca gerçek nöronlara karşılık gelirler ve bir ağ içinde birbirlerine
bağlanırlar; bu yapı da sinir ağlarını oluşturmaktadır (Yurtoğlu, 2005).
Sinirsel (neural) hesaplamanın merkezinde dağıtılmış, adaptif ve doğrusal olmayan
işlem kavramları vardır. YSA'lar, geleneksel işlemcilerden farklı şekilde işlem
yapmaktadırlar. Geleneksel işlemcilerde, tek bir merkezi işlem birimi her hareketi
sırasıyla gerçekleştirir. YSA'lar ise her biri büyük bir problemin bir parçası ile
ilgilenen, çok sayıda basit işlem birimlerinden oluşmaktadır. En basit şekilde, bir
işlem birimi, bir girdiyi bir ağırlık kümesi ile ağırlıklandırır, doğrusal olmayan bir
şekilde dönüşümünü sağlar ve bir çıktı değeri oluşturur. Đlk bakışta, işlem
birimlerinin çalışma şekli yanıltıcı şekilde basittir. Sinirsel hesaplamanın gücü,
toplam işlem yükünü paylaşan işlem birimlerinin birbirleri arasındaki yoğun bağlantı
yapısından gelmektedir (Yurtoğlu, 2005).
Çoğu YSA'da, benzer karakteristiğe sahip nöronlar tabakalar halinde yapılandırılırlar
ve transfer fonksiyonları eş zamanlı olarak çalıştırılırlar. Hemen hemen tüm ağlar,
veri alan nöronlara ve çıktı üreten nöronlara sahiptirler (Yurtoğlu, 2005).
11
YSA'nın ana öğesi olan matematiksel fonksiyon, ağın mimarisi tarafından
şekillendirilir. Daha açık bir şekilde ifade etmek gerekirse, fonksiyonun temel
yapısını ağırlıkların büyüklüğü ve işlem elemanlarının işlem şekli belirler. YSA'ların
davranışları, yani girdi veriyi çıktı veriye nasıl ilişkilendirdikleri, ilk olarak
nöronların transfer fonksiyonlarından, nasıl birbirlerine bağlandıklarından ve bu
bağlantıların ağırlıklarından etkilenir (Yurtoğlu, 2005).
3.2. Tabu Arama Algoritmaları
Yerel arama teknikleri, mümkün çözümlerin sadece küçük bir kısmıyla, birçok
problemi en iyi şekilde çözme veya en iyi çözümü verme yeteneğine sahiptir. Burada
mümkün çözümlerden kasıt mevcut çözümün komşularının araştırılmasıdır. Bu
esnada karşılaşılan problemlerden birisi yerel optimum çözüme takılmadır. Birçok
arama tekniğinde, incelenecek komşu seçimi belli bir olasılıkla rastgele seçildiğinden
dolayı yerel optimumdan kaçma imkânı bulunabilir. Fakat incelenmiş çözümlere
tekrar geri dönme olasılığı olduğundan arama yerel optimum civarında takılabilir. Bu
aşırı zaman kaybına sebep olur. Bu yüzden daha önceden incelenmiş belli sayıda
çözüm bir listede tutulur. Bu listede yer alan çözümler tekrar hesaplamaya
katılmadığından aramanın tekrarlanması mümkün değildir. Đşte böyle listelerin
oluşturulduğu ve ‘tabu listesi’ adı verilen arama yaklaşımına tabu arama algoritması
denir.
Tabu kelimesi, literatürde dokunulmaz, kutsal, sosyal açıdan korunması gereken
yasaklar anlamında kullanılmıştır. Ayrıca yapılması risk taşıyan eylemlere de denir.
Tabu sayılan eylemler zamanla değişen yapıdadır. Toplum zamanla bazı eylemleri
tabu olmaktan çıkarmakta, bunları normal karşılamakta, bazılarını ise tabu tutmaya
devam etmektedir.
Glover tarafından geliştirilen Tabu Search(TS) algoritması önceleri ayrık
optimizasyon problemlerine uygulanmıştır. Bu tür problemlerde gradyent kullanarak
çözüm elde edilemeyeceğinden deneme-yanılma metodu izlenmesi gerekir. Fakat
bütün olasılıkları denemek çok fazla zaman alır. Bu sebepten “zeki” bir yöntemle, en
12
az hesaplama yaparak en iyi çözüme ulaşmak için tabu arama algoritması
geliştirilmiştir. Arama uzayındaki denenen çözümlerin bilgilerini bellekte tutması
özelliğinden dolayı arama sınırlandırılmış ve yerel optimumdan kurtulmuş olur.
Brucker’a göre TS yerel optimuma düşmeden kaçınmak için bir bellek fonksiyonu
kullanıp, küresel optimumu hızlı bir şekilde aramada bir veya daha çok yerel arama
prosedürünü hiyerarşik olarak yönlendiren zeki bir tekniktir.
TS genel olarak incelendiğinde yeni çözüm metotlarının geliştirilmesi için üst düzey
bir serbestliğe izin vermesinden dolayı, birçok araştırmacı TS algoritması üzerinde
yeni çözüm metotları ve stratejileri geliştirmek için çaba göstermişlerdir.
Algoritmanın oluşturulmasında temel alınan iki unsur, daha önce denenmiş
çözümleri yeniden işleme almaması ve yerel optimum noktadan uzaklaşıp küresel
optimum çözüme ulaşabilmesidir.
Bu amaçla, algoritma temelde iki parçaya ayrılabilir.
1. Değiştirilmiş Greedy Araması: Arama işleminin her adımında, algoritma
üretilen komşu çözümlerinden en iyi değerlendirme değeri olanını seçer ve o
noktayı bir sonraki adımda kullanır. Standart greedy algoritmasıyla aradaki fark
ise, bu algoritmada belli bir iterasyonda üretilen komşu çözümlerin
değerlendirilmesinde en iyi olanı, o anki çözümden daha kötü olsa bile yine de
kötü sonuç veren ama en iyi komşu çözüm olan çözüm kümesinin seçilmesidir.
Böylece yerel minimum bölge aşılıp diğer bölgelere doğru arama yapılabilir.
2. Kısır Döngülerden Kurtulmak için Geliştirilen Strateji: Kötü olan çözümün
seçilmesi, bazı durumlarda yerel minimumdan kurtulmada yeterli olmayabilir.
Bu durumda, daha önce arama yapılan noktaları yeniden denememek, yani kısır
döngüye girmemek için geriye dönük denenen noktaların bir listesi tutulmuştur.
Bu listenin boyu seçilirken, çok küçük seçilmemesi gerekir. Bu durumda kısır
döngüden çıkamama ihtimali ortaya çıkmaktadır.
13
Şekil 3.1. Klasik Tabu Arama Algoritmasının Akış Diyagramı
3.3. Tavlama Benzetimi
Tavlama benzetimi NP zor problemlerinin çözümünde iyi performans gösteren
sezgisel bir yöntemdir. Fiziksel tavlama işlemi, ısı banyosu içerisindeki katı bir
cismin düşük enerjisini elde etmek için kullanılan bir yöntemdir. Katı bir cisim erime
noktasına kadar ısıtılır ve sonra katı cisim hızla soğutulmaya başlanırsa katı cismin
moleküler yapısı soğutma oranına bağlı olarak değişir (Biroğul, 2005).
Eniyileme teorisi, nicel olarak en iyiyi bulmayı ve bunun yöntemlerini inceler. En
iyinin nasıl tanımlanacağını ve ona nasıl ulaşılacağını araştırır. Arama uzayının
büyüklüğü nedeniyle kombinasyonel eniyileme problemlerinin çözümü, eniyileme
yöntemlerinden faydalanmayı gerektirir. Büyük bir arama uzayı içinde gerekirci
yöntemlerin kullanımı, hemen hemen imkânsızdır. Çünkü bu arama uzayı içinde en
14
iyi çözümlerin bulunması çok zaman alır. Yerel arama yöntemleri de, arama
sürecinde yerel en küçük çözümde takılıp, daha iyi bir çözüm değerine ulaşılmasına
engel olabilir. Arama algoritmaları için bir dezavantaj sayılan bu durum karşısında
daha detaylı arama yapan arama yöntemleri geliştirilmiştir. Tavlama benzetimi
algoritması, bu yöntemlerden birisidir (Kirkpatrick, 1983).
Tavlama benzetimi algoritması, pek çok değişkene sahip fonksiyonların en büyük
veya en küçük değerlerinin bulunması ve özellikle pek çok yerel en küçük değere
sahip doğrusal olmayan fonksiyonların en küçük değerlerinin bulunması için
tasarlanmıştır. Diğer olasılıklı yaklaşımlar (genetik algoritmalar, tabu arama vb.) gibi
en iyi çözümün en kısa zamanda üretimini sağlar. Bu sebeple, özellikle matematiksel
modellerle gösterilemeyen kombinasyonel problemlerin eniyileme uygulamalarında
tercih edilir. Benzetilmiş tavlama algoritması; elektronik devre tasarımı, görüntü
işleme, yol bulma problemleri, seyahat problemleri, malzeme fiziği simulasyonu,
kesme ve paketleme problemleri, akış çizelgeleme ve iş çizelgeleme problemlerinin
çözümlerinde başarılı sonuçlar vermiştir (Lutfiyya, 1992).
3.4. Karınca Kolonileri Đyilemesi
Karıncalar, yuvaları ile besin kaynakları arasındaki en kısa yolu bulabilmektedirler.
Karıncaların bu davranış kalıplarının optimizasyon probleminde kullanılabileceği ilk
kez 1992 yılında Marco Dorigo tarafından ortaya atılmıştır. Karınca Kolonileri Meta
sezgiselinden türetilmiş ve çeşitli problemlerin çözümünde kullanılan çok sayıda
algoritma vardır. Bu algoritmalar ile birçok optimizasyon problemleri çözülmüştür
(Alaykıran, ve Engin, 2005).
Optimizasyon problemlerinin çözümünde kullanılan sezgisel yöntemlerin
belirlenmesinde yeni metot, doğal süreçleri gözlemlemek ve optimizasyon
problemlerinde kullanılabilecek bir model elde etmektir. Örneğin Metropolis
algoritması, genetik algoritmalar ve yapay sinir ağları bu şekilde bulunmuş
yöntemlerdir (Colomi, 1994).
15
Hayvanlar dünyasında da basit yeteneklere sahip bireylerin oluşturduğu karmaşık ve
üstün yeteneklere sahip pek çok sosyal sistem örneği vardır. Bunlara bir örnek
karınca kolonileridir. Karınca kolonileri meta sezgiseli, doğal karıncaların yuvaları
ile besin kaynakları arasında izledikleri yolların izlenmesi sonucu ortaya çıkan
bilimsel gerçekler üzerine doğmuştur. Gerçek karıncalar ile ilgili deneyler Goss ve
arkadaşları tarafından 1989 yılında laboratuar ortamında yetiştirilmiş karınca
kolonileri üzerinde yapılmıştır. Bu çalışmalardan elde edilen sonuçlar şu şekilde
özetlenmiştir. Karıncalar neredeyse kördür. Karıncalar, feromen adı verilen bir tür
kimyasal maddeyi yuvalarından yiyecek kaynağına veya tersi yönde hareket
ederlerken geçtikleri yollara bırakmaktadırlar. Karıncalar bir yol seçmeleri gerektiği
zaman bu seçimi feromen madde yoğunluğuna göre belirlemektedirler ve
karıncaların bu hareketleri merkezi bir kontrol ile sağlanmamaktadır. Karıncaların
yuvaları ile yiyecek kaynağı arasındaki hareketleri Şekil 3.2’de gösterilmiştir
(Alaykıran, ve Engin, 2005).
Şekil 3.2. Karıncaların yuvaları ile yiyecek kaynağı arasındaki hareketleri
16
Şekil 3.3. Karıncaların yuvaları ile yiyecekleri arasına bıraktıkları feromenler
Şekil 3.2’de görüldüğü gibi, karıncalar yuvalarının etrafındaki alanda yiyecek
kaynaklarını rassal bir şekilde ararlar. Bir karınca bir yiyecek kaynağı bulduğu
zaman kaynağın kalitesini veya miktarını değerlendirir ve bir miktar yiyecek alarak
yuvasına geri döner. Bu geri dönüş sırasında, bulduğu yiyecek kaynağının kalitesi
veya miktarıyla doğru orantılı olacak şekilde kullandığı yola feromen maddesi koyar.
Böylece diğer karıncalar bu yolun sonundaki yiyecek kaynağının kalitesi veya
miktarı konusunda bilgi sahibi olurlar. Yuvaya yakın kaynaklara ulaşmak daha kolay
olacağı için bu bölgelerde feromen maddesinin yoğunluğu daha fazla olacaktır.
Karıncaların bu hareketlerinin sayısal bir örneği Şekil 3.3’de verilmiştir. Karıncaların
bu önemli özellikleri Hewlett-Packard ve British Telecom’daki araştırmacılar
tarafından iletişim ağlarının dengelenmesi ve mesaj rotalaması problemlerinde
kullanılmıştır. Burada ağ üzerinde yapay karıncaların feromen bırakma ve bu bilgiyi
kullanma özellikleri simule edilmiş ve elde edilen sonuçlara göre rotalama
yapılmıştır. (Alaykıran, ve Engin, 2005).
Karıncaların doğal hareketleri ile kombinatoriyel optimizasyon problemlerinin
uyuşan karakteristik özellikleri; Gerçek karıncaların arama alanı ile kombinatoriyel
problemlerin mümkün sonuçlar kümesi, bir kaynaktaki yiyecek miktarı ile amaç
fonksiyonu, feromen madde ile hafıza’dır. Karınca Kolonileri Meta sezgiselinden
türetilmiş ve çeşitli problemlerin çözümünde kullanılan çok sayıda algoritma vardır.
Bu algoritmalar formülasyon olarak birbirinden ayrılmakta fakat hepsi karınca
17
kolonileri meta sezgiselinin ortak özelliklerini kullanmaktadır (Alaykıran ve Engin,
2005).
3.5. Yapay Bağışıklık Sistemleri
Doğal bağışıklık sistemleri canlıları bakteriler, virüsler, parazitler ve toksinler gibi
tehlikeli dış patojenlerden, antijenlerden korumaktadır. Bağışıklık sisteminin örüntü
tanıma, teklik, kendini tanıma, çeşitlilik, kullanıldıktan sonra atılabilme, özerklik,
çok katmanlılık, güvenlik katmanı olmama, anomali tespiti, dinamik olarak değişen
kapsama, dağınıklılık, gürültü toleransı, esneklik, hata toleransı, sağlamlık, öğrenme
ve hafıza, kendi kendine organizasyon ve diğer sistemlerle entegre gibi sahip olduğu
karakteristik özellikleri ve işleyiş yapısının kolayca basit algoritmalara
dönüştürülebilecek nitelikte olması bu sistemi bir metafor olarak kullanma fikrini
getirmiştir. Bu şekilde yapay bağışıklık sistemleri(YBS), örüntü tanıma, hesapsal
güvenlik, anomali tespiti, optimizasyon, makine öğrenmesi, robotik, kontrol,
çizelgeleme, hata teşhisi gibi alanlarda ve bunların alt dallarında; ayrıca ekoloji,
üretim sistemleri, akıllı evler, adaptif gürültü nötralizasyonu, indüktif problem
çözümü, açık web sunucu koordinasyonu, protein yapısı tahmini gibi alanlarda
başarıyla kullanılmış ve etkili sonuçlar alınmıştır. Etkili olarak daha birçok alanda
kullanılabilecektir. (Alataş ve Akın, 2004).
YBS’nin yapısı, katmanlı bir yaklaşım olarak düşünülebilir. Her sistemin temeli
uygulama alanıdır. Bu alan için sistemin bileşenlerinin uygun bir temsiline karar
verildikten sonra bir ya da daha fazla afinite ölçüleri sistemin elemanları arasındaki
etkileşimleri ölçmek için kullanılır. Birçok olası afinite ölçüleri Hamming ya da
Öklit uzaklıkları gibi, vardır. Bir sonraki katman sistemin davranışını (dinamiğini)
yöneten işlemler ya da algoritmaları içerir. Buna göre yapı, şekil-uzayı olarak
adlandırılan bağışık hücreler ve moleküllerin genel soyut modelini çıkarmakla başlar.
(Alataş ve Akın, 2004)
18
3.5.1. Bağışık Hücre, Molekül ve Bunların Etkileşiminin Soyut Modelleri
Bir antijenin tanınabilmesi için moleküllerin (antijen ya da antikor) yüzeylerindeki
belli bölgelerde birbirleriyle tümleyen olarak bağlanmaları gerekmektedir. Bu
yüzden moleküller arasında geniş tümleyen bölgelerine ihtiyaç vardır. Temsil olarak
vektörler kullanılabilir. Antikor = ⟨Ab1, Ab2, ..., AbL⟩, Antijen = ⟨Ag1, Ag2, ...,
AgL⟩ gibi. Gerçek değerli şekil uzayı, tam sayı şekil uzayı, Hamming şekil uzayı ve
sembolik şekil uzayı da kullanılabilir. Hücreler arasındaki etkileşim de afinite ile
açıklanır. Afinite çeşitli uzaklık ölçülerine bağlıdır. Bunun için Öklit, Hamming,
Manhattan vb. uzaklıklar kullanılabilir (Alataş ve Akın, 2004).
3.5.2. Algoritmalar ve Đşlemler
Đki temel bileşen (kemik iliği ve timus) ve iki ayrı teori (klonal seçim ve bağışık ağ)
bağışıklık sistemini modellemek için kullanılır (de Castro ve Timmis, 2002).
a) Kemik iliği modeli: Hücreler ve moleküllerin repertuarını üretmede kullanılır.
b) Timus modeli: Öz/öz olmayan ayrımı yapmaya yetenekli hücre ve moleküllerin
repertuarını üretmede kullanılır.
c) Klonal seçim algoritmaları: Bağışıklık sisteminin bileşenlerinin harici çevre ve
antijenlerle nasıl etkileşim yaptığını kontrol etmede kullanılır
d) Bağışık ağ modelleri: Yapılarını, dinamiğini ve metadinamiğini de içeren
bağışık ağların benzetiminde kullanılır.
3.5.2.1. Kemik Đliği Modelleri
Gen kütüphanesi kemik iliğinden antikorları üretmek için kullanılır. Bu fikri
reseptörleri temsil eden nitelik dizgelerini üretmek için kullanırız. Antikorlar gen
kütüphanelerinden gelişigüzel birbirine bağlanma ile oluşur (Alataş ve Akın, 2004).
19
3.5.2.2. Timus Modelleri
T hücreleri kemik iliğinde üretilir ve timusa göçer ve orada immünokompetent
hücrelere farklılaşır (pozitif seçim) ve diğerleri öz peptit/MHC kompleksleriyle güçlü
bir tanıma yaptığından repertuardan temizlenir (negatif seçim). Bu timik pozitif ve
negatif seçim timustan ayrılan ve perifere giden T hücre populasyonunun öz
peptitleri tanıyan hücreleri ihtiva etmediğini ve aynı zamanda bir öz MHC molekülü
tarafından sunulan bir peptit ile uyarılmaya hazır olduğunu garanti eder. Pozitif
seçim algoritmaları, şu şekilde özetlenebilir (de Castro ve Timmis, 2002):
1) Başlangıç: Olgunlaşmamış T hücrelerinin potansiyel repertuarını, P, üret. Tüm
molekülleri (reseptör ve MHCler) aynı uzunluklu, L, ikili dizgeler ile temsil
edildiği varsayıldığında 2L
ayrı hücre üretilir.
2) Afinite değerlendirmesi: P’deki tüm elemanların öz hücre kümesi S’deki tüm
elemanlar ile afinitelerini belirle.
3) Uygun repertuarın üretimi: P’nin bir elemanı ile MHC’nin en az bir elemanı
arasındaki afinite verilen çapraz reaktif eşiği ε’den büyükse ya da buna eşitse o
zaman T hücresi bu MHC’yi tanır ve pozitif olarak seçilir ve sisteme tanıtılır
(uygun repertuar A’ya); değilse T hücresi yok edilir.
T hücrelerinin negatif seçimi reseptörleri öz MHC tarafından sunulan öz peptitlere
bağlanma kabiliyeti olan T hücrelerinin yok edilmesinden sorumludur. Bu işlem
timustan ayrılan T hücrelerinin herhangi bir öz hücreyi ya da molekülü
tanımayacağını garanti eder. Bu işlemlerden esinlenerek geliştirilen negatif seçim
algoritması, şu şekilde özetlenebilir (Gonzales vd., 2003):
1) Başlangıç: Gelişigüzel dizgeler üret ve bunları olgunlaşmamış T hücrelerinin bir
P kümesine yerleştir. Tüm moleküllerin (reseptör, öz peptitler) aynı uzunlukta, L,
ikili dizgeler olarak temsil edildiğini varsayıldığında 2L ayrı hücre üretilir.
2) Afinite değerlendirmesi: P’deki tüm T hücrelerinin S’deki tüm elemanlarla
afinitesini belirle.
20
3) Uygun repertuarın üretimi: Olgunlaşmamış bir T hücresinin (P’nin elemanı) en
az bir öz peptitle afinitesi verilen çapraz reaktif eşiğinden, ε, büyükse ya da buna
eşitse o zaman T hücresi bu öz peptidi tanır ve yok edilmelidir (negatif seçim);
değilse T hücresi uygun repertuar A’ya tanıtılır.
Negatif seçim iki aşamaya bölünmüştür. Yukarıda anlatılan algılama safhasıdır.
Diğer safha ise gözetleme safhasıdır. Bu safhada korunmuş dizgeler kümesi, S*
uygun repertuar A’nın elemanları ile karşılaştırılır. S* kümesi S’in kendisi olabilir ya
da tamamen yeni bir küme olabilir ya da, S’nin elemanlarından oluşmuş olabilir. Bir
tanıma olursa o zaman bir öz olmayan örüntü tespit edilmiştir (Alataş ve Akın,
2004).
3.5.2.3. Klonal Seçim Algoritmaları
Klonal seçim prensibi, bağışıklık sisteminin bir antijenik uyarıma karşı bağışıklık
cevabının temel özelliklerini tanımlamak amacıyla kullanılır. Bu prensip sadece
antijenleri tanıyan hücrelerin çoğaldığı yani tanımayanlara göre seçildiği fikrini
vurgular. Bu seçilmiş hücreler, afinite olgunlaşma işlemine mazur kalırlar ve bu
işlem seçilmiş hücrelerin antijenlere benzerliğini geliştirir. Burada, bağışıklıkla ilgili
dikkate alınan temel olaylar aşağıda verilmiştir:
• Dağarcıktan fonksiyonel olarak ayırt edilmiş olan hafıza hücrelerinin varlığının
sağlanması
• En fazla uyarılmış hücrelerin seçimi ve klonlaşması
• Uyarılmamış hücrelerin ölümü
• Daha yüksek afiniteli klonların afinite olgunlaşması ve tekrar seçimi
• Farklılaşmanın üretilmesi ve sağlanması
• Hücre afinitesi ile orantılı olarak hipermutasyon işleminin uygulanması
Algoritma Şekil 3.4’de özetlenmiştir (de Castro ve Von Zuben, 2000a):
21
Gelişigüzel bir populasyon (P) üret For Antijendeki her örüntü için Her P ile afiniteyi belirle P ile en yüksek n afiniteliyi seç Antijen afinitesi ile doğru orantılı olarak klonlama ve mutasyon yap P’ye yeni mutantlar ekle endFor M nin bölümünü oluşturmak için en yüksek afiniteli P’yi seç n tanesini yeni oluşturulmuşlarla yer değiştir Sonlandırma kriterine kadar
Şekil 3.4. Klonal seçim algoritması
3.5.2.4. Bağışık Ağ Modelleri
Diferansiyel denklemler temelli sürekli ağ modelleri başarılı bir şekilde özerk
hareket, optimizasyon ve otomatik kontrol gibi kompleks problemlere uygulanmıştır.
Bunlar aynı zamanda fark denklemleri temelli ayrık ağ modellerine de ilham
olmuştur. Bu model Şekil 3.5’de özetlenmiştir (De Castro ve Von Zuben, 2000b).
1. Başlangıç: Ağ antikorlarının gelişigüzel bir başlangıç populasyonunu üret 2. Antijenik temsil: Her antijenik örüntü için do: 2.1. Klonal seçim ve genişletme: Her ağ elemanı için sunulan antijen için afiniteyi hesapla. Yüksek afiniteli birkaç elemanı seç ve afiniteleri ile doğru orantılı olarak bunları tekrar üret (klonla) 2.2.Afinite olgunlaşması: Afinitelerle ters orantılı olarak her klona mutasyon uygula. En iyi afiniteli birkaç klonu tekrar seç ve bunları klonal bellek setine yerleştir 2.3. Metadinamik: Antijenle afinitesi verilen eşikten düşük olan hafıza klonlarını yok et 2.4.Klonal etkileşim: Klonal hafıza setinin tüm elemanları arasında ağ etkileşimini (afinite) belirle 2.5. Klonal baskı: Birbirleriyle afinitesi verilen eşikten az olan hafıza klonlarını elime et 2.6. Ağ yapımı: Kalan klonal hafızanın klonlarını tüm ağ antikorları ile dahil et 3. Ağ etkileşimi: Her ağ antikor çifti arasındaki benzerliği belirle 4. Ağ baskılama: Afinitesi verilen eşikten az olan ağ antikorlarını yok et 5. Çeşitlilik: Ağa yeni gelişigüzel üretilmiş antikorlar ilave et 6. Çevrim: Đkiden beşinciye kadarki aşamaları verilen iterasyon sayısına kadar tekrar et.
Şekil 3.5. De Castro ve Von Zuben’in ağ modeli
3.6. Genetik Algoritmalar
Genetik algoritmalar, doğada gözlemlenen evrimsel sürece benzer bir şekilde çalışan
arama ve eniyileme yöntemidir. Karmaşık çok boyutlu arama uzayında en iyinin
hayatta kalması ilkesine göre bütünsel en iyi çözümü arar.
Genetik algoritmaların temel ilkeleri ilk kez Michigan Üniversitesi'nde John Holland
tarafından ortaya atılmıştır. Holland 1975 yılında yaptığı çalışmaları “Adaptation in
Natural and Artificial Systems” adlı kitabında bir araya getirmiştir. Đlk olarak
22
Holland evrim yasalarını genetik algoritmalar içinde eniyileme problemleri için
kullanmıştır.
Genetik algoritmanın temel çalışma prensibi Darwin’in ‘Doğal Seçim’ ilkesine
dayanır. Darwin, “Türlerin Kökeni” adlı yapıtında iki varsayımı ortaya atmıştır
(Demirsoy, 1998):
1) Tüm organizmalar, gereğinden fazla yavru meydana getirme yeteneğine
sahiptirler. Bununla beraber elemine edilenler ile popülasyonda denge
sağlanmaktadır.
2) Bir tür içerisindeki bireyler, kalıtsal özellikleri bakımından farklıdırlar.
Genetik Algoritma doğadaki canlıların geçirdiği evrim sürecini ele alır. Amaç, doğal
sistemlerin uyum sağlama özelliğini dikkate alarak, yapay sistemler tasarlamaktır.
Genetik algoritmada tasarlanan yapay sistemde ele alınan en önemli faktör ise
sağlamlıktır. Yapay sistemler, doğal sistemler kadar sağlam olabilse, mevcut
sistemler faaliyetlerini daha uzun zaman sürdürecekler ve pahalı olan yeniden
tasarlama ve uyarlama işlemleri ortadan kalkacaktır. Genetik algoritmalar
konusundaki esas gelişim ise, John Holland’ın doktora öğrencisi David E. Goldberg
tarafından 1985 yılında hazırlanan “Gaz Boru hatlarının Genetik Algoritma
Kullanılarak Denetlenmesi” konulu tez ile sağlanmıştır. Bu ilk uygulamadan sonra
Goldberg’in 1989 yılında yayımladığı “Makine Öğrenmesi, Arama ve Optimizasyon
Đçin Genetik Algoritma” adlı kitabı, genetik algoritmaya yeni bir boyut kazandırmış
ve günümüzde dahi genetik algoritma konusunda en kapsamlı referans olma
özelliğini korumuştur (Körez, 2005).
Genetik algoritmalar problemlerin çözümü için evrimsel süreci bilgisayar ortamında
taklit ederler. Diğer eniyileme yöntemlerinde olduğu gibi çözüm için tek bir yapının
geliştirilmesi yerine, böyle yapılardan meydana gelen bir küme oluştururlar. Problem
için olası pek çok çözümü temsil eden bu küme genetik algoritma terminolojisinde
nüfus adını alır. Nüfuslar vektör, kromozom veya birey adı verilen sayı dizilerinden
23
oluşur. Birey içindeki her bir elemana gen adı verilir. Nüfustaki bireyler evrimsel
süreç içinde genetik algoritma işlemcileri tarafından belirlenirler.
Problemin bireyler içindeki gösterimi problemden probleme değişiklik gösterir.
Genetik algoritmaların problemin çözümündeki başarısına karar vermedeki en
önemli faktör, problemin çözümünü temsil eden bireylerin gösterimidir. Nüfus
içindeki her bireyin problem için çözüm olup olmayacağına karar veren bir uygunluk
fonksiyonu vardır. Uygunluk fonksiyonundan dönen değere göre yüksek değere
sahip olan bireylere, nüfustaki diğer bireyler ile çoğalmaları için fırsat verilir. Bu
bireyler çaprazlama işlemi sonunda çocuk adı verilen yeni bireyler üretirler. Çocuk
kendisini meydana getiren ebeveynlerin (anne, baba) özelliklerini taşır. Yeni bireyler
üretilirken düşük uygunluk değerine sahip bireyler daha az seçileceğinden bu
bireyler bir süre sonra nüfus dışında bırakılırlar. Yeni nüfus, bir önceki nüfusta yer
alan uygunluğu yüksek bireylerin bir araya gelip çoğalmalarıyla oluşur. Aynı
zamanda bu nüfus önceki nüfusun uygunluğu yüksek bireylerinin sahip olduğu
özelliklerin büyük bir kısmını içerir. Böylelikle, pek çok nesil aracılığıyla iyi
özellikler nüfus içersinde yayılırlar ve genetik işlemler aracılığıyla da diğer iyi
özelliklerle birleşirler. Uygunluk değeri yüksek olan ne kadar çok birey bir araya
gelip, yeni bireyler oluşturursa arama uzayı içerisinde o kadar iyi bir çalışma alanı
elde edilir. Probleme ait en iyi çözümün bulunabilmesi için;
• Bireylerin gösterimi doğru bir şekilde yapılmalı,
• Uygunluk fonksiyonu etkin bir şekilde oluşturulmalı,
• Doğru genetik işlemciler seçilmeli.
Bu durumda çözüm kümesi problem için bir noktada birleşecektir. Genetik
algoritmalar, diğer eniyileme yöntemleri kullanılırken büyük zorluklarla karşılaşılan,
oldukça büyük arama uzayına sahip problemlerin çözümünde başarı göstermektedir.
Bir problemin bütünsel en iyi çözümünü bulmak için garanti vermezler. Ancak
problemlere makul bir süre içinde, kabul edilebilir, iyi çözümler bulurlar. Genetik
algoritmaların asıl amacı, hiçbir çözüm tekniği bulunmayan problemlere çözüm
aramaktır. Kendilerine has çözüm teknikleri olan özel problemlerin çözümü için
24
mutlak sonucun hızı ve kesinliği açısından genetik algoritmalar kullanılmazlar.
Genetik algoritmalar ancak;
• Arama uzayının büyük ve karmaşık olduğu,
• Mevcut bilgiyle sınırlı arama uzayında çözümün zor olduğu,
• Problemin belirli bir matematiksel modelle ifade edilemediği,
• Geleneksel eniyileme yöntemlerinden istenen sonucun alınmadığı alanlarda
etkili ve kullanışlıdır.
Genetik algoritmalar çizelgeleme, parametre ve sistem tanılama, kontrol sistemleri,
robot uygulamaları, görüntü ve ses tanıma, mühendislik tasarımları, planlama, yapay
zeka uygulamaları, uzman sistemler, fonksiyon ve kombinasyonel eniyileme
problemleri ağ tasarım problemleri, yol bulma problemleri, sosyal ve ekonomik
planlama problemleri için diğer eniyileme yöntemlerinin yanında başarılı sonuçlar
vermektedir.
3.6.1. Genetik Algoritmanın Diğer yöntemlerden farkı
Genetik algoritmalar problemlerin çözümünü parametrelerin değerleriyle değil,
kodlarıyla arar. Parametreler kodlanabildiği sürece çözüm üretilebilir. Bu sebeple
genetik algoritmalar ne yaptığı konusunda bilgi içermez, nasıl yaptığını bilir.
• Genetik algoritmalar aramaya tek bir noktadan değil, noktalar kümesinden başlar.
Bu nedenle çoğunlukla yerel en iyi çözümde sıkışıp kalmazlar.
• Genetik algoritmalar türev yerine uygunluk fonksiyonunun değerini kullanır. Bu
değerin kullanılması ayrıca yardımcı bir bilginin kullanılmasını gerektirmez.
• Genetik algoritmalar gerekirci kuralları değil olasılıksal kuralları kullanır.
3.6.2. Genetik Algoritma Tekniği
Genetik Algoritmada Kullanılan Temel Kavramlar şu şekilde sıralanabilir:
25
3.6.2.1. Gen
Kendi başına anlamlı genetik bilgi taşıyan en küçük genetik yapıdır. Genetik
algoritmanın kullanıldığı programlama yapısında gen yapıları programcının
tanımlamasına bağlıdır.
3.6.2.2. Kromozom
Birden fazla genin bir araya gelerek oluşturduğu diziye denir. Kromozomlar,
alternatif aday çözümleri gösterirler. Kromozomlar genetik algoritma yaklaşımında
üzerinde durulan en önemli birim olduğu için bilgisayar ortamında iyi ifade edilmesi
gerekir.
3.6.2.3. Popülasyon
Kromozomlardan oluşan topluluğa denir. Popülasyon, geçerli alternatif çözüm
kümesidir. Popülasyondaki birey sayısı (kromozom) genellikle sabit tutulur. Genetik
algoritmada popülasyondaki birey sayısı ile ilgili genel bir kural yoktur.
Popülasyondaki kromozom sayısı arttıkça çözüme ulaşma süresi (iterasyon sayısı)
azalır. Problemin özelliğine göre seçilecek olan popülasyon sayısı programcı
tarafından iyi belirlenmelidir.
3.6.2.4. Allel (Allele)
Bir özelliği temsil eden bir genin alabileceği değişik değerlere denilir.
3.6.2.5. Locus
Kromozom üzerindeki her bitin yerine verilen isimdir.
26
3.6.2.6. Genotip (Genotype)
Kodlanmış çözümden eski haline dönüştürülen çözümdür.
3.6.2.7. Fenotip (Phenotype)
Kodlanan çözümdür (Cengiz, 2004).
3.6.3. Genetik Algoritmada Kullanılan Operatörler
Algoritma ilk olarak popülasyon diye tabir edilen bir çözüm (kromozomlarla ifade
edilir) seti ile başlatılır. Bir popülasyondan alınan sonuçlar bir öncekinden daha iyi
olacağı beklenen yeni bir popülasyon oluşturmak için kullanılır. Yeni popülasyon
oluşturulması için seçilen çözümler uyumluluklarına göre seçilir. Çünkü uyumlu
olanların daha iyi sonuçlar üretmesi olasıdır. Bu istenen çözüm sağlanıncaya kadar
devam ettirilir (Kurt ve Semetay, 2001).
3.6.3.1. Kodlama
Her bir kromozom bir diziden oluşur. Bu dizideki her bir bit, çözümün bir
karakterine sahip olabilir.
Đkili Sayı Sisteminde (Binary) Kodlama
En yaygın olarak kullanılan kodlama çeşididir. Binary kodlamada kromozomlar 1 ve
0 sayılarından oluşur.
Çizelge 3.1. Đkili sayı sisteminde kodlanmış örnek kromozomlar
27
Permutasyon Kodlama
Permutasyon kodlama gezici satıcı problemi gibi sıralı problemlerde
kullanılabilmektedir.
Permutasyon kodlamasında her kromozom, her biri art arda gelen sayı dizisinin bir
elemanı olan çok basamaklı bir sayı ile ifade edilir. Permutasyon kodlaması, sadece
sıralama problemlerinin çözümü için kullanılabilir. Bu durumda bile bazı çaprazlama
ve mutasyon tipleri için düzeltmeler kromozomu uygun hale getirecek şekilde
yapılmalıdır.
Çizelge 3.2. Permutasyon kodlama sistemi ile kodlanmış örnek kromozomlar
Değer Kodlaması
Reel sayılar gibi bazı karmaşık değerlerin kullanıldığı durumda problemlerin
çözümünde direkt değer şifrelemesi kullanılabilir. Bu tip problemlerde 0-1
kodlamasının kullanılması oldukça zordur.
Değer kodlamasında her kromozom, değerlerin oluşturduğu bir dizidir. Değerler
probleme bağlı olarak reel sayılardan karmaşık objelere kadar birçok şey olabilir.
Değer kodlamasında bazı özel problemler için çok uygundur. Diğer yandan, bu
şifrelemede probleme özgü bazı çaprazlama ve mutasyonlar geliştirilmelidir.
28
Çizelge 3.3. Değer kodlama sistemi ile kodlanmış örnek kromozomlar
3.6.3.2. Seçim
Bir nesildeki kromozomlardan bir kısmı bir sonraki nesile aktarılırken bir kısmı da
yok olur. Đşte bu aşamada hangi kromozomların bir sonraki nesile aktarılacağı
kurulan seçim mekanizmaları ile sağlanır.
Kromozomların eşlenmesi, kromozomların uygunluk değerlerine göre yapılır. Bu
seçimi yapmak için Rulet Çarkı, Sıralı Seçim, Düzenli Durum Seçimi ve Elitizim
Seçimi gibi seçme yöntemleri vardır. Burada amaç, uygunlukları küçük olan
kromozomların elenip uygunlukları büyük olan kromozomların ağırlıklarını
hissettirerek yeni bir nesil oluşturmaktır. Seçim işlemi, uygunlukları büyük
kromozomlar uygunlukları küçük kromozomlar üzerine tekrar yazılarak yapılır.
Kromozomların karakterleri, sahip oldukları uygunluk değerlerine göre saptanır
(Cengiz, 2004).
Seçim, çeşitli kriterlere göre yapılabilir. Rulet Çarkı, Sıralı Seçim, Düzenli Durum
Seçimi ve Elitizim Seçimi bunlardan bazılarıdır.
Rulet Çarkı
Rulet seçiminde kromozomlar uyumluluk fonksiyonuna göre bir rulet etrafına
gruplanır. Uyumluluk fonksiyonu, herhangi bir kritere uyan bireylerin seçilmesi için
kullanılır. Buradaki çalışma prensibi, bu çarkın döndürülerek herhangi bir dilimde
durmasını beklemektir. Doğal olarak okun en fazla dilime sahip olan kromozomu
gösterme olasılığı en büyüktür.
29
Sıralı Seçim
Rulet seçimi eğer uyumluluk çok fazla değişiyorsa sorun çıkartabilir. Örneğin en iyi
kromozomun uyumluluğu %90 ise diğer kromozomların seçilme şansı azalacaktır.
Bunu önlemek için sıralı seçim kullanılabilir. Sıralı seçimde en kötü uyumlulukta
olan kromozoma 1 değeri sonrakine 2 değeri verilir ve böylelikle seçilmede bunlara
öncelik tanınmış olur. Bu şekilde onların da seçilme şansı artar. Fakat bu, çözümün
daha geç yakınsamasına neden olabilir (Obitko, 1998).
Kararlı Durum Seçimi
Bu seçim, anne baba belirlenmesinde özel bir metod değildir. Kromozomların büyük
bir bölümü bir sonraki nesilde hayatını devam ettirecektir düşüncesi, bu seçimin ana
fikrini oluşturur. Bu seçimde ilk olarak her bir nesilde uyumlulukları yüksek olan
bazı kromozomlar çocukları oluşturmak için belirlenirler. Daha sonra uyumluluk
değerleri düşük olan kromozomlar atılır. Kalan bireyler yeni nesili devam ettirir
(Obitko, 1998).
Elitizm (Seçkinlik) Seçimi
Çaprazlama ve mutasyon ile yeni nesil oluşturulduğunda en iyi kromozomun
kaybedileceği büyük bir değişim meydana gelir. Elitizm adı verilen bu metotta ilk
olarak yeni nesil için en iyi kromozomun bir kopyası alınır. Geriye kalan adımlar
diğer metotlara benzer şekilde gerçekleştirilir. Kaybolan en iyi çözümü koruduğu
için bu metot genetik algoritmanın performansını çok hızlı bir şekilde arttırabilir
(Obitko, 1998).
3.6.3.3. Çaprazlama
Kromozomların nasıl temsil edileceğine karar verildikten sonra çaprazlama
yapılabilir. Çaprazlama ebeveynlerden bazı genleri alarak yeni bireyler oluşturma
işlemidir. Burada amaç, eldeki nesilden farklı nesiller elde etmektir. Çaprazlama
30
yapılacak konum rastgele seçilir. Oluşan yeni birey ebeveynlerin bazı özelliklerini
almış ve bir bakıma ikisinin kopyası olmuştur. Daha iyi performans almak amacıyla
değişik çaprazlamalar kullanılabilir (Kurt ve Semetay, 2001).
Tek Noktalı Çaprazlama
Bu işlemde kromozomlar rastgele bir yerinden kesilir ve sonra ilgili genler ile yer
değiştirilir.
Şekil 3.6. Tek noktalı çaprazlama
Çift Noktalı Çaprazlama
Bir öncekine benzer şekilde işlem, kesimin kromozom boyunca iki yerde yapılması
ile aynen tekrarlanır.
Şekil 3.7. Çift noktalı çaprazlama
Uniform Çaprazlama
Anne ve babadan bitler rastgele şekilde seçilerek bir sonraki nesile kopyalanır.
31
Şekil 3.8. Uniform çaprazlama
Aritmetik Çaprazlama
Bu çaprazlama metodunda anne ve babanın genleri çeşitli aritmetik işlemlere tabi
tutularak yeni nesilin oluşması sağlanır (Obitko, 1998).
Şekil 3.9. Aritmetik çaprazlama
3.6.3.4. Mutasyon
Genetik algoritmada tam anlamı ile rastlantısal işlem, mutasyondur. Mutasyon, bir
bireyin içerdiği bilginin (genin) rastlantısal olarak değiştirilmesi işlemidir. Bu şekilde
her bireye bir sayı gözü ile bakıldığında, mutasyon sonucunda oluşabilecek sayı,
bireylerin her birinin içerdiği değerden bağımsız olacaktır. Çaprazlamadaki kısıtlama
bu işlemde bulunmamaktadır. Mutasyon, genetik algoritmanın yerel bir en iyi
noktasına takılmasını engeller. Önemli olan, mutasyon olasılığının uygun seçimidir.
Bu olasılık, yöntemin yerel bir noktaya takılmasını engelleyecek derecede yüksek,
ancak çaprazlama ve çoğullama işlemlerinin getirdiği en iyi noktaya gidişi
engellemeyecek ölçüde düşük seçilmelidir (Cengiz, 2004).
Mutasyon ikili sayı sisteminde, popülasyon belirli bir büyüklüğe geldiği zaman
popülasyon içerisindeki herhangi bir bireyin herhangi bir bitinin değiştirilmesi ile
32
gerçekleştirilmektedir. Bu bit 1 (bir) ise 0 (sıfır); 0 (sıfır) ise 1 (bir) olmaktadır.
Onluk Sistemde ise Mutasyon biraz değişik yapılmaktadır.
• Ters Çevirme Mutasyonu
• Ekleme Mutasyonu
• Yer Değişikliği Mutasyonu
• Karşılıklı Değişim Mutasyonu
Ters Çevirme Mutasyonu
Rast gele iki pozisyon seçerek yerlerini değiştirerek işlemi gerçekleştirir.
Çizelge 3.4. Ters Çevirme Mutasyonu
Çocuk 7 3 2 9 10 1 6 4 5 8
Mutasyonlu Çocuk 7 3 1 10 9 2 6 4 5 8
Ekleme Mutasyonu
Rastgele bir parça seçerek o parçayı rastgele bir yere yerleştirir.
Çizelge 3.5. Ekleme Mutasyonu
Çocuk 7 3 2 9 1 6 4 5 8
Mutasyonlu Çocuk 7 3 4 2 9 1 6 5 8
Yer Değişikliği Mutasyonu
Rastgele bir alt dizi seçerek rastgele başka bir alt dizi ile yer değiştirir.
33
Çizelge 3.6. Yer Değişikliği Mutasyonu
Çocuk 7 3 2 9 10 1 6 4 5 8
Mutasyonlu Çocuk 7 3 6 4 5 2 9 10 1 8
Karşılıklı Değişim Mutasyonu
Rastgele iki gen seçer ve yerlerini değiştirir.
Çizelge 3.7. Karşılıklı Değişim Mutasyonu
Çocuk 7 3 2 9 10 1 6 4 5 8
Mutasyonlu Çocuk 7 3 5 9 10 1 6 4 2 8
3.6.4. Genetik Algoritmanın Çalışma Prensibi
Đlk olarak toplumda bulunacak birey sayısı belirlenir. Kullanılacak sayı için bir
standart yoktur. Genel olarak önerilen 100-300 aralığında bir büyüklüktür. Büyüklük
seçiminde yapılan işlemlerin karmaşıklığı ve aramanın derinliği önemlidir. Toplum,
bu işlemden sonra belirlenen uzay içerisinde rastgele sayılardan oluşturulur.
Kromozomların ne kadar iyi olduğunu bulan fonksiyona uygunluk fonksiyonu denir.
Bu fonksiyon işletilerek kromozomların uygunluklarının bulunmasına ise hesaplama
(evaluation) adı verilir. Bu fonksiyon genetik algoritmanın beynini oluşturmaktadır.
Genetik algoritmada probleme özel çalışan tek kısım bu fonksiyondur. Uygunluk
fonksiyonu kromozomları problemin parametreleri haline getirerek onların bir
bakıma şifresini çözmektedir (decoding). Daha sonra bu parametrelere göre
hesaplama yapılarak kromozomların uygunluğu bulunur. Kromozomların eşlenmesi
kromozomların uygunluk değerlerine göre yapılır. Bir sonraki nesil için anne ve baba
olacak kromozomlar, seçim metotlarından herhangi birisi ile belirlenir. Anne ve baba
olarak belirlenen kromozomlar, yine daha önceden belirlenen çaprazlama
metotlarından birisi ile çaprazlanırlar. Çaprazlama, genetik algoritmanın en temel
34
operatörüdür. Çaprazlama, toplumda çeşitliliği sağlar. Đyi özelliklerin bir araya
gelmesini kolaylaştırarak en iyiye yaklaşmayı sağlar. Mutasyon, kromozomun bir
parçasının dışarıdan değiştirilmesi şeklinde tanımlanır. Değiştirme görünüşte genetik
algoritmanın dayanak noktasıdır, ancak etkisi bir çözüm üzerindedir. Bu da yalnız
başına başarılı olmasını zorlaştırır. Çaprazlama ve mutasyonun olasılıkları için kesin
bir sayı yoktur. Mutasyon olasılığı 0.01-0.001, çaprazlama olasılığı 0.5-1.0 aralığında
tavsiye edilir (Cengiz, 2004).
Çaprazlama ve mutasyon sonucu elde edilmiş yeni kromozomlar ile eski
kromozomlar uygunluk değerlerine bağlı olarak en iyiden en kötüye doğru
sıralanırlar. Uygunluk değeri kötü olan kromozomlar çıkartılarak sabit büyüklükte
bir toplum sağlanır.
Genetik algoritma defalarca çalıştırılarak çok sayıda toplum oluşturulup hesaplanır.
Toplumların hesaplanması sırasında en iyi bireyler saklandığı için o ana kadar
bulunmuş en iyi çözüm çözümdür. Şekil 3.10’de genetik algoritmanın akış diyagramı
verilmiştir (Cengiz, 2004).
35
Şekil 3.10. Genetik algoritmanın akış diyagramı
36
3.6.5. Örnek Uygulama
Buradaki amaç genetik algoritmanın bilgisayar üzerinde nasıl çalıştığını anlatmaktır
(Engin, 2001).
Amaç: f(x)=2x, x€[0,31] şeklinde verilen bir fonksiyonun, verilen aralıkta
maksimizasyonu yapılması istenmektedir.
Đlk olarak x sayısının 0 ve 1’lerden oluşan 2 tabanında kodlanması işlemi
yapılmalıdır. Burada x, 5 bit uzunluğunda bir kodla temsil edilmelidir. Yani
0: “00000” ve 31: “11111” şeklinde gösterilecektir.
Toplumun birey sayısı n:4 olarak seçilmiştir. Toplumu oluşturan dört birey, her biri 5
bit uzunluğunda birer kromozomla temsil edildiği için toplam 20 kere yazı tura
atmak suretiyle belirlenmiştir. Elde edilen birey kromozomları aşağıdadır.
Birey 1: 01100, x = 12 , 2x = 24
Birey 2: 11001, x = 25 , 2x = 50
Birey 3: 00100, x = 4 , 2x = 8
Birey 4: 10010, x = 18 , 2x = 36
Yukarıda belirlenen bireyler için f(x)=2x, bireylerin uygunluk değerlerini verir. Dört
bireyin toplam uygunluk değerleri “24+50+8+36=118” dir. Dolayısıyla her bir
bireyin rulet çarkında kaplayacağı alan şu şekilde hesaplanır.
Birey 1: 24/118=0.20 : %20
Birey 2: 50/118=0.42 : %42
Birey 3: 8/118=0.08 : %8
Birey 4: 36/118=0.30 : %30
37
Bu değerler, rulet tekerleğinin her çevrilişinde hangi olasılıkla hangi bireyin
seçileceğini belirtir, yani 0.20 olasılıkla 1 numaralı birey seçilecektir. Rulet tekerleği
ve bireylerin tekerlek üzerindeki dağılımları Şekil 3.11’de gösterilmiştir.
Şekil 3.11. Rulet çarkı dağılımı
Toplumdaki birey sayısının sabit kaldığı varsayıldığından dolayı, rulet tekerleği 4
kere çevrilerek çiftleşme havuzu oluşturulacaktır. Rulet tekerleği döndürülmüş ve şu
sonuçlar elde edilmiştir.
Birey 1 : 1 kere
Birey 2 : 2 kere
Birey 3 : 0 kere
Birey 4 : 1 kere
Bunun sonucunda elde edilen çiftleşme havuzunda şu şekildedir;
Aday 1 : 01100 (Birey 1)
Aday 2 : 11001 (Birey 2)
Aday 3 : 11001 (Birey 2)
Aday 4 : 10010 (Birey 4)
Çiftleşme havuzu belirlendikten sonra iki aşamalı çaprazlama uygulanır. Đlk aşamada
adaylar çiftleşmek üzere rastgele olarak eşlenirler. Her ikili grup için bir kere zar
atılarak çaprazlaşmanın oluşacağı nokta belirlenir. Rastgele eşleştirme yapılmış ve
bunun sonucunca (Aday 1, Aday 2) ve (Aday 3, Aday 4) ikili grupları oluşmuştur.
B1 %20
B2 %42
B4 %30
B3%8
38
Çaprazlaşma noktaları, zar atılarak 1. Grup için k=4 ve 2. Grup içinde k=2 olarak
belirlenmiştir. Bu aşamadan sonra çaprazlaşma gerçekleştirilmiş ve şu sonuçlar
oluşmuştur; (çaprazlaşma noktaları “/” ile belirtilmiştir.)
Çiftleşme grubu 1: (k=4)
Aday 1 : 0110/0 oluşan Birey 1 : 01101
Aday 2 : 1100/1 oluşan Birey 2 : 11000
Çiftleşme grubu 2 : (k=2)
Aday 3 : 11/001 oluşan Birey 3 : 11010
Aday 4 : 10/010 oluşan Birey 4 : 10001
Son aşama olan mutasyon, bitler düzeyinde uygulanır. Bu örnekte her bir bit için
(toplam 20 bit var) mutasyon olma olasılığı 0.01 olarak seçilmiştir. Dolayısıyla her
bir bit için ağırlıklı yazı/tura (mutasyon olasılığına göre) atılarak hangi bitlerin
mutasyona uğrayacağı belirlenir. Bu işlem yapılmış ve sonuçta, Birey 3’ün 1
numaralı bitinde mutasyon olacağı ortaya çıkmıştır.
Oluşan Birey 3 : 11010
Mutasyon sonucu oluşan Birey 3 : 11011
Bu adımın tamamlanmasıyla bir sonraki kuşağı oluşturacak toplumun bireyleri
belirlenmiş olur. Yeni toplum şu şekildedir;
Birey 1 : 01101, x=13, 2x=26
Birey 2 : 11000, x=24, 2x=48
Birey 3 : 11011, x=27, 2x=54
Birey 4 : 10001, x=15, 2x=30
3 temel operatörden oluşan genetik algoritma her aşamada yeni oluşan kuşağa
uygulanarak bir sonraki kuşak elde edilecektir. Yukarıdaki örnekte tek bir iterasyon
yapılmış ve başlangıç toplumundan bir sonraki kuşak oluşturulmuştur. Ancak genetik
39
algoritmanın çalışmasının tam olarak gözlenebilmesi için tek bir iterasyon yeterli
değildir. Yukarıdaki işlemlerde her şey çok fazla rastgele gibi görünse de, uygunluk
değeri yüksek olan bireylerin seçilme ve çiftleşme olasılıkları yüksek olduğu için
kuşaklar ilerledikçe toplumu oluşturan bireylerin uygunluk değerlerinin
ortalamasının da arttığı gözlenecektir. Bunun için ise tek bir iterasyon yeterli değildir
(Cengiz, 2004).
40
4. ARAŞTIRMA BULGULARI
Bu bölümde yapılan uygulama çalışması araştırması ve bulgularına yer verilmiştir.
Çalışmada hazırlanan program anlatılmıştır. Ayrıca genetik algoritmanın hemşire
çizelgeleme problemlerine uygulanışı adım adım ele alınmış ve elde edilen bulgular
belirtilmiştir.
4.1. Aylık Hemşire Nöbet Çizelgesi Hazırlama Đşlemi
Çift vardiya sistemine göre çalışan hastaneler, 7 gün 24 saat açık olan, günlük
mesailerin 8:00-16:00 ve 16:00-8:00 saatleri arasında yapıldığı hastanelerdir.
Hastanede çalışan tüm hemşireler haftada en az 40 saat çalışmaktadır. Üzerinde
çalışılan zaman çizelgeleme problemi, bu tür hastanelerin tüm servisleri için eldeki
kısıtları sağlayacak en uygun şekilde atanmasını hedef almaktadır. Aylık hemşire
nöbet çizelgesi gün kapama ve kısıtlar olmak üzere 2 kısımda toplanmaktadır.
4.1.1. Gün Kapama
Aylık hemşire nöbet çizelgesinde, her oluşturulacak çizelge için aynen kalması
istenen durumdur. Zorunlu hallerde hemşirelerin isteği doğrultusunda atanmasını
istediği güne ve vardiyaya göre gün kapama işlemi yapılabilmektedir. Ayrıca süt izni
vb. durumlarda çizelgenin oluşturulacağı ay boyunca sadece gündüz vardiyası veya
sadece gece vardiyası isteyen hemşirelere gün kapama işlemi uygulanabilmektedir.
Hemşirelerin izinli olduğu günlerde herhangi bir vardiya yazılmaması da gün
kapama işlemine girmektedir.
4.1.2. Kısıtlar
Aylık hemşire nöbet çizelgelerinin yapılabilmesi için hastanelerin ihtiyaçlarına göre
kısıtlar belirlenmelidir. Bu kısıtlar zorunlu ve esnek kısıtlar olmak üzere ikiye
ayrılabilir. Genetik algoritmanın karşılaması gereken zorunlu kısıtlar ilgili kanun ve
yönetmeliklerle belirlenmiştir. Esnek kısıtlar ise tercihe bağlıdır. Bütün bu kısıtlara
41
ceza değerleri verilerek zorunlu kısıtların tamamen yok edilmesi ve esnek kısıtların
ise en iyi başarı performansının sağlanması gerekmektedir.
Zorunlu Kısıtlar
1) Bir serviste, gece vardiyalarında çalışacak hemşire sayısı bir ay boyunca aynı
olmalıdır.
2) Aynı hemşire iki gün üst üste gece vardiyasında çalışmamalıdır.
3) Aynı hemşire için gece ve gündüz vardiyaları arka arkaya verilmemelidir.
4) Gece vardiyalarından sonraki gün tatil edilmelidir.
5) Hafta sonu gündüz vardiyasında çalışacak hemşire sayısı o servisteki gece
vardiyasında çalışan hemşirelerin sayısı kadar olmalıdır.
6) Aynı hemşire cumartesi ve pazar günleri arka arkaya gündüz vardiyasında
çalışmamalıdır.
7) Her hemşire haftada en az 40 saat çalışmalıdır.
8) Sorumlu hemşireler sadece gündüz vardiyalarında çalışmalıdır.
9) Hemşirelerin izinli veya istekte bulunduğu günlere vardiya yazılmamalıdır.
Esnek Kısıtlar
1) Aynı hemşirenin gün aşırı gece vardiyasında çalışmaması istenebilir.
2) Gece vardiyalarında birden fazla hemşirenin çalıştığı servislerde, birlikte gece
vardiyasında çalışan hemşirelerin tekrar aynı vardiyaya verilmesi önlenebilir.
3) Hafta sonu gündüz vardiyaları farklı hemşirelere verilebilir.
4) Bir serviste çalışan tüm hemşirelerin vardiyaları eşit sayıda olması istenebilir.
4.2. Aylık Hemşire Nöbet Çizelgeleme Đçin Genetik Algoritmalar
Şekil 4.1’de aylık hemşire nöbet çizelgeleme için kullanılan genetik algoritmanın
akış şeması verilmiştir (Yiğit, 2006).
42
Şekil 4.1. Aylık hemşire nöbet çizelgeleme için GA akıl şeması
Tarih girin Başlangıç Popülasyonunu oluştur.
Bireyleri ceza fonksiyonuna göre uygunluk değerlerini hesapla
Bireyleri Rulet çemberinden geçir ve seçilen bireyleri eşleştirme havuzuna al
Eslesen bireyleri çaprazla
Yeni bireylerde değişim oranına göre değişime (mutasyona) uğrat
BAŞLA
Yeni bireyleri gerçek kromozom yapısına göre tamir fonksiyonundan geçir.
Yeni bireylerin uygunluk değerlerini hesapla ve yeni popülasyonda yerine koy
DUR
Belirlenen durum kriteri sağlandı mı?
Hayır
Evet
Ceza fonksiyonuna göre en uygun bireyi al ve uygun nöbet çizelgesi için kaydet
43
4.2.1. Kromozomların Kodlanması
Genetik algoritmanın çizelgelemede çözüm uzayını en iyi ifade edecek kodlarla
oluşturulması gerekmektedir. Çözümün dizilere nasıl kodlanacağı genetik
algoritmada anahtar niteliğindedir. Bu yüzden aday çözüm için her gen bir vardiyaya
karşılık gelir. Kromozom boyutu aşağıdaki gibi ifade edilecek olursa,
Toplam kromozom boyutu = servis sayısı x hemşire sayısı x gün sayısı (4.1)
toplam kromozom boyutunu verir. Bu çalışma için kromozom boyutu her servisteki
hemşire sayısı ve çizelgenin oluşturulacağı ayın gün sayısına çarpımına eşittir ve her
bir gen hemşirelerin çalışacağı vardiyayı göstermektedir. Çalışmada genlere Çizelge
4.1’de gösterildiği gibi onluk sayı sisteminde değerler verilmiştir.
Çizelge 4.1. Kromozomların Kodlanması
Gündüz Vardiyası 1
Gece Vardiyası 2
Tatil 0
Đzin 3
Đstekte bulunulan gece vardiyası 4
Đstekte bulunulan gündüz vardiyası 5
Tüm ay boyunca istenen gündüz vardiyası 7
Tüm ay boyunca gece vardiyası 9
Şekil 4.2’de kromozomların kodlanması için temsili gösterim sunulmuştur (Yiğit,
2006).
44
Şekil 4.2. Kromozomların kodlanması için temsili gösterim
4.2.2. Başlangıç Popülasyonun Oluşturulması
GA’nın ilk aşamasında olası çözümlerin kodlandığı bir çözüm grubu oluşturulur. Bu
çözüm grubu popülasyon, çözümlerin kodları da kromozom(birey) olarak
adlandırılır. Bireyler rastgele oluşturulacağı gibi belirli şartlara bağımlı kalarak da
oluşturulabilir.
Bu çalışmada, popülasyon büyüklüğü 20 birey olarak seçilmiştir. Đlk popülasyondaki
bireyler mümkün olduğunca kısıtlara uygun şekilde oluşturulmaktadır.
Kromozomdaki her gen için gece ve gündüz vardiyaları rastgele olarak atanmaktadır.
Gece vardiyalarından sonraki gün tatil olarak belirlenmektedir. Hazırlanan program
vasıtasıyla daha önceden girilen izin kayıtlarına ve hemşirelerin isteği doğrultusunda
verilecek istek vardiyalara göre ilgili genler uygun şekilde kodlanmaktadır.
4.2.3. Uygunluk Fonksiyonu
Uygunluk fonksiyonu herhangi bir kısıta uymayan bir atamanın cezalandırılması ile
hesaplanır. Yapılan çalışmada aylık nöbet çizelgesinin performansını zorlayacak
Nesil 1 Nesil 2 Nesil 3 ……… Nesil n Đtereasyon
Birey 1 Birey 2 Birey 3 ……… Birey n Popülasyon
Servis 1 Servis 2 Servis 3 ……… Servis n Kromozom
Hemşire 1 Hemşire 2 Hemşire 3 ……… Hemşire n
Gün 1 Gün 2 Gün 3 ……… Gün n Gen
Vardiya_no
2
45
kısıtlara daha önceden belirlenen ceza değerleri atanır ve popülasyondaki her bir
bireyin cezası bu ceza değerlerinin toplanması ile bulunur. Popülasyondaki bireylerin
cezalarının hesaplanması,
F= ∑ ci.ai (4.2)
ile ifade edilir. Burada ci, bir bireydeki kısıtları, ai, açılan kısıt için ceza değerini
göstermektedir. n, ise bir popülasyondaki birey sayısını vermektedir. Böylece, bir
bireyin ceza toplamını minimize ederek bir bireyin uygunluk fonksiyonu,
f= (4.3)
ile bulunabilir. Burada, bir bireyde tüm kısıtlar yerine getirildiğinde uygunluk
fonksiyonunun tanımsız olmasını önlemek için paydadaki ceza toplamına bir
eklenmiştir (Yiğit, 2006).
Çizelge 4.2. Nöbet çizelgesi için sağlanmaya çalışılan kısıtlar ve ceza değerleri
Kısıtlar Ceza Değeri 1 nolu zorunlu kısıt 100
2 nolu zorunlu kısıt 50
3 nolu zorunlu kısıt 50
4 nolu zorunlu kısıt 80
5 nolu zorunlu kısıt 50
6 nolu zorunlu kısıt 70
7 nolu zorunlu kısıt 100
8 nolu zorunlu kısıt (Gün kapama)
9 nolu zorunlu kısıt (Gün kapama)
1 nolu esnek kısıt 20
2 nolu esnek kısıt 2
3 nolu esnek kısıt 2
4 nolu esnek kısıt 2
i=1
n
1
1 + F
46
4.2.4. Rulet Çarkı
Bu çalışmada mevcut popülasyonda en iyi uygunluk değerine sahip bireylerin bir
sonraki nesile aktarılması için rulet çarkı metodu kullanılmıştır. Kullanılan rulet çarkı
metodunda aşağıdaki adımlar takip edilmiştir.
1. Popülasyondaki tüm bireylerin uygunlukları bulunur.
2. Popülasyondaki tüm bireylerin uygunluk toplamı hesaplanır - T.
3. 0 ile T aralığından rastgele bir sayı üretilir - r.
4. Popülasyon büyüklüğü kadar döngü açılır. 0’dan itibaren popülasyondaki
bireylerin uygunluklarının toplamı alınmaya başlanır - t,
5. t, r’den büyük olduğu zaman döngü durdurulur ve bulunulan yerdeki birey
döndürülür.
Bu adımlardan sonra 10 tane anne birey ve 10 tane baba birey seçilmiş olur.
4.2.5. Çaprazlama
Bir önceki nesilden daha iyi nitelikler içeren yeni bireyler yaratmak amacı ile
çaprazlama operatörü kullanılmaktadır. Anne ve baba bireyler seçildikten sonra
karşılıklı gen yapılarının değişmesi çaprazlama operatörü ile sağlanır. Çaprazlama
operatörünün uygulanma olasılığı ne kadar yüksek olursa gen çeşitliliği de o kadar
korunmuş olur. Bu çalışmada, çaprazlama yöntemlerinden biri olan tek noktalı
çaprazlama yöntemi kullanılmış ve çaprazlama oranı %85 olarak belirlenmiştir.
Anne bireyden ve baba bireyden bitler rastgele şekilde seçilerek bir sonraki çocuk
bireylere kopyalanmıştır. Çaprazlama işleminden sonra popülasyonda 20 tane çocuk
birey oluşmuştur.
4.2.6. Mutasyon
Çaprazlama işlemlerinden sonra popülasyonda birbirinin aynı veya çok benzeri
kromozomlar meydana gelir. Bu durumda farklılığı sağlamak ve çözüm uzayında
47
farklı alanları incelemek için mutasyon operatörü kullanılır. Mutasyon aynı bireyde
genlerin yer değiştirilmesi ile sağlanır.
Bu çalışmada mutasyon işleminin uygulanma oranı %15 seçilmiştir ve bu işlem
bireylerden rastgele bir alt dizi seçilip ters çevrilerek yapılmıştır.
4.2.7. Yeni Popülasyon
Bu çalışmada, çaprazlama işleminden sonra popülasyonun büyüklüğü çocuk
bireylerle birlikte 40 birey olmaktadır. Tüm bireylerin uygunlukları hesaplanarak en
uygun 20 birey bir sonraki nesile aktarılır.
4.2.8. Đyileştirme ve En Đyi Birey
Bireyler iyileştirme işlemine tabi tutularak daha iyi bireylerin elde edilmesi
sağlanmıştır.
Bu çalışmada, nesil sayısı(iterasyon) 100 olarak belirlenmiştir. Her iterasyonda,
genetik operatörler olan uygunluk bulma, rulet çarkı, çaprazlama, mutasyon, yeni
popülasyon ve Đyileştirme işlemleri tekrar edilir. 100 nesil sonunda bulunan en iyi
uygunluk değerine sahip olan birey, hastanedeki tüm servisler için aylık nöbet
çizelgesini vermektedir. Çünkü popülasyonların hesaplanmasında en iyi bireyler
saklanmıştır.
4.3. Genetik Algoritma Kullanılarak Hazırlanan Programın Tanıtılması
Aylık nöbet çizelgesi için hazırlanan çizelgeleme programının genel bir akış şeması
Şekil 4.3’de gösterilmiştir. Program için gerekli parametreler kullanıcı etkileşimli bir
grafik ara yüzü kullanılarak sisteme girilir. Daha sonra, çizelgeleme işlemi için GA
ile en uygun aylık nöbet çizelgesi oluşturulur (Yiğit, 2006).
48
Şekil 4.3. Program genel akış şeması
Aylık hemşire nöbet çizelgesi programı C# programlama dili kullanılarak
hazırlanmıştır. Veritabanı olarak Microsoft Access 2007 kullanılmıştır. Bu
veritabanında “cizelgeAy”, “hemsire”, “istek”, “izinler”, “servis”, “Yedek”,
“YedekHftSonu” ve “grafik” isimlerinde toplam 8 tane tablo bulunmaktadır.
“cizelgeAy” tablosu hemşirelerin aylık vardiyalarının, “hemsire” ve “servis”
tabloları, hemşire ve servis kayıtlarının, “izinler” ve “istekler” tabloları hemşire
izinlerinin ve isteklerinin tutulduğu tablolardır. “Yedek” ve “YedekHftSonu”
tabloları ise çizelgenin oluşturulduğu aya ait bilgilerin bir sonraki ay kullanılmak
üzere saklandığı tablolardır. Hazırlanan program “Kayıt”, “Çizelge”, “Đzinler” ve
“Đstekler” olmak üzere 4 sekmeden oluşmaktadır.
4.3.1. Kayıt
Kayıt sekmesinde, hemşirelerin ve servislerin listesi bulunmaktadır. Bu veriler
program çalıştırıldığında veritabanındaki “hemsire” ve “servis” tablolarından
çekilmektedir. Bu sekme kullanılarak yeni hemşire kaydı eklenebilir, değiştirilebilir
veya silinebilir. Servis seçeneğinin yanındaki “Düzenle” seçeneği ile aynı işlemler
servis kayıtları için de yapılabilir. Düzenlenen ve eklenen kayıtlar tekrar ilgili
tablolara kaydedilmektedir. Kayıt sekmesi Şekil 4.4’de gösterilmiştir.
Kullanıcı
Gün Kapama
Veriler Veri Tabanı Access 2007
Genetik
Algoritma
Raporlama
Çizelgeler
49
Şekil 4.4. Kayıt Sekmesi
4.3.2. Çizelge
Aylık nöbet çizelgesi oluşturmak için Çizelge sekmesi kullanılır. Bu sekmede
çizelgenin oluşturulacağı tarih seçilerek “Oluştur” butonuna tıklanmalıdır. “Oluştur”
butonuna tıklanmasıyla birlikte veritabanından veriler alınır ve Genetik Algoritma
çalışmaya başlar. 2 dakika süren işlemlerden sonra program her servise ait nöbet
çizelgesini oluşturur ve “Yazdırmak istediğiniz servisi seçiniz.” alanı aktif duruma
gelir. Bu alanda çizelgesi alınmak istenen servis seçilerek “Yaz” butonuna
tıklanmalıdır. Ekrana sadece seçilen servisin o aya ait nöbet çizelgesi gelir. Bu
çizelge kaydedilebilir veya yazıcıdan çıktısı alınabilir. Çizelge sekmesi Şekil 4.5’de
verilmiştir.
50
Şekil 4.5. Çizelge Sekmesi
4.3.3. Đzinler
Hemşirelerin izinleri ile ilgili işlemler “Đzinler” sekmesinde yapılır. Bu sekmede
kullanıcılardan Şekil 4.6’daki bilgiler istenir. Girilen kayıtlar veritabanındaki
“izinler” tablosuna kaydedilir. Ayrıca girilen kayıtlar değiştirilebilir ve silinebilir.
Đzin tarihleri çizelgenin oluşturulacağı yıla ait olmalıdır. Her sene başında eski yıla
ait olan kayıtlar silinmektedir. Đzinler sekmesi Şekil 4.6’da verilmiştir.
51
Şekil 4.6. Đzinler Sekmesi
4.3.4. Đstekler
Hemşirelerin istekleri doğrultusunda gün ve vardiya belirleme işlemi “Đstekler”
sekmesinde yapılmaktadır. Aynı zamanda bu sekmede bütün servislerde gece
vardiyalarında çalışacak hemşire sayısı belirlenebilmektedir. Girilen kayıtlar
veritabanındaki “istekler” tablosuna kaydedilir. Ayrıca girilen kayıtlar değiştirilebilir
ve silinebilir. Đstek tarihleri çizelgenin oluşturulacağı yıla ait olmalıdır. Her sene
başında eski yıla ait olan kayıtlar silinmektedir.
Đstekler 3 türlü olabilmektedir. Bunlardan birincisi hemşirelerin seçilen günde seçilen
vardiyada(gece, gündüz veya tatil) çalışması, ikincisi ise süt izni vb. gibi durumlarda
bütün bir ay boyunca sadece gece veya sadece gündüz nöbeti tutması ile ilgili
isteklerdir. Bir diğeri ise seçilen serviste gece vardiyasında çalışacak hemşire
sayısının belirlenmesidir. Đstekler sekmesi Şekil 4.7’de verilmiştir.
52
Şekil 4.7. Đstekler Sekmesi
4.3.5. Raporlar
Çizelge sekmesinde nöbet çizelgesi alınmak istenen servis seçilip “Yaz” butonuna
tıklandığında ekrana seçilen servise ait nöbet çizelgesi gelir. Şekil 4.8’de Cildiye
servisinin 2009 Haziran ayına ait örnek çizelgesi verilmiştir. Çizelge incelendiğinde
zorunlu kısıtların tamamen sağlandığı görülmektedir. Sağlanan zorunlu kısıtlar
aşağıdaki gibidir:
1. Gece vardiyalarında çalışacak hemşire sayısı bir ay boyunca sabit tutulmuştur.
Cildiye servisi için gece vardiyalarına 1 hemşire yazılmıştır.
2. Şekil 4.8’de görüldüğü gibi aynı hemşireye iki gün üst üste gece vardiyası
yazılmamıştır.
3. Aynı hemşire için gece ve gündüz vardiyaları ardışık olarak verilmemiştir.
53
4. Gece vardiyalarında çalışacak hemşirelerin bir sonraki günü tatil olarak
belirlenmiştir.
5. Hafta sonu gündüz vardiyasında çalışacak hemşire sayısı bütün ay boyunca 1
hemşire olarak yazılmıştır.
6. Aynı hemşireye cumartesi ve pazar günleri arka arkaya gündüz vardiyası
yazılmamıştır.
7. Her hemşireye haftada en az 40 saat, en fazla 48 saat görev yazılmıştır.
8. Cildiye servisinin sorumlu hemşiresine gece vardiyası verilmemiş ve sadece
hafta içi gündüz vardiyası verilmiştir.
Çizelge incelendiğinde esnek kısıtların da mümkün olduğunca sağlandığı
görülebilir. Hiçbir hemşireye gün aşırı gece vardiyası verilmediği görülebilir. Hafta
sonu gündüz vardiyaları farklı hemşirelere verilmeye çalışılmış fakat servisteki
hemşire yetersizliğinden dolayı 20 Haziran ve 28 Haziran tarihlerinde aynı
hemşireye gündüz vardiyası yazılmıştır. Serviste çalışan bütün hemşirelerin
vardiyaları eşit sayıda dağıtılmaya çalışılmıştır. Şekil 4.8’e göre üç hemşireye 8 saat
fazla mesai yazıldığı görülebilir.
54
Şekil 4.8. Cildiye Servisine Ait Örnek Aylık Hemşire Çizelgesi
55
5. TARTIŞMA VE SONUÇ
Bu çalışmada, çift vardiya çalışan hastaneler için aylık nöbet çizelgelerinin GA
kullanılarak hazırlanabileceği gösterilmiştir. Bunun için C# programlama dili
kullanılarak kullanıcı etkileşimli bir program geliştirilmiştir. Kullanıcılar, gerekli
verileri program vasıtası ile girebilmektedir. Uygun nöbet çizelgesi elde edildiğinde
çizelgeyi veri tabanına kaydedip saklayabilmekte ve raporlandırabilmektedir.
Araştırma algoritması olarak GA kullanılması ile uygun genetik operatörlerin ve
kısıtların seçimi ile uygun nöbet çizelgesinin elde edilebileceği gösterilmiştir.
Yapılan deneysel çalışma ile nöbet çizelgesinde gün kapama işleminin ve zorunlu
kısıtların tamamen yok edildiği, esnek kısıtların ise istenen başarıyı gösterdiği
gözlenmiştir. Aylık nöbet çizelgesi için yapılan deney sonuçları Şekil 5.1 ve Şekil
5.2’de verilmiştir. x ekseni nesil(iterasyon), y ekseni ceza toplamlarını
göstermektedir. Program sadece zorunlu kısıtlarla çalıştırılarak Şekil 5.1’deki grafik
elde edilmiştir. Bu grafikte 85. nesilde(iterasyonda) zorunlu kısıtların tamamen yok
edildiği görülmektedir. Daha sonra program esnek ve zorunlu kısıtlarla çalıştırılarak
Şekil 5.2’deki grafik elde edilmiştir. Bu grafikte en iyi bireye 95. nesilde ulaşıldığı
ve bazı esnek kısıtların yok edilemediği görülebilir. Bunun nedeni 2, 3 ve 4 numaralı
esnek kısıtların, servislerdeki hemşire sayısı göz önünde bulundurulduğunda
tamamen yok edilmesinin imkânsızlığıdır.
Şekil 5.1. Zorunlu Kısıtların Ceza Toplamlarının Nesillere Göre Değişim Grafiği
56
Şekil 5.2. Zorunlu ve Esnek Kısıtların Ceza Toplamlarının Nesillere Göre Değişim Grafiği
Aylık nöbet çizelgesi hazırlama işlemi çok zaman alan bir iş olduğu için bu çalışma
ile sorumlu hemşirenin iş yükü azalmıştır. Çizelgeler hazırlanırken oluşabilecek
yanlılığı ortadan kaldırarak vardiyaların eşit dağılımı sağlanmış ve çalışan
hemşirelerin memnuniyeti ve hastalara bakım kalitesi de artmıştır.
Geliştirilen program, temelde çift vardiya sisteminde çalışan hastaneler için
hazırlanmıştır, fakat diğer vardiya sistemlerine de kolaylıkla uygulanabilir yapıda
olduğundan onlar için de nöbet çizelgelerinin hazırlanması düşünülebilir. Ayrıca,
ceza değerlerinin çalışma esnasında değiştirilebilmesi için geliştirilecek bir algoritma
ile uygun değerlerin bulunabilmesi ve sistemin araştırma zamanını kısaltmak için
çeşitli algoritmaların oluşturulması düşünülebilir.
57
6. KAYNAKLAR Aickelin, U., Dowsland, K, 2004. An Indirect Genetic Algorithm for a Nurse
Scheduling Problem. Computers & Operations Research, 31 (5), 761-778. Alataş, B., Akın, E., 2004. Yapay Zekada Yeni Bir Alan: Yapay Bağışıklık
Sistemleri. Yöneylem Araştırması/Endüstri Mühendisliği-XXIV Ulusal Kongresi, 10-12.
Alaykıran, K., Engin, O., 2005. Karınca Kolonileri Metasezgiseli Ve Gezgin Satıcı
Problemleri Üzerinde Bir Uygulaması. Gazi Üniversitesi Mühendislik Mimarlık Fakültesi Dergisi, 20 (1), 69-76.
Beasley, D., Bull, D.R., Martin, R.R., 1993a. An Overview of Genetic Algorithms:
Part 1, Fundamentals. University Computing, 15 (2), 58-69. Beasley, D., Bull, D.R., Martin, R.R., 1993b. An Overview of Genetic Algorithms:
Part 2, Research Topics. University Computing, 15 (4), 170-181. Bingul, Z., Sekmen, A.S., Zein, S., 1999. An Application of Multi-Dimensional
Optimization Problems Using Genetic Algorithms. Proceedings of the IASTED International Conference Intelligent Systems and Control, Santa Barbara, CA, Usa.
Bingul, Z., Sekmen, A.S. and Zein, S., 2000. Genetic Algorithms Applied to Real
Time Multi-objective Optimization Problems. IEEE SoutheastCon 2000 Conference, Nashville, TN, Usa.
Biroğul, S., 2005. Genetik Algoritma Yaklaşımıyla Atölye Çizelgeleme. Gazi
Üniversitesi Fen Bilimleri Enstitüsü, Yüksek Lisans Tezi, 95s, Ankara. Cengiz, Y., 2004. Optimum Performanslı Mikrodalga Kuvvetlendirici Tasarımı.
Yıldız Teknik Üniversitesi Fen Bilimleri Enstitüsü, Doktora Tezi, 224s, Đstanbul.
Colorni A., Dorigo, M., Maniezzo, V., Trubian, M., 1994. Ant system for Job-shop
Scheduling. Belgian Journal of Operations Research, 34 (1), 39-53. Çetin, E.Đ., Kuruüzüm, A., Irmak, S., 2008. Ekip Çizelgeleme Probleminin Küme
Bölme Modeli ile Çözümü. Havacılık ve Uzay Teknolojileri Dergisi, 3 (4), 47-54.
Daban, F., Özdemir, E., 2004. Eğitimde Verimliliği Artıran Ders Programlarının
Hazırlanması Đçin Genetik Algoritma Kullanımı. Journal of Educational Sciences & Practices, 3 (6), 245-257.
De Castro, L. N., Von Zuben, F. J., 2000a. The Clonal Selection Algorithm with
Engineering Applications. GECCO’2000, 36-37.
58
De Castro, L. N., Von Zuben, F. J., 2000b. An Evolutionary Immune Network for Data Clustering. IEEE SBRN’2000 (Brazilian Symposium on Artificial Neural Networks), 84-89.
De Castro, L.N., Timmis, J., 2002. Artificial Immune Systems: A New Computational Intelligence Systems. Springer, 357 s Londra.
Demirsoy, A., 1998, Kalıtım ve Evrim. Meteksan Yayınları, No:14, 902s. Ankara. Dorigo, M., Maniez, V., Colorni A., 1996. The ant system: optimization by a colony
of cooperating agents. IEEE Transactions on Systems, Man, and Cybernetics–Part, 26 (1), 29-41.
Dorigo, M., Gambardella, L.M., 1997. Ant Colony System: A Cooperative Learning
Approach to the Traveling Salesman Problem. IEEE Transactionson Evolutionary Computation, 1 (1), 53-66.
Drezner, Z., Wesolowsky, G.O., 2003. Network Design: Selection and Design of
Links and Facility Location. Transportation Research Part A, 37, 241-256. Emel, G.G., Taşkın, Ç., 2002. Genetik Algoritmalar ve Uygulama Alanları. Uludağ
Üniversitesi Đktisadi ve Đdari Bilimler Fakültesi Dergisi, 21 (1), 129-152. Engin, O., 2001. Akış Tipi Çizelgeleme Problemlerinin Genetik Algoritma Đle
Çözüm Performansının Artırılmasında Parametre Optimizasyonu. ĐTÜ Fen Bilimleri Enstitüsü, Doktora Tezi, 220s, Đstanbul.
Engin, O., Fığlalı, A., 2002. Akış tipi çizelgeleme problemlerinin genetik algoritma
yardımı ile çözümünde uygun çaprazlama operatörünün belirlenmesi. Doğuş Üniversitesi Dergisi, 6, 27-35.
Ersoy, E., 2004. Final Exam Scheduler. Yeditepe Üniversitesi Mühendislik-Mimarlık
Fakültesi Bilgisayar Mühendisliği Bölümü, Engineering Project Report, 57s, Đstanbul.
Gambardella, L.M., Dorigo, M., 1995. Ant-Q: A Reinforcement Learning Approach
to the Traveling Salesman Problem. In Proceedings of the Eleventh International Conference on Machine Learning, 252-260.
Gen, M., 1996. Genetic Algorithms and Industiral Engineering. Computers and
Industrial Engineering, 30 (4), 835-837. Gen, M., Cheng, R., Oren, S.S., 2001. Network Design Techniques Using Adapted
Genetic Algorithms. Advances in Engineering Software, 32, 731-744. Goldberg, D.E., 1989. Genetic Algorithms in Search, Optimization and Machine
Learning, Addison-Wesley, USA.
59
Gonzalez, F., vd., 2003. A Randomized Real-Valued Negative Selection Algorithm', Proceedings of the 2nd International Conference on Artificial Immune Systems. UK.
Goss, S., Aron, S., Deneubourg, J. L., Pasteels, J. M., 1989. Self-organized Shortcuts
in the Argentine Ant. Naturwissenschaften, 76, 579-581. Holland, J.H., 1975. Adaption in Natural and Artificial Systems. University of
Michigan Pres, Ann Arbor, MI. Inoue, T., Furuhashi, T., Maeda, H., Takaba, M., 2003. A proposal of combined
method of evolutionary algorithm and heuristics for nurse scheduling support system. IEEE Transactions on Industrial Electronics, 50(5), 833-838.
Jan, A., Yamamoto, M., Ohuchi, A., 2000. Evolutionary algorithms for nurse
scheduling problem. Proceedings of the 2000 congress on evolutionary computation, 1 , 196-203.
Kakmacı, Ö., ve Hasgül, S., 2004. Eğitim Kurumlarında Karşılaşılan Nöbet Çizelgesi
Hazırlama Probleminde Karar Modeli Kullanımı, YA/EM’2004 Kongresi, Çukurova Üniversitesi, Adana.
Kalender, M., 2007. Ders Çizelgeleme Programı. TMMOB Elektrik Mühendisleri
Odası Đstanbul Şubesi, 2006-2007 Öğretim Yılı Proje Yarışması, Đstanbul. Kawanaka, H., Yamamoto, K., Yoshikawa, T., Shinogi, T., Tsuruoka, S., 2001.
Genetic algorithm with the constraints for nurse scheduling problem. Proceedings of the 2001 Congress on Evolutionary Computation, 2, 1123-1130.
Kaya, S., 2006. Operasyonel Sabit Đş Çizelgeleme Problemlerinin Genetik
Algoritmalar ile Çözümü. Selçuk Üniversitesi Fen Bilimleri Enstitüsü, Yüksek Lisans Tezi, 83s, Konya.
Kirkpatrick, S., Gelatt, C.D., Vecchi, M.P., 1983. Optimization by Simulated
Annealing. Science, New Series, 220 (4598), 671-680. Körez, M.T., 2005. Sıralı Akış Tipi Çizelgeleme Problemlerinde Genetik Algoritma
Uygulaması. Yıldız Teknik Üniversitesi Fen Bilimleri Enstitüsü, Yüksek Lisans Tezi, 85s, Đstanbul.
Kurt, M., Semetay, C., 2001. Genetik Algoritma ve Uygulama Alanları, M.M.O.
Makine Mühendis Dergisi, 42 (501), 19-24. Lai, K.K., Chan, J.W.M., 1997. Developing A Simulated Annealing Algorithm for
The Cutting Stock Problem. Computers and Industrial Engineering, 32 (1), 115-127, Great Britain.
60
Lutfiyya, H., McMillin, B., Poshyanonda, P., Dagli, C., 1992. Composite Stock Cutting Through Simulated Annealing. Mathemetical Computing Modelling, 16(1), 57-74.
Man, K.F., Tang, K.S., Kwong, S., 1996. Genetic Algorithms: Concepts and
Applications. IEEE Transactions on Industrial Electronics, 43, (5), 519-533. Ohki, M., Morimoto, A., Miyake, K., 2006. Nurse Scheduling by Using Cooperative
GA with Efficient Mutation and Mountain-Climbing Operators. 3rd IEEE International Conference on Intelligent Systems, 164-169.
Özcan, E., Alkan, A., 2002. Çok Nüfuslu Kararlı Hal Genetik Algoritması
Kullanarak Otomatik Çizelgeleme. TBD 19. Bilişim Kurultayı, 149-155 Özcan, E., 2005. Memetic Algorithms for Nurse Rostering. Lecture Notes in
Computer Science, Springer-Verlag, 3733 (2005), 482-492. Öztemel, E., 2003. Yapay Sinir Ağları. Papatya Yayıncılık, pp. 29, Đstanbul. Öztürk, Z.K., Özdemir, M.S., 2005. Çok Ölçütlü Çizelgeleme Problemleri: Gelinen
Nokta Ve Potansiyel Araştırma Alanları. V. Ulusal Üretim Araştırmaları Sempozyumu, Đstanbul Ticaret Üniversitesi, Đstanbul.
Taillard, D., Gambardella, M., Gendreau, M, Potvin J., 2000. Adaptive Memory
Programming: A unified view of MetaHeuristics. European Journal of Operational Research, 135(2001), 1-16.
Tuncel, H., 2005. Askeri Nöbet Çizelgelerinin Genetik Algoritma Kullanılarak
Eniyilenmesi. Anadolu Üniversitesi Fen Bilimleri Enstitüsü, Yüksek Lisans Tezi, 87s, Eskişehir.
Yiğit, T., 2006. Meslek Liseleri Haftalık Ders Çizelgelerinin Genetik Algoritmalar
Yardımıyla Oluşturulması. Gazi Üniversitesi Endüstriyel Sanatlar Eğitim Fakültesi Dergisi, 19, 25-39.
Yurtoğlu, H., 2005. Yapay Sinir Ağları Metodolojisi Đle Öngörü Modellemesi: Bazı
Makroekonomik Değişkenler Đçin Türkiye Örneği. Ekonomik Modeller Ve Stratejik Araştırmalar Genel Müdürlüğü, Uzmanlık Tezi, 103s, Ankara
61
EK C# Programlama Dili ile Hazırlanan Hemşire Çizelgeleme Programının Kodları using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using ZedGraph;
namespace WindowsFormsApplication10
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
object a;
string c;
private void hemsireBindingNavigatorSaveItem_Click(object sender,EventArgs e)
{
string mesaj = "";
if (adTextBox.Text == "" || soyadTextBox.Text == "" || gorevTextBox.Text
== "" || servisComboBox.Text == "")
{
if (adTextBox.Text == "")
mesaj = mesaj + "Ad";
if (soyadTextBox.Text == "")
mesaj = mesaj + " Soyad";
if (gorevTextBox.Text == "")
mesaj = mesaj + " Gorev";
if (servisComboBox.Text == "")
mesaj = mesaj + " Servis";
MessageBox.Show("Lütfen " + mesaj + " alanlarını doldurunuz!", "Uyarı");
}
else
{
c = servisComboBox.Text;
this.servisTableAdapter.FillByServis(hemsireDataSet.servis, c);
a = hemsireDataSet.servis.Rows[0][0];
servisTextBox.Text = Convert.ToString(a);
this.Validate();
this.hemsireBindingSource.EndEdit();
this.tableAdapterManager.UpdateAll(this.hemsireDataSet);
}
}
private void rastgeleDizi()
{
Random yeni = new Random();
byte a;
int RastgeleSayi = 0;
for (a = 0; a <= 30; a++)
{
gunler[a] = 0;
}
int[] F = new int[31];
int i = 0;
gunler[i] = RastgeleSayi;
while (i != (gunsayisi - 1))
{
RastgeleSayi = yeni.Next(0, 40);
if (gunler.Contains(RastgeleSayi) == false)
{
if (RastgeleSayi <= (gunsayisi - 1))
{
62
i++;
gunler[i] = RastgeleSayi;
}
}
}
RastgeleSayi = yeni.Next(0, (gunsayisi - 1));
gunler[0] = gunler[RastgeleSayi];
gunler[RastgeleSayi] = 0;
}
byte[, , ,] bireyler = new byte[25, 20, 35, 31];
byte[, , ,] anneler = new byte[25, 10, 35, 31];
byte[, , ,] babalar = new byte[25, 10, 35, 31];
byte[, , ,] cocuk = new byte[25, 20, 35, 31];
byte[] hemsiresayisi = new byte[25];
byte servissayisi;
byte gunsayisi;
byte[] nobetsayisi = new byte[25];
byte ayy;
int izinSayac = -1;
int yil;
int[] izinT = new int[20];
int[] gorevT = new int[20];
int[] izinYil = new int[20];
int[] gorevYil = new int[20];
int[] izinAy = new int[20];
int[] gorevAy = new int[20];
string[] izinServis = new string[30];
string[] izinHemsire = new string[30];
int[] gunler = new int[31];
int[] gunlerYedek = new int[31];
public int[,] cezaBireyler = new int[25, 20];
public int[,] cezaCocuk = new int[25, 20];
public int[,] CezaToplam = new int[25, 40];
public int[,] rulett = new int[25, 20];
public double[,] uygunluk = new double[25, 20];
public double[,] uygunlukCocuk = new double[25, 20];
public double[,] ToplamUygunluk = new double[25, 40];
private void populasyon(int plsyn)
{
int b, sayac, i, j, k, ser;
int gece;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= (plsyn - 1); i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
for (k = 0; k <= (gunsayisi - 1); k++)
{
bireyler[ser, i, j, k] = 1;
}
}
}
}
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= (plsyn - 1); i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
for (k = 0; k <= gunsayisi - 1; k++)
{
DateTime dt = new DateTime(Vyil, VAy, k + 1);
if ((int)dt.DayOfWeek == 0 || (int)dt.DayOfWeek == 6)
{
bireyler[ser, i, j, k] = 0;
}
}
}
}
63
}
int s, asd;
bool kk = false;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= (plsyn - 1); i++)
{
for (asd = 0; asd <= (nobetsayisi[ser] - 1); asd++)
{
rastgeleDizi();
kk = false;
while (kk == false)
{
if (gunler[0] == gunlerYedek[0])
{
kk = false;
rastgeleDizi();
}
else
kk = true;
}
for (s = 0; s <= (gunsayisi - 1); s++)
gunlerYedek[s] = gunler[s];
sayac = 0;
while (sayac <= (gunsayisi - 1))
{
for (k = 0; k <= (hemsiresayisi[ser] - 1); k++)
{
if (sayac == gunsayisi)
break;
gece = gunlerYedek[sayac];
bireyler[ser, i, k, gece] = 2;
sayac++;
}
}
}
}
}
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= (plsyn - 1); i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
for (k = 0; k <= (gunsayisi - 1); k++)
{
if (bireyler[ser, i, j, k] == 2)
{
if (k == (gunsayisi - 1))
break;
else
{
bireyler[ser, i, j, (k + 1)] = 0;
}
}
}
}
}
}
byte sayi;
int sno;
//Ayın son günü hemşirenin hangi nöbeti tuttuğuna bakılacak. bir sonraki ay ona
göre hesaplanacak
int kayitsayisi;
string servis;
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
64
if (Aylar[ayy] == "Ocak")
{
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
servis = Convert.ToString(this.hemsireDataSet.servis.Rows[ser][1]);
this.yedekTableAdapter.FillByBul(this.hemsireDataSet.Yedek,
servis, "Aralık", Convert.ToInt32(comboBox3.Text) - 1);
kayitsayisi = this.hemsireDataSet.Yedek.Rows.Count;
for (i = 0; i <= 19; i++)
{
for (k = 0; k <= (kayitsayisi - 1); k++)
{
sayi = Convert.ToByte(this.hemsireDataSet.Yedek.Rows[k][2]);
if (bireyler[ser, i, sayi, 0] == 2 || bireyler[ser, i, sayi, 0] == 1)
{
bireyler[ser, i, sayi, 0] = 0;
}
}
}
}
}
else
{
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
servis =
Convert.ToString(this.hemsireDataSet.servis.Rows[ser][1]);
this.yedekTableAdapter.FillByBul(this.hemsireDataSet.Yedek,
servis, Aylar[ayy - 1], Convert.ToInt32(comboBox3.Text));
kayitsayisi = this.hemsireDataSet.Yedek.Rows.Count;
for (i = 0; i <= 19; i++)
{
for (k = 0; k <= (kayitsayisi - 1); k++)
{
sayi = Convert.ToByte(this.hemsireDataSet.Yedek.Rows[k][2]);
if (bireyler[ser, i, sayi, 0] == 2 || bireyler[ser, i, sayi, 0] == 1)
{
bireyler[ser, i, sayi, 0] = 0;
}
}
}
}
}
//izinler
DateTime izinB, gorevB = new DateTime();
this.izinlerTableAdapter.Fill(this.hemsireDataSet.izinler);
for (t = 0; t <= (this.hemsireDataSet.izinler.Rows.Count - 1); t++)
{
izinB = Convert.ToDateTime(this.hemsireDataSet.izinler.Rows[t][3]);
gorevB = Convert.ToDateTime(this.hemsireDataSet.izinler.Rows[t][4]);
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
if (Convert.ToString(this.hemsireDataSet.izinler.Rows[t][1]) ==
servisler[ser])
{
this.servisTableAdapter.FillByServis(this.hemsireDataSet.servis, servisler[ser]);
servisno = Convert.ToInt32(this.hemsireDataSet.servis.Rows[0][0]);
this.hemsireTableAdapter.FillByServis(this.hemsireDataSet.hemsire,
servisno);
hsayisi = hemsireDataSet.hemsire.Rows.Count;
if (ayy == izinB.Month && ayy == gorevB.Month)
{
izin(ser, plsyn, hsayisi, (izinB.Day - 1), (gorevB.Day - 1), t);
}
if (ayy == izinB.Month && ayy != gorevB.Month)
{
izin(ser, plsyn, hsayisi, (izinB.Day - 1), (gunsayisi - 1), t);
}
if (ayy != izinB.Month && ayy == gorevB.Month)
{
65
izin(ser, plsyn, hsayisi, 0, (gorevB.Day - 1), t);
}
}
}
}
//istekler
for (t = 0; t <= (this.hemsireDataSet.istek.Rows.Count - 1); t++)
{
tarih = Convert.ToDateTime(this.hemsireDataSet.istek.Rows[t][3]);
Vyil = tarih.Year;
vardiya = Convert.ToString(this.hemsireDataSet.istek.Rows[t][4]);
TumAy = Convert.ToString(this.hemsireDataSet.istek.Rows[t][5]);
VardiyaAy = Convert.ToString(this.hemsireDataSet.istek.Rows[t][6]);
if (vardiya != "")
{
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
if (Convert.ToString(this.hemsireDataSet.istek.Rows[t][1]) ==
servisler[ser])
{
if (tarih.Month == ayy)
{
this.servisTableAdapter.FillByServis(this.hemsireDataSet.servis, servisler[ser]);
servisno = Convert.ToInt32(this.hemsireDataSet.servis.Rows[0][0]);
this.hemsireTableAdapter.FillByServis(this.hemsireDataSet.hemsire, servisno);
hsayisi = hemsireDataSet.hemsire.Rows.Count;
for (k = 0; k <= (plsyn - 1); k++)
{
for (h = 0; h <= (hsayisi - 1); h++)
{
adsoyad =
this.hemsireDataSet.hemsire.Rows[h][1] + " " +
this.hemsireDataSet.hemsire.Rows[h][2];
if (adsoyad ==
Convert.ToString(this.hemsireDataSet.istek.Rows[t][2]))
{
gun = tarih.Day - 1;
if (vardiya == "Gece")
{
bireyler[ser, k, h, gun] = 4;
bireyler[ser, k, h, gun + 1] = 0;
for (z = 0; z <= (hemsiresayisi[ser] - 1); z++)
{
if (bireyler[ser, k, z, gun] == 2)
{
bireyler[ser, k, z, gun] = 1;
bireyler[ser, k, z, gun + 1] = 1;
break;
}
}
}
else if (vardiya == "Gündüz")
{
bireyler[ser, k, h, gun] = 5;
DateTime dtTar = new DateTime(yil,
ayy, gun + 1);
if ((int)dtTar.DayOfWeek == 6 ||
(int)dtTar.DayOfWeek == 0)
{
for (z = 0; z <=
(hemsiresayisi[ser] - 1); z++)
{
if (bireyler[ser, k, z, gun]
== 1)
{
bireyler[ser, k, z, gun]
= 0;
}
}
}
}
66
else if (vardiya == "Tatil")
bireyler[ser, k, h, gun] = 0;
}
}
}
}
}
}
}
}
}
private void izin(int ser, int plsyn, int hsayisi, int ilkgun, int songun,
int t)
{
int h, k, j;
string adsoyad;
for (k = 0; k <= (plsyn - 1); k++)
{
for (h = 0; h <= (hsayisi - 1); h++)
{
adsoyad = this.hemsireDataSet.hemsire.Rows[h][1] + " " +
this.hemsireDataSet.hemsire.Rows[h][2];
if (adsoyad ==
Convert.ToString(this.hemsireDataSet.izinler.Rows[t][2]))
{
for (j = ilkgun; j <= songun; j++)
{
bireyler[ser, k, h, j] = 3;
}
}
}
}
}
public void Kisit(byte[, , ,] dizi, int[,] ceza)
{
int i, j, k;
int kontrol = new int();
byte ser, ast;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
ceza[ser, i] = 0;
}
}
//1 günde gece nöbeti tutacak hemşire sayısı
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (k = 0; k <= 19; k++)
{
for (i = 0; i <= (gunsayisi - 1); i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
if (dizi[ser, k, j, i] == 2 || dizi[ser, k, j, i] == 4)
kontrol = kontrol + 1;
}
if (kontrol == 0)
{
if (nobetsayisi[ser] == 1) ceza[ser, k] = ceza[ser, k] + 100;
if (nobetsayisi[ser] == 2) ceza[ser, k] = ceza[ser, k] + 200;
if (nobetsayisi[ser] == 4) ceza[ser, k] = ceza[ser, k] + 400;
continue;
}
if (nobetsayisi[ser] == 1 && kontrol != 1)
{
ceza[ser, k] = ceza[ser, k] + 100 * (kontrol - 1);
}
if (nobetsayisi[ser] == 2 && kontrol != 2)
{
if (kontrol == 1) ceza[ser, k] = ceza[ser, k] + 100;
67
else ceza[ser, k] = ceza[ser, k] + 100 * (kontrol - 2);
}
if (nobetsayisi[ser] == 4 && kontrol != 4)
{
if (kontrol == 1) ceza[ser, k] = ceza[ser, k] + 300;
else if (kontrol == 2) ceza[ser, k] = ceza[ser, k] + 200;
else if (kontrol == 3) ceza[ser, k] = ceza[ser, k] + 100;
else ceza[ser, k] = ceza[ser, k] + 100 * (kontrol - 4);
}
kontrol = 0;
}
}
}
//aynı hemşire ard arda iki gün gece nöbeti tutamaz
//gece nöbetinden sonraki gün gündüz nöbeti verilemez
//gece nöbetlerinden sonraki gün tatil olmalı
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
for (k = 0; k <= (gunsayisi - 2); k++)
{
if ((dizi[ser, i, j, k] == 2 || dizi[ser, i, j, k] == 4)
&& (dizi[ser, i, j, (k + 1)] != 0))
{
ceza[ser, i] = ceza[ser, i] + 50;
}
}
}
}
}
int hft = new int();
//haftasonu gündüz nöbeti tutacak hemşire sayısı, gece nöbetlerindeki
hemşire sayısı kadar olmalı
for (i = 0; i <= (gunsayisi - 1); i++)
{
DateTime dtTarih = new DateTime(yil, ayy, i + 1);
if ((int)dtTarih.DayOfWeek == 6 || (int)dtTarih.DayOfWeek == 0)
{
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (k = 0; k <= 19; k++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
if (dizi[ser, k, j, i] == 1 || dizi[ser, k, j, i] == 5)
hft = hft + 1;
}
if (hft == 0)
{
if (nobetsayisi[ser] == 1) ceza[ser, k] = ceza[ser, k] + 50;
if (nobetsayisi[ser] == 2) ceza[ser, k] = ceza[ser, k] + 100;
if (nobetsayisi[ser] == 4) ceza[ser, k] = ceza[ser, k] + 200;
continue;
}
if (nobetsayisi[ser] == 1 && hft != 1)
{
ceza[ser, k] = ceza[ser, k] + 50 * (hft - 1);
}
if (nobetsayisi[ser] == 2 && hft != 2)
{
if (hft == 1) ceza[ser, k] = ceza[ser, k] + 50;
else ceza[ser, k] = ceza[ser, k] + 50 * (hft - 2);
}
if (nobetsayisi[ser] == 4 && hft != 4)
{
if (hft == 1) ceza[ser, k] = ceza[ser, k] + 150;
else if (hft == 2) ceza[ser, k] = ceza[ser, k] + 100;
68
else if (hft == 3) ceza[ser, k] = ceza[ser, k] + 50;
else ceza[ser, k] = ceza[ser, k] + 50 * (hft - 4);
}
hft = 0;
}
}
}
}
//aynı hemşire cumartesi ve pazar günleri arka arkaya gündüz nöbeti
tutamaz
for (i = 0; i <= (gunsayisi - 2); i++)
{
DateTime dtTarih = new DateTime(yil, ayy, i + 1);
if ((int)dtTarih.DayOfWeek == 6)
{
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (k = 0; k <= 19; k++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
if (dizi[ser, k, j, i] == 1)
{
if (dizi[ser, k, j, i + 1] == 1 || dizi[ser, k,
j, i + 1] == 5)
{
ceza[ser, k] = ceza[ser, k] + 70;
}
}
}
}
}
}
}
int yedekGun, gun, GunduzNobet, GeceNobet, ss, Tatil;
bool kntrl;
int saat;
//her hemşire haftada 40 saat çalışmalı
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
GunduzNobet = 0;
GeceNobet = 0;
kntrl = false;
for (i = 0; i <= 19; i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
GunduzNobet = 0;
GeceNobet = 0;
for (k = 1; k <= gunsayisi; k++)
{
DateTime dtTarih = new DateTime(yil, ayy, k);
if ((int)dtTarih.DayOfWeek == 1)
{
GunduzNobet = 0;
GeceNobet = 0;
Tatil = 0;
ss = 0;
while (ss <= 6)
{
if (dizi[ser, i, j, (k - 1)] == 1 || dizi[ser,
i, j, (k - 1)] == 5)
GunduzNobet++;
if (dizi[ser, i, j, (k - 1)] == 2 || dizi[ser, i,
j, (k - 1)] == 4)
GeceNobet++;
if (dizi[ser, i, j, (k - 1)] == 0)
Tatil++;
k++;
ss++;
if (k == gunsayisi)
69
{
if (dizi[ser, i, j, (k - 1)] == 1 ||
dizi[ser, i, j, (k - 1)] == 5)
GunduzNobet++;
if (dizi[ser, i, j, (k - 1)] == 2 ||
dizi[ser, i, j, (k - 1)] == 4)
GeceNobet++;
break;
}
}
k--;
saat = GunduzNobet * 8 + GeceNobet * 16;
if (saat < 40)
ceza[ser, i] = ceza[ser, i] + 100;
else if (saat > 40)
ceza[ser, i] = ceza[ser, i] + 20;
GunduzNobet = 0;
GeceNobet = 0;
Tatil = 0;
}
}
}
}
}
//Haftada en az bir kere ardışık iki tam gün tatil
bool kont = false;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
for (k = 1; k <= gunsayisi - 2; k++)
{
DateTime dtTarih = new DateTime(yil, ayy, k);
if ((int)dtTarih.DayOfWeek == 1)
{
ss = 0;
while (ss <= 5)
{
kont = false;
if (k - 1 < gunsayisi - 1)
{
if (dizi[ser, i, j, k - 1] == 0 || dizi[ser,
i, j, k - 1] == 8)
{
if (dizi[ser, i, j, k] == 0 || dizi[ser,
i, j, k] == 8)
{
DateTime dTarih = new DateTime(yil,
ayy, k);
if ((int)dTarih.DayOfWeek == 1)
{
k = k + 1;
}
kont = true;
break;
}
}
}
k++;
ss++;
}
if (kont == false)
{
ceza[ser, i] = ceza[ser, i] + 100;
}
70
k--;
}
}
}
}
}
//Gün aşırı gece nöbeti gelmemeli
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
for (k = 0; k <= (gunsayisi - 3); k++)
{
if (dizi[ser, i, j, k] == 2 || dizi[ser, i, j, k] == 4)
{
if (dizi[ser, i, j, k + 2] == 2)
ceza[ser, i] = ceza[ser, i] + 20;
}
}
}
}
}
//(esnek kısıt)bir gecede 1den fazla tutulan nöbetlerde aynı hemşireler
aynı nöbete verilmesin
int sayi1, sayi2, ns, nt;
int z;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
sayi1 = 0;
sayi2 = 0;
if (nobetsayisi[ser] >= 2)
{
for (i = 0; i <= 19; i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 2); j++)
{
byte[] diziNobet = new byte[100];
byte[] diziHemsire = new byte[100];
for (k = 0; k <= (gunsayisi - 1); k++)
{
if (dizi[ser, i, j, k] == 2 || dizi[ser, i, j, k] == 4)
{
for (z = j + 1; z <= (hemsiresayisi[ser] - 1); z++)
{
if (dizi[ser, i, z, k] == 2 || dizi[ser, i, j,
k] == 4)
{
diziNobet[sayi1] = (byte)z;
sayi1++;
}
}
}
}
for (ns = 0; ns <= (hemsiresayisi[ser] - 1); ns++)
{
for (nt = 0; nt <= (sayi1 - 1); nt++)
{
if (diziNobet[nt] == ns)
{
diziHemsire[ns]++;
}
}
}
for (ns = 0; ns <= (hemsiresayisi[ser] - 1); ns++)
{
if (diziHemsire[ns] > 1)
{
ceza[ser, i] = ceza[ser, i] + (diziHemsire[ns] -
1) * 2;
}
71
}
sayi1 = 0;
}
}
}
}
//(esnek kısıt)hafta sonu nöbetleri farklı kişilere verilsin
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
sayi1 = 0;
sayi2 = 0;
for (i = 0; i <= 19; i++)
{
for (j = 0; j <= (hemsiresayisi[ser] - 1); j++)
{
for (k = 0; k <= (gunsayisi - 1); k++)
{
DateTime dt = new DateTime(yil, ayy, k + 1);
if ((int)dt.DayOfWeek == 6 || (int)dt.DayOfWeek == 0)
{
if (dizi[ser, i, j, k] == 1 || dizi[ser, i, j, k] == 5)
{
sayi1++;
}
}
}
if (sayi1 >= 2)
ceza[ser, i] = ceza[ser, i] + (sayi1 - 1) * 2;
sayi1 = 0;
}
}
}
}
public void UygunlukBul(double[,] uygun, int[,] ceza)
{
int i;
double toplam;
byte ser;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
toplam = 0d;
for (i = 0; i <= 19; i++)
{
uygun[ser, i] = (double)1 / (double)(1 + ceza[ser, i]);
toplam = toplam + uygun[ser, i];
}
for (i = 0; i <= 19; i++)
{
uygun[ser, i] = (double)uygun[ser, i] / (double)toplam;
}
}
}
public void RuletCarki(int[,] ceza)
{
int i, j;
Random rnd = new Random();
double rastgelesayi, UygunlukToplam = new double();
int kontrol = new int();
byte z;
int[,] rulet = new int[25, 20];
int[,] ruletb = new int[25, 20];
UygunlukBul(uygunluk, ceza);
byte ser;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
rastgelesayi = rnd.NextDouble();
for (j = 0; j <= 19; j++)
{
72
UygunlukToplam = UygunlukToplam + uygunluk[ser, j];
if (rastgelesayi <= UygunlukToplam)
{
rulet[ser, j] = rulet[ser, j] + 1; break;
}
}
UygunlukToplam = 0;
}
}
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
rulett[ser, i] = rulet[ser, i];
}
}
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
j = 0; kontrol = 0;
do
{
if (rulet[ser, j] != 0)
{
for (z = 1; z <= rulett[ser, j]; z++)
{
kontrol = kontrol + 1;
if (kontrol < 11)
{
anne(ser, j, (kontrol - 1));
rulet[ser, j] = rulet[ser, j] - 1;
}
}
}
j = j + 1;
if (j == 20) break;
}
while (kontrol <= 10);
}
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
ruletb[ser, i] = rulet[ser, i];
}
}
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
j = 0; kontrol = 0;
do
{
if (rulet[ser, j] != 0)
{
for (z = 1; z <= ruletb[ser, j]; z++)
{
kontrol = kontrol + 1;
if (kontrol < 11)
{
baba(ser, j, (kontrol - 1));
rulet[ser, j] = rulet[ser, j] - 1;
}
}
}
j = j + 1;
if (j == 20) break;
}
while (kontrol <= 10);
}
}
public void anne(int ser, int deger, int kont)
{
byte i1, j1;
73
for (i1 = 0; i1 <= (hemsiresayisi[ser] - 1); i1++)
{
for (j1 = 0; j1 <= (gunsayisi - 1); j1++)
{
anneler[ser, kont, i1, j1] = bireyler[ser, deger, i1, j1];
}
}
}
public void baba(int ser, int deger, int kont)
{
byte i1, j1;
for (i1 = 0; i1 <= (hemsiresayisi[ser] - 1); i1++)
{
for (j1 = 0; j1 <= (gunsayisi - 1); j1++)
{
babalar[ser, kont, i1, j1] = bireyler[ser, deger, i1, j1];
}
}
}
private void Eslesme()
{
Random rnd = new Random();
int RastgeleGun, RastgeleHemsire;
int i, j, z, k, l, h, gun;
byte ss, ser;
int RastgeleGun2, RastgeleGun3;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (z = 0; z <= 9; z++)
{
RastgeleGun = rnd.Next(0, (gunsayisi - 2));
listBox52.Items.Add(z + " " + RastgeleGun);
if (RastgeleGun != 0)
{
for (j = 0; j <= (RastgeleGun - 1); j++)
{
for (i = 0; i <= (hemsiresayisi[ser] - 1); i++)
{
cocuk[ser, (2 * z), i, j] = anneler[ser, z, i, j];
cocuk[ser, (2 * z + 1), i, j] = babalar[ser, z, i, j];
}
}
}
if (RastgeleGun != gunsayisi - 1)
{
for (k = RastgeleGun; k <= (RastgeleGun + 1); k++)
{
for (i = 0; i <= (hemsiresayisi[ser] - 1); i++)
{
cocuk[ser, (2 * z), i, k] = babalar[ser, z, i, k];
cocuk[ser, (2 * z + 1), i, k] = anneler[ser, z, i, k];
}
}
if (RastgeleGun != gunsayisi - 2)
{
for (l = (RastgeleGun + 2); l <= (gunsayisi - 1); l++)
{
for (i = 0; i <= (hemsiresayisi[ser] - 1); i++)
{
cocuk[ser, (2 * z), i, l] = anneler[ser, z, i, l];
cocuk[ser, (2 * z + 1), i, l] = babalar[ser,z,i,l];
}
}
}
}
}
}
74
}
private byte max(double[] dizi, int d)
{
byte dongu, i;
byte index;
double buyuk;
buyuk = -1; index = 0;
if (d == 1) dongu = 19;
else dongu = 39;
for (i = 0; i <= dongu; i++)
{
if (dizi[i] != 3)
{
if (dizi[i] > buyuk)
{
buyuk = dizi[i];
index = i;
}
}
}
return index;
}
private byte min(double[] dizi, int d)
{
byte dongu, i;
byte index;
double kucuk;
kucuk = 2; index = 0;
i = 0;
if (d == 1) dongu = 19;
else dongu = 39;
for (i = 0; i <= dongu; i++)
{
if (dizi[i] != 3)
{
if (dizi[i] < kucuk)
{
kucuk = dizi[i];
index = i;
}
}
}
return index;
}
double[] uy = new double[20];
double[] TPuy = new double[40];
public void YeniPopulasyon()
{
byte i, j, minimum, maximum;
byte ser;
Kisit(cocuk, cezaCocuk);
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
CezaToplam[ser, i] = cezaBireyler[ser, i];
CezaToplam[ser, i + 20] = cezaCocuk[ser, i];
}
}
double toplam;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
toplam = 0d;
for (i = 0; i <= 39; i++)
{
ToplamUygunluk[ser, i] = (double)1 /(double)(1+CezaToplam[ser, i]);
toplam = toplam + ToplamUygunluk[ser, i];
}
for (i = 0; i <= 39; i++)
75
{
ToplamUygunluk[ser, i]=(double)ToplamUygunluk[ser,i]/(double)toplam;
}
byte h, g;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
sayac = 0;
for (i = 0; i <= 39; i++)
{
TPuy[i] = ToplamUygunluk[ser, i];
}
for (i = 0; i <= 19; i++)
{
minimum = min(TPuy, 2);
TPuy[minimum] = 3;
}
for (i = 0; i <= 19; i++)
{
if (TPuy[i] == 3)
{
for (j = 20; j <= 39; j++)
{
if (TPuy[j] != 3)
{
TPuy[j] = 3;
for (h = 0; h <= (hemsiresayisi[ser] - 1); h++)
{
for (g = 0; g <= (gunsayisi - 1); g++)
{
bireyler[ser, i, h, g] = cocuk[ser, (j -
20), h, g];
}
}
break;
}
}
}
}
}
}
}
byte[] eniyi = new byte[25];
private void EnIyiBirey()
{
byte s;
for (s = 0; s <= servissayisi - 1; s++)
{
eniyi[s] = 0;
}
byte index, a;
a = 0;
int kucuk;
index = a;
byte ser;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
index = 0;
kucuk = cezaBireyler[ser, 0];
for (a = 1; a <= 19; a++)
{
if (cezaBireyler[ser, a] < kucuk)
{
kucuk = cezaBireyler[ser, a];
index = a;
}
}
eniyi[ser] = index;
}
}
byte[] enkotu = new byte[25];
76
private void EnKotuBirey()
{
Kisit(bireyler, cezaBireyler);
byte index, a;
a = 0;
int buyuk;
index = a;
byte ser;
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
index = 0;
buyuk = cezaBireyler[ser, 0];
for (a = 0; a <= 19; a++)
{
if (cezaBireyler[ser, a] > buyuk)
{
buyuk = cezaBireyler[ser, a];
index = a;
}
}
enkotu[ser] = index;
}
}
private void Mutasyon()
{
int i, j, k, ser, r1, r2, rh, s, kotu, r3;
byte[,] en = new byte[30, 31];
byte yedek;
Random rnd = new Random();
EnIyiBirey();
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
r1 = rnd.Next(0, 20);
if (r1 == eniyi[ser])
{
EnKotuBirey();
for (i = 0; i <= (hemsiresayisi[ser] - 1); i++)
{
for (k = 0; k <= (gunsayisi - 1); k++)
{
en[i, k] = bireyler[ser, r1, i, k];
}
}
}
r2 = rnd.Next(0, gunsayisi - 3);
r3 = rnd.Next(0, hemsiresayisi[ser]);
for (j = 0; j <= 1; j++)
{
yedek = bireyler[ser, r1, r3, r2 + j];
bireyler[ser, r1, r3, r2 + j] = bireyler[ser, r1, r3, r2 + (3 - j)];
bireyler[ser, r1, r3, r2 + (3 - j)] = yedek;
}
if (r1 == eniyi[ser])
{
kotu = enkotu[ser];
for (i = 0; i <= (hemsiresayisi[ser] - 1); i++)
{
for (k = 0; k <= (gunsayisi - 1); k++)
{
bireyler[ser, kotu, i, k] = en[i, k];
}
}
}
}
}
private void Iyilestirme()
{
77
int i, j, k, hft, hftSonuGunduz;
bool kontrol;
hft = 0;
byte ser;
Random rnd = new Random();
for (j = 0; j <= (gunsayisi - 1); j++)
{
DateTime dtTarih = new DateTime(yil, ayy, j + 1);
if ((int)dtTarih.DayOfWeek == 6 || (int)dtTarih.DayOfWeek == 0)
{
for (ser = 0; ser <= (servissayisi - 1); ser++)
{
for (i = 0; i <= 19; i++)
{
for (k = 0; k <= (hemsiresayisi[ser] - 1); k++)
{
if (bireyler[ser, i, k, j] == 1 || bireyler[ser, i,
k, j] == 5)
hft = hft + 1;
}
if (hft < nobetsayisi[ser])
{
kontrol = false;
while (kontrol == false)
{
hftSonuGunduz = rnd.Next(0, (hemsiresayisi[ser] -
1));
if ((int)dtTarih.DayOfWeek == 6)
{
if (j != 0 && j != (gunsayisi - 1))
{
if ((bireyler[ser, i, hftSonuGunduz, j -
1] != 2 && bireyler[ser, i, hftSonuGunduz, j - 1] != 4) && (bireyler[ser, i,
hftSonuGunduz, j + 1] != 1 && bireyler[ser, i, hftSonuGunduz, j + 1] != 5) &&
bireyler[ser, i, hftSonuGunduz, j] == 0)
{
if (bireyler[ser, i, hftSonuGunduz,
j] != 8)
{
listBox32.Items.Add(bireyler[ser,
i, hftSonuGunduz, j]);
bireyler[ser, i, hftSonuGunduz,
j] = 1;
hft++;
if (hft == nobetsayisi[ser])
break;
}
}
}
else if (j == 0)
{
if ((bireyler[ser, i, hftSonuGunduz, j +
1] != 1 && bireyler[ser, i, hftSonuGunduz, j + 1] != 5) && (bireyler[ser, i,
hftSonuGunduz, j] != 2 && bireyler[ser, i, hftSonuGunduz, j] != 4) && (bireyler[ser,
i, hftSonuGunduz, j] != 1 && bireyler[ser, i, hftSonuGunduz, j] != 5) &&
bireyler[ser, i, hftSonuGunduz, j] != 3)
{
if (bireyler[ser, i, hftSonuGunduz,
j] != 8)
{
bireyler[ser, i, hftSonuGunduz,
j] = 1;
hft++;
if (hft == nobetsayisi[ser])
break;
}
}
}
else if (j == (gunsayisi - 1))
{
78
if ((bireyler[ser, i, hftSonuGunduz, j]
!= 2 && bireyler[ser, i, hftSonuGunduz, j] != 4) && (bireyler[ser, i, hftSonuGunduz,
j] != 1 && bireyler[ser, i, hftSonuGunduz, j] != 5) && bireyler[ser, i,
hftSonuGunduz, j] != 3)
{
if (bireyler[ser, i, hftSonuGunduz,
j] != 8)
{
bireyler[ser, i, hftSonuGunduz,
j] = 1;
hft++;
if (hft == nobetsayisi[ser])
break;
}
}
}
}
else
{
if (j != 0 && j != (gunsayisi - 1))
{
if ((bireyler[ser, i, hftSonuGunduz, j -
1] != 2 && bireyler[ser, i, hftSonuGunduz, j - 1] != 4) && (bireyler[ser, i,
hftSonuGunduz, j - 1] != 1 && bireyler[ser, i, hftSonuGunduz, j - 1] != 5) &&
(bireyler[ser, i, hftSonuGunduz, j] != 2 && bireyler[ser, i, hftSonuGunduz, j] != 4)
&& (bireyler[ser, i, hftSonuGunduz, j] != 1 && bireyler[ser, i, hftSonuGunduz, j] !=
5) && bireyler[ser, i, hftSonuGunduz, j] != 3 && bireyler[ser, i, hftSonuGunduz, j]
!= 8)
{
bireyler[ser, i, hftSonuGunduz, j] =
1;
hft++;
if (hft == nobetsayisi[ser])
break;
}
}
else if (j == 0)
{
if ((bireyler[ser, i, hftSonuGunduz, j]
!= 2 && bireyler[ser, i, hftSonuGunduz, j] != 4) && (bireyler[ser, i, hftSonuGunduz,
j] != 1 && bireyler[ser, i, hftSonuGunduz, j] != 5) && bireyler[ser, i,
hftSonuGunduz, j] != 3 && bireyler[ser, i, hftSonuGunduz, j] != 8)
{
bireyler[ser, i, hftSonuGunduz, j] =
1;
hft++;
if (hft == nobetsayisi[ser])
break;
}
}
else if (j == (gunsayisi - 1))
{
if ((bireyler[ser, i, hftSonuGunduz, j -
1] != 2 && bireyler[ser, i, hftSonuGunduz, j - 1] != 4) && (bireyler[ser, i,
hftSonuGunduz, j - 1] != 1 && bireyler[ser, i, hftSonuGunduz, j - 1] != 5) &&
(bireyler[ser, i, hftSonuGunduz, j] != 2 && bireyler[ser, i, hftSonuGunduz, j] != 4)
&& (bireyler[ser, i, hftSonuGunduz, j] != 1 && bireyler[ser, i, hftSonuGunduz, j] !=
5) && bireyler[ser, i, hftSonuGunduz, j] != 3 && bireyler[ser, i, hftSonuGunduz, j]
!= 8)
{
bireyler[ser, i, hftSonuGunduz, j] =
1;
hft++;
if (hft == nobetsayisi[ser])
break;
}
}
}
}
}
hft = 0;
}
}
79
}
}
}
private void cizelge()
{
Random rnd = new Random();
int r;
int sayac;
populasyon(20);
int cezatoplam = 0;
for (sayac = 0; sayac <= 100; sayac++)
{
Kisit(bireyler, cezaBireyler);
r = rnd.Next(0, 100);
RuletCarki(cezaBireyler);
if (r < 80)
{
Eslesme();
YeniPopulasyon();
}
else
Mutasyon();
Iyilestirme();
}
Kisit(bireyler, cezaBireyler);
EnIyiBirey();
}
private void Form1_Load(object sender, EventArgs e)
{
this.tatilTableAdapter.Fill(this.hemsireDataSet.tatil);
this.grafikkTableAdapter.Fill(this.hemsireDataSet.grafikk);
this.grafikTableAdapter.Fill(this.hemsireDataSet.grafik);
this.yedekHftSonuTableAdapter.Fill(this.hemsireDataSet.YedekHftSonu);
this.yedekTableAdapter.Fill(this.hemsireDataSet.Yedek);
this.hemsireDataSet.Tables["istek"].Columns["istek_no"].AutoIncrement= true;
this.hemsireDataSet.Tables["istek"].Columns["istek_no"].AutoIncrementSeed=1;
this.hemsireDataSet.Tables["istek"].Columns["istek_no"].AutoIncrementStep=1;
this.hemsireDataSet.Tables["istek"].Columns["istek_no"].AllowDBNull = false;
this.hemsireDataSet.Tables["istek"].Columns["istek_no"].Unique = true;
this.hemsireDataSet.Tables["istek"].PrimaryKey = new DataColumn[] {
this.hemsireDataSet.Tables["istek"].Columns["istek_no"] };
this.istekTableAdapter.Fill(this.hemsireDataSet.istek);
this.cizelgeGunduzTableAdapter.Fill(this.hemsireDataSet.cizelgeGunduz);
this.cizelgeTableAdapter.Fill(this.hemsireDataSet.cizelge);
int bugun, izinsayisi;
DateTime iziny = new DateTime();
bugun = DateTime.Today.Year;
this.hemsireDataSet.Tables["izinler"].Columns["izin_no"].AutoIncrement = true;
this.hemsireDataSet.Tables["izinler"].Columns["izin_no"].AutoIncrementSeed= 1;
this.hemsireDataSet.Tables["izinler"].Columns["izin_no"].AutoIncrementStep= 1;
this.hemsireDataSet.Tables["izinler"].Columns["izin_no"].AllowDBNull = false;
this.hemsireDataSet.Tables["izinler"].Columns["izin_no"].Unique = true;
this.hemsireDataSet.Tables["izinler"].PrimaryKey = new DataColumn[] {
this.hemsireDataSet.Tables["izinler"].Columns["izin_no"] };
this.izinlerTableAdapter.Fill(this.hemsireDataSet.izinler);
izinsayisi = this.hemsireDataSet.izinler.Rows.Count;
if (izinsayisi != 0)
{
iziny = Convert.ToDateTime(this.hemsireDataSet.izinler.Rows[0][3]);
if (iziny.Year != bugun)
{
this.izinlerTableAdapter.DeleteQuery();
this.izinlerTableAdapter.Fill(this.hemsireDataSet.izinler);
}
}
this.hemsireDataSet.Tables["servis"].Columns["servis_no"].AutoIncrement = true;
this.hemsireDataSet.Tables["servis"].Columns["servis_no"].AutoIncrementSeed= 1;
this.hemsireDataSet.Tables["servis"].Columns["servis_no"].AutoIncrementStep= 1;
this.hemsireDataSet.Tables["servis"].Columns["servis_no"].AllowDBNull = false;
this.hemsireDataSet.Tables["servis"].Columns["servis_no"].Unique = true;
this.hemsireDataSet.Tables["servis"].PrimaryKey = new DataColumn[] {
80
this.hemsireDataSet.Tables["servis"].Columns["servis_no"] };
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
this.hemsireDataSet.Tables["hemsire"].Columns["no"].AutoIncrement = true;
this.hemsireDataSet.Tables["hemsire"].Columns["no"].AutoIncrementSeed = 1;
this.hemsireDataSet.Tables["hemsire"].Columns["no"].AutoIncrementStep = 1;
this.hemsireDataSet.Tables["hemsire"].Columns["no"].AllowDBNull = false;
this.hemsireDataSet.Tables["hemsire"].Columns["no"].Unique = true;
this.hemsireDataSet.Tables["hemsire"].PrimaryKey = new DataColumn[] {
this.hemsireDataSet.Tables["hemsire"].Columns["no"] };
this.hemsireTableAdapter.Fill(this.hemsireDataSet.hemsire);
this.grafikTableAdapter.DeleteQuery();
this.grafikkTableAdapter.DeleteQuery();
}
private void bindingNavigatorAddNewItem_Click(object sender, EventArgs e)
{
adTextBox.Focus();
int i;
int kayitsayisi = this.hemsireDataSet.servis.Rows.Count;
servisComboBox.Items.Clear();
for (i = 0; i <= kayitsayisi - 1; i++)
{
servisComboBox.Items.Add(this.hemsireDataSet.servis.Rows[i][1]);
}
}
private void label1_Click(object sender, EventArgs e)
{
Form2 yeniform = new Form2();
yeniform.Show();
}
private void fillByToolStripButton_Click(object sender, EventArgs e)
{
try
{
this.servisTableAdapter.FillBy(this.hemsireDataSet.servis);
}
catch (System.Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message);
}
}
int no;
private void toolStripButton1_Click(object sender, EventArgs e)
{
string adsoyad;
this.hemsireTableAdapter.FillByAd(hemsireDataSet.hemsire, no);
adsoyad = Convert.ToString(this.hemsireDataSet.hemsire.Rows[0][1]) + " "
+ Convert.ToString(this.hemsireDataSet.hemsire.Rows[0][2]);
this.hemsireTableAdapter.Fill(this.hemsireDataSet.hemsire);
if (MessageBox.Show(adsoyad + " isimli hemşireyi silmek istediğinize emin
misiniz?", "Dikkat", MessageBoxButtons.YesNo, MessageBoxIcon.Question) ==
DialogResult.Yes)
{
this.hemsireTableAdapter.DeleteQuery1(no);
this.hemsireTableAdapter.Fill(this.hemsireDataSet.hemsire);
}
}
private void toolStripButton1_MouseDown(object sender, MouseEventArgs e)
{
no = Convert.ToInt32(noTextBox.Text);
}
private void Form1_Activated(object sender, EventArgs e)
{
this.hemsireTableAdapter.Fill(this.hemsireDataSet.hemsire);
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
81
}
private void button1_Click(object sender, EventArgs e)
{
string ay;
int[] servisno = new int[25];
byte ser;
ayy = 0;
ay = comboBox2.Text;
yil = Convert.ToInt32(comboBox3.Text);
switch (ay)
{
case "Ocak": ayy = 1; gunsayisi = 31; break;
case "Şubat": ayy = 2;
if (yil == 2012 || yil == 2016)
gunsayisi = 29;
else
gunsayisi = 28;
break;
case "Mart": ayy = 3; gunsayisi = 31; break;
case "Nisan": ayy = 4; gunsayisi = 30; break;
case "Mayıs": ayy = 5; gunsayisi = 31; break;
case "Haziran": ayy = 6; gunsayisi = 30; break;
case "Temmuz": ayy = 7; gunsayisi = 31; break;
case "Ağustos": ayy = 8; gunsayisi = 31; break;
case "Eylül": ayy = 9; gunsayisi = 30; break;
case "Ekim": ayy = 10; gunsayisi = 31; break;
case "Kasım": ayy = 11; gunsayisi = 30; break;
case "Aralık": ayy = 12; gunsayisi = 31; break;
}
servissayisi = Convert.ToByte(this.hemsireDataSet.servis.Rows.Count);
for (ser = 1; ser <= servissayisi; ser++)
{
this.hemsireTableAdapter.FillByServis(hemsireDataSet.hemsire, ser);
hemsiresayisi[ser - 1] =
Convert.ToByte(this.hemsireDataSet.hemsire.Rows.Count);
if (hemsiresayisi[ser - 1] <= 10)
nobetsayisi[ser - 1] = 1;
else if (hemsiresayisi[ser - 1] <= 21)
nobetsayisi[ser - 1] = 2;
else
nobetsayisi[ser - 1] = 4;
}
byte k;
listBox1.Items.Clear();
listBox2.Items.Clear();
for (k = 0; k <= (servissayisi - 1); k++)
{
listBox1.Items.Add(hemsiresayisi[k]);
}
for (k = 0; k <= (servissayisi - 1); k++)
{
listBox2.Items.Add(nobetsayisi[k]);
}
}
private void tabPage2_Enter(object sender, EventArgs e)
{
int i;
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
int kayitsayisi = this.hemsireDataSet.servis.Rows.Count;
comboBox1.Items.Clear();
for (i = 0; i <= kayitsayisi - 1; i++)
{
comboBox1.Items.Add(this.hemsireDataSet.servis.Rows[i][1]);
}
comboBox3.Text = DateTime.Today.Year.ToString();
}
private void tabPage4_Enter(object sender, EventArgs e)
{
82
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
int kayitsayisi = this.hemsireDataSet.servis.Rows.Count;
}
int n;
private void tabPage5_Enter(object sender, EventArgs e)
{
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
}
private void servis_adiComboBox_SelectedIndexChanged_1(object sender,
EventArgs e)
{
int i;
hemsire_adiComboBox.Items.Clear();
this.servisTableAdapter.FillByServis(this.hemsireDataSet.servis,
servis_adiComboBox.Text);
n = Convert.ToInt32(this.hemsireDataSet.servis.Rows[0][0]);
string adsoyad;
this.hemsireTableAdapter.FillByServis(hemsireDataSet.hemsire, n);
hemsire_adiComboBox.Text = "";
for (i = 0; i <= (this.hemsireDataSet.hemsire.Rows.Count - 1); i++)
{
adsoyad = Convert.ToString(this.hemsireDataSet.hemsire.Rows[i][1]) +
" " + Convert.ToString(this.hemsireDataSet.hemsire.Rows[i][2]);
hemsire_adiComboBox.Items.Add(adsoyad);
}
this.hemsireTableAdapter.Fill(this.hemsireDataSet.hemsire);
}
private void bindingNavigatorAddNewItem1_Click(object sender, EventArgs e)
{
servis_adiComboBox.Text = "";
hemsire_adiComboBox.Text = "";
izin_tarihiDateTimePicker.Text = "";
goreve_baslamaDateTimePicker.Text = "";
int i;
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
servis_adiComboBox.Items.Clear();
int kayitsayisi = this.hemsireDataSet.servis.Rows.Count;
for (i = 0; i <= kayitsayisi - 1; i++)
{
servis_adiComboBox.Items.Add(this.hemsireDataSet.servis.Rows[i][1]);
}
}
private void tabPage1_Enter_1(object sender, EventArgs e)
{
this.hemsireTableAdapter.Fill(this.hemsireDataSet.hemsire);
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
}
private void toolStripButton2_Click(object sender, EventArgs e)
{
int bugun;
bugun = DateTime.Today.Year;
if (hemsire_adiComboBox.Text == "" || servis_adiComboBox.Text == "")
{
MessageBox.Show("Bütün alanları doldurunuz.", "Uyarı");
}
else
{
if (izin_tarihiDateTimePicker.Value.Year == bugun &&
goreve_baslamaDateTimePicker.Value.Year == bugun)
{
83
if (izin_tarihiDateTimePicker.Value <
goreve_baslamaDateTimePicker.Value || izin_tarihiDateTimePicker.Value ==
goreve_baslamaDateTimePicker.Value)
{
this.Validate();
this.izinlerBindingSource.EndEdit();
this.tableAdapterManager.UpdateAll(this.hemsireDataSet);
}
else
MessageBox.Show("Lütfen tarihleri kontrol ediniz.");
}
else
{
izin_tarihiDateTimePicker.Text = "";
goreve_baslamaDateTimePicker.Text = "";
MessageBox.Show("Lütfen " + bugun.ToString() + " yılına ait
izinleri giriniz.", "Uyarı");
}
}
}
public void yaz(byte[] eniyi, int serv)
{
string[] Gunler = new string[] { "Pazar", "Pazartesi", "Salı",
"Çarşamba", "Perşembe", "Cuma", "Cumartesi" };
string[] Aylar = new string[] { "", "Ocak", "Şubat", "Mart", "Nisan",
"Mayıs", "Haziran", "Temmuz", "Ağustos", "Eylül", "Ekim", "Kasım", "Aralık" };
string t;
int i, j, k, ser;
string adsoyadgc, adsoyadgnz;
adsoyadgc = "";
adsoyadgnz = ""; adsoyadtatil = "";
this.cizelgeTableAdapter.DeleteQuery();
this.cizelgeGunduzTableAdapter.DeleteQuery();
this.hemsireTableAdapter.FillByServis(this.hemsireDataSet.hemsire, serv +
1);
for (i = 0; i <= (gunsayisi - 1); i++)
{
DateTime dtTarih = new DateTime(yil, ayy, (i + 1));
DayOfWeek Gun_Adi;
Gun_Adi = dtTarih.DayOfWeek;
t = Convert.ToString(i + 1) + " " + Aylar[ayy] + " " +
Convert.ToString(yil) + " " + Gunler[(int)Gun_Adi];
for (j = 0; j <= (hemsiresayisi[serv] - 1); j++)
{
if (bireyler[serv, eniyi[serv], j, i] == 2 || bireyler[serv,
eniyi[serv], j, i] == 4)
{
adsoyadgc = adsoyadgc + hemsireDataSet.hemsire.Rows[j][1] + "
" + hemsireDataSet.hemsire.Rows[j][2] + " ";
}
if (bireyler[serv, eniyi[serv], j, i] == 1 || bireyler[serv,
eniyi[serv], j, i] == 5 || bireyler[serv, eniyi[serv], j, i] == 7)
{
adsoyadgnz = adsoyadgnz + hemsireDataSet.hemsire.Rows[j][1] +
" " + hemsireDataSet.hemsire.Rows[j][2] + " ";
}
}
hemsireDataSet.cizelge.AddcizelgeRow(t, adsoyadgc, serv);
hemsireDataSet.cizelgeGunduz.AddcizelgeGunduzRow(t, adsoyadgnz,
serv);
adsoyadgc = "";
adsoyadgnz = ""; adsoyadtatil = "";
}
cizelgeTableAdapter.Update(hemsireDataSet.cizelge);
cizelgeGunduzTableAdapter.Update(hemsireDataSet.cizelgeGunduz);
string servis;
int bugunyil, bugunay;
bugunyil = DateTime.Today.Year;
bugunay = DateTime.Today.Month;
if (bugunay == 2)
84
{
this.yedekTableAdapter.DeleteQueryAll(bugunyil - 1);
this.yedekHftSonuTableAdapter.DeleteQueryAll(bugunyil - 1);
}
servis = Convert.ToString(this.hemsireDataSet.servis.Rows[serv][1]);
this.yedekTableAdapter.DeleteQuery(servis, Aylar[ayy],
Convert.ToInt32(comboBox3.Text));
this.yedekHftSonuTableAdapter.DeleteQuery(servis, Aylar[ayy],
Convert.ToInt32(comboBox3.Text));
servis = Convert.ToString(this.hemsireDataSet.servis.Rows[serv][1]);
for (j = 0; j <= (hemsiresayisi[serv] - 1); j++)
{
if (bireyler[serv, eniyi[serv], j, (gunsayisi - 1)] == 2 ||
bireyler[serv, 0, j, (gunsayisi - 1)] == 4)
{
hemsireDataSet.Yedek.AddYedekRow(servis, j, Aylar[ayy],
Convert.ToInt32(comboBox3.Text));
yedekTableAdapter.Update(hemsireDataSet.Yedek);
}
}
DateTime zt = new DateTime(yil, ayy, gunsayisi);
if ((int)zt.DayOfWeek == 6)
{
servis = Convert.ToString(this.hemsireDataSet.servis.Rows[serv][1]);
for (j = 0; j <= (hemsiresayisi[serv] - 1); j++)
{
if (bireyler[serv, eniyi[serv], j, (gunsayisi - 1)] == 1 ||
bireyler[serv, 0, j, (gunsayisi - 1)] == 5)
{
hemsireDataSet.YedekHftSonu.AddYedekHftSonuRow(servis, j,
Aylar[ayy], Convert.ToInt32(comboBox3.Text));
yedekHftSonuTableAdapter.Update(hemsireDataSet.YedekHftSonu);
}
}
}
adsoyadgc = "";
}
private void button3_Click_1(object sender, EventArgs e)
{
Cagir(comboBox1.SelectedIndex);
KontrolUygunluk(comboBox1.SelectedIndex);
}
bool yeni;
private void bindingNavigatorAddNewItem2_Click(object sender, EventArgs e)
{
servis_adiComboBox1.Text = "";
hemsire_adiComboBox1.Text = "";
tarihDateTimePicker.Text = "";
vardiyaComboBox.Text = "";
int i;
this.servisTableAdapter.Fill(this.hemsireDataSet.servis);
servis_adiComboBox1.Items.Clear();
int kayitsayisi = this.hemsireDataSet.servis.Rows.Count;
for (i = 0; i <= kayitsayisi - 1; i++)
{
servis_adiComboBox1.Items.Add(this.hemsireDataSet.servis.Rows[i][1]);
}
yeni = true;
}
private void toolStripButton3_Click(object sender, EventArgs e)
{
int bugun;
bugun = DateTime.Today.Year;
int ksayi, i;
string servis, ad;
DateTime t = new DateTime();
if (radioButton1.Checked == true)
85
{
groupBox1.Enabled = true;
groupBox2.Enabled = false;
}
if (radioButton2.Checked == true)
{
groupBox2.Enabled = true;
groupBox1.Enabled = false;
}
if (hemsire_adiComboBox1.Text == "" || servis_adiComboBox1.Text == "")
{
MessageBox.Show("Bütün alanları doldurunuz.", "Uyarı");
}
else
{
if (groupBox1.Enabled == true)
{
if (tarihDateTimePicker.Value.Year == bugun)
{
ksayi = this.hemsireDataSet.istek.Rows.Count;
if (yeni == true)
{
for (i = 0; i <= ksayi - 1; i++)
{
t =
Convert.ToDateTime(this.hemsireDataSet.istek.Rows[i][3]);
servis =
this.hemsireDataSet.istek.Rows[i][1].ToString();
ad = this.hemsireDataSet.istek.Rows[i][2].ToString();
if (servis == servis_adiComboBox1.Text && ad ==
hemsire_adiComboBox1.Text && t.Day == tarihDateTimePicker.Value.Day && t.Month ==
tarihDateTimePicker.Value.Month && t.Year == tarihDateTimePicker.Value.Year)
{
MessageBox.Show("Bu kayıt daha önce girilmiş",
"Uyarı");
break;
}
if (i == ksayi - 1)
{
this.Validate();
this.istekBindingSource.EndEdit();
this.tableAdapterManager.UpdateAll(this.hemsireDataSet);
}
}
yeni = false;
}
else
{
this.Validate();
this.istekBindingSource.EndEdit();
this.tableAdapterManager.UpdateAll(this.hemsireDataSet);
}
}
else
{
tarihDateTimePicker.Text = "";
MessageBox.Show("Lütfen " + bugun.ToString() + " yılına ait
istekleri giriniz.", "Uyarı");
}
}
if (groupBox2.Enabled == true)
{
if (comboBox6.Text == bugun.ToString())
{
this.Validate();
this.istekBindingSource.EndEdit();
86
this.tableAdapterManager.UpdateAll(this.hemsireDataSet);
}
else
{
comboBox6.Text = "";
MessageBox.Show("Lütfen " + bugun.ToString() + " yılına ait
istekleri giriniz.", "Uyarı");
}
}
}
}
private void servis_adiComboBox1_SelectedIndexChanged(object sender,
EventArgs e)
{
int i;
hemsire_adiComboBox1.Items.Clear();
this.servisTableAdapter.FillByServis(this.hemsireDataSet.servis,
servis_adiComboBox1.Text);
n = Convert.ToInt32(this.hemsireDataSet.servis.Rows[0][0]);
string adsoyad;
this.hemsireTableAdapter.FillByServis(hemsireDataSet.hemsire, n);
hemsire_adiComboBox.Text = "";
for (i = 0; i <= (this.hemsireDataSet.hemsire.Rows.Count - 1); i++)
{
adsoyad = Convert.ToString(this.hemsireDataSet.hemsire.Rows[i][1]) +
" " + Convert.ToString(this.hemsireDataSet.hemsire.Rows[i][2]);
hemsire_adiComboBox1.Items.Add(adsoyad);
}
this.hemsireTableAdapter.Fill(this.hemsireDataSet.hemsire);
}
private void Cagir(int s)
{
yaz(eniyi, s);
this.cizelgeTableAdapter.FillByServis(this.hemsireDataSet.cizelge, s);
this.cizelgeGunduzTableAdapter.FillByServis(this.hemsireDataSet.cizelgeGunduz, s);
grafikKayit = s;
Form3 yeniform = new Form3();
yeniform.Show();
Form4 yeniform2 = new Form4();
yeniform2.Show();
Form5 yeniform3 = new Form5();
yeniform3.Show();
}
private void radioButton1_CheckedChanged(object sender, EventArgs e)
{
if (radioButton1.Checked == true)
{
groupBox1.Enabled = true;
groupBox2.Enabled = false;
}
}
private void radioButton2_CheckedChanged(object sender, EventArgs e)
{
if (radioButton2.Checked == true)
{
groupBox2.Enabled = true;
groupBox1.Enabled = false;
}
}
}
}
87
ÖZGEÇMĐŞ
Adı Soyadı : Hanife ÇĐVRĐL
Doğum Yeri ve Yılı : Çivril, 1983
Medeni Hali : Bekâr
Yabancı Dili : Đngilizce
Eğitim Durumu (Kurum ve Yıl)
Lise : Isparta Anadolu Meslek ve Meslek Lisesi, 2001
Lisans : Süleyman Demirel Üniversitesi Teknik Eğitim Fakültesi,
Bilgisayar Sistemleri Öğretmenliği, 2005
Çalıştığı Kurum/Kurumlar ve Yıl
Milas Anadolu Meslek ve Meslek Lisesi, 2005-2008.
Süleyman Demirel Üniversitesi Uzaktan Eğitim Meslek Yüksek Okulu, 2008-…