Doç. Dr. Özgür Baştürk
Ankara Üniversitesi, Astronomi ve Uzay Bilimleri Bölümü
obasturk at ankara.edu.tr
http://ozgur.astrotux.org
Bu derste neler öğreneceksiniz?¶
Bilgisayarda Sayıların Temsili ve Yuvarlama Problemleri ile Python Çözümleri¶
Yuvarlama Yanlışları¶
Yuvarlama konusunun ayrıntlı olarak anlatıldığı Hata Analizi dersinde ayrıntılı olarak verildiği gibi Yuvarlama yanlışları temelde iki problemden kaynaklanır:
$\pi$, $e$, $\sqrt{7}$ gibi sayılar sabit sayıda anlamlı rakamla temsil edilemezler. Bu nedenle bilgisayarlar da bu sayıları tam olarak temsil edemez.
Bilgisayarlar ikilik sayı sistemini kullandıklarından onluk sayı sistemine dayalı tüm sayıları aynı duyarlılıkta temsll edemezler.
Yuvarlama işlemi kaynaklı hatalar sayıların bilgisayarda tutulma şekline doğrudan bağlıdır. 10 parmağımız olduğu için onluk sayı sistemi biz insanlar için “doğal” olandır. Bir bilgisayar ise sadece 2 parmağı olan bir varlık gibi düşünülebilir. Bu nedenle ikilik sayı sistemi de onun için “doğal” olandır.
Herhangi bir tamsayı onluk ve ikilik sayı sistemlerinde aşağıdaki şekillerde çözümlenir (Chapra & Canale 2009).
from IPython.display import Image
Image(filename='images/sayi_sistemleri.png', width=400)
Bu durum her iki sayı sisteminde ve diğer tüm sayı sistemlerinde sayıların mükemmel temsil edilemiyor olmasına yol açar. Buna ek olarak bilgisayarlar sınırlı kapasiteleri nedeniyle sadece belirli bir sayı aralığını temsil edebilirler. Örneğin 16 bitlik bir sayı sistemi varsayılan olarak -32768 ile 32767 arasındaki tam sayıları saklayabilir. 16 bitlik CCD dedektörlerde algılanan fotonların ADU biriminden karşılığının 0-65535 arasında olbilmesinin nedeni de budur. Foton algılama işlemi doğası gereği bir "sayım" işlemi olduğundan negatif sayılara ihtiyaç duyulmaz.
from IPython.display import Image
Image(filename='images/sayi_sistemleri_16bit.png', width=400)
Yukarıdaki şekilde şematik olarak gördüğünüz 16 bit ikilik sayı sisteminde, her bir basamak sadece 0 veya 1 değerini alabilir ve toplamda 16 basamak vardır. 1. basamak işaret için ayrılır ve 0 iki kere sayılmaz. En baştaki 0: pozitif, 1: negatif sayıları ifade eder. Bu durumda yazılabilecek en küçük sayı $1111111111111111$ (bu sayının onluk sayı sistemindeki karşılığı -32767 olduğu halde 0'ı iki kez saymamak için onu pozitif sayılara dahil edip saymaya -1'den başladığımız için -32768) olurken en büyük sayı $0111111111111111$ (32767) olur.
Kayan Noktalı Sayılar¶
Bilgisayarlar tam sayılar dışındaki sayıları göstermek üzere "kayan noktalı" sayıları (ing. floating point numbers) kullanırlar. Aşağıda kayan noktaları sayıların hafızada saklanma şeklini örnekleyen bir şekil bulunmaktadır. Herhangi bir sayı bu şekilde m: mantis, b: taban, e: üssü göstermek üzere
$$ m~b^e $$şeklinde ifade edilir.
from IPython.display import Image
Image(filename='images/sayi_sistemleri_floatingpoint.png', width=400)
Örneğin onluk sayı sistemindeki $156.78$ sayısını düşünelim. Bu sayıyı bilimsel gösterimde (ing. scientific notation) şu şekilde ifade edebiliriz: $0.15678 x 10^{3}$.
Eğer mantis başında gereksiz $0$ sayıları varsa normalize edilebilir. Örneğin, $1 / 34 = 0.029411765...$ sadece 4 basamağa izin verilen 10'luk bir kayan sayı sisteminde $0.0294 x 10^0$ şeklinde saklanabilir. Ancak bu şekilde noktadan sonraki 0 nedeniyle 5. basamaktaki $1$ sayısını kaybetmiş oluruz. Bunu sayıyı $0.2941 x 10^{-1}$ şeklinde göstererek aşabiliriz. Noktanın bu şekilde kaydırılması bu sayıların "kayan noktalı sayılar” (ing. floating point numbers) olarak adlandırılmış olmasının da kaynağıdır. Böylece noktadan sonra gelen gereksiz 0'a da izin verilmemiş olur. Bu işleme normalizasyon adı verilir ve sayılarda anlamsız rakamların elenmesi işlevini de görür.
Normalizasyonun doğal bir sonucu mantis (m) için limitli bir değer aralığına sahip olunmasıdır. b, tabanı; m, mantisi göstermek üzere
$$\frac{1}{b} \le m \lt 1$$Örneğin onluk sayı sisteminde
$$0.1 \le m \lt 1$$iken ikilik sayı sisteminde
$$ 0.5 \le m \lt 1$$Örnek: Yedi bitlik ikilik bir sayı sistemini ele alalım (Şekil Chapra & Canale 2009'dan alınmış ve Türkçeleştirilmiştir) ve bu sayı sisteminde ifade edilebilecek en büyük ve en küçük sayıları hesaplamak istiyor olalım.
from IPython.display import Image
Image(filename='images/sayi_sistemleri_7bit.png', width=300)
Bu sistemde ifade edebileceğimiz en küçük poziftif sayı $011100$ 'dir. bu sayının onluk sayı sistemindeki karşılığı $m = 1x2^{-1} + 0x2^{-2} + 0x2^{-3} = 0.5$, $b=2$ , $e = -(1x2^0 + 1x2^1) = -3$ olduğundan
$$ (1x2^{-1} + 0x2^{-2} + 0x2^{-3}) x 2^{-(1x2^1+1x2^0)} = 0.5 x 2^{-3} = 0.0675 $$sayısıdır.
En büyük poziftif sayı ise $0011111$ sayısı olup onluk sayı sistemindeki karşılığı $m = 1x2^{-1} + 1x2^{-2} + 1x2^{-3} = 0.875$, $b=2$ , $e = 1x2^0 + 1x2^1 = 3$ olduğundan
$$ 1x2^{-1} + 1x2^{-2} + 1x2^{-3}) x 2^{1x2^1 + 1x2^0} = 0.875 x 2^{3} = 7 $$sayısıdır.
Aslında bu sayı sisteminde daha küçük mantisler yazabiliriz ($000$, $001$, $010$, $011$) ancak normalizsyon gereği noktadan sonraki gereksiz $0$'ları atmaya yönelik bir işlem uygulanacağından buna izin verilmez. Dolayısı ile en küçük olarak ifade edilebilien bu sayıyı aşağıdaki sayılar takip eder:
$$ 0111101 = (1 x 2^{−1} + 0 x 2^{−2} + 1x2^{−3}) x 2^{−3} = (0.078125)_{10} $$$$ 0111101 = (1 x 2^{−1} + 1 x 2^{−2} + 0x2^{−3}) x 2^{−3} = (0.093750)_{10} $$$$ 0111101 = (1 x 2^{−1} + 1 x 2^{−2} + 1x2^{−3}) x 2^{−3} = (0.109375)_{10} $$
Bu sayı sistemiyle $0.0675$ sayısından küçük pozitif sayıların temsil edilememesinin yanı sıra her sayının da temsil edilemediğine dikkat ediniz. Sayılar $0.015625$ aralıkla artmakta, bu artışın altındaki artışlarla ulaşılacak sayılar gösterilememektedir! Bu noktadan sonra sayıyı büyütmek için üssü büyütmeliyiz!
$$ 0110100 = (1 x 2^{−1} + 0 x 2^{−2} + 0x2^{−3}) x 2^{−2} (0.125000)_{10} $$$$ 0110101 = (1 x 2^{−1} + 0 x 2^{−2} + 1x2^{−3}) x 2^{−2} = (0.156250)_{10} $$...
...
Görüldüğü üzere sayılar büyüdükçe aralarındaki farklar da artmakta ve tam olarak temsil edilemeyen sayıların sayısı da buna bağlı olarak artmaktadır. Ayrıca 7 sayısının üstündeki sayılar da bu sayı sisteminde temsil edilememektedir. 7 bitlik sayı sistemi kuşkusuz modern bilgisayarlarda kullanılan 32 bit ve 64 bitlik sayı sistemleriyle karşılaştırıldığında son derece basit ve kullanışsız ve bir sistemdir. Ancak onlarda karşılaşılan güçlükleri örneklemek açısından faydaldır.
Sayı Sistemlerinde Temsil Sorunları ve Sonuçları¶
Yukarıdaki örneklerden çıkarsanması gereken dört temel sonuç:
Sadece belirlii bir aralıktaki sayılar temsil edilebilir. Tıpkı tam sayıda olduğu gibi ($-32768 – 32767$) kayan noktalı sayı gösteriminde de çok büyük pozitif ve çok küçük negatif sayıların temsili sorunu vardır. Bu sınırların dışına çıkmaya kalkarsanız taşma (overflow) hatası alırsınız.
Normalizasyon nedeniyle çok küçük pozitif sayıların gösterimiyle de ilgili bir problem yaşanır. Bu problem 0'dan sonra ilk temsil edilebilen sayıya kadar büyük bir boşluğun (underflow) oluşmasına neden olur.
Tüm nicelikler temsil edilemezler! Bu nedenle hassasiyet de sınırlıdır. Açık ki irrasyonel sayılar tam olarak temsil edilemezler. Ayrıca temsil edilebilen küme dışında kalan rasyonel sayılar da tam olarak temsil edilemezler. Bu sorun kuantizasyon hatası (quantization error) olarak bilinen hataya yol açar.
Temsil edilmek istenen sayı büyüdükçe temsil edilebilen sayılar arasındaki uzaklığın da artmasıdır (64 bitlik sayı sisteminde $1.0$ ile $2.0$ arasında $8~388~607$ tane kayan noktalı sayı varken $1023$ ile $1024$ arasında sadece $8191$ tane vardır).
Çözüm: Temsil edemediğniz basamakları ya keser atarsınız (ing. truncation) ya da yuvarlarsınız (rounding)!
from IPython.display import Image
Image(filename='images/sayi_sistemleri_yuvarlama_kesme.png', width=500)
Kesme ve Yuvarlama İşlemleri¶
“Kırpma” ya da kesme (truncation, chopping) işlemi uygulanırsa, şekilden de görüleceği gibi sondan atılan $\Delta x$ kadar hata yapılmış olur. Bu durumda yapılan hata her zaman pozitiftir. Örneğin $\pi = 3.14159265358...$ sayısına bakalım. Sayımız 6. basamaktan sonra temsil edilemiyor olsun. Bu durumda kesme işi uygularsak sayı $\pi ~ 3.141592$ şeklinde ifade edilir ve hatası $|\epsilon_t| = 0.00000065...$ olur. Oysa ki yuvarlama işlemi uygulanmış olsaydı sayı $\pi ~ 3.141593$ şeklinde ifade edilir ve hatası $\epsilon_t = 0.00000035...$ olurdu. Dolaysı ile kesme işleminde hatanın üst sınırı $\Delta x$ iken, yuvarlamada $\Delta x / 2$'dir. Ayrıca yuvarlama işleminden gelen hatada yanlılık da daha azdır; pozitif olabileceği gibi negatif de olabilir. Ancak yuvarlama işlemi ek kod gerektirir. Bu ek koddan kaçınmak için, modern bilgisayarların oldukça büyük ve küçük sayıları saklayabiliyor olması gerekçesiyle, kesme işlemine gidilir.
Bir başka problem de temsil edilmek istenen sayı büyüdükçe temsil edilebilen sayılar arasındaki uzaklığın da artmasıdır. Dolayısı ile kuantizasyon hatası sayının büyüklüğüne bağlıdır. Bu ilişki kesme işlemi için $\Delta x / x \le \epsilon$, yuvarlama işlemi için $\Delta x / x \lt \epsilon / 2$ şeklinde ifade olunur. Burada $\epsilon$ sistem (ya da makine) epsilonu olarak bilinir ve $\epsilon = b^{1 - t}$ olarak ifade edilir. t, mantisteki anlamlı rakam sayısını göstermektedir.
Örnek: 7 bitlik hayali sayı sistemimiz için makine epsilonu değerini hesaplayalım:
Sistemimizin tabanı 2 olduğundan $b = 2$ 'dir. Mantisteki anlamlı rakam sayısı $t = 3$ 'tür. Bu durumda makine epsilonu $\epsilon = b^{1 - t} = 2^{-2} \rightarrow \epsilon = 0.25$ olarak bulunur. Dolayısı ile kesme işlemi uygulandığında yapılabilecek maksimum göreli hata da bu kadar olacaktır. Sayılar büyüdükçe kesme işlemi sonucu yapılan hata büyüyor olsa da sayının mutlak değeri de büyüdüğünden göreli hata değeri bu üst sınırın altında kalmaya devam edecektir. Örneğimizde maksimum hata $(0.125000)_{10}$ ile $(0.156250)_{10}$ arasında gerçekleşmektedir. Dolayısı ile hata $(0.156250 – 0.125000) / 0.125000 = 0.25$ olur.
Önemli Sonuç: Bu problem özellikle iki kayan noktalı sayıyı karşılaştırırken karşımıza çıkar. Matematiksel olarak birbirine eşitmiş gibi görünen iki ifade kesme ya da yuvarlama nedeniyle birbirinden farklı iki kayan noktalı sayıyla sonuçlanabilir. Doğrusu iki kayan noktalı sayıyı karşılaştırmak yerine, aralarındaki farkın mutlak değerini yeterince küçük seçilmiş bir tolerans değeriyle karşılaştırmak; bu tolerans değerini seçerken ise programı sistem bağımsız hale getirmek üzere makine epsilonundan faydalanmaktır!
$a$ ve $b$ kayan noktalı sayıları için; $a == b$ ya da $a != b$ yerine $abs(a – b) \gt tolerans $ (örn. $2~\epsilon$) gibi bir karşılaştırma yapmak daha doğrudur.
Makine Epsilonu¶
Makine epsilonu aşağıdaki basit kodla hesaplanabileceği gibi her sistemin makine epsilionu sys.float_info.epsilon ile de öğrenilebilir.
epsilon = 1.
while epsilon + 1 > 1:
epsilon /= 2.
epsilon *= 2
print("Makine epsilonu", epsilon)
import sys
print(sys.float_info.epsilon)
7 bitlik hayali sayı sistemi örneğimiz konuyu daha iyi kavratabilmek amacıyla oldukça abartılı limitlere sahiptir. Modern bilgisayarlar kayan noktalı sayı hassasiyeti konusunda çok daha başarılıdır. IEEE standardını takip eden bilgisayarlar sayının işareti için 1 bit, üs için 8 bit, mantis için 24 bit (toplam 32 bit) kullanırlar. Normalizasyon nedeniyle bu bitlerini birincisi her zaman $1$ olduğundan geriye kalan 23 bitle $10^{-38} - 10^{39}$ arasındaki sayılar ifade edilebilmektedir.
Daha da fazla hassasiyete ihtiyaç duyulduğunda pek çok sistem ek bir hassasiyet seçeneği sunar: Çifte Duyarlılık (Double Precision). 15-16 ek basamağın sağlandığı bu seçenekle $10^{-308} - 10^{308}$ arasındaki sayıları ifade edilebilecek duyarlılığa kadar inilebilmektedir.
Tabi bu ek duyarlılık işlemci ve RAM üzerine daha çok yük ve dolayısı ile daha uzun çalışma dezavantajıyla birlikte gelir, bu nedenle uygun yerlerde, dikkatli ve seçilerek kullanılması gereklidir!
Aritmetik İşlemlerin Getirdiği Kesme ve Yuvarlama Yanlışları¶
1 Toplama ve Çıkarma¶
Toplama ve çıkarma işlemleri küçük sayının mantisi her iki sayının üssü eşit olacak şekilde düzenlendikten sonra yapılır.
Örnek 1. $1.5571$ ile $0.4381$ sayılaırnı topluyor olalım. Bu sayılar alt alta yazılırken noktanın aynı yere getirilmesine dikkat ediliyor.
$$ 0.1557~~~~10^1 $$$$ 0.004381~~~10^1 $$$$ +----------- $$$$ 0.160081~~~10^1 $$Sayı daha az sayıda basamak içeren (4) sayı kadar rakam içereceğinden bunun için kesilir ve
$$ 0.1600 x 10^1 $$şeklinde ifade edilir.
Örnek 2. $364.1$'den $268.6$'yı çıkarıyor olalım.
$$ ~0.3641~~~~10^2 $$$$- 0.2686~~~~10^2 $$$$ ------------ $$$$ ~0.0955~~~~10^2 $$Normalizasyon gereği sayı,
$$ 0.9550 x 10^1 $$şeklinde ifade edilir.
Örnek 3.
$$ ~0.7642~~~~10^3 $$$$- 0.7641~~~~10^2 $$$$ ------------ $$$$ ~0.0001~~~~10^3 $$Normalizasyon gereği sayı,
$$ 0.1000 x 10^0 = 0.1$$şeklinde ifade edilir.
2 Çarpma ve Bölme¶
Çarpma ve bölme işlemleri görece daha kolaydır: Mantisler çarpılır, üsler toplanır! Pek çok sistem ara adımları çift duyarlılıkta saklayarak ilerler.
Örnek:
$$ 0.6313~10^3~x~0.6423~10^{-1} = 0.08754549~10^2 $$Normalizasyon ve kesme işlemleri sonrası
$$ 0.8754549~10^1 \Rightarrow 0.8754~10^1$$3 Büyük ve Küçük Sayıyla Toplama Çıkarma¶
Kesme / yuvarlama nedeniyle bazen işlem yapılmamış gibi bir sonuçla dahi karşılaşılabilir.
$$ 0.4000~~~~10^4 $$$$ 0.0000001~~~10^4 $$$$ +----------- $$$$ 0.4000001~~~10^4 $$Kesme işlemi sonrası
$$ 0.4000~10^4 $$x = 0.000001
toplam = 0.
for i in range(0, 1000000, 1):
toplam += x
print("Toplam: ", toplam)
4 Yakın İki Sayıyı Çıkarma¶
Birbirlerine çok yakın iki sayı çıkarılmaya çalışıldığında sayıların tam temsil edilememesi ve yuvarlama / kesme işlemi kaynaklı olan, ancak beklenmeyen sorunlarla karşılaşılabilir. Buna iyi bir örnek ikinci dereceden bir denklemin kökleri hesaplanırken karşılaşılabilecek olan aşağıdaki gibi bir sonuçtur.
$$ \frac{-b \pm \sqrt{b^2 - 4~a~c}}{2~a} $$from math import sqrt
a = 1.
b = 3000.001
c = 3.
x1 = (-1*b - sqrt(b**2 - 4*a*c))/(2*a)
x2 = (-1*b + sqrt(b**2 - 4*a*c))/(2*a)
print("x1: ", x1)
print("x2: ", x2)
Python'da Kayan Noktalı Sayılar¶
Görüldüğü gibi kayan noktalı sayılar ilgili olarak karşılaşılan en temel sorun onluk sayı sistemindeki bir sayının ikilik sayı sisteminde tam olarak ifade edilememesidir. Örneğin, $0.1$ sayısının ikilik sayı sistemindeki karşılığı $0.0001100110011001100110011001100110011001100110011...$
Python $repr()$ fonksiyonu ve Python promptu kayan noktalı bir sayıyı 17 basamak duyarlıılıkla gösterir. İstenirse sayı ekrana daha büyük ya da küçük bir duyarlılıkla da getirilebilir.
from math import pi
print(format(pi, '.12g'))
print(repr(pi))
Gerçekte bu bir ilüzyondur. Zira bu sayının tam bir gösterimini yapabilmek mümkün değildir. Ekrana bindirilen görüntü her zaman belirli duyarlılıkta bir yaklaşımdan ibarettir. Aşağıdaki örnek daha açıklayıcıdır.
print(.1 + .1 + .1 == .3)
print(round(.1, 1) + round(.1, 1) + round(.1, 1) == round(.3, 1))
print(round(.1 + .1 + .1, 10) == round(.3, 10))
math modülü fonksiyonlarından fsum ise toplama işleminde yuvarlama kaynaklı hataların giderilmesini sağlar.
from math import fsum
print(sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1]))
print(fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1]))
Python'da bir kayan noktalı sayının hangi iki tam sayının oranı olarak ifade edildiğini veren bir metot bulunmaktadır. Kayan sayı nesnelerinin bir metodu olan as_integer_ratio().
print(3.5.as_integer_ratio())
from math import pi
print(pi.as_integer_ratio())
Bu fonksiyonu kullanarak 0.1 sayısının nasıl temsil edildiğine bakalım. 1/10 değil, çünkü 1/10 ikilik sayı sisteminde tam olarak gösterilemez!
0.1.as_integer_ratio()
$fractions$ modülü fonksyonları bu tür sorunların çözümünü kolaylaştırmak konusunda oldukça yardımcı olur.
from fractions import Fraction
Fraction.from_float(0.1)
Decimal Modülü¶
Decimal modülü kayan noktalı sayılarla işlemlerde hızlı ve doğru bir şekilde yuvarlama olanağı sağlayan fonksiyonlara sahiptir. Modül float nesnesine göre bazı önemli avantajlarla gelmektedir.
Decimal insanların elle işlem yapma prensiplerini temel alarak dizayn edilen bir kayan noktalı sayı modeline dayanır (IEEE Standart 854-1987). Bu şekilde bilgisayarın insanların okulda öğrendikleri şekilde işlem yapabilmelerine olanak sağlamış olur. $Decimal$ modülünde sayılar onluk sayı sisteminde temsil edildikleri şekliyle "tam olarak" temsil edilebilirler. $0.1$ gibi sayılar standart float veri türü ile gördüğünüz gibi tam olarak temsil edilememektedir. Ayrıca hem kayan noktalı (floating point) hem de sabit noktalı (fixed point) aritmetik desteği sağlar.
Modül üç kavram üzerine kuruludur: Decimal sayı nesnesi (decimal number), aritmetik işlemler ve uyarılar (Warnings). Decimal sayı nesnesi içeriği değiştirilemezdir (immutable). İşareti, mantisi ve üssü ile tanımlıdır. Sayıların sonundaki sıfırlar anlamlı rakam sayısını korumak üzere atılmaz. $Infinity$, $-Infinity$ ve $NaN$ gibi özel türleri de içerir. Aritmetik işlemler için kurallar tanımlıdır ve pek çok yuvarlama opsiyonu sağlanır (ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_UP ve ROUND_05UP). İşlem sonucuna göre de pek çok uyarı döndürme opsiyonu bulunmaktadır ($InvalidOperation$, $DivisionByZero$, $Inexact$, $Rounded$, $Subnormal$, $Overflow$, $Underflow$ ve $FloatOperation$). Modül, metot ve öznitelikleri için bkz..
Genel olarak onluk sayı sisteminde ifade edildiği şekilde bir metin nesnesi (string) olarak tanımlanır ve daha sonra decimal.Decimal fonksiyonu kullanılarak bir Decimal nesnesine dönüştürülür.
import bitstring
sayi = bitstring.BitArray(float=0.1, length=32)
print(sayi.bin)
from decimal import *
Decimal("0.1")
Bir kayan noktalı sayıyı da bir Decimal dönüştürmek mümkündür. Ancak bu kez sayı amaçlandığı şekilde onluk sayı sisteminde ifade edildiği şekilde değil ikilik sayı sisteminde ifade edilebildiği şekilde onluk sayı sistemine dönüştürülmüş olur.
Decimal(0.1)
Sayıları ondalık sayı sisteminde olduğu şekilde temsil edebildiğiniz gibi ölçüm duyarlılığı da korunur. Ancak işlemlerde anlamlı rakam sayısı sonuca tam olarak anlamlı rakamlarla aritmetik kurallarına göre transfer edilmez.
print(Decimal('0.1') + Decimal('0.1') + Decimal('0.1') == Decimal('0.3'))
print(Decimal('3.40') + Decimal('1.60'))
print(Decimal('0.745')*Decimal('2.2')/Decimal('3.885'))
Decimal modülünde işlem yaparken sisteminiz tarafından sağlanan duyarlılığın üzerine çıkabilirsiniz. Daha fazla bilgi için bkz
getcontext().prec = 6
print(Decimal(1) / Decimal(7))
getcontext().prec = 28
print(Decimal(1) / Decimal(7))
Decimal('0.1428571428571428571428571429')
print(getcontext()) # limitler
Pek çok uygulama için $getcontext$ fonksiyonu ile mevcut ortama (kontekst) ulaşılarak ayarlar değiştirilebliir. Ancak bazen kullanıcı kendi ortamını (kontekst) yaratmaya ya da birden fazla ortamda işlem yapmaya ihtiyaç duyabilir. $Context()$, $setcontext()$ metodları yeni bir ortam oluşturmak için kullanılabilir. $decimal$ modülü tarafından sağlanan standart ortamlar (kontekstler) ise $BasicContext$ ve $ExtendedContext$'tir.
benimortamim = Context(prec=60, rounding=ROUND_HALF_DOWN)
setcontext(benimortamim)
print("Benim Ortamim")
print(getcontext())
print("1/7 = ", Decimal(1) / Decimal(7))
print("----------------------")
setcontext(ExtendedContext)
print("Extended Context")
print(getcontext())
print("1/7 = ", Decimal(1) / Decimal(7))
print("42 / 0 =", Decimal(42) / Decimal(0))
print("------------------------")
#print("Basic Context")
#setcontext(BasicContext)
#print("42 / 0 = ", Decimal(42) / Decimal(0))
Kontekstlerin problemli durumlar karşısında kullanıcıyı uyarmak üzere uyarı mesajı işaretleri ($flag$) vardır. Hangi uyarı mesajlarının oluştuğunu görmek için öncelkle clear_flags() metodu ile var olan işaretleri "temizlemekte" fayda vardır.
Aşağıdaki örnekte $\pi$ sayısına yaklaşık bir oran (355 / 113) veren bir bölme işlemiyle hangi işaretlerin "uyandırıldığına" bakalım.
from decimal import *
setcontext(ExtendedContext)
print(getcontext())
ExtendedContext.clear_flags()
print("355 / 113 = ", Decimal("355") / Decimal("113"))
print(getcontext())
Burada yapılan bölmenin yaklaşık sonucunun yuvarlandığını ($Rounded$) ve bu nedenle sonucun tam olmadığını ($Inexact$) gösteren bir işaret ($Flag$) bulunmaktadır. Ayrıca getcontext() fonksiyonunun flags özniteliğiyle de hangi uyarı işaretlerinin "uyandırıldığını görebiliriz.
getcontext().flags
Bu tür durumları belirleyerek kodumuzu ona göre değiştirmek isteyebiliriz.
if getcontext().flags[Inexact]:
getcontext().prec = 64
else:
getcontext().prec = 28
print(getcontext().prec)
İstendiğinde bir kontekstin (ortamın) hata mesajı verecek şekilde ayarlanması mümkündür. Bunun için kontekstin (ortamın) traps sözlüğünden faydalanılır.
#setcontext(ExtendedContext)
getcontext().clear_traps()
print("1 / 0 = ", Decimal("1") / Decimal("0"))
print("Traps:")
print(getcontext().traps)
getcontext().traps[DivisionByZero] = 1
print("1 / 0 = ", Decimal("1") / Decimal("0"))
Görüldüğü gibi bir ortamın DivisionByZero işareti (flag) de ve tuzağı (trap) da bulunmaktadır. Yapılan işlemin sonucuna göre işaret $True$ değerine ayarlanırken, istendiğinde bu işarete erişilerek kodun örneğin kullanıcıya bir uyarı vermesi ya da hassasiyeti değiştirmesi sağlanabilir. Tuzak (trap) $True$ değerine ayarlandığında ise program bir hata mesajı ile hata verir. Bu noktadan sonra programcı hatayı program gerekliliklerine göre yönetir.
Örneğin kullanıcının kayan noktalı sayılar (float) yerine düzenli olarak metin (string) nesneleriyle işlem yapması istendiğinde FloatOperation tuzağı ayarlanabilir.
getcontext().traps[FloatOperation] = False
Decimal(2.675)
Decimal("2.675")
getcontext().traps[FloatOperation] = False
Decimal(0.1) + Decimal(0.1) + Decimal(0.1) == Decimal(0.3)
getcontext().traps[FloatOperation] = False
Decimal("0.1") + Decimal("0.1") + Decimal("0.1") == Decimal("0.3")
Decimal Modülünün Kullanımına Bazı Örnekler¶
Decimal nesnesi Python "ekosisteminin" diğer parçalarıyla uyumludur. Dolayısı ile ekosistem üzerinde çalıştırabildiğiniz pek çok fonksiyon ve işlem Decimal nesneleriyle de çalışır.
setcontext(BasicContext)
birliste = ['3.14','2.73', '1.80','23.7']
veri = list(map(Decimal, birliste))
veri
print("Listenin maksimum degeri: ", max(veri))
print("Listenin toplami: ", sum(veri))
print("str(veri[2])", str(veri[2]))
print("veri[-1] / veri[0]", veri[-1] / veri[0])
Decimal nesnelerine matematiksel fonksiyonlar uygulanabildiği gibi bu fonksiyonlar için metotlar da bulunmaktadır.
from math import e,sin,log10
print(sin(Decimal('3.14159')))
print(log10(Decimal('1000')))
print(Decimal('1000').log10())
print(Decimal(e).ln())
Decimal nesnelerle aritmetik işlemler ile tamsayılar ve kayan noktalı sayılarla yapılan aritmetik işlemler arasında bazı küçük farklar vardır. Decimal nesnelere % kalan operatörü uygulandığında, sonucun işareti bölenin işareti değil, bölünenin işaretidir. Bu iki işlemin aslında farklı bir mantıkta çalıştığını göstermektedir. Birinci işlem bir modüler aritmetik işlemi ilken ikincisi bir negatif bölme kalanı olarak düşünülmelidir.
print(-7 % 4)
print(Decimal("-7") % Decimal("4"))
Tamsayı bölme operatörü de // benzer şekilde davranır, $x == (x // y) * y + x \% y$ eşitiğini korumak için gerçek bölümün tabanı (aşağı yuvarlanması) yerine (sıfıra doğru kesilerek) tamsayı kısmı döndürülür.
print(-7 // 4)
print(Decimal(-7) // Decimal(4))
Decimal Modülünde Yuvarlama Seçenekleri¶
Decimal modülünde yuvarlama işlemleri için quantize metodu kullanılır. Herhangi bir yuvarlama stratejisi kullanılabilir ancak varsayılan yöntemde (ROUND_HALF_EVEN) yuvarlamada tıpkı round fonksiyonunda olduğu gibi, klasik olarak takip edilen yuvarlama kurallarına uyulur. Ancak bu kez yuvarlamada sayının gösterim şekli esas alınır.
print(Decimal('1.65').quantize(Decimal('1.0')))
print(Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN))
print(Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP))
Son olarak kullanılan yuvarlama kuralı kalıcı hale getirildiğinden varsayılana dönmek için varsayılan kuralın tekrar hatırlatılması gerekir.
print(Decimal('1.65').quantize(Decimal('1.0')))
print(Decimal('1.65').quantize(Decimal('1.0'), rounding=ROUND_HALF_EVEN))
print(Decimal("2.675").quantize(Decimal("1.00")))
Decimal modülünün yuvarlama fonksiyonlarından bazıları klasik yuvarlama stratejilerinden bir miktar farklı çalışmaktadır. Örneğin ROUND_HALF_UP fonksiyonu beklentinin (ve genel kuralın) aksine sayıları 0'dan uzaklatırşacak şekilde yuvarlarken ROUND_HALF_DOWN sayıları 0'a yaklaştıracak şekilde yuvarlar. Bu yaklaşımın temel amacı yuvarlama yanlılığını minimize etmektir.
getcontext().rounding = ROUND_UP
print(Decimal("4.42").quantize(Decimal("1.0")))
print(Decimal("-4.42").quantize(Decimal("1.0")))
getcontext().rounding = ROUND_DOWN
print(Decimal("6.28").quantize(Decimal("1.0")))
print(Decimal("-6.28").quantize(Decimal("1.0")))
Bu iki fonksiyonun sondaki rakamın 5 olması durumundaki her iki yöndeki (pozitif ve negatif) davranışları da aynı şekildedir. ROUND_UP 0'dan uzaklaştıracak, ROUND_DOWN 0'a yaklaştıracak şekilde sayıları yuvarlar. ROUND_HALF_UP ve ROUND_HALF_DOWN 'ın davranışları da benzerdir.
getcontext().rounding = ROUND_HALF_UP
print(Decimal("4.45").quantize(Decimal("1.0")))
print(Decimal("-4.45").quantize(Decimal("1.0")))
getcontext().rounding = ROUND_HALF_DOWN
print(Decimal("6.25").quantize(Decimal("1.0")))
print(Decimal("-6.25").quantize(Decimal("1.0")))
Decimal modülündeki ROUND_05UP fonksiyonu ise ilginç bir yuvarlama stratejisi daha sağlar.
getcontext().rounding = ROUND_05UP
print(Decimal("3.76").quantize(Decimal("1.0")))
print(Decimal("4.45").quantize(Decimal("1.0")))
print(Decimal("-4.45").quantize(Decimal("1.0")))
Yukarıdaki davranışı itibarı ile strateji her sayıyı 0'a doğru yuvarlar gibi görünmektedir. Ancak aşağıdaki ilk örnekte sayı önce 0'a doğru yuvarlanmaktadır ($1.4$). Ancak bir sonraki sayı 4 olduğu (0 ya da 5 olmadığı) için sayı olduğu gibi bırakılmaktadır. İkinci örnekte ise sayı 0' doğru yuvarlandıktan sonra ($1.5$) 5 ile karşılaşılmakta, bu ise sayının yukarıya yuvarlanmasına neden olmaktadır. Karşılaşılan sayı 0 olduğunda da davranış şekli aynıdır.
print(Decimal("1.49").quantize(Decimal("1.0")))
print(Decimal("1.51").quantize(Decimal("1.0")))
Numpy Modülünde Yuvarlama Seçenekleri¶
Numpy modülündeki around fonksiyonu, Python'un round fonksiyonuna benzer şekilde çalışır ve tıpkı onun gibi sayıların mükemmel temsil edilememesi sorunundan muzdariptir.
import numpy as np
np.random.seed(444) #her calismada ayni ciktiyi uretmek icin
dizi = np.random.randn(3, 5)
print(dizi)
yeni_dizi = np.around(dizi, decimals=4)
print(yeni_dizi)
math modülündeki ceil, trunc ve floor fonksiyonlarının diziler için çalışan eşlenikleri numpy için de vardır.
print(np.ceil(dizi))
print(np.trunc(dizi))
print(np.floor(dizi))
Sayılardan bazılarının negatif sıfıra ($-0$) yuvarlandığında dikkat ediniz. Negatif 0, bize bu sayının yuvarlandığını ve 0'dan küçük bir sayıdan yuvarlandığını söylemektedir. Bu durum, örneğin suyun sıcaklığı olduğunda onun donma noktasnın altında bir sıcaklığa sahip olduğu konusunda bir fikir verebilir.
Tam sayıya yuvarlamada klasik yuvarlama stratejisi numpy modülünde rint fonksiyonu ile sağlanmıştır.
print(np.rint(dizi))
Diğer yuvarlama seçenekleri numpy'da verilen bu seçenekler kullanılarak kodlanabilir. Numpy modülü Decimal modülü ile birlikte kullanılamamaktadır. Yine de istenirse, istenen gösterimdeki metin nesneleri bir liste içinde Decimal nesnesine dönüştürüldükten sonra numpy.array fonksiyonu ile numpy dizilerine dönüştürülebilir.
Pandas Modülünde Yuvarlama Seçenekleri¶
math modülündeki round ve numpy modülündeki around fonksiyonlarının pandas modülündeki karşılığı da round fonksiyonudur ve hem pandas serileri (pandas.series) hem de veri çeerçeveleri (pandas.DataFrame) üzerinde kullanılabilir.
import pandas as pd
import numpy as np
np.random.seed(444)
seri = pd.Series(np.random.randn(5))
print(seri)
print(seri.round(3))
np.random.seed(1234)
df = pd.DataFrame(np.random.randn(4, 4), columns=["A", "B", "C", "D"])
print(df)
df.round(2)
İstenirse her bir sütun (seriye) ayrı bir basamağa da yuvarlanabilir.
df.round({"A": 1, "B": 2, "C": 3, "D": 0})
basamak_sayisi = pd.Series([3, 0, 1, 2], index=["A", "B", "C", "D"])
df.round(basamak_sayisi)
numpy modülünün ceil, trunc, floor ve rint fonksiyonları pandas serileri ve dizileri üzerinde de kullanılabilir.
print(np.ceil(dizi))
print(np.floor(dizi))
print(np.trunc(dizi))
print(np.rint(dizi))
Gerek yuvarlamada, gerekse hata hesaplarında kritik olan tüm kavramalara hakim olup yerli yerince kullanmaktır. Kullanılan gözlemsel / deneysel verinin duyarlılığına bağlı seçimler yapılarak uygun yuvarlama / kesme seçenekleri kullanılmalı; anlamlı rakamlara özen gösterilmelidir. İşlemler ve fonksiyonlar sonucu elde edilen niceliklerin duyarlılıkları (üzerlerindeki belirsizlikler) verilirken işleme giren parametrelerin üzerindeki belirsizlikler dikkate alınmalıdır. Bir sonucun hatası verileriken hatanın türü (standart sapma, standart hata, tahmini hata, uyumlamadan fark karelerin toplamının karekökü (ing. root-mean-square, rms), varyans ...) mutlaka belirtilmeli, verilen niceliğin basamak sayısı ile hatasının basamak sayısnın aynı olmasına özen gösterilmeldir.
Kaynaklar¶
Sayı Sistemleri ve Yuvarlama Problemleri: "Numerical Methods for Engineers", 6th ed., Steven C. Chapra, Raymond P. Canale, McGraw Hill, 2009
Yuvarlama ve Decimal Modülü Konuları: Real Python, Dan Bader
Yuvarlama Konusu (round fonksiyonu): round Fonksiyonu Dokümantasyonu
[Decimal Modülü Dokümantasyonu](https://docs.python.org/3/library/decimal.html