R'de Sayılar: Numeric, Integer ve Matematik Fonksiyonları

Numeric ve Integer: R'nin İki Sayı Türü

R sayıları iki şekilde saklar. Numeric (çift duyarlıklı kayan noktalı sayı olarak saklanır) varsayılandır - aksini söylemedikçe yazdığınız her sayı bir double'dır. Integer, L sonekiyle istediğiniz ayrı ve tam bir tam sayı türüdür:

x <- 3.14
n <- 42L

cat(typeof(x), typeof(n), "\n")
cat(class(x), class(n), "\n")

Pratikte buna nadiren dikkat etmeniz gerekir: R aralarında sessizce dönüşüm yapar ve is.numeric() ikisi için de TRUE'dur (tüm tür sistemi için bkz. veri türleri). Ayrımın kendini gösterdiği tek yer bölmedir - / iki tam sayı arasında bile her zaman bir double döndürür:

cat(7L / 2L, "\n")
cat(typeof(7L / 2L), "\n")

Integer'lar çoğunlukla sayma fonksiyonlarının (length(), seq_len(), nrow()) çıktısı ve indeks değerleri olarak görünür. Tam sayı bölmesine ihtiyacınız olduğunda R'nin buna adanmış bir operatörü vardır - aşağıda ele alınıyor.

Yuvarlama Ailesi

R bir sayıyı budamanın, her biri farklı anlama gelen beş yolunu sunar:

cat(round(3.14159, 2), "\n")
cat(floor(2.7), "\n")
cat(ceiling(2.1), "\n")
cat(trunc(-2.7), "\n")
cat(signif(123456, 2), "\n")

• round(x, digits) - belirli sayıda ondalık basamağa (varsayılan 0).
• floor(x) - aşağıya, en yakın tam sayıya, her zaman eksi sonsuza doğru.
• ceiling(x) - yukarıya, her zaman artı sonsuza doğru.
• trunc(x) - ondalıkları keser, her zaman sıfıra doğru. Negatiflerdeki farka dikkat: trunc(-2.7) -2, ama floor(-2.7) -3'tür.
• signif(x, digits) - ondalık basamağa değil, belirli sayıda anlamlı basamağa: signif(123456, 2) 120000'dir.

Ve ünlü bir sürpriz: round(), IEEE 754 standardı gereği tam yarımlarda çift sayıya yuvarlama (bankacı yuvarlaması) kullanır:

cat(round(0.5), round(1.5), round(2.5), round(3.5), "\n")

Bu 0 2 2 4 yazdırır - her yarım en yakın çift sayıya yuvarlanır. Bu bir hata değildir; çok sayıda yuvarlanmış değeri topladığınızda sistematik yukarı sapmayı önler. Bir rapor okul yuvarlaması gerektiriyorsa küçük bir itme ekleyin ya da bunun yerine sunum katmanında biçimlendirin.

Gündelik Matematik Fonksiyonları

Temel işlemler tam da tahmin ettiğiniz gibi çalışır:

cat(sqrt(16), "\n")
cat(abs(-7.5), "\n")
cat(2^10, "\n")
cat(round(exp(1), 6), "\n")

sqrt() karekök, abs() mutlak değer, ^ üs alma ve exp(x) e sayısının x. kuvvetidir - yani exp(1), yaklaşık 2.718282 olan Euler sayısıdır.

İnsanları tökezleten tek fonksiyon log()'dur. R'de log(), 10 tabanında değil doğal logaritmadır (e tabanı):

cat(log(100), "\n")
cat(log10(100), "\n")
cat(log2(8), "\n")
cat(log(8, base = 2), "\n")

İlk satır kabaca 4.60517 yazdırır - 10 tabanı bekleyen bir okurun umduğu 2'yi değil. O tabanları kastediyorsanız log10() ve log2() kullanın ya da base = argümanını açıkça geçirin. (Bu gelenek, doğal logaritmanın varsayılan olduğu istatistik alanında standarttır.)

Mod %% ve Tam Sayı Bölmesi %/%

Kalanlı aritmetiği iki operatör karşılar:

cat(17 %% 5, "\n")
cat(17 %/% 5, "\n")

%% mod (kalan) işlemidir: 17 bölü 5, 3 kalan 2'dir. %/% ise tam sayı bölmesidir: 17'nin içine kaç tam 5 sığar. İkisi birlikte x == (x %/% y) * y + (x %% y) eşitliğini sağlar.

%% işlecinin klasik kullanımı bölünebilirlik testidir:

n <- 12
cat(n %% 2 == 0, "\n")
cat(n %% 5 == 0, "\n")

Negatif sayılarla ilgili bir incelik: R'nin %% işleci bölenin işaretini alır (Python gibi, C'nin aksine):

cat(-7 %% 3, "\n")

Bu -1 değil 2'dir - R "-7'ye ulaşmak için 3'ün bir katına ne eklemeliyim?" sorusunu yanıtlar ve pozitif bir bölen için sonuçları 0..2 aralığında tutar. İndeksleri sarmalamak için kullanışlıdır; C ya da Java'dan geliyorsanız şaşırtıcıdır.

Özel Değerler: Inf, -Inf ve NaN

R'nin sayıları IEEE 754'ü izler, dolayısıyla bazı işlemler hata yerine özel değerler üretir:

cat(1 / 0, "\n")
cat(-1 / 0, "\n")
cat(0 / 0, "\n")

1/0 Inf'tir (sonsuz), -1/0 -Inf'tir ve gerçekten tanımsız bir nicelik olan 0/0 ise "sayı değil" anlamında NaN'dır. Ayrım önemlidir: Inf bir yanıttır ("her şeyden büyük"), NaN ise yanıtın yokluğudur. Bunları özel fonksiyonlarla test edersiniz, çünkü == NaN asla işe yaramaz:

cat(is.infinite(1 / 0), "\n")
cat(is.nan(0 / 0), "\n")
cat(is.na(0 / 0), "\n")

Son satıra dikkat: NaN aynı zamanda NA sayılır, dolayısıyla is.na() onu da yakalar - is.na()'nın standart "bu değer kullanılamaz mı?" kontrolü olmasının bir nedeni daha (eksik değerler sayfasında dahası var).

R ayrıca bilimsel gösterimi doğal olarak okur ve yazar - 2.5e3 2500'dür ve çok küçük ya da çok büyük sayılar varsayılan olarak e-gösterimiyle yazdırılır:

cat(2.5e3, "\n")
cat(1e-4, "\n")
cat(format(1e-4, scientific = FALSE), "\n")

Bir rapor düz ondalık gerektiriyorsa format(x, scientific = FALSE) (ya da scipen seçeneği) kullanın.

Kayan Nokta Sürprizi

Ondalıkları ikili tabanda saklayan her dil bunu paylaşır ve R bir istisna değildir:

cat(0.1 + 0.2 == 0.3, "\n")
print(0.1 + 0.2, digits = 17)

FALSE - çünkü 0.1 + 0.2 aslında 0.30000000000000004'tür. Ne 0.1'in ne de 0.2'nin tam bir ikili karşılığı vardır ve küçücük hatalar birikir. R'nin varsayılan yazdırması 7 anlamlı basamak göstererek bunu gizler; sorunun bir == karşılaştırması başarısız olana dek görünmez hissettirmesinin nedeni budur.

Kural: hesaplanmış ondalıkları asla == ile karşılaştırmayın. Makul bir tolerans içinde karşılaştıran all.equal() kullanın:

cat(isTRUE(all.equal(0.1 + 0.2, 0.3)), "\n")

Bunu isTRUE() içine sarın, çünkü değerler farklı olduğunda all.equal() FALSE değil farkın bir açıklamasını döndürür. Kesinliğin önemli olduğu tam sayı işlerinde integer'lar yaklaşık 2,1 milyara kadar kesindir - sayma kodunun integer türünü kullanmasının bir nedeni daha.

Buradan Ne Çıkarıyorsunuz

• Yazılan her sayı bir double'dır; 42L bir integer yapar ve / her hâlükârda bir double döndürür.
• round() yarımları çift sayıya yuvarlar; floor/ceiling/trunc/signif her biri farklı budar - hangisini kastettiğinizi bilin.
• log() doğal logaritmadır; diğer tabanlar için log10(), log2() ya da base = kullanın.
• %% kalanı verir (işaret böleni izler), %/% ise tam bölümü.
• 1/0 Inf'tir, 0/0 NaN'dır ve 0.1 + 0.2 != 0.3 - ondalıkları == ile değil, all.equal() ile karşılaştırın.

Sırada: gündelik verinin diğer yarısı - metinler ve R'nin onları kurmanız, biçimlendirmeniz ve aramanız için verdiği fonksiyonlar.