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 dı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ı dı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 İş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
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; 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; i:integer; Clrscr; for i:=1 to 10 do writeln(i); End. Bu programda bilgisayar ekran kontrolleri kullanmak için USES CRT yazarak ekranı temizleyecek komutun çalışması için gerekli kütüphaneleri 44
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; i:integer; Clrscr; for i:=1 to 10 do i:=i+1; writeln(i); 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; 45
i:integer; Clrscr; for i:=10 downto 1 do i:=i+1; writeln(i); 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; i,n:integer; 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. 46
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; harf, harf_yaz: char; clrscr; for harf:= A to Z do writeln(harf); 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 dı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
yapmaktayız. Genel olarak yazacağımız matris program (matris_1) kodlarını aşağıdaki gibi yazabiliriz. Program matris_1; İ,j,k:integer; matris: array [1..50,1..50] of integer 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]); 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 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; i,j,k:integer; vek: array[1..50] of integer; veks: array[1..50] of integer; 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 writeln( vektor (,i, )= ); readln(vek[i]); for i:= 1 to n do veks[i]= k * vek[i]; writeln( veks (,i, ) =, veks[i]) ; readln; End. 49
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; Var i,n,eleman: integer: ort: real; dizi :array[1..50] of integer; 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]); eleman:=0; for i:=1 to n do eleman:= eleman+ dizi[i]; ort:= eleman/n; writeln( Girilen dizinin elemanlarının ortalaması =, ort, dir ); readln; End. 50
Ortalaması alınacak olan sayılar n boyutlu dizi[n] elemanına 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 1 2 3 4 5 6 7 8 9 10 11 Sayı 1 1 2 3 5 8 13 21 34 55 89 Fibonacci serisinin n terimli olarak Pascal 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
Program Fibonacci; Var i, n, terim_1, terim_2, terim_3; 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 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. 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ı dır. PROGRAM Gauss_Jordan; CONST np=20; 52
mp=20; TYPE glnpbynp = ARRAY [1..np,1..np] OF real; glnpbymp = ARRAY [1..np,1..mp] OF real; glnp = ARRAY [1..np] of integer; glnpbynp = ARRAY [1..np,1..np] OF real; glnpbymp = ARRAY [1..np,1..mp] OF real; glnp = ARRAY [1..np] OF integer; VAR j,k,l,m,n : integer; a,ai,u : glnpbynp; b,x,t : glnpbymp; dfile : text; TYPE double = real; char12 = string[12]; FUNCTION sngl(x:real):real; BEGIN sngl := x PROCEDURE glopen(var infile:text; filename:char12); BEGIN assign(infile,filename); reset(infile) 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 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 ELSE IF (ipiv[k] > 1) THEN BEGIN writeln('pause 1 in GAUSSJ - singular matrix'); readln 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
a[icol,l] := dum FOR l := 1 TO m DO BEGIN dum := b[irow,l]; b[irow,l] := b[icol,l]; b[icol,l] := dum indxr[i] := irow; indxc[i] := icol; IF (a[icol,icol] = 0.0) THEN BEGIN writeln('pause 2 in GAUSSJ - singular matrix'); readln pivinv := 1.0/a[icol,icol]; a[icol,icol] := 1.0; FOR l := 1 TO n DO BEGIN a[icol,l] := a[icol,l]*pivinv FOR l := 1 TO m DO BEGIN b[icol,l] := b[icol,l]*pivinv FOR ll := 1 TO n DO BEGIN IF (ll <> icol) THEN BEGIN dum := a[ll,icol]; a[ll,icol] := 0.0; FOR l := 1 TO n DO BEGIN a[ll,l] := a[ll,l]-a[icol,l]*dum FOR l := 1 TO m DO BEGIN b[ll,l] := b[ll,l]-b[icol,l]*dum 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 BEGIN glopen(dfile,'matrx1.dat'); 10: readln(dfile); readln(dfile); readln(dfile,n,m); 54
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]) 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]) (* save matrices for later testing of results *) FOR l := 1 to n DO BEGIN FOR k := 1 to n DO BEGIN ai[k,l] := a[k,l] FOR k := 1 to m DO BEGIN x[l,k] := b[l,k] (* invert matrix *) gaussj(ai,n,np,x,m,mp); writeln; writeln('inverse of matrix a : '); FOR k := 1 to n DO BEGIN FOR l := 1 to n-1 DO write(ai[k,l]:12:6); writeln(ai[k,n]:12:6) (* test results *) (* check inverse *) writeln('a times a-inverse (compare with unit matrix)'); FOR k := 1 to n DO BEGIN 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] FOR l := 1 to n-1 DO write(u[k,l]:12:6); writeln(u[k,n]:12:6) (* 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,':'); FOR k := 1 to n DO BEGIN 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
writeln(' ':8,b[k,l]:12:6,t[k,l]:12:6); writeln('***********************************'); IF eof(dfile) THEN GOTO 99; writeln('press RETURN for next problem:'); readln; GOTO 10; 99: close(dfile). 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
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; say; ilk_sayi, carp: integer; clrscr; say:=1 ilk_sayi:=3; carp:=1; repeat 57
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; say:integer; 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
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; dosya_deg: text; sayi, topla: real; bitis: boolean; 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 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ı 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; Type Katar50: string[50]; Var Cevap: katar50; 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 ); 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
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 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 ); 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; 61
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. Mühendislik problemlerinde veya fizik deneylerinde serbest düşüş deneylerini arasıra yaparız. Bu deneylerde uzaklık yerçekimi ve zamanın karesi ile doğru orantılıdır. Formülü ise 1 2 2 l = g * t şeklinde yazılır. Uzaklık l 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; yuk, kule, t, delta_t: real; 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
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. Bu deneyde girilen değişken tiplerinin gerçel (real) tipte olması gerektiğini unutmamalıyız. Yükseklik değeri ger zaman 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 isteriz. Sakladığımız bu yazı dosyası bize analizlerimiz konusunda yardımcı olacak ve sonuçları MSExcel 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; dosya_deg: text; const g = 9.80655; yuk, kule, t, delta_t: real; ASSIGN(dosya_deg, C:\data\sonuc.dat ); 63
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; 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