Hafta 1 - turhancoban.com

Transkript

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:
f ( x)  x 2  2 x  5
2  x  5 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));}
}
Örnek 2:
f ( x)  e x
2  x  5 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:
xk
k 1 k!
f ( x)  e x  exp(x)  
2  x  5 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;
}
}
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
x 2  2
f ( x)  
Örnek 4:
 2 1/ x
0 x2
2 x5
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:
f ( x)  sin( x)   (1) k
k 0
x 2 k 1
(2k  1)!
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;
}
2  x  4 dx=0.1 aralığıyla hesaplayalım. Bu hesap için
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));}
}
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
tanımlanmıştır.
{
F(1)=1 F(n)=F(n-1)+F(n-2) olarak
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));
}
}
n= 4 Fibonnachi = 5
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));
}
}
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.
erf ( x) 
2


 (1)n
n 0
x 2 n 1
n!( 2n  1)
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;
}
{
String s="";
double x=0;
{ x=x1+(x2-x1)/(n-1)*i;
s+="x = "+x+" f = "+erf(x)+"\n";
}
return s;
}
}
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 :
  y 2n 
y2 y4 y6
ln( x)  2 y 

2
y
(
1



 ...)

3
5
7
 n 0 (2n  1) 
x 1
y
x 1
{
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;
}
}
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 :
a x  exp( x * ln(a )) 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
f ( x) 
x 3  3x  5
x2  3
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;
fonksiyonunu
 2  x  2 0.1 aralığıyla
{ x=x1+(x2-x1)/(n-1)*i;
s+="x = "+x+" f = "+log(x)+"\n";
}
return s;
}
}
f ( x)  cos( x)
fonksiyonunu
   x   0.1 aralığıyla hesaplayan
bir kod yazınız. Cos fonksiyonu kütüphaneden Math.cos(x) olarak çağrılabilir.
f ( x)  cos( x)

bir kod yazınız. Cos fonksiyonunu
cos( x)   (1) k
k 0
fonksiyonunu
 sayısı Math.PI olarak çağrılacaktır.
   x   0.1 aralığıyla hesaplayan
x 2k
taylor serisi açılım formülünden bir static fonksiyon
(2k )!
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ı
(2k  1)
k 1
xPk 1 ( x) 
Pk 2 ( x), k  2 denklemiyle tanımlanır.
k
k
Burada P0(x)=1 ve P1(x)=x olarak tanımlanmıştır. Legendre polinomu Pk (x ) I hesaplayan bir static fonksiyon
irdeleyelim. Legendre Polinomlarını Pk ( x) 
yazınız ve k=5 için
0  x  5 aralığında hesaplayınız.
HAFTA 2
2.1 GİRİŞ
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:
f ( x)  x 2  2 x  5
2  x  5 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: f ( x)  ax  bx  c  0
2
Diskriminant   b  4ac
2
Eğer   0
Eğer   0
Eğer   0
b 
b 
x2 
2a
2a
b
x1  x2 
2a
x1 
x1 
b

b


i x2 

i (kökler sanal)
2a 2a
2a 2a
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");
}
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:
z1  nr1  ni1i
Örnek 4:
z 2  nr2  ni2 i
z3  z1  z 2  (nr1  nr2 )  (ni1  ni2 )i
z3  z1  z 2  (nr1  nr2 )  (ni1  ni2 )i
z3  z1 * z 2  (nr1 * nr2  ni1 * ni2 )  (nr1 * ni2  ni1 * nr2 )i
a  (nr2 * nr2  ni2 * ni2 )
z3  z1 / z 2  (nr1 * nr2  ni1 * ni2 ) / a   (nr1 * ni2  ni1 * nr2 ) / a  i
z3  z1
Z2
 exp( z 2 log( z1 ))
z3 
z1  exp( 0.5 log( z1 ))
z3  e  exp( z1 )  exp( nr1 ) * cos( ni1 )  exp( nr1 ) * sin( ni1 )i
z1
z3  log( z1 )  (nr1 * nr1  ni1 * ni1 ) *  tan 1 (
ni1
)i
nr1
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);
}
}
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.
xn1  xn 
f ' ( xn ) 
f ( xn )
f ' ( xn )
 f ( xn  2x)  8 f ( xn  x)  8 f ( xn  x)  f ( xn  2x)
12x
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.
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: f ( x)  x 4  3 x 2  4 fonksiyonunun köklerini hesaplayan bir program yazınız
PROBLEM 3: f ( x)  x 4  3 x 2  4 fonksiyonunun köklerini hesaplayan bir program yazınız (kökler
sanal sayı)
PROBLEM 4: f ( x)  x 2  4 fonksiyonunun köklerini ikinci dereceden denklem formülünü
kullanarak hesaplayınız.
PROBLEM 5: f ( x)  x 2  4 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)
HAFTA 3
3.1 GİRİŞ
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());}
{
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=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(double yi,double yj,double yk,double R, double costetai, double costetaj,double costetak)
{
n=new nokta3D1(yi,yj,yk);
F=new double[3];
M=new double[3];
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);
}
}
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]);
}}
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 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));
}
}
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:
 a11
a
 21
 ....

a n1
a12
a 22
....
an2
a1n   X 1   b1 
..... a 2 n   X 2  b2 

.... ....   ...  ....
   
.... a nn   X n  bn 
....
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
a'11
 0

 0

 0
 0
a '12
a'13
a '14
a' 22
a ' 23
a ' 24
0
a '33
a'34
0
0
a ' 44
0
0
0
a '15   X 1   b'1 
a ' 25   X 2  b' 2 
a '35   X 3   b'3 
   
a ' 45   X 4  b' 4 
a '55   X 5  b'5 
şekline getirmemiz gerekir. Bunu yapabilmek için sistematik bir eleme uygulayabiliriz. Örneğin a 21 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 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.
2 zar atma ihtimali
0,25
P, ihtimal
0,2
0,15
0,1
0,05
0
0 1 2 3 4 5 6 7
8 9 10 11 12 13 14 15 16
N
iki zar atışta sayıların dağılımı
zar
toplamı
zar kombinasyonu
0
1
ihtimal
zar frekansı
0
0
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);
}
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:
{
{
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);
}
}
(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));
}
}
}
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.
1 0.3333  0.3333  X 0  0.6667
1
4
1   X 1    12 

2
1
2   X 2   10 
Problem 6: Üç zar atıldığında oluşacak olusılık dağılımını hesaplayan bir program yazınız.

Hafta 1 - turhancoban.com

Transkript

Benzer belgeler

Veri Yapıları - Ders Notu - Süper