ALGORİTMA GELİTİRME M. Turhan Çoban°TMA... · 2015-07-19 · olarak bilgisayar programlama ve sayısal ve analitik matematiğin çeúitli kısımlarını içeren bir kapsamdadır

ALGORİTMA GELİŞTİRME

M. Turhan Çoban

HAFTA 1 1.1 GİRİŞ

Bu dersimizde matematiksel formüllerin bilgisayar kodlarına nasıl dönüştürüleceği üzerinde durulacaktır. Kurs temel

olarak bilgisayar programlama ve sayısal ve analitik matematiğin çeşitli kısımlarını içeren bir kapsamdadır. Ders

haftalık ödev setleri olarak oluşturulacaktır. Derse devamın tek şartı verilen ödev setlerini çözerek ödevleri

[email protected] eposta adresine haftalık olarak göndermektir. Ödev setleri devamlılık gösterdiğinden

başlangıçtan itibaren takip edilmesi ve çözülmesi gerekmektedir.

Ders notlarına ve ek olarak verilen java diliyle programlama ve sayısal analiz kitaplarının kopyelerine

www.turhancoban.com/dersler/algoritma adresinden ulaşılabilir. Hafta için gerekli bilgisayar kavramlarının ne

olduğu ve ne şekilde oluşturulacağı, bilgisayar kitabından ilgili bölüm referans gösterilerek verilecektir. Aynı şekilde

sayısal analiz kitabındanda çeşitli sayısal metodlar referans olarak alınarak algoritmaların geliştirilmesi için

kullanılacaktır. Bir çok hazır program kodu ek olarak verilmektedir, ve derslerimizde sizin geliştireceğinize benzer

örnek kodlar yer alacaktır. İyi çalışmalar.

1.2 BİLGİSAYAR KAVRAMLARI

Bölüm 1 : Java programlarını kurma ve çalıştırma

Bölüm 1 : Değişken türleri, tamsayı, gerçek sayı, harf(char), yazı(String), mantık(boolean) değişkenleri ve işlemleri .

Bölüm 1: Mantık yapısı if deyimi, döngü yapıları while ve for deyimi

Bölüm 2: metot kavramı ve static metodlar

1.3 MATEMATİKSEL KAVRAMLAR

Bölüm 1.7 Taylor serileri ve hata açılımı

Bölüm 1.8 Çeşitli fonksiyonların seri açılımları

1.4 ÖRNEK KODLAR

Üzerinde ilk duracağımız kavram standart bir fonksiyonun yazılımı ve hesaplanmasıdır.

Örnek 1: 52)( 2 xxxf 52 x 0.1 aralığıyla hesaplayalım

import javax.swing.*;

public class algoritmaH1_E1

{

public static double func(double x)

{double f=x*x-2*x+5;

return f;

}

public static String print(double x1,double x2,double dx)

{

String s="";

for(double x=x1;x<x2;x+=dx)

{s+="x = "+x+" f = "+func(x)+"\n";}

return s;

}

public static void main(String arg[])

{JOptionPane.showMessageDialog(null,print(2.0,5.0,0.1));}

}

mailto:[email protected]

http://www.turhancoban.com/dersler/algoritma

Örnek 2: xexf )( 52 x n=31 adet veri oluşturacak şekilde hesaplayalım. Bu hesap için hazır kütüphane

fonksiyonu Math.exp(x) kullanılacaktır.


{

public static String print(double x1,double x2,int n)

{

String s="";

double x;

for(int i=0;i<n;i++)

{ x=x1+(x2-x1)/(n-1)*i;

s+="x = "+x+" f = "+Math.exp(x)+"\n";

}

return s;

}


{System.out.println(print(2.0,5.0,31));}

}

---------- Capture Output ----------

> "C:\java\bin\java.exe" algoritmaH1_E2

x = 2.0 f = 7.38905609893065

x = 2.1 f = 8.166169912567652

x = 2.2 f = 9.025013499434122

x = 2.3 f = 9.974182454814718

x = 2.4 f = 11.023176380641601

x = 2.5 f = 12.182493960703473

x = 2.6 f = 13.463738035001692

x = 2.7 f = 14.879731724872837

x = 2.8 f = 16.444646771097048

x = 2.9 f = 18.17414536944306

x = 3.0 f = 20.085536923187668

x = 3.1 f = 22.197951281441636

x = 3.2 f = 24.532530197109352

x = 3.3 f = 27.112638920657883

x = 3.4000000000000004 f = 29.964100047397025

x = 3.5 f = 33.11545195869231

x = 3.6 f = 36.59823444367799

x = 3.7 f = 40.4473043600674

x = 3.8 f = 44.701184493300815

x = 3.9000000000000004 f = 49.40244910553019

x = 4.0 f = 54.598150033144236

x = 4.1 f = 60.34028759736195

x = 4.2 f = 66.68633104092515

x = 4.300000000000001 f = 73.69979369959584

x = 4.4 f = 81.45086866496814

x = 4.5 f = 90.01713130052181

x = 4.6 f = 99.48431564193378

x = 4.7 f = 109.94717245212352

x = 4.800000000000001 f = 121.51041751873497

x = 4.9 f = 134.28977968493552

x = 5.0 f = 148.4131591025766

> Terminated with exit code 0.

Örnek 3:

1 !

)exp()(k

kx

k

xxexf 52 x n=31 adet veri oluşturacak şekilde hesaplayalım. Bu hesap

için formül seri açılımı olarak oluşturulacaktır.


{

public static double exp(double x)

{

double factorial=1;

double power=1;

double exp=0;

for(int k=1;k<200;k++)

{exp+=power/factorial;

power*=x;

factorial*=k;

}

return exp;

}


{

String s="";

double x;


{ x=x1+(x2-x1)/(n-1)*i;

s+="x = "+x+" f = "+exp(x)+"\n";

}

return s;

}



}

---------- Capture Output ----------


x = 2.0 f = 7.389056098930649

x = 2.1 f = 8.166169912567652

x = 2.2 f = 9.02501349943412

x = 2.3 f = 9.974182454814718

x = 2.4 f = 11.0231763806416

x = 2.5 f = 12.182493960703471

x = 2.6 f = 13.463738035001693

x = 2.7 f = 14.879731724872837

x = 2.8 f = 16.444646771097037

x = 2.9 f = 18.174145369443067

x = 3.0 f = 20.08553692318766

x = 3.1 f = 22.197951281441632

x = 3.2 f = 24.532530197109352

x = 3.3 f = 27.112638920657893

x = 3.4000000000000004 f = 29.96410004739703

x = 3.5 f = 33.115451958692326

x = 3.6 f = 36.598234443677995

x = 3.7 f = 40.4473043600674

x = 3.8 f = 44.70118449330082

x = 3.9000000000000004 f = 49.402449105530195

x = 4.0 f = 54.598150033144265

x = 4.1 f = 60.34028759736196

x = 4.2 f = 66.68633104092514

x = 4.300000000000001 f = 73.69979369959582

x = 4.4 f = 81.45086866496814

x = 4.5 f = 90.0171313005218

x = 4.6 f = 99.48431564193376

x = 4.7 f = 109.94717245212354

x = 4.800000000000001 f = 121.510417518735

x = 4.9 f = 134.28977968493552

x = 5.0 f = 148.41315910257657


Örnek 4:

52/12

202)(

2

xx

xxxf

fonksiyonunu n=51 adet veri oluşturacak şekilde hesaplayalım.



{


{

double f;

if(x>=0 && x<=2) f=x*x-2;

else if(x>2 && x<=5) f=2-1/x;

else f=0;

return f;

}


{

String s="";

double x;


{ x=x1+(x2-x1)/(n-1)*i;

s+="x = "+x+" f = "+func(x)+"\n";

}

return s;

}


{JOptionPane.showMessageDialog(null,print(0.0,5.0,51));}

}

Örnek 5:

0

12

)!12()1()sin()(

k

kk

k

xxxf 42 x dx=0.1 aralığıyla hesaplayalım. Bu hesap için

formül seri açılımı olarak oluşturulacaktır.


{

public static double sin(double x)

{int isaret=1;

double pow=x;

double fact=1;

int n=1;

double sin=0;


{sin+=pow/fact*isaret;

pow*=x*x;

n=2*k+1;

fact*=n*(n-1);

isaret*=-1;

}

return sin;

}

public static String print(double x1,double x2,double dx)

{

String s="";

for(double x=x1;x<=x2+0.0001;x+=dx)

{s+="x = "+x+" f = "+sin(x)+"\n";}

return s;

}


{System.out.println(print(2.0,4.0,0.1));}

}

---------- Capture Output ----------


x = 2.0 f = 0.9092974268256817

x = 2.1 f = 0.8632093666488739

x = 2.2 f = 0.8084964038195899

x = 2.3000000000000003 f = 0.7457052121767199

x = 2.4000000000000004 f = 0.6754631805511507

x = 2.5000000000000004 f = 0.5984721441039558

x = 2.6000000000000005 f = 0.5155013718214636

x = 2.7000000000000006 f = 0.4273798802338295

x = 2.8000000000000007 f = 0.3349881501559044

x = 2.900000000000001 f = 0.23924932921398148

x = 3.000000000000001 f = 0.1411200080598659

x = 3.100000000000001 f = 0.04158066243328991

x = 3.200000000000001 f = -0.058374143427581265

x = 3.300000000000001 f = -0.15774569414324965

x = 3.4000000000000012 f = -0.255541102026832

x = 3.5000000000000013 f = -0.3507832276896219

x = 3.6000000000000014 f = -0.44252044329485346

x = 3.7000000000000015 f = -0.5298361409084955

x = 3.8000000000000016 f = -0.6118578909427209

x = 3.9000000000000017 f = -0.6877661591839747

x = 4.000000000000002 f = -0.7568024953079282


Double ile yapılan for döngüsünde x değerlerinin tam olmadığını vurgulayalım döngüleri tamsayı (int) olarak

döndürmek daha iyi bir çözümdür.



{

public static double sin(double x)

{int isaret=1;

double pow=x;

double fact=1;

int n=1;

double sin=0;


{sin+=pow/fact*isaret;

pow*=x*x;

n=2*k+1;

fact*=n*(n-1);

isaret*=-1;

}

return sin;

}


{

String s="";

double x;


{ x=x1+(x2-x1)/(n-1)*i;

s+="x = "+x+" f = "+sin(x)+"\n";

}

return s;

}


{JOptionPane.showMessageDialog(null,print(2.0,4.0,21));}

Örnek 7,8:Fibonnachi serisi : 1 1 2 3 5 8 13.. şeklindedir. Temel olafak F(0)=1 F(1)=1 F(n)=F(n-1)+F(n-2) olarak

tanımlanmıştır.



{

public static int fibonnachi(int n)

{int f0=1;

int f1=1;

if(n==0) return f0;

else if(n==1) return f1;

else return fibonnachi(n-1)+fibonnachi(n-2);

}


{int n=Integer.parseInt(JOptionPane.showInputDialog("n="));

System.out.println("n= "+n+" Fibonnachi = "+fibonnachi(n));

}

}

---------- Capture Output ----------


n= 4 Fibonnachi = 5


---------- Capture Output ----------


n= 6 Fibonnachi = 13


Örnek 8 : Örnek 5 deki sin(x) fonksiyonunu ekrandan girdiğimiz bir programda kullanalım.



{


{double x=Double.parseDouble(JOptionPane.showInputDialog("x="));

System.out.println("sin("+x+") = "+algoritmaH1_E5.sin(x));

}

}

---------- Capture Output ----------


sin(3.1415926) = 5.3589792995680525E-8


Örnek 9,10,11,12: Chebychev ortagonal fonksiyonu Tn(x)=cos(n arccos(x)) şeklindedir. Bu terimi açarsak

T0(x)=1

T1(x)=x

T2(x)=2x2-x

…..

Tn+1(x)=2x Tn(x)- Tn-1(x)

Şeklinde bir dizi olarak hesaplanabilen bir polinom fonksiyon olduğunu görürüz.

Bu formülü programa dönüştürürsek:



{

public static double chebychev(int n,double x)

{double c0=1;

double c1=x;

if(n==0) return c0;

else if(n==1) return c1;

else return 2.0*x*chebychev((n-1),x)-chebychev((n-2),x);

}


{ int n=Integer.parseInt(JOptionPane.showInputDialog("n="));

double x=Double.parseDouble(JOptionPane.showInputDialog("x="));

String s="n= "+n+" x = "+x+ " Chebychev("+n+","+x+") = "+chebychev(n,x);

JOptionPane.showMessageDialog(null,s,"Chebychev function",JOptionPane.PLAIN_MESSAGE);

}

}

Burada yaptığımız işleme metodun kendini çağırması (recursion) diyoruz. Elbette aynı işlemi döngü ile de

yapabiliriz.



{


{double c0=1;

double c1=x;

if(n==0) return c0;


else

{double c2=1.0;

for(int i=2;i<=n;i++)

{c2=2.0*x*c1-c0;c0=c1;c1=c2;}

return c2;

}

}






}

}

For yerine her zaman while döngüsü de kullanılabilir.



{


{double c0=1;

double c1=x;

if(n==0) return c0;


else

{double c2=1.0;

int i=2;

while(i<=n)

{c2=2.0*x*c1-c0;c0=c1;c1=c2;i++;}

return c2;

}

}






}

}

Alternatif kod:



{ public static double chebychev(int n,double x)

{return Math.cos(Math.acos(x)*n);}






}}

Örnek 13: Hata fonksiyonu erf(x) aşağıdaki formülle tanımlanabilir.

Bu formülü hesaplayacak olan statik erf metodunu yazalım


{

public static double erf(double x)

{

int isaret=1;

double pow=x;

double fact=1;

int n=0;

int k;

double ef=0;

while(n<200)

{ef+=isaret*pow/(fact*(2*n+1));

n++;

pow*=x*x;

fact*=n;

isaret*=-1;

}

return 2.0/Math.sqrt(Math.PI)*ef;

}

)12(!)1(

2)(

12

0

nn

xxerf

n

n

n


{

String s="";

double x=0;


{ x=x1+(x2-x1)/(n-1)*i;

s+="x = "+x+" f = "+erf(x)+"\n";

}

return s;

}



}

---------- Capture Output ----------


x = 0.0 f = 0.0

x = 0.1 f = 0.1124629160182849

x = 0.2 f = 0.22270258921047845

x = 0.30000000000000004 f = 0.3286267594591275

x = 0.4 f = 0.42839235504666845

x = 0.5 f = 0.5204998778130465

x = 0.6000000000000001 f = 0.603856090847926

x = 0.7000000000000001 f = 0.6778011938374184

x = 0.8 f = 0.7421009647076603

x = 0.9 f = 0.7969082124228323

x = 1.0 f = 0.8427007929497148

x = 1.1 f = 0.8802050695740816

x = 1.2000000000000002 f = 0.9103139782296353

x = 1.3 f = 0.9340079449406524

x = 1.4000000000000001 f = 0.952285119762649

x = 1.5 f = 0.9661051464753108

x = 1.6 f = 0.976348383344644

x = 1.7000000000000002 f = 0.983790458590775

x = 1.8 f = 0.9890905016357304

x = 1.9000000000000001 f = 0.9927904292352573

x = 2.0 f = 0.9953222650189532


Not : ödev problemlere geçmeden önce tüm eksersiz problemlerini yazınız, çalıştırınız ve sonuçları irdeleyiniz,

eksersizlere bakmadan ödev problemlerine direk geçerseniz zorlanabilirsiniz.

Örnek 14: logaritma aşağıdaki seriyle hesaplanabilir :

...)753

1(2)12(

2)ln(642

0

2

yyyy

n

yyx

n

n

1

1

x

xy


{

public static double log(double x)

{

// ln(x) = 1+y^2/3+y^4/5+y^6/7+... y=(x-1)/(x+1)

double power=1;

double ln=1;

double y=(x-1)/(x+1);

double n=1;

do

{ power*=y*y;

ln+=power /(2.0*n+1.0);

n++;

} while(n<=100000);

ln*=2*y;

return ln;

}


{

String s="";

double x=0;


{ x=x1+(x2-x1)/(n-1)*i;

s+="x = "+x+" f = "+log(x)+"\n";

}

return s;

}



}

---------- Capture Output ----------


x = 1.0 f = 0.0

x = 1.05 f = 0.048790164169432056

x = 1.1 f = 0.09531017980432495

x = 1.15 f = 0.13976194237515865

x = 1.2 f = 0.18232155679395456

x = 1.25 f = 0.22314355131420974

x = 1.3 f = 0.26236426446749117

x = 1.35 f = 0.30010459245033816

x = 1.4 f = 0.3364722366212128

x = 1.45 f = 0.37156355643248296

x = 1.5 f = 0.4054651081081644

x = 1.55 f = 0.43825493093115525

x = 1.6 f = 0.47000362924573574

x = 1.65 f = 0.500775287912489

x = 1.7000000000000002 f = 0.5306282510621706

x = 1.75 f = 0.5596157879354225

x = 1.8 f = 0.5877866649021191

x = 1.85 f = 0.6151856390902335

x = 1.9 f = 0.6418538861723945

x = 1.9500000000000002 f = 0.6678293725756556

x = 2.0 f = 0.6931471805599455


Örnek 15: bir sayının kuvvetini almak için :

))ln(*exp( axa x formülünden yararlanabiliriz. Bunun için bir algoritma geliştirelim.



{


{

// ln(x) = 1+y^2/3+y^4/5+y^6/7+... y=(x-1)/(x+1)

double power=1;

double ln=1;


double n=1;

while(n<=1000)

{ power*=y*y;

ln+=power /(2.0*n+1.0);

n++;

}

ln*=2*y;

return ln;

}


{

double factorial=1;

double power=1;

double exp=0;



power*=x;

factorial*=k;

}

return exp;

}

public static double pow(double a,double x)

{return exp(x*log(a));}


{

String s="";

double x=0;


{ x=x1+(x2-x1)/(n-1)*i;

s+="x = "+x+" f = "+log(x)+"\n";

}

return s;

}


{ double a=Double.parseDouble(JOptionPane.showInputDialog("a="));


String s=""+a+"^"+x+" = "+pow(a,x);

JOptionPane.showMessageDialog(null,s,"power of a number",JOptionPane.PLAIN_MESSAGE);

}

}

1.5 ÖDEV PROBLEMLERİ

ÖDEV 1 : kod ismi: algoritmaH1_O1 3

53)(

2

3

x

xxxf fonksiyonunu 22 x 0.1 aralığıyla

hesaplayan bir kod yazalım


{


{

// ln(x) = 1+y^2/3+y^4/5+y^6/7+... y=(x-1)/(x+1)

double power=1;

double ln=1;


double n=1;

do

{ power*=y*y;

ln+=power /(2.0*n+1.0);

n++;

} while(n<=100000);

ln*=2*y;

return ln;

}


{

String s="";

double x=0;


{ x=x1+(x2-x1)/(n-1)*i;

s+="x = "+x+" f = "+log(x)+"\n";

}

return s;

}



}

ÖDEV 2 : kod ismi: algoritmaH1_O2 )cos()( xxf fonksiyonunu x 0.1 aralığıyla hesaplayan

bir kod yazınız. Cos fonksiyonu kütüphaneden Math.cos(x) olarak çağrılabilir. sayısı Math.PI olarak çağrılacaktır.

ÖDEV 3 : kod ismi: algoritmaH1_O3 )cos()( xxf fonksiyonunu x 0.1 aralığıyla hesaplayan

bir kod yazınız. Cos fonksiyonunu

0

2

)!2()1()cos(

k

kk

k

xx taylor serisi açılım formülünden bir static fonksiyon

olarak hesaplayınız. sayısı Math.PI olarak çağrılacaktır.

ÖDEV 4 : kod ismi: algoritmaH1_O2 Legendre ortagonal polinomlarını kullanarak fonksiyon yaklaşımını

irdeleyelim. Legendre Polinomlarını 2),(1

)()12(

)( 21

kxPk

kxxP

k

kxP kkk

denklemiyle tanımlanır.

Burada P0(x)=1 ve P1(x)=x olarak tanımlanmıştır. Legendre polinomu )(xPk I hesaplayan bir static fonksiyon

yazınız ve k=5 için 50 x aralığında hesaplayınız.


Bu haftanın temel konusu sınıf kavramı ve algoritmaların sınıf kavramı etrafında oluşturulması. Sınıflar değişkenleri

ve metodları içeren daha organize bilgi guruplarıdır ve bu gurupları kullanarak kendi değişkenlerimizi veya montaj

parçalarımızı oluşturmak mümkündür, sınıf kavramıyla birlikte montaj edilebilir parçalar üretilmeye başlanmıştır.

Örneğin piston ve silindiri ayrı ayrı programlayıp motor bloğunda kullanabiliriz. Sınıf kavramı ile ilgili detaylı

bilgiyi ve örnekleri “Java bilgisayar diliyle programlama” kitabımızda bulacaksınız, burada yine algoritma

örnekleriyle kullanım üzerinden gideceğiz.

2.2 BİLGİSAYAR KAVRAMLARI (JAVA PROGRAMLAMA DİLİ)

Bölüm 2 : Sınıf Kavramına giriş ve metodlar

Bölüm 3 Sınıf(Class) Yapılarına giriş

2.3 MATEMATİKSEL KAVRAMLAR (JAVA PROGRAMLAMA DİLİ ÖRNEKLERİYLE SAYISAL

ÇÖZÜMLEME)

Bölüm 2 : Fonksiyonların kökleri

2.4 ÖRNEK KODLAR

Üzerinde ilk duracağımız kavram standart bir fonksiyonun yazılımı ve hesaplanmasıdır.

Örnek 1: 52)( 2 xxxf 52 x 0.1 aralığıyla hesaplayalım


public class fonksiyon1

{

public double func(double x)

{double f=x*x-2*x+5;

return f;

}

public String print(double x1,double x2,double dx)

{ String s="";

for(double x=x1;x<x2;x+=dx)

{s+="x = "+x+" f = "+func(x)+"\n";}

return s;

}}



{


{ fonksiyon1 f=new fonksiyon1();

JOptionPane.showMessageDialog(null,f.print(2.0,5.0,0.1));}

}

Görüldüğü gibi burada H1’in ilk örneğini yeniden düzenledik func ve print metodlarını yeni bir sınıfın içinde ayrıca

tanımladık ve bu sınıfı ikinci programımızda çağırarak kullandık.

Örnek 2: Bir kutunun hacmini hesaplayalım:

public class kutu

{

double en,boy,yukseklik;

public kutu(double eni,double boyu,double yuksekligi)

{en=eni;

boy=boyu;

yukseklik=yuksekligi;

}

public double hacim()

{return en*boy*yukseklik;}

public String toString()

{String s="en = "+en+"\n";

s+="boy = "+boy+"\n";

s+="yukseklik = "+yukseklik+"\n";

s+="hacim = "+hacim()+"\n";

return s;

}

}

public class kututesti

{public static void main(String arg[])

{kutu a=new kutu(1.0,2.0,3.0);

System.out.println(a);

}

}

---------- Capture Output ----------

> "C:\java\bin\java.exe" kututesti

en = 1.0

boy = 2.0

yukseklik = 3.0

hacim = 6.0


Örnek 3: İkinci dereceden bir denklemin köklerini hesaplayalım: 0)( 2 cbxaxxf

Diskriminant acb 42

Eğer 0 a

bx

21

a

bx

22

Eğer 0 a

bxx

221

Eğer 0 iaa

bx

221

i

aa

bx

222

(kökler sanal)


public class ikinci_derece_denklem

{ double a,b,c;

double D;//discriminant

double x1r,x1i,x2r,x2i; //kökler

//kurucu metod(constructor)

public ikinci_derece_denklem(double ai,double bi,double ci)

{a=ai;b=bi;c=ci;D=b*b-4.0*a*c;

if(D>0) {x1r=(-b-sqrt(D))/(2.0*a);x2r=(-b+sqrt(D))/(2.0*a);x1i=0;x2i=0;}

else if(D==0) {x1r=x2r=-b/(2.0*a);x1i=0;x2i=0;}

if(D<0) x1r=x2r=b/(2.0*a);x1i=-sqrt(-D)/(2.0*a);x2i=sqrt(-D)/(2.0*a);

}

//fonksiyonları tanımlayan statik metodlar


{

// ln(x) = 1+y^2/3+y^4/5+y^6/7+... y=(x-1)/(x+1)

double power=1;

double ln=1;


double n=1;

while(n<=1000)

{ power*=y*y;

ln+=power /(2.0*n+1.0);

n++;

}

ln*=2*y;

return ln;

}


{

double factorial=1;

double power=1;

double exp=0;



power*=x;

factorial*=k;

}

return exp;

}

public static double sqrt(double a)

{return exp(0.5*log(a));}

//çıktı alamak için kullanılan metod: toString()


{ String s="";

if(D>=0)

{s+="Kökler gerçek sayı+\n";

s+="x1 = "+x1r+"\nx2 = "+x2r+"\n";

}

else

{s+="Kökler sanal sayı+\n";

s+="x1 = "+x1r+" + "+x1i+"*i \nx2 = "+x2r+" + "+x2i+" *i \n";}

return s;

}}



{

public static double gir(String s)

{ String s1=JOptionPane.showInputDialog("İkinci dereceden denklemi kökleri "+s+ " = ?");

double x=Double.parseDouble(s1);

return x;

}


{ double a=gir("a");

double b=gir("b");

double c=gir("c");

ikinci_derece_denklem denklem1=new ikinci_derece_denklem(a,b,c);

JOptionPane.showMessageDialog(null,denklem1);}

}

ALGORİTMA GELİŞTİRME ÖNEMLİ KURAL: Programlar bir kere yaz tekrar kullan

olmalıdır, bir kere yazılan kod tekrar tekrar kullanılır, tekrar yazılmaz. Bu yüzden 1 hafta

yazdığımız exp ve log kodlarını bu programı geliştirirken tekrar yazmamız gerekmiyordu.

Program üzerinde bu değişikliği uygulayalım:

public class ikinci_derece_denklem1

{ double a,b,c;




public ikinci_derece_denklem1(double ai,double bi,double ci)


if(D>0) {x1r=(-b-sqrt(D))/(2.0*a);x2r=(-b+sqrt(D))/(2.0*a);x1i=0;x2i=0;}


if(D<0) x1r=x2r=b/(2.0*a);x1i=-sqrt(-D)/(2.0*a);x2i=sqrt(-D)/(2.0*a);

}

//fonksiyonları tanımlayan statik metodlar

public static double sqrt(double a)

{return algoritmaH1_E15.exp(0.5*algoritmaH1_E15.log(a));}



{ String s="";

if(D>=0)


s+="x1 = "+x1r+"\nx2 = "+x2r+"\n";

}

else



return s;

}}


public class algoritmaH2_E2A

{


{ double a=algoritmaH2_E2.gir("a");

double b=algoritmaH2_E2.gir("b");

double c=algoritmaH2_E2.gir("c");

ikinci_derece_denklem1 denklem1=new ikinci_derece_denklem1(a,b,c);


}

Bu programımız algoritmaH1_E15 sınıfının exp ve log statik metodlarını kullandığından bu

programın aynı dosyada olduğunu ve derlendiğini varsaymaktadır, yoksa hata verir. Aynı şekilde

algoritmaH2_E2 sınıfının gir metodu da kullanılmaktadır.

ALGORİTMA GELİŞTİRME ÖNEMLİ KURAL: Tekrar kullanmada java

kütüphanelerindeki metodları direk olarak kullanabiliyorsak tercih edilmelidir.



{ double a,b,c;






if(D>0) {x1r=(-b-Math.sqrt(D))/(2.0*a);x2r=(-b+Math.sqrt(D))/(2.0*a);x1i=0;x2i=0;}


if(D<0) x1r=x2r=b/(2.0*a);x1i=-Math.sqrt(-D)/(2.0*a);x2i=Math.sqrt(-D)/(2.0*a);

}



{ String s="";

if(D>=0)


s+="x1 = "+x1r+"\nx2 = "+x2r+"\n";

}

else



return s;

}

}


public class algoritmaH2_E2B

{


{ double a=algoritmaH2_E2.gir("a");

double b=algoritmaH2_E2.gir("b");

double c=algoritmaH2_E2.gir("c");



}

Örnek 4: Algoritmasal olarak sınıf kavramının en önemli kullanımı yeni bir değişken türü

tanımlayabilmemizdir. Örneğin kompleks değişkenler ve kompleks değişkenler üzerinden log,

exp gibi fonksiyonlar javada kütüphane fonksiyonu olarak tanımlanmamıştır, kendi tanımımızı

yaparak bunları kullanabiliriz.

Kompleks sayı matematiği:

ininrz 111

ininrz 222

inininrnrzzz )()( 2121213

inininrnrzzz )()( 2121213

inrnininrnininrnrzzz )**()**(* 21212121213

)**( 2222 nininrnra

ianrnininranininrnrzzz /)**(/)**(/ 21212121213

))log(exp( 12132 zzzz

Z

))log(5.0exp( 113 zzz

ininrninrzezz

)sin(*)exp()cos(*)exp()exp( 1111131

inr

ninininrnrzz )(tan*)**()log(

1

11

111113

Kompleks işlemler basit işlemlere kolaylıkla dönüştürülerek kullanılabilirler. Bu formülleri vern bir kompleks sınıfı

oluşturalım:


//kompleks sayı

class c {

public double nr; //kompleks sayının gerçek kısmı

public double ni; //kompleks sayının sanal kısmı

//kurucu metodlar

public c(double nre,double nim)

{nr=nre;ni=nim;}

public c(double nre)

{nr=nre;ni=0.0;}

public c()

{nr=0.0;ni=0.0;}

public static c topla(c z1, c z2)

{ // iki kompleks sayısı toplar

double r1=(z1.nr + z2.nr);

double i1=(z1.ni + z2.ni);

c sonuc;

sonuc=new c(r1,i1);

return sonuc;}

public static c cikar(c z1, c z2)

{ // iki kompleks sayıyı çıkarır

c sonuc;

sonuc=new c((z1.nr - z2.nr),

(z1.ni - z2.ni));

return sonuc;

}

public static c carp(c z1, c z2)

{ // iki kompleks sayıyı çarpar

c sonuc;

sonuc=new c

((z1.nr*z2.nr - z1.ni*z2.ni),

(z1.nr*z2.ni + z1.ni*z2.nr));

//System.out.println("z1="+z1.toString()+"z2="+z2.toString()+"sonuc="+sonuc.toString());

return sonuc;}

public static c bol(c z1, c z2)

{ // iki kompleks sayıyı böler

double a=z2.nr*z2.nr+z2.ni*z2.ni;

c sonuc;

sonuc=new c

((z1.nr*z2.nr + z1.ni*z2.ni)/a,

(-z1.nr*z2.ni + z1.ni*z2.nr)/a);

return sonuc;}

//kompleks sayının üssü

public static c pow(c z1, c z2)

{ c p1=log(z1);

c p2=c.carp(z2,p1);

c p3=exp(p2);

return p3;

}

//kompleks sayının eksponenti

public static c exp(c z1)

{ // exp(x+i*y)

c sonuc=new c((Math.exp(z1.nr)*Math.cos(z1.ni) ),

(Math.exp(z1.nr)*Math.sin(z1.ni) ));

return sonuc;

}

//kompleks sayının kare kökü

public static c sqrt(c z)

{ c x=new c(0.5,0);

return pow(z,x);}

//kompleks sayının logaritması

public static c log(c z)

{ c z1;

double x=Math.log(Math.sqrt(z.nr*z.nr+z.ni*z.ni));

double y=Math.atan2(z.ni,z.nr);

z1=new c(x,y);

return z1;

}

//çıktı metodu


{String b="";

if(Math.abs(ni)!=1)

{

if(ni > 0)

b=b+"("+nr+" + "+ni+"i )";

else if(ni < 0)

b=b+"("+nr+" - "+(-ni)+"i )";

else

b=b+"("+nr+")";

}

else

{

if(ni > 0)

b=b+"("+nr+" + i )";

else

b=b+"("+nr+" - i )";

}

return b;}

}

Artık çeşitli işlemleri kompleks sınıfında yapabiliriz:



{


{ String s1=JOptionPane.showInputDialog("kompleks sayı "+s+ " = ?");


return x;

}


{ double nr1=gir("n1_gerçek ");

double ni1=gir("n1_sanal ");

double nr2=gir("n2_gerçek ");

double ni2=gir("n2_sanal ");

c z1=new c(nr1,ni1);

c z2=new c(nr2,ni2);

c z3=c.topla(z1,z2);

String s="toplama = "+z3+"\n";

z3=c.cikar(z1,z2);

s+="cikarma = "+z3+"\n";

z3=c.carp(z1,z2);

s+="carpma = "+z3+"\n";

z3=c.bol(z1,z2);

s+="bolme = "+z3+"\n";

c z4=c.sqrt(z1);

s+="kök = "+z4+"\n";

JOptionPane.showMessageDialog(null,s);}

}

Şimdi ikinci dereceden denklemin kökleri problemine geri dönelim, ikinci dereceden denklem

kökleri kompleks sayılar olabileceğinden kompleks sayılar olarak hesaplanmalıdır.



{ public double a1,b1,c1;

public double D;//discriminant

c z1,z2; //kökler



{a1=ai;b1=bi;c1=ci;D=b1*b1-4.0*a1*c1;

c w1=new c((-b1/(2.0*a1)),0);

c D1=new c(D,0.0);

c w2=new c();

w2=c.sqrt(D1);

c w3=new c(2.0*a1,0);

c w4=c.bol(w2,w3);

z1=c.topla(w1,w4);

z2=c.cikar(w1,w4);

}



{ String s="";

s+="z1 = "+z1+"\n";

s+="z2 = "+z2+"\n";

return s;

}

}



{


{ String s1=JOptionPane.showInputDialog("İkinci dereceden denklemi kökleri "+s+ " = ?");


return x;

}


{ double a=gir("a");

double b=gir("b");

double c=gir("c");



}

Örnek 6:

Benzer bir şekilde rasyonel (kesirli) sayıları da bir sınıf olarak tanımlayabiliriz.

import javax.swing.JOptionPane;

public class rasyonel {

public int pay;

public int payda;

// kurucu metodlar

public rasyonel()

{pay=0;payda=1;}

public rasyonel(int npay,int npayda)

{pay=npay;payda=npayda;}

public rasyonel(rasyonel c )

{pay=c.pay;payda=c.payda;}

//hesap metodları

public int en_kucuk_ortak_bolen()

{ // iki tam sayinin en küçük ortak bölenini hesaplar

int n=pay,m=payda;

if(n==0) return m;

if(m==0) return n;

while(m != n) { if(n>m) {n=n-m;} else {m=m-n;}}

return n;

}

public void basitlestir()

{ //bayağı kesiri sadeleştirir

int isaret=1;

if(pay<0)

{isaret=-isaret;pay=-pay;}

if(payda<0) { isaret=-isaret;payda=-payda;}

else if(payda==0)

{ JOptionPane.showMessageDialog(null,toString(),

"Bayağı kesir sıfıra bölme hatası",JOptionPane.ERROR_MESSAGE);System.exit(0);

}

int ekob=en_kucuk_ortak_bolen();

ekob=Math.abs(ekob);

pay=isaret*pay/ekob;

payda=payda/ekob;

}

public void gir_rasyonel(rasyonel sag)

{pay=sag.pay;payda=sag.payda;}

public void gir_rasyonel(int nr,int ni)

{pay=nr;payda=ni;}

public void gir_rasyonel(double d)

{ // tam sayinin rasyonel esitini yükle ,eh.. birazcık yaklaşım var tabi

gir_rasyonel((int)d*100000,100000);

basitlestir();

}

public double toDouble()

{//rasyonel sayinin gercek sayi esidi

return ((double)pay/(double)payda);

}

public static rasyonel topla(rasyonel sol, rasyonel sag)

{

int r1= sol.pay*sag.payda + sag.pay*sol.payda;

int i1= sol.payda*sag.payda;

rasyonel R;

R=new rasyonel(r1,i1);

R.basitlestir();

return R;

}

public static rasyonel topla(int sol, rasyonel sag)

{int r1=sag.pay + sol*sag.payda;

int i1=sag.payda;

rasyonel R;

R=new rasyonel(r1,i1);

R.basitlestir();

return R;

}

public static rasyonel cikar(rasyonel sol, rasyonel sag)

{// iki rasyonel sayının toplamını return deyimiyle rasyonel olarak aktarır

int r1= sol.pay*sag.payda-sag.pay*sol.payda;

int i1= sol.payda*sag.payda;

rasyonel R=new rasyonel(r1,i1); R.basitlestir();

return R;

}

public static rasyonel carp(rasyonel sol, rasyonel sag)

{rasyonel R=new rasyonel(sol.pay*sag.pay,sol.payda*sag.payda);

R.basitlestir();return R;

}

public static rasyonel bol(rasyonel sol, rasyonel sag)

{double a=sag.pay*sag.pay+sag.payda*sag.payda;

rasyonel R=new rasyonel(sol.pay*sag.payda,sol.payda*sag.pay);

R.basitlestir();

return R;

}


{// yazima hazır rasyonel formda String deşiskenini iletir.

String b="";

if(Math.abs(payda)!=1)

{

b=b+"( "+pay+" / "+payda+" )";

}

else

{

b=b+pay+" ";

}

return b;

}

}



{

public static int gir(String s)

{ String s1=JOptionPane.showInputDialog("rasyonel(kesirli) sayı "+s+ " = ?");

int x=Integer.parseInt(s1);

return x;

}


{ int pay1=gir("n1_pay ");

int payda1=gir("n1_payda ");

int pay2=gir("n2_pay ");

int payda2=gir("n2_payda ");

rasyonel z1=new rasyonel(pay1,payda1);

rasyonel z2=new rasyonel(pay2,payda2);

rasyonel z3=rasyonel.topla(z1,z2);

String s="Rasyonel sayı 1 = "+z1+"\n";

s+="Rasyonel sayı 2 = "+z2+"\n";

s+="toplama = "+z3+"\n";

z3=rasyonel.cikar(z1,z2);

s+="cikarma = "+z3+"\n";

z3=rasyonel.carp(z1,z2);

s+="carpma = "+z3+"\n";

z3=rasyonel.bol(z1,z2);

s+="bolme = "+z3+"\n";

JOptionPane.showMessageDialog(null,s);}

}

Örnek 7: Sınıflar diğer sınıfların içinde iç içe değişken şeklinde kullanılarak değerlendirilebilir.

) nokta3D ve kuvvet sınıfları kuvvet ve moment dönüşümlerini yapmak için oluşturulmuştur. Kuvvet

sınıfı kuvvetin 3 boyutlu etki noktası, üç boyutlu kuvvet ve moment komponentlerini kapsamaktadır. Bu

sınıf yardımıyla bir kuvvet veya kuvvet çiftini yeni bir noktaya taşıyabiliriz. Programlar ve bir örnek

program verilmiştir.

n1(1,1,1) noktasında F1(1,1,1) ve M1(0,0,0) ve

n2(1,2,3) noktasında F2(1,0,0) ve M2(0,0,0) kuvvet-moment çifti verilmişse, bu çiftin n3(0,0,0)

noktasındaki toplam etkisini hesaplayınız.

public class nokta3D

{

public double xi,xj,xk;

public nokta3D()

{

xi=0;

xj=0;

xk=0;

}

public nokta3D(double yi,double yj,double yk)

{

xi=yi;

xj=yj;

xk=yk;

}

public nokta3D(nokta3D y)

{

xi=y.xi;

xj=y.xj;

xk=y.xk;

}

public void noktaGir(double yi,double yj,double yk)

{

xi=yi;

xj=yj;

xk=yk;

}

public void noktaGir(nokta3D y)

{

xi=y.xi;

xj=y.xj;

xk=y.xk;

}

public void topla(nokta3D y)

{

xi+=y.xi;

xj+=y.xj;

xk+=y.xk;

}

public static nokta3D topla(nokta3D y1,nokta3D y2)

{

nokta3D x=new nokta3D(y1);

x.topla(y2);

return x;

}

public void fark(nokta3D y)

{

xi-=y.xi;

xj-=y.xj;

xk-=y.xk;

}

public static nokta3D fark(nokta3D y1,nokta3D y2)

{

nokta3D x=new nokta3D(y1);

x.fark(y2);

return x;

}

public nokta3D noktaOku()

{

return this;

}

public double R(nokta3D y)

{

//iki nokta arasındaki mesafe

return Math.sqrt((xi-y.xi)*(xi-y.xi)+(xj-y.xj)*(xj-y.xj)+(xk-y.xk)*(xk-y.xk));

}

public double R()

{

//koordinat merkezi ile nokta arasındaki mesafe

return Math.sqrt(xi*xi+xj*xj+xk*xk);

}

public double cosai()

{

//noktanın i ekseniyle yaptığı açının cosinüsü

return xi/R();

}

public double cosaj()

{

//noktanın j ekseniyle yaptığı açının cosinüsü

return xj/R();

}

public double cosak()

{

//noktanın k ekseniyle yaptığı açının cosinüsü

return xk/R();

}

public boolean esittir(nokta3D v)

{

boolean b=((xi==v.xi)&&(xj==v.xj)&&(xk==v.xk));

return b;

}

public boolean buyuktur(nokta3D v)

{

return (this.R()>v.R());

}

public boolean kucuktur(nokta3D v)

{

return (this.R()<v.R());

}

public String cikti()

{

String s="";

s+=xi+" i ";

if(xj>=0 )

s+="+ "+xj+" j";

else if(xj<0)

s+="- "+Math.abs(xj)+" j";

if(xk>=0 )

s+="+ "+xk+" k";

else if(xk<0)

s+="- "+Math.abs(xk)+" k";

return s;

}

}

public class kuvvet

{ nokta3D n; // etki noktası

double Fi,Fj,Fk; // Kuvvet komponentleri

double Mi,Mj,Mk; // Moment komponentleri

public kuvvet()

{

n=new nokta3D();

Fi=0;

Fj=0;

Fk=0;

Mi=0;

Mj=0;

Mk=0;

}

public kuvvet(double yi,double yj,double yk,

double Ffi,double Ffj,double Ffk,

double Mfi,double Mfj,double Mfk)

{

n=new nokta3D(yi,yj,yk);

Fi=Ffi;

Fj=Ffj;

Fk=Ffk;

Mi=Mfi;

Mj=Mfj;

Mk=Mfk;

}

public kuvvet(nokta3D ni,

double Ffi,double Ffj,double Ffk,

double Mfi,double Mfj,double Mfk)

{

n=ni;

Fi=Ffi;

Fj=Ffj;

Fk=Ffk;

Mi=Mfi;

Mj=Mfj;

Mk=Mfk;

}

public kuvvet(double yi,double yj,double yk,double R, double costetai, double costetaj,double costetak)

{

n=new nokta3D(yi,yj,yk);

Fi=R*costetai;

Fj=R*costetaj;

Fk=R*costetak;

Mi=0;

Mj=0;

Mk=0;

}

public kuvvet(kuvvet F)

{

n=new nokta3D(F.n);

Fi=F.Fi;

Fj=F.Fj;

Fk=F.Fk;

Mi=F.Mi;

Mj=F.Mj;

Mk=F.Mk;

}

public void tasi(nokta3D n1)

{ //kuvveti uygulama noktasını değiştirir

//momentler değişir kuvvetler aynı kalır

double di=n1.xi-n.xi;

double dj=n1.xj-n.xj;

double dk=n1.xk-n.xk;

Mi=Mi+(dj*Fk-dk*Fj);

Mj=Mj-(di*Fk-dk*Fi);

Mk=Mk+(di*Fj-dj*Fj);

n=n1;

}

public static kuvvet tasi(nokta3D n1,kuvvet F1)

{ //kuvveti uygulama noktasını değiştirir

//momentler değişir kuvvetler aynı kalır

kuvvet F=new kuvvet(F1);

double di=n1.xi-F.n.xi;

double dj=n1.xj-F.n.xj;

double dk=n1.xk-F.n.xk;

F.Mi=F.Mi+(dj*F.Fk-dk*F.Fj);

F.Mj=F.Mj-(di*F.Fk-dk*F.Fi);

F.Mk=F.Mk+(di*F.Fj-dj*F.Fj);

F.n=n1;

return F;

}

public void topla(kuvvet F)

{ // iki kuvvet toplanıyor, uygulama noktası il kuvvetin uygulama noktası

// momentler de taşınıyor

nokta3D n=new nokta3D(F.n);

double di=F.n.xi-n.xi;

double dj=F.n.xj-n.xj;

double dk=F.n.xk-n.xk;

Mi=Mi+(dj*Fk-dk*Fj);

Mj=Mj-(di*Fk-dk*Fi);

Mk=Mk+(di*Fj-dj*Fj);

Fi+=F.Fi;

Fj+=F.Fj;

Fk+=F.Fk;

}

public static kuvvet topla(kuvvet F1,kuvvet F2)

{ // iki kuvvet toplanıyor, uygulama noktası ilk kuvvetin uygulama noktası


kuvvet F3=new kuvvet(F1);

double di=F3.n.xi-F2.n.xi;

double dj=F3.n.xj-F2.n.xj;

double dk=F3.n.xk-F2.n.xk;

F3.Mi+=(dj*F2.Fk-dk*F2.Fj);

F3.Mj-=(di*F2.Fk-dk*F2.Fi);

F3.Mk+=(di*F2.Fj-dj*F2.Fj);

F3.Fi+=F2.Fi;

F3.Fj+=F2.Fj;

F3.Fk+=F2.Fk;

return F3;

}

public double F()

{

// Toplam kuvvet komponenti

return Math.sqrt(Fi*Fi+Fj*Fj+Fk*Fk);

}

public double M()

{

// Toplam moment komponenti

return Math.sqrt(Mi*Mi+Mj*Mj+Mk*Mk);

}

public String Fcikti()

{

String s="";

s+=Fi+" i ";

if(Fj>=0 )

s+="+ "+Fj+" j";

else if(Fj<0)

s+="- "+Math.abs(Fj)+" j";

if(Fk>=0 )

s+="+ "+Fk+" k";

else if(Fk<0)

s+="- "+Math.abs(Fk)+" k";

return s;

}

public String Mcikti()

{

String s="";

s+=Mi+" i ";

if(Mj>=0 )

s+="+ "+Mj+" j";

else if(Mj<0)

s+="- "+Math.abs(Mj)+" j";

if(Mk>=0 )

s+="+ "+Mk+" k";

else if(Mk<0)

s+="- "+Math.abs(Mk)+" k";

return s;

}

public String Pcikti()

{ return n.cikti();}


{ return "P = "+Pcikti()+" F = "+Fcikti()+" M = "+Mcikti();}

}


{


{

nokta3D n1=new nokta3D(0.0,0.0,0.0);



kuvvet F1=new kuvvet(n2,0.0,0.0,1.0,0.0,0.0,0.0);

kuvvet F2=new kuvvet(n3,0.0,0.0,-1.0,0.0,0.0,0.0);

F1.tasi(n1);

F1.topla(F2);

System.out.println(F1);

}

}

---------- Capture Output ----------


P = 0.0 i + 0.0 j+ 0.0 k F = 0.0 i + 0.0 j+ 0.0 k M = 0.0 i + 2.0 j+ 0.0 k


public class kuvvettest

{


{



kuvvet F=new kuvvet(n2,0.0,0.0,1.0,0.0,0.0,0.0);

F.tasi(n1);

System.out.println(F);

}}

---------- Capture Output ----------

> "C:\java\bin\java.exe" kuvvettest

P = 0.0 i + 0.0 j+ 0.0 k F = 0.0 i + 0.0 j+ 1.0 k M = 0.0 i + 2.0 j+ 0.0 k


Örnek problem : kütlesi 80 kg olan bir adam 20 derece eğimli bir kalasın üzerinde durmaktadır.

Durmakta olduğu kalasa etkilediği dik ve normal kuvvetleri bulunuz:

Çözüm: Normal bileşen 20 derece açıdadır. 80 kg’lık bir adamın etkilediği ağırlık kuvveti

F=80*9.8=784 Newton’dur. Buna göre normal bileşeni:

Fi=784*cos(20)=737 N, parallel bileşeni;

Fj=784*sin(20)=270 N olur.

public class kuvvettest1

{


{

double cosfi=Math.cos((90-20)*Math.PI/180.0);

double cosfj=Math.cos(20*Math.PI/180.0);

double cosfk=Math.cos(90.0*Math.PI/180.0);

double F=784.0;

kuvvet F1=new kuvvet(0,0,0,F,cosfi,cosfj,cosfk);


}

}

---------- Capture Output ---------- > "C:\java\bin\java.exe" kuvvettest1

P = 0.0 i + 0.0 j+ 0.0 k F = 268.14379236732435 i + 736.7190146961522 j+ 4.800615452657625E-14 k M = 0.0 i + 0.0 j+ 0.0 k


Örnek 8 : kök bulma: biraz da matematiksel içerikli algoritmalara bakalım, bir fonksiyonun

kökünü bumka için kiriş yöntemini kullanacağız.

)('

)(1

n

nnn

xf

xfxx

x

xxfxxfxxfxxfxf nnnn

n

12

)2()(8)(8)2()('


public class kok

{

double x,y;

public kok(double xi)

{x=secant(xi);

y=func(x);

}


{ double f=x*x-2.0;

return f;

}

public static double df(double x,double h)

{ // türev formülü

double hh=1.0/h;

return (-func(x+2.0*h)+8.0*func(x+h)-8.0*func(x-h)+func(x-2.0*h))/12.0*hh;

}

public static double secant(double x)

{

int nmax=500;

double tolerance=1.0e-15;

double fx,dfx;

for(int i=0;i<nmax;i++)

{

fx=func(x);

dfx=df(x,0.00001);

x-=fx/dfx;

if(Math.abs(fx)<tolerance) { return x;}

}

JOptionPane.showMessageDialog(null,"Uyarı maksimum iterasyon sayısı aşıldı sonuç geçerli olmayabilir \n","MAKSİMUM

İTERASYON UYARISI",JOptionPane.WARNING_MESSAGE);

return x;

}


{ String s="Kök değeri : \nx = "+x+"\n fonksiyon değeri \ny = "+y+"\n";

return s;

}


{ double x=1.0;

kok z=new kok(x);

JOptionPane.showMessageDialog(null,z);

}

}

Kompleks değişkenleri hesaplayan bir sınıf oluşturmuştuk. Aynı kök bulma programını kompleks

değişkenler için de yazabiliriz. import javax.swing.*;

public class kok_c

{ c x,y;

public kok_c(c xi)

{x=secant(xi);

y=func(x);

}

public static c df(c x)

{ // c sayısal türev

double hh=0.001;

c h=new c(hh,hh);

c he=new c(-hh,-hh);

c h2=new c(2.0*hh,2.0*hh);

c he2=new c(-2.0*hh,-2.0*hh);

c xah=c.topla(x,h);

c xa2h=c.topla(x,h2);

c xeh=c.topla(x,he);

c xe2h=c.topla(x,he2);

c s1=new c((1.0/12.0),0.0);

c fe2h=c.carp(func(xe2h),s1);

c s2=new c((-8.0/12.0),0.0);

c feh=c.carp(func(xeh),s2);

c s3=new c((8.0/12.0),0.0);

c fah=c.carp(func(xah),s3);

c s4=new c((-1.0/12.0),0.0);

c fa2h=c.carp(func(xa2h),s4);

c df=c.topla(fe2h,c.topla(feh,c.topla(fah,fa2h)));

df=c.bol(df,h);

return df;

}

public static c func(c x)

{ c f=c.topla(c.carp(x,x),new c(2.0,0.0));

return f;

}

public static c secant(c x)

{

int nmax=500;


c fx,dfx;


{

fx=func(x);

dfx=df(x);

x=c.cikar(x,c.bol(fx,dfx));

if(Math.sqrt(fx.nr*fx.nr+fx.ni*fx.ni)<tolerance) { return x;}

}

JOptionPane.showMessageDialog(null,"Uyarı maksimum iterasyon sayısı aşıldı sonuç geçerli olmayabilir \n","MAKSİMUM

İTERASYON UYARISI",JOptionPane.WARNING_MESSAGE);

return x;

}



return s;

}


{ c x=new c(0.0,1.0);

kok_c z=new kok_c(x);

JOptionPane.showMessageDialog(null,z);

}

}

ÖDEV PROBLEMLER:

PROBLEM 1: Örnek 2 de verilen kutu programına kutunun yüzey alanını hesaplayan bir metod ekleyiniz ve

çıktıda alanı da yazdırınız.

PROBLEM 2: 43)( 24 xxxf fonksiyonunun köklerini hesaplayan bir program yazınız

PROBLEM 3: 43)( 24 xxxf fonksiyonunun köklerini hesaplayan bir program yazınız (kökler

sanal sayı)

PROBLEM 4: 4)( 2 xxf fonksiyonunun köklerini ikinci dereceden denklem formülünü

kullanarak hesaplayınız.

PROBLEM 5: 4)( 2 xxf fonksiyonunun köklerini ikinci dereceden denklem formülünü

kullanarak hesaplayınız. (kökler sanal sayı)

PROBLEM 6: P1(1,1,1) noktasında F=2i+j+k F(2,1,1) kuvveti verilmiştir. Bu kuvvet

P2(0,0,0) noktasına taşındığında oluşan momenti bulunuz)


Bu haftanın temel konusu yine sınıf kavramı ve algoritmaların sınıf kavramı etrafında oluşturulması. Bu hafta ek

olarak abstract sınıf, interface kavramları eklenerek oluşturulacak. Ayrıca boyutlu değişkenler kavramına da

gireceğiz.

3.2 BİLGİSAYAR KAVRAMLARI (JAVA PROGRAMLAMA DİLİ)

Bölüm 4 : Sınıfları bir arada kullanma, sınıf nesnelerinin diğer sınıflarda sınıf değişkeni olarak kullanılması

(composıtıon), kalıtım(ınherıtance)

Bölüm 5 Boyutlu değişkenler

3.3 MATEMATİKSEL KAVRAMLAR (JAVA PROGRAMLAMA DİLİ ÖRNEKLERİYLE SAYISAL

ÇÖZÜMLEME)

Bölüm 2 : Fonksiyonların kökleri

Bölüm 7: İntegral ve türev

3.4 ÖRNEK KODLAR

Örnek 1:

Hafta 2 de kök bulmak için kok sınıfını yazıp kullanmıştık. Bu programda değişik fonksiyonların köklerini almak

için her seferinde kök programının içinde değişiklik yapmamız gerekirdi. Yeni programımızda func_x isimli abstract

bir sınıf tanımlayıp fonksiyonu bu sınıftan yeni bir sınıf içinde extends kelimesiyle abstract sınıfa bağlayarak

oluşturacağız.

abstract class func_x

{

abstract public double func(double x);

public double df(double x,double h)


double hh=1.0/h;


}

}


class f1 extends func_x

{


{ double f=x*x-2.0;

return f;

}

}

public class kok1

{

double x,y;

public static double secant(func_x f,double x)

{

int nmax=500;


double fx,dfx;


{

fx=f.func(x);

dfx=f.df(x,0.00001);

x-=fx/dfx;


}

JOptionPane.showMessageDialog(null,"Uyarı maksimum iterasyon sayısı aşıldı sonuç geçerli olmayabilir

\n","MAKSİMUM İTERASYON UYARISI",JOptionPane.WARNING_MESSAGE);

return x;

}



return s;

}


{ double x=1.0;

f1 f=new f1();

x=secant(f,x);

double y=f.func(x);

String s="Kök değeri : \nx = "+x+"\n fonksiyon değeri \ny = "+y+"\n";

JOptionPane.showMessageDialog(null,s);

}

}

Örnek 2: İkinci örneğimiz birinci örneğimizle aynı, ancak bunda abstract sınıf yerine interface kullanacağız

interface ifunc_x

{

abstract public double func(double x);

default double df(double x,double h)


double hh=1.0/h;


}

}


class f1 implements ifunc_x

{


{ double f=x*x-2.0;

return f;

}

}

public class kok2

{

double x,y;

public static double secant(ifunc_x f,double x)

{

int nmax=500;


double fx,dfx;


{

fx=f.func(x);

dfx=f.df(x,0.00001);

x-=fx/dfx;


}



return x;

}



return s;

}


{ double x=1.0;

f1 f=new f1();

x=secant(f,x);

double y=f.func(x);



}

}

Örnek 3: üçüncü örneğimizde yine aynı çözümü yine interface ifunc_x kullanarak yapacağız, fakat bu sefer lambda

deyimleri denen yapıyı kullanarak ayrıca bir sınıf yazmadan programın içinde yeni foksiyonu tanımlayacağız.


public class kok3

{

double x,y;

public static double secant(ifunc_x f,double x)

{

int nmax=500;


double fx,dfx;


{

fx=f.func(x);

dfx=f.df(x,0.00001);

x-=fx/dfx;


}



return x;

}



return s;

}


{

ifunc_x f=x->x*x-2.0;

double x=1.0;

x=secant(f,x);

double y=f.func(x);



}

}

Örnek 4: Abstract sınıf ve abstract kavramını her türlü fonksiyonun kullanımı için değerlendirebiliriz. Bu

örneğimizde yeni bir kavrama giriyoruz: boyutlu değişkenler. Boyutlu değişkenler birden fazla değişkeni bir

değişkende indis ile tutan yapılardır. Örneğin

double[] list = new double[3];

list[0]=1.2;

list[1]=2.2;

list[2]=3.2;

veya kısaca double[] list = {1.2, 2.2, 3.2};

şeklinde tanımlanabilir. Ayrıca listedeki eleman sayısı list.length değişkeniyle elde edilebilir

for(int i=0;i<list.length;i++) {System.out.pritln(list[i]);}



{

//INTEGRAL

public static double integral(ifunc_x f,double a,double b)

{ //10 point Gauss-Legendre formula

//integral f(x)dx

double r[]={-0.973906528517171,-0.865063366688984,-0.679409568299024,-0.433395394129247,-

0.148874338981631,

0.148874338981631,0.433395394129247,0.679409568299024,0.865063366688984,0.973906528517171};

double

c[]={0.066671344308684,0.149451349150580,0.219086362515982,0.269266719309996,0.295524224714752,

0.295524224714752,0.269266719309996,0.219086362515982,0.149451349150580,0.066671344308684};

double z=0,x,y;

double k1=(b-a)/2.0;

double k2=(b+a)/2.0;

for(int i=0;i<r.length;i++)

{

x=k2+k1*r[i];

y=f.func(x);

z+=k1*c[i]*y;

}

return z;

}


{ ifunc_x f=x->x*x-2.0;

double I=integral(f,0.0,1.0);

String s="Integral = "+I+"\n";


}

}

Örnek5: Nokta3D ve Kuvvet sınıflarını geçen hafta tanımlamış ve kullanmıştık. Şimdi bu sınıflardaki alt

değişkenleri boyutlu değişken haline getirerek kullanalım:

public class nokta3D1 {

public double x[];

public nokta3D1()

{

x=new double[3]; x[0]=0;

x[1]=0;

x[2]=0; }

public nokta3D1(double yi,double yj,double yk) {

double x1[]={yi,yj,yk};

x=x1; }

public nokta3D1(double y[])

{x=y;}

public nokta3D1(nokta3D1 y) {x=y.x;}

public void noktaGir(double yi,double yj,double yk) {double x1[]={yi,yj,yk};

x=x1;

}

public void noktaGir(nokta3D1 y)

{x=y.x;}

public void topla(nokta3D1 y)

{ for(int i=0;i<3;i++) x[i]+=y.x[i];}

public static nokta3D1 topla(nokta3D1 y1,nokta3D1 y2)

{ nokta3D1 x=new nokta3D1(y1);

x.topla(y2);

return x;

}

public void fark(nokta3D1 y) { for(int i=0;i<3;i++) x[i]-=y.x[i];}

public static nokta3D1 fark(nokta3D1 y1,nokta3D1 y2) {

nokta3D1 x=new nokta3D1(y1);

x.fark(y2); return x;

}

public nokta3D1 noktaOku()

{return this;}

public double R(nokta3D1 y)

{

//iki nokta arasındaki mesafe

double toplam=0;

for(int i=0;i<3;i++) toplam+=(x[i]-y.x[i])*(x[i]-y.x[i]); return Math.sqrt(toplam);

}

public double R()

{

//koordinat merkezi ile nokta arasındaki mesafe double toplam=0;

for(int i=0;i<3;i++) toplam+=x[i]*x[i];

return Math.sqrt(toplam); }

public double cosa(int i) {

//noktanın i ekseniyle yaptığı açının cosinüsü

return x[i]/R();

}

public boolean esittir(nokta3D1 v)

{boolean b=((x[0]==v.x[0])&&(x[1]==v.x[1])&&(x[2]==v.x[2]));

return b; }

public boolean buyuktur(nokta3D1 v) {return (this.R()>v.R());}

public boolean kucuktur(nokta3D1 v) {return (this.R()<v.R());}

public String cikti() {

String s="";

s+=x[0]+" i "; if(x[1]>=0 )

s+="+ "+x[1]+" j";

else if(x[1]<0) s+="- "+Math.abs(x[1])+" j";

if(x[2]>=0 )

s+="+ "+x[2]+" k"; else if(x[2]<0)

s+="- "+Math.abs(x[2])+" k";

return s; }

}

public class kuvvet1

{ nokta3D1 n; // etki noktası

double F[]; // kuvvet1 komponentleri

double M[]; // Moment komponentleri

public kuvvet1() {

n=new nokta3D1();

F=new double[3]; M=new double[3];

F[0]=0;

F[1]=0; F[2]=0;

M[0]=0;

M[1]=0; M[2]=0;

}

public kuvvet1(double y[],double FF[],double MF[])

{n=new nokta3D1(y);;F=FF;M=MF;}

public kuvvet1(double yi,double yj,double yk,

double FFi,double FFj,double FFk, double MFi,double MFj,double MFk)

{

n=new nokta3D1(yi,yj,yk); F=new double[3];

M=new double[3];

F[0]=FFi; F[1]=FFj;

F[2]=FFk;

M[0]=MFi; M[1]=MFj;

M[2]=MFk;

} public kuvvet1(nokta3D1 ni,

double FFi,double FFj,double FFk,

double MFi,double MFj,double MFk)

{

n=ni;


F[0]=FFi;

F[1]=FFj; F[2]=FFk;

M[0]=MFi;

M[1]=MFj; M[2]=MFk;

}

public kuvvet1(double yi,double yj,double yk,double R, double costetai, double costetaj,double costetak) {

n=new nokta3D1(yi,yj,yk);


F[0]=R*costetai;

F[1]=R*costetaj; F[2]=R*costetak;

M[0]=0;

M[1]=0; M[2]=0;

}

public kuvvet1(kuvvet1 F1)

{

n=new nokta3D1(F1.n); F=new double[3];

M=new double[3]; F[0]=F1.F[0];

F[1]=F1.F[1];

F[2]=F1.F[2]; M[0]=F1.M[0];

M[1]=F1.M[1];

M[2]=F1.M[2];

}

public void tasi(nokta3D1 n1) { //kuvvet1i uygulama noktasını değiştirir

//momentler değişir kuvvet1ler aynı kalır

double di=n1.x[0]-n.x[0]; double dj=n1.x[1]-n.x[1];

double dk=n1.x[2]-n.x[2];

M[0]=M[0]+(dj*F[2]-dk*F[1]); M[1]=M[1]-(di*F[2]-dk*F[0]);

M[2]=M[2]+(di*F[1]-dj*F[1]);

n=n1; }

public static kuvvet1 tasi(nokta3D1 n1,kuvvet1 F1)

{ //kuvvet1i uygulama noktasını değiştirir

//momentler değişir kuvvet1ler aynı kalır

kuvvet1 F=new kuvvet1(F1);

double di=n1.x[0]-F.n.x[0];

double dj=n1.x[1]-F.n.x[1]; double dk=n1.x[2]-F.n.x[2];

F.M[0]=F.M[0]+(dj*F.F[2]-dk*F.F[1]);

F.M[1]=F.M[1]-(di*F.F[2]-dk*F.F[0]); F.M[2]=F.M[2]+(di*F.F[1]-dj*F.F[1]);

F.n=n1;

return F; }

public void topla(kuvvet1 F1) { // iki kuvvet1 toplanıyor, uygulama noktası il kuvvet1in uygulama noktası


nokta3D1 n1=new nokta3D1(F1.n); double di=F1.n.x[0]-n1.x[0];

double dj=F1.n.x[1]-n1.x[1];

double dk=F1.n.x[2]-n1.x[2];

M[0]=M[0]+(dj*F[2]-dk*F[1]);

M[1]=M[1]-(di*F[2]-dk*F[0]);

M[2]=M[2]+(di*F[1]-dj*F[1]); F[0]+=F1.F[0];

F[1]+=F1.F[1];

F[2]+=F1.F[2]; }

public static kuvvet1 topla(kuvvet1 F1,kuvvet1 F2) { // iki kuvvet1 toplanıyor, uygulama noktası ilk kuvvet1in uygulama noktası


kuvvet1 F3=new kuvvet1(F1); double di=F3.n.x[0]-F2.n.x[0];

double dj=F3.n.x[1]-F2.n.x[1];

double dk=F3.n.x[2]-F2.n.x[2]; F3.M[0]+=(dj*F2.F[2]-dk*F2.F[1]);

F3.M[1]-=(di*F2.F[2]-dk*F2.F[0]);

F3.M[2]+=(di*F2.F[1]-dj*F2.F[1]); F3.F[0]+=F2.F[0];

F3.F[1]+=F2.F[1];

F3.F[2]+=F2.F[2]; return F3;

}

public double F()

{

// Toplam kuvvet1 komponenti return Math.sqrt(F[0]*F[0]+F[1]*F[1]+F[2]*F[2]);

} public double M()

{

// Toplam moment komponenti return Math.sqrt(M[0]*M[0]+M[1]*M[1]+M[2]*M[2]);

}

public String Fcikti()

{

String s=""; s+=F[0]+" i ";

if(F[1]>=0 )

s+="+ "+F[1]+" j"; else if(F[1]<0)

s+="- "+Math.abs(F[1])+" j";

if(F[2]>=0 ) s+="+ "+F[2]+" k";

else if(F[2]<0)

s+="- "+Math.abs(F[2])+" k"; return s;

} public String Mcikti()

{

String s="";

s+=M[0]+" i ";

if(M[1]>=0 )

s+="+ "+M[1]+" j"; else if(M[1]<0)

s+="- "+Math.abs(M[1])+" j";

if(M[2]>=0 ) s+="+ "+M[2]+" k";

else if(M[2]<0)

s+="- "+Math.abs(M[2])+" k"; return s;

}

public String Pcikti()

{ return n.cikti();}


{ return "P = "+Pcikti()+" F = "+Fcikti()+" M = "+Mcikti();}

}

Sınıfları kullanma açısından bir fark yoktur.


{


{

nokta3D1 n1=new nokta3D1(0.0,0.0,0.0);



kuvvet1 F1=new kuvvet1(n2,0.0,0.0,1.0,0.0,0.0,0.0);

kuvvet1 F2=new kuvvet1(n3,0.0,0.0,-1.0,0.0,0.0,0.0);

F1.tasi(n1);

F1.topla(F2);


}

}

---------- Capture Output ---------- > "C:\java\bin\java.exe" algoritmaH3_E5

P = 0.0 i + 0.0 j+ 0.0 k F = 0.0 i + 0.0 j+ 0.0 k M = 0.0 i + 2.0 j+ 0.0 k


Örnek 6: Sınıfları da boyutlu değişken olarak kullanabiliriz.


{


{

nokta3D1 n[]=new nokta3D1[3];

n[0]=new nokta3D1(0.0,0.0,0.0);

n[1]=new nokta3D1(2.0,0.0,0.0);

n[2]=new nokta3D1(4.0,0.0,0.0);

kuvvet1 F[]=new kuvvet1[2];

F[0]=new kuvvet1(n[1],0.0,0.0,1.0,0.0,0.0,0.0);

F[1]=new kuvvet1(n[2],0.0,0.0,-1.0,0.0,0.0,0.0);

F[0].tasi(n[0]);

F[0].topla(F[1]);

System.out.println(F[0]);

}}

---------- Capture Output ----------

> "C:\java\bin\java.exe" algoritmaH3_E6 P = 0.0 i + 0.0 j+ 0.0 k F = 0.0 i + 0.0 j+ 0.0 k M = 0.0 i + 2.0 j+ 0.0 k


Örnek 7: Artık fonksiyon hesaplarımızı yaparken boyutlu değişkenlerden yararlanabiliriz. public class algoritmaH3_E7

{

public static double[] x(double x1,double x2,int n)

{double xx[]=new double[n];

for(int i=0;i<n;i++) {xx[i]=x1+(x2-x1)/(n-1)*i;}

return xx;

}

public static double[] y(ifunc_x f,double x[])

{ int n=x.length;

double yy[]=new double[n];

for(int i=0;i<n;i++) {yy[i]=f.func(x[i]);}

return yy;

}

public static double[] dy(ifunc_x f,double x[])

{ int n=x.length;

double yy[]=new double[n];

for(int i=0;i<n;i++) {yy[i]=f.df(x[i],0.0001);}

return yy;

}

public static String print(double x[],double y[],double dy[])

{

String s="";

for(int i=0;i<x.length;i++)

{ s+="x = "+x[i]+" y = "+y[i]+" dy = "+dy[i]+"\n";}

return s;

}


{

ifunc_x f=x->x*x-2*x+5;

double x1[]=x(0.0,10.0,20);

double y1[]=y(f,x1);

double dy1[]=dy(f,x1);

System.out.println(print(x1,y1,dy1));

}

}

---------- Capture Output ----------


x = 0.0 y = 5.0 dy = -1.9999999999975593

x = 0.5263157894736842 y = 4.224376731301939 dy = -0.9473684210536959

x = 1.0526315789473684 y = 4.002770083102493 dy = 0.10526315789238794

x = 1.5789473684210527 y = 4.335180055401662 dy = 1.1578947368355113

x = 2.1052631578947367 y = 5.221606648199446 dy = 2.2105263157934374

x = 2.631578947368421 y = 6.662049861495844 dy = 3.2631578947395212

x = 3.1578947368421053 y = 8.65650969529086 dy = 4.315789473693006

x = 3.6842105263157894 y = 11.204986149584487 dy = 5.368421052643532

x = 4.2105263157894735 y = 14.30747922437673 dy = 6.421052631570371

x = 4.7368421052631575 y = 17.96398891966759 dy = 7.47368421049425

x = 5.263157894736842 y = 22.174515235457058 dy = 8.526315789424052

x = 5.789473684210526 y = 26.93905817174515 dy = 9.578947368359772

x = 6.315789473684211 y = 32.257617728531855 dy = 10.63157894732214

x = 6.842105263157895 y = 38.13019390581717 dy = 11.684210526254901

x = 7.368421052631579 y = 44.556786703601105 dy = 12.736842105229112

x = 7.894736842105263 y = 51.53739612188365 dy = 13.789473684167792

x = 8.421052631578947 y = 59.072022160664815 dy = 14.842105263130161

x = 8.947368421052632 y = 67.1606648199446 dy = 15.894736842057

x = 9.473684210526315 y = 75.80332409972299 dy = 16.947368420971998

x = 10.0 y = 85.0 dy = 17.999999999827782


Örnek 8: Boyutlu değişkenler birden çok boyutta verilebilir. Bu eksersizimizde doğrusal denklem

sistemi çözümü yapacağız. Matrisler iki boyutlu olduğundan iki boyutlu değişkenler

kullanacağız. Ayrıca yazdırma eyleminde matrislerin çıktısını daha düzgün görebilmek için

String.format deyimini kullandık, bu deyim temel olarak c dilindeki formatlama deyimlerinden

yararlanır. Örneğin %d tamsayı formatı, %5.3f toplam 5 basamak, üçü sıfırdan sonra olmak üzere

tam sayı formatıdır. Format deyimi kullanıldığında ondalık basamak bulunulan ülkeye göre

oluşturulur. Örneğin türkiye için virgül(,) kullanılır. Bu yüzden ondalık basamak olarak nokta

kullanmak için Amerika için formatladık (Locale.US). Java kitabında listelenen format deyimleri

Tablo 8.1.1 Format yapıları

‘b’ veya ‘B’ genel

‘h’ veya ‘H’ genel

‘s’ veya ‘S’ String

‘c’ veya ‘C’ harf değişkeni

‘d’ on basamak (desimal) tam sayı değişkeni (integer)

‘o’ sekiz basamak (octal) tam sayı değişkeni (integer)

‘x’ 16 basamak integer (hexadecimal) tam sayı değişkeni (integer)

‘e’ veya ‘E’ bilimsel gerçek sayı (eksponent ile birlikte verilir)

‘f’ veya ‘F’ gerçek sayı

‘g’ veya ‘G’gerçek sayı sayının büyüklüğüne göre f veya e gibi davranır

‘a’ veya ‘A’ gerçek sayı

Gauss eleme yöntemini kısaca anlatalım:

nnnnnn

n

n

b

b

b

X

X

X

aaa

aaa

aaa

.......

....

................

.....

....

2

1

2

1

21

22221

11211

Gauss eleme yöntemi en basit formunda matrislerin temel özelliklerine dayanan bir işlemdir. Matrislerin satırlarını

değiştirmek, matrisin bir satırını belli bir çarpanla çarpmak veya satırları birbiriyle toplamak(veya çıkarmak)

doğrusal denklem sistemindeki bilinmeyenlerin değerini etkilemez. Bu yüzden doğrusal denklem sisteminde

(i numaralı satır)- Sabit * (j numaralı satır) gibi bir işlemi denklem sisteminin değerini değiştirmeden

oluşturabiliriz. Gauss eleme metodunda bu manipülasyonu yapmaktaki gayemiz üst üçgen matris dediğimiz

matrisin diyagonalinin altının tamamen sıfıra eşitlendiği eşdeğer formunu elde etmektir. Örneğin n=5 için

5

4

3

2

1

5

4

3

2

1

55

4544

353433

25242322

1514131211

'

'

'

'

'

'0000

''000

'''00

''''0

'''''

b

b

b

b

b

X

X

X

X

X

a

aa

aaa

aaaa

aaaaa

şekline getirmemiz gerekir. Bunu yapabilmek için sistematik bir eleme uygulayabiliriz. Örneğin a21 elemanını 0 a

dönüştürmek için

a’21 = 0 = a 21 – C1 * a 11 işleminde sabitin değeri

C1=(a 21/a 11) olacaktır. İkinci satırın her elemanı için C1 çarpanı kullanılarak yeni değerine çevrilir. Örneğin

a’ 22 = a 22 – C1*a 12

a’ 23 = a 23 – C1*a 13

…………………………..

a’ 25 = a 25 – C1*a15

b’2=b2 – C1*b1

Bu işlemin sonunda a’21 elemanı sıfırlanmış olur. Aynı işlem önce a11 in altındaki tüm satırlara uygulanarak birinci

sütundaki 0 değerleri oluşturulur. Daha sonra aynı işlem a22 nin altındaki kolon için yinelenir.

Lineer denklem sistemi üst üçgen matris şekline dönüştürüldükten sonra tersten itibaren çözme yöntemiyle

bilinmeyenler çözülür. Yukarıda verilen beşli sistemin çözüm seti :

X5 = b’5 / a’55

X4 = (b’4 – a’45*X5)/a’44

X3 = (b’3 – a’34*X4 – a’35*X5)/a’33

X2 = (b’2 – a’23*X3 – a’24*X3 – a’25*X5)/a’22

X1 = (b’1 – a’12*X2 – a’13*X3 – a’14*X4 – a’15*X5)/a’11

import java.util.Locale;

class Gauss

{

public static double[] gauss(double a[][],double b[])

{

int n=a.length;

double x[]=new double[n];

double carpan=0;

double toplam=0;

//gauss eleme

int i,j,k;

for(k=0;k<(n-1);k++)

{

for(i=k+1;i<n;i++)

{ carpan=a[i][k]/a[k][k];

a[i][k]=0;

for(j=k+1;j<n;j++)

{ a[i][j]-=carpan*a[k][j]; }

b[i] =b[i] -carpan*b[k];

}

}

//geriye doğru yerine koyma

x[n-1]=b[n-1]/a[n-1][n-1];

for(i=n-2;i>=0;i--)

{

toplam=0;

for(j=i+1;j<n;j++)

{ toplam+=a[i][j]*x[j];}

x[i]=(b[i]-toplam)/a[i][i];

}

return x;

}

public static String toString(double a[][])

{//matrisin string eşdeğerini oluşturur

int n,m;

String s="";

n=a.length;

m=a[0].length;


{ for(int j=0;j<m;j++)

{s+=String.format(Locale.US,"%10.7f ",a[i][j]);}

s+="\n";

}

return s;

}

public static String toString(double b[])

{//vektörün string eşdeğerini oluşturur

int n;

String s="";

n=b.length;


{ s+=String.format(Locale.US,"%10.7f%n",b[i]);}

return s;

}

public static void main(String args[])

{

double a[][]={{1,2,5},{2,1,2},{3,1,1}};

double b[]={1,1,2};

String s="Elemedan önce :\na : \n"+toString(a)+"\nb = \n"+toString(b);

System.out.println(s);

double x[]=gauss(a,b);

s="Elemedan sonra :\na : \n"+toString(a)+"\nb = \n"+toString(b)+"\n x = \n"+toString(x);


}

}

---------- Capture Output ---------- > "C:\java\bin\java.exe" Gauss

Elemedan önce :

a : 1.0000000 2.0000000 5.0000000

2.0000000 1.0000000 2.0000000

3.0000000 1.0000000 1.0000000

b = 1.0000000

1.0000000

2.0000000

Elemedan sonra :

a : 1.0000000 2.0000000 5.0000000

0.0000000 -3.0000000 -8.0000000

0.0000000 0.0000000 -0.6666667

b = 1.0000000

-1.0000000

0.6666667

x =

-0.0000000 3.0000000

-1.0000000


Örnek 9: Bu örneğimizde gelişmiş döngü yapısından bahsedeceğiz, kişisel olarak çok

kullanmasamda, dil yapılarında kullanıldığından bilmemiz gereken bir programlama yapısıdır.

Sayıların toplamını klasik yöntemle bulan bir program public class algoritmaH3_E9

{

public static void main( String args[] )

{

int boyut[] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };

int toplam = 0;

for ( int i=0;i<boyut.length;i++)

{toplam += boyut[i];}

System.out.println( "toplam = "+toplam );

} // main metodunun sonu

}

Aynı programın gelişmiş for yapısı kullanan eşdeğeri


{

public static void main( String args[] )

{

int boyut[] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };

int toplam = 0;

for ( int sayi:boyut)

{toplam += sayi;}

System.out.println( "toplam = "+toplam );

} // end main

}

Örnek 10: Bu örneğimizde tek boyutlu vektör taşıyan ve çeşitli matematik işlemlerini

gerçekleştiren vektör sınıfını inceleyeceğiz.


public class vektor

{

public double V[];

//kurucu metodlar

public vektor(double Vi[])

{ V=new double[Vi.length];

input_vektor(Vi);

}

public vektor(vektor Vi)

{ V=new double[Vi.V.length];

input_vektor(Vi.V);

}

public vektor(int n)

{ V=new double[n];


{ V[i]=0.0;}

}

public void input_vektor(double Vi[])

{ for(int i=0;i<V.length;i++)

{V[i]=Vi[i];}

}

public static vektor topla(vektor V1,vektor V2)

{

//

int n=V1.V.length;

vektor V3=new vektor(n);


{V3.V[i]=V1.V[i]+V2.V[i];}

return V3;

}

public void topla(vektor V1)

{

//

int n=V.length;


{V[i]+=V1.V[i];}

}

public static vektor topla(double[] V1,double[] V2)

{

//

int n=V1.length;

vektor M=new vektor(n);


{M.V[i]=V1[i]+V2[i];}

return M;

}

public static double[][] carp(vektor V1,vektor V2)

{

// V1Tranpose*V2

int n=V1.V.length;

double a[][]=new double[n][n];



{ for(int j=0;j<n;j++)

{a[i][j]=V1.V[i]*V2.V[j];}

}

return a;

}

public static double carpT(vektor V1,vektor V2)

{

// // V1*V2Tranpose

int n=V1.V.length;

double a=0;



{ for(int j=0;j<n;j++)

{a+=V1.V[i]*V2.V[j];}

}

return a;

}

public static String cikti(vektor M)

{ int n=M.V.length;

String s="";


{s+=M.V[i]+" ";}

s+="\n";

return s;

}


{ Locale tr=new Locale("TR");

int n=V.length;

String s1="";


{ s1+=String.format(tr," %10.5f ",V[i]);}

s1+="\n";

return s1;

}

}


class algoritmaH3_E10 {

public static void main(String args[] )

{ double A[]={1.0,2.0,3.0,4.0};

double B[]={1.0,1.0,1.0,1.0};

vektor M1=new vektor(A);

vektor M2=new vektor(B);

M1.topla(M2);

String s="iki vektörün toplamı : \n"+M1.cikti();

String s1="class vektor";

JOptionPane.showMessageDialog(null,s,s1,JOptionPane.PLAIN_MESSAGE);

} }


class algoritmaH3_E10A {


{ double A[]={1.0,2.0,3.0,4.0};

double B[]={1.0,1.0,1.0,1.0};

vektor M1=new vektor(A);

vektor M2=new vektor(B);

vektor M3=vektor.topla(M1,M2);

String s="iki vektörün toplamı : \n"+M3.cikti();

String s1="class vektor";


} }

Örnek 11:


public class matris

{

public double A[][];

//constructor methods

public matris(double Ai[][])

{ A=new double[Ai.length][Ai[0].length];

matris_gir(Ai);

}

public matris(matris M)

{ A=new double[M.A.length][M.A[0].length];

matris_gir(M.A);

}

public matris(int n,int m)

{ A=new double[n][m];



{A[i][j]=0.0;}

}

}

public void matris_gir(double Ai[][])

{ for(int i=0;i<A.length;i++)

{ for(int j=0;j<A[0].length;j++)

{A[i][j]=Ai[i][j];}

}

}

public static matris topla(matris M1,matris M2)

{

//

int n=M1.A.length;

int m=M1.A[0].length;

matris M3=new matris(n,m);



{M3.A[i][j]=M1.A[i][j]+M2.A[i][j];}

}

return M3;

}

public static matris topla(double[][] A1,double[][] A2)

{

//

int n=A1.length;

int m=A1[0].length;

matris M=new matris(n,m);



{M.A[i][j]=A1[i][j]+A2[i][j];}

}

return M;

}

public void topla(matris M1)

{

//

int n=A.length;

int m=A[0].length;



{A[i][j]+=M1.A[i][j];}

}

}

public void topla(double [][] B)

{

//

int n=A.length;

int m=A[0].length;



{A[i][j]+=B[i][j];}

}

}

public static String cikti(matris M)

{ int n=M.A.length;

int m=M.A[0].length;

String s="";



{s+=M.A[i][j]+" ";}

s+="\n";

}

return s;

}


{ Locale tr=new Locale("TR");

int n=A.length;

int m=A[0].length;

String s1="";



{ s1+=String.format(tr," %10.5f ",A[i][j]);}

s1+="\n";

}

return s1;

} //end of method cikti

}//matris sınıfının sonu


class algoritmaH3_E11 {


{ double A[][]={{1.0,2.0},{3.0,4.0}};

double B[][]={{1.0,1.0},{1.0,1.0}};

matris M1=new matris(A);

String s="ilk matris = \n"+M1.cikti();

matris M2=new matris(B);

s+="ikinci matris = \n"+M1.cikti();

M1.topla(M2);

s+="iki matrisin toplamı : \n"+M1.cikti();

String s1="çok boyut örneği matris sınıfı testi";


} }


class algoritmaH3_E11A {


{ double A[][]={{1.0,2.0},{3.0,4.0}};

double B[][]={{1.0,1.0},{1.0,1.0}};

matris M1=new matris(A);

String s="ilk matris = \n"+M1.cikti();

matris M2=new matris(B);

s+="ikinci matris = \n"+M1.cikti();

matris M3=matris.topla(M1,M2);

s+="iki matrisin toplamı : \n"+M1.cikti();

String s1="çok boyut örneği matris sınıfı testi";


} }

Örnek 12: Tavla oyunu iki zar atarak oynanır. Tek bir zar atımında her zarın olasılığı 1/6 dır. Ancak 2 zar

atıldığında iki zarın toplamı değişik zar kombinasyonlarından etkileneceği için değişir. 2 gelme olasılığı

1/6*1/6=1/36=0.0277777777 iken 3 gelme olasılığı ([1 2] veya [2 1] zarlarının toplamı 3 edeceğinden

1/6*1/6+1/6*1/6=0.0555555 dir.

iki zar atışta sayıların dağılımı

zar

toplamı

zar kombinasyonu ihtimal zar frekansı

0 0 0

1 0 0

2 11 0,027778 1/36 1

3 12 21 0,055556 2/36 2

4 22 13 31 0,083333 3/36 3

5 14 41 23 32 0,111111 4/36 4

6 33 15 51 42 24 0,138889 5/36 5

7 16 61 25 52 34 43 0,166667 6/36=1/6 6

8 44 26 62 35 53 0,138889 5/36 5

9 26 63 45 54 0,111111 4/36 4

10 55 46 64 0,083333 3/36 3

11 56 65 0,055556 2/36 2

12 66 0,027778 1/36 1

13 0 0

14 0 0

15 0 0

Toplam 1 36

Bu durumu gerçek zar atarak ve gelen zarların istatistiğini hesaplayarak görelim.

public class zaristatistigi

{

//çift zar atıldığında her zarın gelme olasılığını

//zar atarak hesaplar

public static int zar()

{

return 1+(int)(Math.random()*6);

}

2 zar atma ihtimali

0

0,05

0,1

0,15

0,2

0,25

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

N

P,

ihti

mal

public double[] zaryuzdesi()

{

double n=6000000;

double gelensayi[]=new double[13];

int sayi=0;


{

sayi=zar()+zar();

for(int j=2;j<=12;j++)

{if(sayi==j) gelensayi[j]++; }

}


{gelensayi[j]/=n; }

return gelensayi;

}


{

String s="zar yüzdeleri : \n";

double yuzde[]=zaryuzdesi();


{s+="zar toplamı : "+j+"yüzde değeri : "+yuzde[j]+"\n"; }

return s;

}

}


class zartest1

{

public static void ciktipenceresi(String s)

{

String s1="zar testi penceresi";

JOptionPane.showMessageDialog(null,s,s1, JOptionPane.PLAIN_MESSAGE);

}

public static void main(String args[])

{

zaristatistigi x=new zaristatistigi();

ciktipenceresi(x.cikti());

}}

Örnek 13: kompleks boyutlu sayıların toplamını hesaplayalım: public class algoritmaH3_E13

{


{

c x[]=new c[2];

x[0]=new c(1.2,2.3);

x[1]=new c(1.1,1.3);

c z=c.topla(x[0],x[1]);

System.out.println(z);

}

}

---------- Capture Output ----------


(2.3 + 3.5999999999999996i )


Örnek 14: Bir polinom fonksiyonunu hesaplayacak bir sınıf yazalım ve kullanalım

public class poly

{// Genel polynom fonksiyonu

// y=a[0]+a[1]*x+a[2]*x^2+...

public double a[];

public poly(double ia[])

{int n=ia.length;

a=new double[n];

for(int i=0;i<n;i++) {a[i]=ia[i];}

}


{

int n=a.length;

double ff=a[n-1];

for(int i=n-2;i>=0;i--)

{ff=ff*x+a[i];}

return ff;

}


{String s=""+a[0];

for(int i=1;i<a.length;i++)

{ if(i==1) s=a[i]+"*x"+" + "+s;

else s=a[i]+"*x^"+i+" + "+s;

}

s="f(x)="+s;

return s;

}

}


{


{

double a[]={1.0,2.0,3.0};

poly z=new poly(a);


for(double x=0;x<=10;x+=1)

{ String s=String.format("x = %10.6f y = %10.6f",x,z.func(x));


}

}

}

---------- Capture Output ----------


f(x)=3.0*x^2 + 2.0*x + 1.0

x = 0,000000 y = 1,000000

x = 1,000000 y = 6,000000

x = 2,000000 y = 17,000000

x = 3,000000 y = 34,000000

x = 4,000000 y = 57,000000

x = 5,000000 y = 86,000000

x = 6,000000 y = 121,000000

x = 7,000000 y = 162,000000

x = 8,000000 y = 209,000000

x = 9,000000 y = 262,000000

x = 10,000000 y = 321,000000




{


{

double a[]={1.0,2.0,3.0};

poly z=new poly(a);


for(double x=0;x<=10;x+=1)

{ String s=String.format(Locale.US,"x = %10.6f y = %10.6f",x,z.func(x));


}

}

}

---------- Capture Output ----------

> "C:\java\bin\java.exe" algoritmaH3_E14A

f(x)=3.0*x^2 + 2.0*x + 1.0

x = 0.000000 y = 1.000000

x = 1.000000 y = 6.000000

x = 2.000000 y = 17.000000

x = 3.000000 y = 34.000000

x = 4.000000 y = 57.000000

x = 5.000000 y = 86.000000

x = 6.000000 y = 121.000000

x = 7.000000 y = 162.000000

x = 8.000000 y = 209.000000

x = 9.000000 y = 262.000000

x = 10.000000 y = 321.000000


ÖDEV PROBLEMLER:

Problem 1: aşağıda iki matrisi çarpmak için bir metod tanımlanmıştır. Bu metodu matris sınıfına

ekleyerek iki matrisi çarpacak bir örnek program yazınız.

public static double[][] carp(double[][] left,double[][] right)

{

//iki matrisin çarpımı

int ii,jj,i,j,k;

int m1=left[0].length;

int n1=left.length;

int m2=right[0].length;

int n2=right.length;

double[][] b;

b=new double[m1][n2];

if(n1 != m2)

{

System.out.println("inner matrix dimensions must agree");

for(ii=0;ii<n1;ii++)

{

for(jj=0;jj<m2;jj++)

b[ii][jj]=0;

}

return b;

}

for(i=0;i<m1;i++)

{

for(j=0;j<n2;j++)

{

for(k=0;k<n1;k++)

b[i][j]+=left[i][k]*right[k][j];

}

}

return b;

//end of multiply of two matrices

}

Problem 2: complex sınıfını kullanarak z[0]=1+2i , z[1]=1.2+3i, z[2]=0.2+0.1i, z[3]=1+i sanal

sayılarını çarpınız.

c z[]=new c[4];

z[0]=new complex(1.0,2.0);

…

z[3]= new complex(1.0,1.0);

Problem 3: f(x)=x*x-3*x+2 fonksiyonunun türevini abstract sınıf func_x’i kullanarak x=1.0

noktasında hesaplayın.

Problem 4: f(x)=sin(x) fonksiyonunun türevini interface ifuncf_x’i kullanarak x= noktasında

lambda deyimi ile hesaplayın.

Problem 5: Aşağıdaki problem Gauss metodu ile çözünüz.

10

12

6667.0

212

141

3333.03333.01

2

1

0

X

X

X

Problem 6: Üç zar atıldığında oluşacak olusılık dağılımını hesaplayan bir program yazınız.

Documents

ALGORİTMA GELİTİRME M. Turhan Çoban°TMA... · 2015-07-19 · olarak bilgisayar programlama ve sayısal ve analitik matematiğin çeúitli kısımlarını içeren bir kapsamdadır