5- Turbo Pascalda Kullanılan Döngü Yapıları

Transkript

Endüstri Mühendisliği Bölümü Bilgisayar Programlama Ders Notları
İrfan MACİT
5- Turbo Pascalda Kullanılan Döngü Yapıları
Bilgisayar programlamada en kolay konulardan birisi olmasına rağmen en
çok hata yapılan konulardan birisi döngülerdir. Döngüler bilgisayar
programlamada bir komutun ardışık olarak yapmasını veya tekrarlamasını
istediğimiz işlemleri için kullanılan oldukça kolay yapılardır. Döngülerde
olması gereken parametreler vardır. Bu parametreler döngünün başlangıç
ve bitiş değerleri, döngünün değişken veya değer atanacak olan dizi
değişkeni ve kontrol değişkeni olarak sayılabilir. Turbo Pascal bilgisayar
programlama dilinde üç farklı döngü yapısı vardır. Döngü yapısının yapısal
farklılıkları dışında temelde yaptıkları iş aynıdır. En fazla kullanılan döngü
yapısı for-do yapısıdır. Turbo Pascal bilgisayar programlama dilinde
repeat- until ve while-do yapıları bilgisayar programlamada kullanılan
algoritmalara göre problem çözümünde kullanılmaktadır.
5.1 Turbo Pascalda for-do Döngüsü
Turbo pascalda for-do döngüsü her hangi bir şart olmadan diğer bir deyiş
ile bir şart olmaksızın komut veya komutları birden fazla işlemek için
kullanılırlar. En genel ve basit hali ile for-do döngüsü aşağıdaki gibi
yazılır;
for kontrol_değ:=başla_değeri to bitiş_değeri do
Begin
İşlenecek_komutlar;
….
End;
Döngülerde kontrol değişkeni olarak belirtilen değişken yapılması gereken
işlem sayısını gösteren değişkendir. Kontrol değişkeni işleyeceğimiz
komutların kaç kez tekrarlanması işlemini yapacaktır. Başlangıç değişkeni
kontrol değişkeninin başladığı değeri bitiş değişkeni ise tekrarlanacak olan
43
İrfan MACİT
sayıyı belirlemektedir. Bir komutu örneğin beş kez çalışmasını istiyorsak
bunu for-do döngüsü ile basit olarak şöyle yazabiliriz
for i:= 1 to 5 do
begin
komut;
end;
Yukarıda kontrol değişkeni olan i 1 (bir) sayısından başlayarak 5 (beş)
ulaşana
kadar
herhangi
bir
şart
olmaksızın
komut
yazan
yeri
tekrarlayacaktır. Kontrol değişkeni i:=1 olduğunda komut yazan satır bir
kez işleyecek ve tekrar başa gidecektir. Daha sonra kontrol değişkeni i:=2
olacaktır, kontrol değişkeninin alacağı değer i:=5’ten küçük olduğundan
komut yazan satır tekrar işletilecektir. Bu işlem kontrol değişkeninin i:=5
olana kadar sürecektir. Kontrol değişkeni i:=5 olduğunda komut son kez
işletilecek ve program kaldığı yerden çalışmaya devam edecektir.
Başka bir örneği ele alalım. Bu örnekte ekrana kontrol değişkeninin aldığı
değerleri yazsın.
Program dongu_1;
USES CRT;
var
i:integer;
Begin
Clrscr;
for i:=1 to 10 do
writeln(i);
end;
End.
Bu programda bilgisayar ekran kontrolleri kullanmak için USES CRT
yazarak ekranı temizleyecek komutun çalışması için gerekli kütüphaneleri
44
İrfan MACİT
programa dahil ediyoruz. Daha sonra clrscr; ile ekranı temizliyoruz,
arkasından kontrol değişkeni olan i bir sayısından başlayarak on sayısına
kadar tekrarlamasını ve her seferinde ekrana i kontrol değişkenin değerini
yazmasını
istiyoruz.
Bu
programın
(dongu_1)
sonucunda
ekranda
yukarıdan aşağıya doğru 1’den 10’ kadar sayılar yazılmaktadır.
Bir başka örneği (dongu_2) ele alalım, bu örnekte indis değişkeni
kümülatif toplanarak ekrana yazılsın.
Program dongu_2;
USES CRT;
var
i:integer;
Begin
Clrscr;
for i:=1 to 10 do
i:=i+1;
writeln(i);
end;
End.
Bu Pascal bilgisayar programında i kontrol değişkeni (indis) ilk değeri olan
i:=i+1; satırında yazan değer ile kendisini toplayacaktır. Ekranda ilk sayı
olarak iki sayısı görünecektir. Bunun sebebi ilk indis değeri olan bir
sayısının ilk satırdaki bir sayısı ile toplanmasından kaynaklamaktadır.
Örneklerimizde indis yani kontrol elemanını artarak gittiği şekilde gördük.
Azalarak gitmesi gerektiğinde bilgisayar program kodlarını ise to yerine
downto yazarak gerçekleştirebiliriz. Bu durumda program (dongu_3)
kodlarımız aşağıdaki hale gelir.
Program dongu_3;
USES CRT;
var
45
İrfan MACİT
i:integer;
Begin
Clrscr;
for i:=10 downto 1 do
i:=i+1;
writeln(i);
end;
End.
Yukarıdaki pascal bilgisayar programlama kodlarında ilk görülecek olan
sayı onbir (11) olur. On (10) indis yani kontrol değişkenimizin aldığı değer
olduğundan ilk sayı ile toplanması sonucu ekranda ilk olarak onbir (11)
sayısı görünür. Sayılar onbir (11) sayısından bir (1) sayısına doğru
azalarak ekrana yazılır.
Biz klavyeden gireceğimiz kontrol değişkenine göre saymasını istersek
kontrol değişkenimizin alacağı son değeri klavyeden girmeliyiz. Kontrol
değişkenimizin en son alacağı değeri klavyeden girmek için yazmamız
gereken kodlar (dongu_4) ise şu şekilde olacaktır.
Program dongu_4;
USES CRT;
var
i,n:integer;
Begin
Clrscr;
writeln (‘ Kontrol değişkeninin en son alacağı değeri
girin -> ’);
readln(n)
for i:=1 to n do
i:=i+1;
writeln(i);
end;
End.
46
İrfan MACİT
Bu programda (dongu_4) klavyeden girilen n sayısı kontrol değişkeni
olarak bildiğimiz indis değerinin alacağı en son değeri temsil etmektedir.
Bu sayede n sayısı ile ekrana yazacağımız aralığın son değerlerini
belirlemekteyiz.
Karakterler için yazılacak olan kontrol değişkeni ve aralık değerlerini
yazacağımız
Pascal
bilgisayar
programlama
kodları
(dongu_5)
ise
aşağıdaki gibi yazılabilir.
Program dongu_5;
USES CRT;
var
harf, harf_yaz: char;
Begin
clrscr;
for harf:= ‘A’ to ‘Z’ do
writeln(harf);
end;
End.
Program
(dongu_5) A harfinden Z harfine kadar tüm harfleri yan yana
yazar. En son Z harfi yazıldıktan sonra programın çalışması sona erer.
Mühendislik uygulamalarında matrisler oldukça fazla kullanılan cebirsel
işlemlerdir.
Endüstri
Mühendisliğinde
kullanılan
lineer
matematiksel
modeller yoğun kullanılan model tipidir. Lineer cebir işlemlerinde vektörel
işlemler uzaysal işlemler gibi bir çok uygulama ve örnek verilebilir.
Endüstri mühendisliği bilim dalında gezgin satıcı, sırt çantası, fabrika
yerleşimi ve buna benzer bir çok uygulama ve probleme yönelik matris
işlemleri vardır.
Dizilerin
ve
dizi
değişkenlerinin
bir
araya
getirilmesinde
matrisleri
oluşturabiliriz. Tek boyutlu dizileri vektör iki boyutlu dizileri matris, üç
boyutlu dizileri sayı küpü olarak adlandırabiliriz. Turbo Pascal bilgisayar
programlama dilinde matris işlemlerini döngüler ve diziler yardımı ile
47
İrfan MACİT
yapmaktayız. Genel olarak yazacağımız matris program (matris_1)
kodlarını aşağıdaki gibi yazabiliriz.
Program matris_1;
USES CRT;
var
İ,j,k:integer;
matris: array [1..50,1..50] of integer
Begin
clrscr;
writeln(‘Matrisin boyutlarını giriniz -> ’);
readln(k);
for i:=1 to k do
begin
j:=1 to k do
begin
writeln(‘Matris( ‘,i,’,‘,j,‘)= ‘);
readln(matris[i,j]);
end;
end;
readln;
End.
Bu programda iki boyutlu olarak oluşturulan matrise matris[i,j]
klavyeden değer girilmektedir. Satır (i) ve sütun (j) elemanları k değeri ile
bize matrisin boyutunu vermektedir. Bu matris boyutu klavyeden girilen k
boyutu ile sınırlanmıştır diyebiliriz. Boyutu k olan bu matrise daha sonra ilk
olarak girilen sayı satır elemanın değeri ikinci olarak girilen ise sütun
elemanın değeridir. Dizi olarak tanımladığımız matris[i,j] eleman sayısı
i x j çarpımından oluşan matristir. İlk değer olarak verilen i satır indisi 1
olduğunda
j
sütün
indis
elemanları
içerisine
değerlerini
readln(
matris[i,j]) k adet kadar yazacaktır. Sütun sayısı k olunca döngü bir
üst döngüye çıkacak ve sayısını bir arttıracaktır. Satır sayısı i 2 olacak ve
48
sütun
k
değerini
alana
kadar
İrfan MACİT
readln(
matris[i,j]);komutu
çalıştırılacaktır.
Bir tek boyutlu matrisi (vektör) katsayı ile çarpmak için yazılacak olan
pascal bilgisayar program kodları şu şekilde olabilir. Bu kodlar daha
geliştirilebilir veya daha kısa yollar kullanılabilir. Kısa yollar olarak bir alt
program (procedure) veya fonksiyon (function) olarak yazılarak da
kullanılır.
Program Vektor;
USES CRT;
var
i,j,k:integer;
vek: array[1..50] of integer;
veks: array[1..50] of integer;
Begin
Clrscr;
Writeln(‘ Vektör boyutunu girin ->’);
readln(j);
writeln(‘ Vektörün çarpılacağı katsayı değerini girin
->’);
readln(k)
for i := 1 to j do
Begin
writeln(‘vektor (’,i,’)= ’);
readln(vek[i]);
end;
for i:= 1 to n do
Begin
veks[i]= k * vek[i];
writeln(‘ veks ( ‘,i,’ ) = ’, veks[i]) ;
end;
readln;
End.
49
İrfan MACİT
Yazdığımız program (vektor) tek j boyutlu matrisi (vek[j]) klavyeden
girilen bir sayı değeri (k) ile çarparak sonucu başka bir matrise (veks[j])
yazdırmaktadır.
Endüstri Mühendisliğinde sıkça kullanılan ortalama bir çok değişik şekilde
yazılabilmektedir. Turbo Pascal bilgisayar programlama dilinde basit olarak
diziler yardımı ile ortalama programını aşağıdaki gibi yazabiliriz.
Program ortalama;
USES CRT;
Var
i,n,eleman: integer:
ort: real;
dizi :array[1..50] of integer;
Begin
clrscr;
writeln(‘ Ortalaması alınacak dizinin eleman sayısını
girin ->’);
readln(n);
for i:= 1 to n do
writeln(‘dizi(‘, i,‘ )= ‘ );
readln(dizi[i]);
end;
eleman:=0;
for i:=1 to n do
eleman:= eleman+ dizi[i];
end;
ort:= eleman/n;
writeln(‘ Girilen dizinin elemanlarının ortalaması =
‘ , ort, ‘ dir’);
readln;
End.
50
Ortalaması
alınacak
olan
sayılar
İrfan MACİT
n
boyutlu
elemanına
dizi[n]
readln(dizi[i]) komutu ile aktarılır. Bu işlemler dizinin elemanlarının
girilmesi sağlamıştır. Ortalama ort nasıl alınacak sorusunun cevabı ise
dizinin tüm elemanlarının eleman değişkeninin toplamının dizi eleman
sayısına n bölünmesi ile bulunur.
Burada önemli olan bir özellik dizinin
tüm elemanlarının bir değişkene aktarılması sırasında değişkenlerin veri
tiplerinin
birbirinden
farklı
olduğunun
unutulmaması
gerekliliğidir.
Değişkenlerden ort ve eleman gerçel tipte n ise tam sayı tipindedir. İşlem
yaparken veri tiplerine çok dikkat etmemiz gerekir. Örneğin real tipte iki
değişken ile işlem yaptıktan sonra sonucu tam sayı tipinde bir değişkene
aktaramayız. Aktardığımız takdirde bu sonucun ondalıklı kısmını göremeyiz
ve sonuç hatalı olur. Hatalı sonuçlar ile karşılaşmamak için işlem
yapacağımız tiplerin sonuç değerleri için bir öngörüde bulunmamız veya
çıkabilecek değerlere yönelik olarak tahminle göre veri tip dönüşümlerini
yapmamız gerekir.
Fibonacci sayıları bir sayı serisinin kendinden önceki iki sayının toplamının
açılımından oluşan seridir. Bu seri ardışık olarak iki sayının toplamının bir
sonraki sayıyı oluşturduğu seridir. Bu seri toplamları kendinden önceki iki
sayıya bağlıdır ve ardışık olarak gider. Sayı serisinin açık hali aşağıdaki
gibidir.
N
Fibonacci
1
2
3
4
5
6
7
Sayı 1
1
2
3
5
8
13 21 34 55 89
serisinin
n
terimli
olarak
8
Pascal
9
10 11
bilgisayar
programında
programlamak istediğimizde klavyeden kaçıncı terime kadar açılmasını
istiyorsak öncelikle terim sayısını belirlemeliyiz daha sonra terimleri
ekrana yazdırmalıyız. Ekrana yazdırılan terimlerin sayısı ve sonucu
klavyeden
girilen
terim
sayısı
ile
belirli
olduğundan
bahsetmiştik.
Terimlerin açılımı ekranda görebilmek için ise readln; fonksiyonundan
yararlanıyoruz.
51
İrfan MACİT
Program Fibonacci;
USES CRT;
Var
i, n, terim_1, terim_2, terim_3;
Begin
clrscr;
writeln(‘ Açılacak terim sayısını girin -> ’);
readln(n);
terim_1:=1 {terimleri başlangıç değerine eşitliyoruz}
terim_2:=1 {terimleri başlangıç değerine eşitliyoruz}
for i := 1 to n-2 do
Begin
terim_3:= terim_1 + terim_2;
writeln
(‘
Üçüncü
terimin
değeri
‘,
terim_3,
‘dür’);
terim_1:= terim_2;
terim_2:= terim_3;
readln;
end;
end.
Matematiksel ifadelerin karşılığının Pascal bilgisayar programında yazılması
işleminde parantez kullanımına dikkat edilmelidir. Herhangi bir değişkenin
başlangıç
değerlerinin
oluşturulması
sırasında
hangi
değerden
başlanacağına da dikkat edilmelidir. Terimlerin ardışık değeri veya
toplamları terim_1 ve terim_2 asıl açılacak olan terim sayısına ulaşmak
için oluşturulan terim sırasına belirlemektedir.
Nümerik analiz matematikte mühendislik uygulamalarının en yoğun
kullanıldığı yöntemdir. Dinamik problemlerinden sayısal integrale kadar
uzanan uygumla alanı vardır.
PROGRAM Gauss_Jordan;
CONST
np=20;
52
mp=20;
TYPE
glnpbynp = ARRAY [1..np,1..np] OF
glnpbymp = ARRAY [1..np,1..mp] OF
glnp = ARRAY [1..np] of integer;
glnpbynp = ARRAY [1..np,1..np] OF
glnpbymp = ARRAY [1..np,1..mp] OF
glnp = ARRAY [1..np] OF integer;
VAR
j,k,l,m,n : integer;
a,ai,u : glnpbynp;
b,x,t : glnpbymp;
dfile : text;
İrfan MACİT
real;
real;
real;
real;
TYPE double = real; char12 = string[12];
FUNCTION sngl(x:real):real; BEGIN sngl := x END;
PROCEDURE glopen(VAR infile:text; filename:char12);
BEGIN assign(infile,filename); reset(infile) END;
PROCEDURE gaussj(VAR a: glnpbynp; n,np: integer;
VAR b: glnpbymp; m,mp: integer);
VAR
big,dum,pivinv: real;
i,icol,irow,j,k,l,ll: integer;
indxc,indxr,ipiv: glnp;
BEGIN
FOR j := 1 TO n DO BEGIN
ipiv[j] := 0
END;
FOR i := 1 TO n DO BEGIN
big := 0.0;
FOR j := 1 TO n DO BEGIN
IF (ipiv[j] <> 1) THEN BEGIN
FOR k := 1 TO n DO BEGIN
IF (ipiv[k] = 0) THEN BEGIN
IF (abs(a[j,k]) >= big) THEN BEGIN
big := abs(a[j,k]);
irow := j;
icol := k
END
END ELSE IF (ipiv[k] > 1) THEN BEGIN
writeln('pause 1 in GAUSSJ - singular
matrix'); readln
END
END
END
END;
ipiv[icol] := ipiv[icol]+1;
IF (irow <> icol) THEN BEGIN
FOR l := 1 TO n DO BEGIN
dum := a[irow,l];
a[irow,l] := a[icol,l];
53
İrfan MACİT
a[icol,l] := dum
END;
FOR l := 1 TO m DO BEGIN
dum := b[irow,l];
b[irow,l] := b[icol,l];
b[icol,l] := dum
END
END;
indxr[i] := irow;
indxc[i] := icol;
IF (a[icol,icol] = 0.0) THEN BEGIN
writeln('pause 2 in GAUSSJ - singular matrix');
readln
END;
pivinv := 1.0/a[icol,icol];
a[icol,icol] := 1.0;
a[icol,l] := a[icol,l]*pivinv
END;
b[icol,l] := b[icol,l]*pivinv
END;
FOR ll := 1 TO n DO BEGIN
IF (ll <> icol) THEN BEGIN
dum := a[ll,icol];
a[ll,icol] := 0.0;
a[ll,l] := a[ll,l]-a[icol,l]*dum
END;
b[ll,l] := b[ll,l]-b[icol,l]*dum
END
END
END
END;
FOR l := n DOWNTO 1 DO BEGIN
IF (indxr[l] <> indxc[l]) THEN BEGIN
FOR k := 1 TO n DO BEGIN
dum := a[k,indxr[l]];
a[k,indxr[l]] := a[k,indxc[l]];
a[k,indxc[l]] := dum
END
END
END
END;
BEGIN
glopen(dfile,'matrx1.dat');
10:
readln(dfile);
readln(dfile);
readln(dfile,n,m);
54
İrfan MACİT
readln(dfile);
FOR k := 1 to n DO BEGIN
FOR l := 1 to n-1 DO read(dfile,a[k,l]);
readln(dfile,a[k,n])
END;
readln(dfile);
FOR l := 1 to m DO BEGIN
FOR k := 1 to n-1 DO read(dfile,b[k,l]);
readln(dfile,b[n,l])
END;
(* save matrices for later testing of results *)
FOR l := 1 to n DO BEGIN
ai[k,l] := a[k,l]
END;
FOR k := 1 to m DO BEGIN
x[l,k] := b[l,k]
END
END;
(* invert matrix *)
gaussj(ai,n,np,x,m,mp);
writeln;
writeln('Inverse of matrix a : ');
FOR l := 1 to n-1 DO write(ai[k,l]:12:6);
writeln(ai[k,n]:12:6)
END;
(* test results *)
(* check inverse *)
writeln('a times a-inverse (compare with unit
matrix)');
FOR l := 1 to n DO BEGIN
u[k,l] := 0.0;
FOR j := 1 to n DO BEGIN
u[k,l] := u[k,l]+a[k,j]*ai[j,l]
END
END;
FOR l := 1 to n-1 DO write(u[k,l]:12:6);
writeln(u[k,n]:12:6)
END;
(* check vector solutions *)
writeln;
writeln('Check the following vectors for equality:');
writeln('original':20,'matrix*sol''n':15);
FOR l := 1 to m DO BEGIN
writeln('vector ',l:2,':');
t[k,l] := 0.0;
FOR j := 1 to n DO BEGIN
t[k,l] := t[k,l]+a[k,j]*x[j,l]
55
İrfan MACİT
END;
writeln(' ':8,b[k,l]:12:6,t[k,l]:12:6);
END
END;
writeln('***********************************');
IF eof(dfile) THEN GOTO 99;
writeln('press RETURN for next problem:');
readln;
GOTO 10;
99:
close(dfile)
END.
Nümerik analizde kullanılan Gauss-Jordan yöntemini çözen programın
içerisinde kullanılan alt programlar ve fonksiyonlar programın modüler
hale gelmesini sağlamıştır. Nümerik analizde Gauss-Jordan eliminasyon
yöntemi olarak bilinen bu program verilen bir yazı dosyasından okuduğu
matrisi çözümlemektedir.
5.2 Turbo Pascalda repeat-until Şartlı Döngü Yapısı
Turbo Pascal bilgisayar programlama dilinde döngü yapılarının bazı
problemleri çözerken şarta bağlı olarak çalışması istenir. Şartlı döngü
yapılarında şartın en az bir kez çalışmasının istendiği veya şart oluştuğu
sürece döngünün çalışmasının istendiği durumlardan bahsedilebilir. Şart
yapılarında hatırladığımız değişkenin eğer bir şart gerçekleşiyor ise
komutun çalışmasını sağlanır. Şartlı döngülerin
repeat-until yapısında
döngü işlemi şart gerçekleşmeden önce çalıştırılır. Genel yazım şekli
aşağıdaki gibidir.
repeat
Komut;
…
until şart_ifadesi ;
Şart yapısında eğer ikinci bir durum veya olay çalıştırılmak isteniyor ise
else kullanılır ve genel yazım şekli aşağıdaki gibi olur.
56
İrfan MACİT
repeat
Komut;
…
else
komut;
until şart_ifadesi ;
İki
durumlu
şart
yapısında
olayın
gerçekleşmesi
beklenir,
olay
gerçekleşmiyor ise en az komut bir kez çalıştırılmış olur ki bu durumda
yazılacak olan komutlar en az bir kez çalışmıştır. Sonucu etkileyecek bir
durum veya olay söz konusu ise çalıştırılacak olan olaylar en az bir kez
gerçekleşmiştir. Bir örnek ele alalım, vereceğimiz bu örnekte ise bir sayısı
ile üç sayısını çarpalım ve sonuç değerini üç ile çarparak altı kez çarparak
karesini alalım.
Bu (kare_carp)Turbo pascal programında say değişkeni sayının çarpılacak
terimlerini belirlemektedir. Diğer
değişkenlerden ilk_sayi
başlangıç
değerini belirlemektedir. Üçüncü değişken carp değişkeni ile çarpımın
kümülatif
toplam
değeri
hesaplanmaktadır.
Değişkenlerin
başlangıç
değerleri belirlendikten sonra şartlı döngü yapısı kullanılarak en az bir kez
çarpım işlemi gerçekleştirilmiş olur. Ekrana dikkat edecek olursak altı adet
sayının yazıldığını görürüz. En son değerin 243 olduğunu ve bu sonuçtan
sonra program repeat-until bloğundan çıkmıştır.
Program kare_carp;
USES CRT;
var
say; ilk_sayi, carp: integer;
Begin
clrscr;
say:=1
ilk_sayi:=3;
carp:=1;
repeat
57
İrfan MACİT
carp:= carp * ilk_sayi;
say:= say + 1;
until say = 6;
writeln(‘Sayının altıncı çarpımı ’, carp,’ tır’);
readln;
end.
Benzer (yıldız) bir örneği yıldız (asteriks) ekrana ikişer adet artırarak 10
satır yazan program kodlarını yazalım. Bu programda ekranda ilk olarak
bir adet yıldız arkasından ikişer adet artarak ekrana 10 satır halinde
yazılan yıldızları göreceğiz. Programda en az bir yıldız göründükten sonra
say değişkeni bir kez arttırılacak daha sonra on değerine ulaşana kadar
yıldız arttırılarak yazdırılmaya devam edecektir. On sayısına ulaşan say
değeri sonucunda readln; satırına geçecek ve programın çalışmasına
klavyeye basılana kadar bekleyecektir.
Program yıldız;
USES CRT;
var
say:integer;
Begin
clrscr;
repeat
writeln(‘*’)
say:= say + 1;
until say = 10;
writeln(‘ Devam için bir tuşa basın …’);
readln;
end.
Dosya
açıp
içerisindeki
değerleri
okumaya
yönelik
repeat-until
komutuna örnek olarak aşağıdaki programı inceleyelim. Bu programda bir
58
İrfan MACİT
yazı dosyası içerisinden belirli değerleri bir değişkene aktararak bunları
kümülatif olarak toplayan bir pascal programı yazılmıştır.
Program oku_topla;
USES CRT;
var
dosya_deg: text;
sayi, topla: real;
bitis: boolean;
Begin
ASSIGN(dosya_deg, ‘C:\data\testdata.dat’);
RESET(dosya_deg);
topla:= 0.0;
bitis:=false;
repeat
readln(dosya_deg, sayi);
if sayi < 0.0 then
bitis := true;
else
toplam := toplam + sayi;
until bitis;
writeln(‘ Dosyain içerisindeki sayıların toplamı ’,
toplam,’ dir’);
readln;
CLOSE (dosya_deg);
End.
Yazılan (oku_topla) programda daha önceden klavyeden girdiğimiz
değerler yerine var olan bir dosyadan (testdata.dat) alınan veriler
üzerinde işlemler yapılmaktadır. Dosyadan okunan değerler dosya_deg ile
okunmakta ve kümülatif toplam oluşturulmaktadır.
Genellikle program yazılırken klavyeden veya başka bir ortamdan girilen
değişkenleri tipi kontrol edilmeden girilir. Kontrolsüz yapılan bu işlemler
59
sonucunda
programımıza
hatalı
İrfan MACİT
değişken
değerleri
veya
tipleri
girilmektedir. Aşağıdaki Pascal (kontrol) programında girilen değerlerin
tipinin kontrol edilmesine yönelik program kodları görülmektedir.
Program kontrol;
USES CRT;
Type
Katar50: string[50];
Var
Cevap: katar50;
Begin
Repeat
Readln (cevap);
Case
‘E’,’e’: cevap:= ‘E’;
‘H’,’h’: cevap:= ’H’;
else
begin
writeln(‘ Lütfen Evet için E-e Hayır için H-h
harfi girin’);
end;
end;
until cevap[1] in [‘Y’,’y’,’H’,’h’];
end.
Klavyeden
girilen
karakterleri
kontrol
ederek
değişkenin
istenen
karakterlerin dışında olması durumunda program belirlenen karakterlerin
girilmesine kadar repeat-until döngüsü komutları çalıştırır.
5.2 Turbo Pascalda while-do Şartlı Döngü Yapısı
Turbo pascalda şartlı döngülerde bir başka yapı while-do yapısıdır. Bu
yapı repeat-until yapısından farklı olarak şart gerçekleştiği durumda
komutları çalıştırır. Eğer şart gerçekleşmiyor ise komutlar çalıştırılmaz ve
60
İrfan MACİT
program bir sonraki yapıdan çalışmaya devam eder. Burada üzerinde
durulması gereken en önemli nokta şart gerçekleşmiyor ise while-do
yapısı içerisine yazılan komutlar çalışmaz. Genel yazım şekli aşağıdaki
gibidir.
while şart_ifadesi do
begin
…
end;
Yapıya örnek olarak vereceğimiz başlangıç örneği aşağıdaki gibi olabilir.
sayi:=0
while sayi < 10 do
begin
sayi:=sayi+1;
writeln(‘Sayı ’,sayi ,’dir’);
end;
yukarıdaki
program
parçacığındaki
sayi
değişkeni
önce
(0)
sıfıra
eşitleniyor. Daha sonra on (10) sayısından küçük olduğundan begin-end
bloğu arasındaki komutlar çalıştırılıyor. Şart sağlanmadığı için while-do
komut seti tekrar çalıştırılıyor. En son toplam değer on (10) olduğunda
şartlı döngü yapısından çıkılarak alt satırdaki komutlar yürütülüyor.
Şartlı döngüler program yazımında fazla kullanılan yapılardır. Örneğin elli
(50) sayısının seri toplamını bulmak isteyelim. Serinin toplamını el ile
toplamak çok zaman almaktadır. Sayı büyüdükçe zaman ve hata oranı
artmaktadır. Turbo Pascal bilgisayar programlama dili ile böyle bir
programı (toplam) aşağıdaki gibi yazabiliriz.
Program toplam;
USES CRT;
61
İrfan MACİT
var
i, topla: integer;
begin
clrscr;
i:=0;
topla:=0;
while i <= 50 do
begin
i:=i+1;
toplam := toplam + i;
writeln(‘toplam seri değeri =’, toplam,’dir’);
end;
end.
Mühendislik
problemlerinde
veya
fizik
deneylerinde
serbest
düşüş
deneylerini arasıra yaparız. Bu deneylerde uzaklık yerçekimi ve zamanın
1
karesi ile doğru orantılıdır. Formülü ise l = g * t 2 şeklinde yazılır. Uzaklık l
2
ise g yerçekimi sabiti ve t zaman olarak alınır. Serbest düşüş deneyini
(serbest) Turbo Pascal bilgisayar programlama dili ile aşağıdaki gibi
programlayabiliriz.
Program serbest;
const
g = 9.80655;
var
yuk, kule, t, delta_t: real;
Begin
writeln(‘Kule yüksekliğini girin -> ’);
readln(kule);
writeln(‘ Düşme süresini girin -> ’);
readln(delta_t);
t:=0.0;
writeln(‘ Süre
‘:20, ‘Yükseklik ’:20);
62
İrfan MACİT
yuk:= kule;
while yuk > 0.0 do
begin
writeln( t:20:3, yuk:20:3);
t:=t + delta_t;
yuk:= kule - 05 * g * SQR(t);
readln;
end;
end.
Bu
deneyde
girilen
değişken
tiplerinin
gerçel
(real)
gerektiğini unutmamalıyız. Yükseklik değeri ger zaman
tipte
olması
tam sayı doğası
gereği olmayacaktır. Bu tür deneylerde programcı deneyin içerisinde
kullanılacak değişkenlerin tipleri konusunda formülasyonu dikkat ile
incelemelidir.
Deneylerimizde genellikle elde ettiğimiz sonuçları bir yazı dosyasında
saklamak
konusunda
isteriz.
Sakladığımız
yardımcı
olacak
ve
bu
yazı
sonuçları
dosyası
bize
MSExcel
analizlerimiz
gibi
bilgisayar
programları ile kolay işlememizi sağlayacaktır. Bu deneyden elde ettiğimiz
sonuçları bir tablolama programı ile grafiğini çizdirmek istersek yazı
dosyasında sakladığımız sonuçlara ihtiyacımı olacaktır.
Deneyi (serbest)
sonuçları elde edecek şekilde yazı dosyasına aktaracak programı aşağıdaki
gibi yazabiliriz.
Program serbest;
USES CRT;
dosya_deg: text;
const
g = 9.80655;
var
yuk, kule, t, delta_t: real;
Begin
ASSIGN(dosya_deg, ‘C:\data\sonuc.dat’);
63
İrfan MACİT
RESET(dosya_deg);
writeln(‘Kule yüksekliğini girin -> ’);
readln(kule);
writeln(‘ Düşme süresini girin -> ’);
readln(delta_t);
t:=0.0;
writeln(dosya_deg, ‘ Süre
‘:20, ‘Yükseklik ’:20);
yuk:= kule;
while yuk > 0.0 do
begin
writeln( dosya_deg, t:20:3, yuk:20:3);
t:=t + delta_t;
yuk:= kule - 05 * g * SQR(t);
readln;
end;
CLOSE (dosya_deg);
end.
Deneyden
elde
ettiğimiz
veriler
“sonuc.dat”
adli
bir
dosyada
saklanmaktadır. Bu dosyadan daha sonra istediğimiz verileri alarak analiz
yapabilir veya başka bir programa girdi verisi olarak kullanabiliriz.
64

5- Turbo Pascalda Kullanılan Döngü Yapıları

Transkript

Benzer belgeler

65 6- Turbo Pascal Programlamada Fonksiyonlar 6.1 Yapısal

Algoritmalar ve Pascal

15 2. Veri Tipleri Turbo Pascal bilgisayar programlama dili ile

BİL264L/ELE263L Deney 1

TURBO PASCAL

4- Turbo Pascal Bilgisayar Programlamada Kullanılan Şart Yapıları

RSLogix 5000 Motion Control (Kinetix 6000)

23 3- Turbo Pascal Programlamada Giriş – Çıkış İşlemleri 3.1 Turbo

Delphi`ye Giriş

Ders Notları Tamamı - Endüstri Mühendisliği Bölümü Üretim