R – Giriş

R, istatistiksel hesaplama ve grafikler için bir dil ve ortamdır. T-testi, ki-kare testleri, standart doğrusal modeller, enstrümental değişkenler tahmini, yerel polinom regresyonları, vb. gibi çok sayıda istatistiksel prosedür içerir. Aynı zamanda yüksek seviye grafik yetenekleri sağlar. R, çok çeşitli UNIX platformları ve benzer sistemleri (FreeBSD ve Linux dahil), Windows ve MacOS üzerinde derlenir ve çalışır. John Chambers ve meslektaşları tarafından Bell Laboratories’de (eskiden AT & T, şimdi Lucent Technologies) geliştirilmiştir.

R ücretsiz ve açık kaynaktır, yani kodlarına bakabilirsiniz. Windows, Mac OS, Unix, Linux gibi bilinen ana platformlarda çalışır. Veri nesneleri ve komut dosyaları bu platformlar arasında sorunsuz bir şekilde paylaşılabilir.

R, veri işleme, hesaplama ve grafik görüntüleme için entegre bir yazılımdır.

R;

    • Etkili bir veri taşıma ve depolama imkani,
    • Diziler, özellikle matrisler üzerinde hesaplamalar için bir operatör grubu,
    • Veri analizi için geniş, tutarlı, bütünleşik orta düzey araç koleksiyonu,
  • Veri analizi ve ekranda ya da basılı olarak gösterilmesi için grafiksel özellikler ve koşullu, döngü, kullanıcı tanımlı özyinelemeli fonksiyonlar, girdi ve çıktı olanakları

içeren iyi geliştirilmiş, basit ve etkili bir programlama dilidir.

Veri bilimi yolculuğunuza başlamak için aslinda R iyi bir seçim, çünkü veri bilimini desteklemek için sıfırdan tasarlanmıştır. R sadece bir programlama dili değil, aynı zamanda veri bilimi yapmak için etkileşimli bir ortamdır. Etkileşimi desteklemek için, R, akranlarının çoğundan çok daha esnek bir dildir. Bu esneklik olumsuzlukları ile birlikte gelir, ancak en olumlu yönü, veri bilimi sürecinin belirli bölümleri için uyarlanmış dil bilgileri geliştirmenin ne kadar kolay olduğudur. Bu mini diller, beyniniz ve bilgisayar arasındaki akıcı etkileşimi desteklerken, bir veri bilimcisi olarak sorunları düşünmenize yardımcı olur.

Kısaca R, veri işleme, hesaplama ve grafik görüntüleme için entegre bir yazılım dilidir. Etkin bir veri işleme ve depolama, diziler üzerinde hesaplamalar için bir operatör grubu, özellikle matrislerle veri analizi için büyük, tutarlı, bütünleşik bir ara araçlar koleksiyonu, veri analizi için grafiksel özellikler ve ekranda ya da ekran dışında görüntüleme olanağı içerir. Koşullu, döngüleri, kullanıcı tanımlı özyinelemeli işlevleri ve girdi ve çıktı olanaklarını içeren, iyi geliştirilmiş, basit ve etkili bir programlama dilidir.

R-ortamı

R ortami R ve Rstudio’ dan oluşur. Önce R ‘taban’(base’) olarak https://github.com/genomicsclass/windows#installing-r ‘den işletim sistemi üzerine kurulur. Kurulum adımları link’te detayli olarak bulunmaktadır. Daha sonra yine buradan Rtools ve Rstudio kuruluşları yapılır.

RStudio R kodu yazmak, çalıştırmak ve R ile analiz yapmaya yardımcı olmak için kullanılan Word, excel gibi bir yazılım programıdır.

R studio yükledikten sonra tıklandığında 3-4 panel içeren bir pencerede açılır. Her biri farklı bilgileri takip eder. Kaynak(Source) paneli R Scriptleri oluşturduğunuz ve düzenlediğiniz yerdir – yani kod koleksiyonunuz buradadır. Endişelenmeyin, R betikleri sadece .R uzantısına sahip metin dosyalarıdır. RStudio’yu açtığınızda, otomatik olarak yeni bir Adsız komut dosyası başlatır.

Konsol(Console) paneli ise R bilgisayar dilinde yazılmış komutları çalıştıracağınız yerdir, yani R’ın kalbidir.

Diğer panel ise Ortam/Geçmiş/Bağlantılar (Environment/History/Connections) sekmelerinden oluşur. Ortam sekmesi, geçerli R oturumunuzda tanımladığınız tüm veri nesnelerini (vektörler, matrisler ve veri çerçeveleri gibi) gösterir. R yorumlayıcısını ilk kez çalıştırdığımızda bir ortam yaratılır. Tanımladığımız her değişken artık bu ortamdadır. Veri nesnelerindeki gözlem sayısı ve satır sayısı gibi bilgileri de burada görebilirsiniz. Sekmede ayrıca, önemli veri için bir grafik kullanıcı arabirimi (GUI) açacak olan “Veriyi İçe Aktar”( “Import Dataset”) gibi birkaç tıklanabilir eylem vardır. Geçmiş (History) sekmesinde ise daha önce Konsolda yazmış olduğunuz tüm kodların geçmişini görebilirsiniz. Bağlantılar sekmesi ise veri kaynaklarına bağlanmak için kullanılır. “Yeni Bağlantı”(new connection) tıklanarak yeni veri kaynağına bağlantı kurulur.

Sonuncu panel ise Dosyalar/Grafikler/Paketler/Yardım (Files/Plots/Packages/Help) sekmelerinden olusur. Dosyalar sekmesi, sabit sürücünüzdeki dosya dizinine erişmenizi sağlar. “Dosyalar” sekmesinin güzel bir özelliği de, çalışma dizininizi ayarlamak için kullanabilmenizdir. Dizin seçip “Daha Fazla” (More) üzerinde tıklarsanız açılan küçük pencerede ”Çalışma Dizini Olarak Ayarla” (Set As Working Directory) seçerek bunu sağlayabilirsiniz. Grafikler sekmesinde ise kullanilan fonksiyonun bar grafiğini görebilirsiniz ve grafiği yayınlayabilir ya da disari görüntüsünü resim ve pdf olarak alabilirsiniz. Paketler sekmesinde sabit sürücünüzde yüklü tüm R paketlerinin bir listesini görebilir ve RStudio’da çalıştığınız anda yüklü olup olmadıklarına bakabilirsiniz. Yüklenmemiş olanlar işaretlenmemiş olarak gelir. Yardım sekmesi eğer daha önce F1 tuşuna basmadıysanız boş olarak gelecektir. Örneğin bir fonksiyon ile ilgi yardım almak istediğinizde, diyelim grafik çizmek için histogram fonksiyonu ile ilgili bilgi almak istiyorsunuz, Kaynak panelinde hist yazip F1 tuşuna basarsanız Yardım sekmesinde histogram fonksiyonu ile ilgili bilgiyi görebilirsiniz.

Panellerdeki sekmelere ekleme/çıkarma yapmak mümkün. Görünüm(View)/ Paneller(Panes)/ Panel Düzeni(Pane layout) seçilerek “Seçenekler”(options) penceresi açılır ve istenen değişiklikler burada yapılır.


Veri tipleri

R, skaler, vektörler (sayısal, karakter, mantıksal), matrisler, veri çerçeveleri ve listeler dahil olmak üzere çok çeşitli veri tiplerine sahiptir.

  • Skaler
  • Vektor
  • Matris
  • Dizi
  • Veri çerçeveleri
  • Liste
  • Faktor

Skaler

R’deki en basit nesne türü bir skalerdir. Bir skalar nesne, bir sayı veya bir isim gibi sadece tek bir değerdir. Skalerin illa sayısal olması gerekmez, karakter ve metin de olabilir.

Nümerik skaler örneği;

a <- 100
b <- 5 / 100
c <- (a + b) / b

Örneği denemek için RStudio’yu açın eğer önünüze Kaynak(Source) paneli boş geliyorsa ve panelin üst köşesinde “isimsiz” (untitled) görüyorsanız kullanmaya devam edebilirsiniz. Eğer daha önce açılıp kullanıldıysa Dosya(File) altındakı “+” üzerinde tıklayarak yeni bir R script dosyasi açınız. “Kaynak”(Source) paneline yukarıdaki üç satırı yazin ve bu üç satırı seçerek panelin sağ üst köşesindeki “Çalıştır” (Run) düğmesine tıklayın. Yazdığınız satırların Konsol(Console) paneline de aktarıldığını ve Ortam sekmesinde de skalerlerin aldıkları değerleri göreceksiniz.

Kaynak(Source) paneli dişinda bu satırları direk olarak Konsol paneline de yazabilirsiniz. Her satırı yazdıktan sonra enter tuşuna bastığınızda “Ortam”(Environment) panelinde skalerlerin aldıkları değerleri görebilirsiniz yine.

Karakter skaler örneği;

a <- ”kalem”
b <- ”yaz”
c <- ”kalemle yaz”

R, sayısal ve karakter skalerlerini farklı şekilde ele alır. Örneğin, sayısal skalerle ilgili temel aritmetik işlemleri yapabilirken karakter skaleri üzerinde çalışmazlar. Karakter skalerinde sayısal işlemler (ekleme gibi) yapmaya çalışırsanız hata mesajı alırsınız. Değişkenler de karakter dizgileri kullandığından, değişken adları ve karakter dizeleri arasında ayrım yapmak için tırnak işareti kullanırız.

a <- ”kalem”
b <- ”yaz”
c = a + b

Burada size “a + b de hata : ikili operatöre sayısal olmayan bağımsız değişken”(Error in a + b : non-numeric argument to binary operator) şeklinde hata donusu olacaktir.
Aşağıda RStudio’da bu işlemlerin yapılmasına bakabilirsiniz.

Burada sol üst tarafta Kaynak(Source) paneli, hemen altında Konsol(Console), sağ üst tarafta Ortam(Environment) paneli ve onun altında da su an klasörleri, grafikleri ve yardım sekmesini içeren paneli görüyorsunuz.

Kaynak(Source) panelinde ilk üç satırı yazmaya başlayalım ve sonra onları fare ile seçip paneldeki “Çalıştır”(Run) üzerinde tıklayalım. Saganaki Ortam(Environment) panelinde Ortam sekmesinde değişkenlere atadığımız değerleri göreceğiz. Altta “Konsol” panelinde ise “Çalıştır”(Run) ile komutların çalıştığını görüyoruz.

İkinci üçlü komutu Kaynak(Source) panelinde yazalım ve yine hepsini fare ile seçip “Çalıştır”(Run) üzerinde tıklayalım.

Aşağıda da göreceğiniz gibi a,b ve c nin değerleri değişti.

Üçüncü üçlü komutu da bunların altına Konsol panelinde yazalım ve yine bunları fare ile seçelim. “Çalıştır”(Run) tıkladığımızda hata mesajini Konsol(Console) da görelim. Böylece karakter skalerler ile dört işlemin yapılamayacağını gördük ve RStudio’yu biraz tanıdık.



Skalerle kullanabileceğimiz bazı fonksiyonlar;
1 ile 100 arasında bir tam sayı vektörü oluşturmak istediğinizi varsayalım. Kesinlikle tüm sayıları bir c () operatörüne yazmak zorunda değilsiniz. Neyse ki R, sayısal vektörler üretmek için birçok basit yerleşik fonksiyona sahiptir. Üç tanesi ile başlayalım: a: b, seq () ve rep ().

a:b fonksiyonu, argüman olarak a ve b olmak üzere iki sayısal skaler alır ve a’dan başlayarak b bitiş noktasına kadar 1’er arttırarak sayı vektörü döndürür.

a<- 1:10
b<- 10:1
c<- 2.5:6.5
a
b
c

Yazarak çalıştırdığımızda Konsol’da a, b ve c’nin aldığı değerleri, Ortam’da ise a ve b’nin tamsayı, c’nin ise sayısal olduğunu görebiliriz.

Seq () fonksiyonu, a:b’ nin daha esnek bir sürümüdür. seq () bir başlangıç numarasından bitiş numarasına doğru bir dizi oluşturmanıza izin verir. Ancak, seq (), sayılar arasındaki adımların boyutunu veya dizinin toplam uzunluğunu belirtmenize olanak tanıyan ek argümanlara sahiptir:

Seq () fonsiyonunun iki yeni argümanı vardır:
# 1 den 10 a kadar 1’er adımlı sayıları tanımlayalım
seq(from = 1, to = 10, by = 1)

[1] 1 2 3 4 5 6 7 8 9 10                                (**buradaki [1] aynı konsolda olduğu gibi işlemin sonucunu gösterir)
# 0’dan 100’e kadar 10’ar 10’ar tamsayılar
seq(from = 0, to = 100, by = 10)

[1] 0 10 20 30 40 50 60 70 80 90 100

Konsol’da da sonuçları görebilmek mümkün. Ortam panelinde bir değisiklik görmeyeceksiniz çünkü bu değerler bir değişkene atanmadı.
Eğer length.out argümanını kullanacak olursak, seq() fonksiyonu uzunluğu length.out’a eşit olacaktır.
# 1’den 5’e kadar 10 sayı elde etmek için
seq(from = 1, to = 5, length.out = 10)

[1] 1.0 1.4 1.9 2.3 2.8 3.2 3.7 4.1 4.6 5.0

# 0’dan 100’e kadar 3 sayı elde etmek için
seq(from = 0, to = 100, length.out = 3)

[1] 0 50 100

Konsol’da sonuçları görebilirsiniz. Dikkat ederseniz yine Ortam panelinde bir değişiklik olmadı.

Rep () fonksiyonu, skaleri (veya vektörü) belirtilen sayıda veya istenen uzunlukta tekrarlamanızı sağlar.

rep(x = 3, times = 10)

[1] 3 3 3 3 3 3 3 3 3 3

rep(x = c(1, 2), each = 3)

[1] 1 1 1 2 2 2

rep(x = 1:3, length.out = 10)

[1] 1 2 3 1 2 3 1 2 3 1

Konsol’da değerler yazılır, yine Ortam panelinde değişiklik yok dikkat ederseniz.
“Zaman”(times) ve “her bir”(each) argümanlarını da bu fonksiyonda kullanmak mümkün.

rep(x = 1:3, each = 2, times = 2)
rep(x=1:3, each = 3, times=2)

[1] 1 1 2 2 3 3 1 1 2 2 3 3
[1] 1 1 1 2 2 2 3 3 3 1 1 1 2 2 2 3 3 3
Sonuçları alınacaktır.

Vektör

Verileri depolamak için R’de mevcut olan en temel birim vektörlerdir. Karmaşık veri kümelerini genellikle bileşenlere vektörler olarak ayrılabiliriz. Bir vektör nesnesi, tek bir nesne olarak saklanan birkaç skalerin sadece birleşimidir. Örneğin, bir ile on arasındaki sayılar,10 uzunluğunda bir vektör olabilir ve İngiliz alfabesindeki karakterler ise 26 uzunluğunda bir vektör olarak tanımlanabilir. Skalerler gibi, vektörler, ya sayısal ya da karakter olabilir (fakat her ikisi de değil!).

R, adlandırılmış veri yapıları üzerinde çalışır, bu yapilarin en basiti sayısal vektörlerdir. R’da vektör tanımlamanın çeşitli yolları vardır. R’da vektör en kolay c() fonksiyonu ile tanımlanır. Buradaki “c” bağlamak anlamındadır. C () fonksiyonu argüman olarak birkaç skaler alır ve bu nesneleri içeren bir vektör döndürür.

1’den 7’ye kadar tam sayıları içeren bir vektör oluşturmak için c () fonksiyonunu kullanalım;

# 1’den 7’ye kadar tamsayılarla bir nesne a oluşturalım
a <- c(1, 2, 3, 4, 5, 6, 7)
# Vektörü a olarak isimlendirmiş olduk, şimdi sonucu yazdıralım
a

Bu arada satır başlarındaki “#” işareti o satırın komut satırı değil de açıklama ya da yorum satırı olduğunu belirtiyor.

Konsol’a bakarsak
[1] 1 2 3 4 5 6 7 şeklinde vektörün yazdırıldığını, ortam panelinde ise a vektörünün sayısal olduğunu ve 1 den 7’ye kadar rakamları içerdiğini görebiliriz.

Karakter skalerleri ile c () fonksiyonunu kullanarak karakter vektörleri oluşturabiliriz:

kar.vek <- c(“Tek”, “gözlükle”, “uzak”, “yakın”, “orta mesafeler”)
kar.vek

Konsol’da;
[1] “Tek” “gözlükle” “uzak” “yakın” “orta mesafeler” ve Ortam’da ise kar.vek’in 5 elemanlı karakter vektörü olduğu ve aldığı değerler görülebilir.

Bir de mantıksal vektörden – yani doğru veya yanlış – bahsedelim. Mantıksal bir vektörün öğeleri TRUE-DOĞRU, FALSE-YANLIŞ ve NA(kayıp değer, uygulanamaz ya da uygun değil anlamındadır) değerlerine sahip olabilir.
Her ne kadar T ve F kısaltmaları tanımlı olsada, bunlar TRUE ve FALSE atanmış ayrılmamış değişkenlerdir. Yani kullanıcı T ve F degiskenlerine istedigi atamayi yapabilir, bu sebeple karışıklığa sebep olmamak icin TRUE ya da FALSE olarak kullanmakta fayda var.

Mantıksal vektörler koşullarla üretilir. Örneğin;
sicaklik <- x > 18

x ile aynı uzunluktaki bir vektör olarak sıcaklık, koşul yerine getirilmediğinde FALSE-YANLIŞ ve koşul sağlandığında TRUE-DOĞRU değerini alır.

Mantıksal operatörler;
Operatör          Tanımı
<                    küçük
<=                  küçük veya eşit
>                    büyük
>=                  büyük veya eşitt
==                  tam olarak eşit
!=                   eşit değil
!x                   x değil
x | y               x veya y
x & y             x ve y
isTRUE(x)    x TRUE (yani Doğru) mu diye test et

Mantıksal vektörler TRUE-DOĞRU olma halinde 1 ve FALSE-YANLIŞ olma durumunda 0 olarak sayısal vektörlere zorlanarak sıradan aritmetik işlemlerde kullanılabilmektedir.

Diyelim ki Kasım ve Aralık aylarındaki uçuşları görmek istiyorsunuz, filtre kullanalım;

filter(ucuslar, ay== 11 | 12) şeklinde filtreyi kullandığınızda ay== 11 | 12 TRUE-DOĞRU değerini döndürecektir, bu da 1’e eşit olduğundan bu filtre fonksiyonu size Ocak ayına ait uçuşları getirecektir. Bu problemin kısa bir çözümü x %in% y (y’nin içindeki x’ler) kullanmaktır. Fonksiyonu buna göre tekrar yazarsak;

filter(ucuslar, ay %in% c(11, 12))

Bize 11 ve 12.ci aya ait uçuşları dönecektir.

Bazen De Morgan’ın kanunlarını akılda tutmak gerekir; !(x & y) ve !x | !y aynıdır, ve !(x | y) de !x & !y ile aynı sonucu verir.

Bir örnek daha yapalım;
x <- c(1:10)
x[(x>8) | (x<5)]

[1] 1 2 3 4 9 10

Bu sonuca nasıl ulaşılır adım adım görelim;
x <- c(1:10)
x
[1] 1 2 3 4 5 6 7 8 9 10

x > 8
[1] F F F F F F F F T T

x < 5
[1] T T T T F F F F F F

x > 8 | x < 5
[1] T T T T F F F F T T
x[c(T,T,T,T,F,F,F,F,T,T)]
[1] 1 2 3 4 9 10

Vektor aritmetiği

Yazılımcılar temel aritmetik işlemcilerinin çoğuna aşinadırlar. R’da bir istatistik platformu olduğundan tam bir aritmetik operatörler kümesine sahiptir,

Operatör              Tanımı                                                         Örnek
x + y                y x’e eklenmiş                                                   2 + 3 = 5
x – y                y x’ten çıkarılmış                                               8 – 2 = 6
x * y                 x y ile çarpılmış                                                 3 * 2 = 6
x / y                 x y’ye bölünmüş                                               10 / 5 = 2
x ^ y (\ x ** y)   x ‘in y kuvveti                                                    2 ^ 5 = 32
x %% y            x y’ye bölündüğünde kalan (x mod y)               7 %% 3 = 1
x %/% y           x y’ye bölünmüş ve yuvarlanmış                      7 %/% 3 = 2

sepet.Oya <- c(12,4,4,6,9,3)
sepet.Ayse <- c(5,3,2,2,12,9)

Oya ve Ayse Bir Dilek Vakfı için vakıf toplantısında para toplamaya karar verdiklerini ve yaptıkları her sepet için bağış toplamak istediklerini varsayalım. Bir senede bu vakıf 6 kez toplanır ve Oya sepet başına 120 TL, Ayse ise 145 TL ister. Her toplantı için topladıkları toplam bağışları nasıl hesaplarsınız? Toplantı başına sepet sayısı ile ücretini çarpıp, sonra hepsini toplayarak değil mi?

#Oya’nın toplantılarda topladığı
para.Oya <- sepet.Oya *120
#Ayse’nin toplantılarda topladığı
para.Ayse<- sepet.Ayse * 145
#Oya’nın topladığı toplam para
sum(para.Oya)
#Ayse’nin topladığı toplam para
sum(para.Ayse)

Şimdi bir de toplantı başına ne kadar toplanmış sorusunun cevabını verelim.

sepet.Oya <- c(12,4,4,6,9,3)
sepet.Ayse <- c(5,3,2,2,12,9)
#Oya’nın toplantılarda topladığı
para.Oya <- sepet.Oya *120
#Ayse’nin toplantılarda topladığı
para.Ayse<- sepet.Ayse * 145
Para.toplam <- para.Oya + para.Ayse

sepet.Oya* 120 + sepet.Ayse * 145 #böylece iki vektör ile de işlem yapmış olduk
[1] 2165 915 770 1010 2820 1665

R’ da operatörlerin sıralamasına bakacak olursak, yukarıdaki örnekte olduğu gibi toplama ve çarpma işlemi olduğunda R önce çarpma sonra toplama işlemini gerçekleştirir. Tüm aritmetik operatörlerin işlem sırası için klasik kurallar geçerlidir. Hesaplamalar aşağıdaki sırayla yapılır:

  1. Üslü işlemler
  2. Operatörlerin sunulduğu sıraya göre çarpma ve bölme
  3. Operatörlerin sunulduğu sıraya göre toplama ve çıkarma

Öncelikle parantez içindekiler yapılır. Mod operatörü (%%) ve tam sayı bölme operatörü (% /%), hesaplamalarda normal bölme operatörüyle aynı önceliğe sahiptir.

İşlemlerin sırasını aşağıdaki gibi parantez kullanarak değiştirebilirsiniz:
Parantez kullanmadan,
4 + 2 * 3
[1] 10
Parantez kullanarak,
(4 + 2)* 3
[1] 18

Bir vektör farklı veri türleri içeremez.

i <- 1:3                                     #1’ den 3’e kadar rakkam atadık
i #yazdıralım
[1] 1 2 3

i <- c(i,pi)                                   #Daha fazla öğe eklemek için tekrar atamanız gerekir, ör. c () kullanarak
i #yazdıralım
[1] 1.000000 2.000000 3.000000 3.141593

i <- c(i, “text”)                              #Bir vektör farklı veri türleri içeremez, bu yüzden …
i                                                  #yazdıralım R, tüm öğeleri aynı türe yani karaktere dönüştürür.

[1] “1” “2” “3” “3.14159265358979” “text”

Hepsi karakter türüne dönüştü.

Vektörlerle ilgili bazı fonksiyonlar

  • Özet istatistikler

Fonksiyon                    Örnek                                   Sonuç
sum(x), product(x)        sum(1:10)                                  55
min(x), max(x)              min(1:10)                                     1
mean(x), median(x)      mean(1:10)                               5.5
sd(x), var(x), range(x)   sd(1:10)                                  3.03
quantile(x, probs)         quantile(1:10, probs = .2)          2.8

ceket <- c(4, 50, 2, 39, 4, 20, 4, 8, 10, 100) #eldeki bedenlere gore ceket adetleri
min(ceket)                                                    #minimum kac adet var?
[1] 2

max(ceket)                                                   #maksimum kac adet var?
[1] 100

mean(ceket)                                                #ortalama ne?
[1] 24.1                                                       # 4+ 50+ 2+ 39+ 4+ 20+ 4+ 8+ 10+ 100=241  241/10=24.1

sd(ceket)                                                    #standard sapma ne?
[1] 29.71346

Sum(ceket)                                                # toplam ceket sayisi
[1] 241

Elle hesaplarsak standart sapma : [(4-24,1)2 + (50-24,1)2+(2-24,1)2 +(39-24,1)2 +(4-24,1)2 +(20-24,1)2 +(4-               24,1)2 + (8-24,1)2 + (10-24,1)2 + (100-24,1)2 ] / 10 = 882.89 ve bunun karekökü sqrt(882.89)= 29.71346

Quantile fonksiyonu, verilen olasılıklara karşılık gelen örnek miktarları üretir. En küçük gözlem 0’lık bir olasılığa             ve en büyük olasılıkla 1’e eşittir.

quantile(x, probs = seq(0, 1, 0.25), na.rm = FALSE, names = TRUE, type = 7, …)
Argümanlar
x ; Numune miktarları istenen sayısal bir vektör veya bir metodun tanımlandığı bir sınıfın nesnesi(aşağıda                     Detaylar’a bakın). Na.rm TRUE-DOĞRU olmadığı sürece NA ve NaN değerlerine sayısal vektörlerde izin                     verilmez.
probs ; [0,1] içinde bulunan değerlerin sayısal vektörü. (Bu aralığın dışındaki 2e-14’e kadar değerler kabul                     edilir ve yakındaki uç noktaya taşınır.)
na.rm ; mantıksal; TRUE ise, tüm NA ve NaN lar quantiles-nicelikler hesaplanmadan önce x’den kaldırılır.
names ; mantıksal; TRUE-DOĞRU ise, sonuç bir ad özelliğine sahiptir. Birçok probs ile hızlandırmak için                       FALSE olarak ayarlayın.
type ; aşağıda ayrıntıları verilen dokuz adet quantile algoritmadan birini kullanmak amacıyla seçmek için 1 ile 9             arasında bir tam sayıdır.
Detaylar;
Eğer names = TRUE ise length(probs) uzunluğunda bir vektör döndürülür, bir names özniteliği vardır.

probs’daki NA ve NaN değerleri, sonuçlara yayılır.

Varsayılan yöntem, elemanları sıralanmış ve toplanmış ve bir sayı ile çarpılmış nümerik vektorler gibi                           sınıflanmış nesneler üzerinde çalışır.

Qi(p)= (1−γ)xj + γxj + 1

1≤ i≤ 9, (j−m)/n ≤ p <(j−m+1)/n , xj j inci sıradaki istatistik, n örnek sayısı,
γ ise j = ⌊np+m⌋ ve g = np+m−j nin bir fonksiyonu, m ise numune quantile türü tarafından belirlenen bir sabittir.

Simdi türlerine(types) bakalım;

Quantile, probs cinsinden olasılıklardaki x cinsinden tedarik edilen elemanlardan bir veya iki mertebeden                      istatistiğe dayanan tahminleri döndürür. Hyndman ve Fan (1996) ‘da tartışılan, türüne göre seçilmiş dokuz                    quantile algoritmadan biri kullanılır. Tüm örnek quantiles ardışık sıra istatistiklerinin ağırlıklı ortalamaları olarak              tanımlanır.

Süreksiz örnek quantile türleri, tip 1, 2 ve 3:

Tip 1 : Ampirik dağılım fonksiyonunun tersi, eğer g=0 ise γ=0, ve aksi takdirde 1 dir.
Tip 2 : Tip 1’e benzer ama süreksizliklerde ortalama alır. Eğer g=0 ise γ=0.5, aksi takdirde 1 dir.

Tip 3 : SAS tanimi: en yakın çift sıra istatistiği. Eger g=0 ve j çift ise γ=0, değilse 1.

Sürekli örnek Quantile türleri 4’den 9’a
4’den 9’a kadar türlerde γ=g ve verilen m ile Qi(p) p’nin sürekli bir fonksiyonudur. Örnek quantile’ler, (pk,xk)                  (xk  k’inci sirali istatistik olmak uzere) noktalar arasındaki doğrusal ara değeri bulma-interpolasyon ile eşdeğer olarak elde edilebilir.

Tip 4 : m=0, pk=k/n. Bu, ampirik cdf’in lineer interpolasyonudur.

Tip 5 : m=½, pk=(k-0.5)/n Bu, düğümlerin ampirik cdf’nin adımlarının ortasındaki değerler olduğu parçalı doğrusal bir fonksiyondur. Bu hidrologlar arasında popülerdir

Tip 6 : m=p, pk=k/(n+1) olduğundan pk= E[F(xk)] bu Minitab ve SPSS tarafından kullanılmıştır.

Tip 7 : m=1-p, pk=(k-1)/(n-1) bu durumda, pk= mode[F(xk)] Bu S tarafından kullanılmıştır.

Tip 8 : m=(1+p)/3, pk= ((k-1)/3)/((n+1)/3) sonra pk≈median[F(xk)] Elde edilen quantile tahminler, x’in dağılımından bağımsız olarak yaklaşık olarak medyan-yansızdır.

Tip 9 : m=p/4 + 3/8, pk=(k-⅜) / (n+¼ ) Sonuçta ortaya çıkan quantile tahminleri, eğer x normal olarak dağıtılırsa, beklenen sıralama istatistikleri için yaklaşık olarak ön yargısızdır.

  • Sayma istatistikleri

Ayrık veya sayısal olmayan verilerle vektörler için ortak sayma fonksiyonlarından bahsedebiliriz. Ayrık veriler cinsiyet, meslek gibi sadece sonlu (veya en azından makul sonlu) yanıt kümelerine izin veren verilerdir. Bu vektörlerin her biri bir argüman olarak bir vektör alır – ancak, baktığımız önceki fonksiyonlardan farklı olarak, bu fonksiyonların argümanları ya sayısal ya da karakter olabilir.

Fonksiyon               Açıklama                                    Örnek                                                          Sonuç
unique(x)                Tüm benzersiz değerlerin
bir vektörünü
döndürür                                     unique(c(1, 1, 2, 10))                                   1, 2, 10
table(x, exclude)    Tüm benzersiz değerleri ve  her bir olayın
sayısını gösteren bir tablo döndürür. NA değerlerini dahil etmek için,
exclude = NULL argümanı ekle
table(c(“a”, “a”, “b”, “c”))                               2-“a”, 1-“b”, 1-“c”
İki ayrı ayrık veri vektöründen başlayarak bu fonksiyonları test edelim:
vec <- c(1, 1, 1, 5, 1, 1, 10, 10, 10)
gender <- c(“M”, “M”, “F”, “F”, “F”, “M”, “F”, “M”, “F”)

Unique (x) fonksiyonu, vektördeki tüm benzersiz değerleri size söyler, ancak her değerin ne sıklıkta meydana geldiğiyle ilgili hiçbir bilgi vermez.

unique(vec)
[1] 1 5 10

unique(gender)
[1] “M” “F”

Table () fonksiyonu,unique () ile aynı şeyi yapar, ancak benzersiz değerlerin her birinin ne sıklıkta gerçekleştiğini de size bildirerek bir adım daha ileriye gider:

table(vec)
vec
1 5 10
5 1 3

vec vektöründe 1, 5, ve 10 benzersiz ve 1 5 kez, 5 1 kez ve 10 3 kez bu vektörde yer alıyor.

table(gender)
gender
F M
5 4

gender vektöründe ise F ve M benzersiz, F 5 kez ve M 4 kez bu vektörde yer alıyor.
Sayım yerine yüzdelik bir sonuç almak istiyorsanız, table () fonksiyonunu toplam fonksiyonuna bölebilirsiniz:
table(vec) / sum(table(vec))
vec
1 5 10
0.5555556 0.1111111 0.3333333

table(gender) / sum(table(gender))
gender
F M
0.5555556 0.4444444

  • Standardizasyon

İstatistikte yaygın yapılan, z-skorlarını hesaplama olarak da bilinen değişkenleri standartlaştırmaktır. Bir vektörün standartlaştırılmasının amacı, onu diğer (standartlaştırılmış) değişkenlerle karşılaştırmanıza olanak tanıyan ortak bir ölçeğe koymaktır. Bir vektörü standartlaştırmak için, vektörü ortalamasından çıkarırsınız ve sonra sonucu, vektörün standart sapmasına göre bölersiniz.

Eğer z-skorları sizin için yeni ise, endişelenmeyin. Bir sonraki örnekte, iki veri kümesini karşılaştırmanıza nasıl yardımcı olabileceğini göreceksiniz. Ancak şimdilik, bir vektörü basit aritmetik kullanarak standartlaştırmanın ne kadar kolay olduğunu görelim.

Bazı verileri içeren bir vektörün olduğunu varsayalım. Vektörü, adlandırılan yeni bir nesneye atayacağız ve ardından ortalama mean () ve sapma sd () fonksiyonlarıyla ortalama ve standart sapmayı hesaplayacağız:

a <- c(5, 3, 7, 5, 5, 3, 4)
mean(a)
[1] 4.6
sd(a)
[1] 1.4

Şimdi, a’nın standart hale getirilmiş bir sürümü olan a.z adlı yeni bir vektör oluşturacağız. Bunu yapmak için, basitçe vektörün ortalamasını çıkarır, sonra standart sapmaya böleriz.

a.z <- (a – mean(a)) / sd(a)

Standartlaşmış değerlere bakarsak;
a.z
[1] 0.31 -1.12 1.74 0.31 0.31 -1.12 -0.41

A.z’nin ortalaması şimdi 0 ve a.z’nin standart sapması 1 olmalıdır. Emin olalım:

mean(a.z)
[1] 2e-16
sd(a.z)
[1] 1

a.z’nin ortalamasının sıfır gibi görünmediğinden endişe etmeyin. Bilimsel olmayan gösterimi kullanarak, sonuç 0.000000000000000198’dir. Sonuç tam olarak 0 değil, bilgisayar hesaplamalarından kaynaklanmaktadır.

Bir başka örnek yapalım;
Glütene alerjisi olan ekip arkadaşınız bir trajik soya sosu vakasında az önce öldü ve ekibinizin bir üyesini yeni boşalan pozisyona atama zamanı geldi. Tabii ki, bir korsan için sadece iki nitelik gerçekten önemlidir: halat tırmanışı ve şarkı söylemesi. Bu nedenle, hangi mürettebatınızın promosyonu hak ettiğini görmek için, bir tırmanma ve şarkı yarışması yapmaya karar verdiniz. Tırmanış yarışmasında, bir korsanın kaç m ipi bir saat içinde tırmanabileceğini ölçüyorsunuz, şarkı yarışmasında ise kimin kac şarkıyı arka arkaya söyleyebileceğini ölçüyorsunuz. Yarışma için beş korsanın gönüllü – ve sonuçları:

Korsan                    şarkı                                   tırmanma
Heidi                        12                                         100
Andrew                      8                                         520
Becki                         1                                          430
Madisen                    6                                          200
David                        2                                          700

Ana sonuçları iki vektörde sarki ve tırmanma ile temsil edebiliriz:

sarki <- c(12, 8, 1, 6, 2)
tirmanma <- c(100, 520, 430, 200, 700)

Artık verileri aldınız, ancak bir sorun var: sayıların ölçekleri çok farklı. sarki numaraları 1 ila 12 arasındayken, tirmanma sayıları 100 ile 700 arasında çok daha geniş bir aralığa sahip. Bu, iki sayı kümesinin doğrudan karşılaştırılmasını zorlaştırır.

Bu sorunu çözmek için standartlaştırmayı kullanacağız. sarki.z ve tirmanma.z adlı yeni standartlaştırılmış vektörler oluşturalım.

sarki.z <- (sarki – mean(sarki)) / sd(sarki)
tirmanma.z <- (tirmanma – mean(tirmanma)) / sd(tirmanma)

Şimdi son sonuçlara bakalım

sarki.z
[1] 1.379 0.489 -1.068 0.044 -0.845
tirmanma.z
[1] -1.20 0.54 0.17 -0.78 1.28

Özellikle iki olağanüstü performans var gibi görünüyor, şarkı söyleme yarışmasında, ilk korsan (Heidi), z-skoru 1.4. Bunu, Heidi’nin ortalama korsandan 1.4 standart sapma kadar daha fazla şarkı söylediğini söyleyerek yorumlayabiliriz. Tırmanış yarışmasında ilk, beşinci korsan (David), 1.3’lik bir z-skoruna sahip. Burada David’in ortalama korsandan 1.3 standart sapmaya daha fazla çıktığı sonucuna varabiliriz.

Fakat her iki olayda da en iyi korsan hangisi? Bunu yanıtlamak için, her korsan için, iki etkinlik boyunca ortalama z puanlarını hesaplayan birleşik bir z-skoru oluşturalım. Bunu iki performans ekleyerek ve ikiye bölerek yapacağız. Bu bize, her korsanın ortalama olarak ne kadar iyi olduğunu söyleyecektir.

average.z <- (sarki.z + (tirmanma.z)) / 2

Sonuçlara bakalım:

round(average.z, 1)
[1] 0.1 0.5 -0.5 -0.4 0.2

En yüksek ortalama z-skoru, 0,5 olan ikinci korsana (Andrew) aittir. Bir olayda başarılı olan ilk korsanlar, diğer olayda zayıf gibi görünüyorlar.

Kıssadan hisse, şarkı söyleyip tırmanabilen korsanı atayın, yani Andrew bu durumda atanmalı.

Burada kullandığımız round() yuvarlama fonksiyonu hakkında da birkaç şey söyleyelim.
R, virgülden sonra 16 haneye kadar doğru bir şekilde hesaplama yapabilir, çoğu zaman 16 hanenin hepsini birden kullanmak istemeyiz. Bu durumda, R’ye yuvarlama fonksiyonunu kullanabilirsiniz. Burada verilen; round(average.z, 1) örneğinde virgülden sonra 1 hane kullanılmış.

İndeksleme vektörleri

tekne.ismi      tekne.rengi           tekne.yaşı     tekne.fiyatı         tekne.maliyeti
a                    siyah                    143                   53                         52
b                    yeşil                       53                   87                         80
c                    pembe                 356                   54                         20
d                    mavi                      23                   66                       100
e                    mavi                    647                 264                       189
f                     yeşil                      24                   32                          12
g                    yeşil                    532                 532                        520
h                    sarı                       43                   58                          68
i                     siyah                     66                   99                          80
j                     siyah                    86                  132                        100

Artık, vektörlere mean () ve table () gibi fonksiyonları rahatlıkla uyguluyor olmalısınız. Bununla birlikte, birçok analizde, bir vektörün istatistiklerini hesaplamayı istemeyeceksiniz. Bunun yerine, muhtemelen bazı ölçütlere göre bir vektörün belirli alt değerlerine erişmek isteyeceksiniz. Örneğin, vektörde belirli bir konumdaki değerlere (yani, ilk 10 öğe) veya bu vektör içindeki bazı ölçütlere (yani, 0’dan büyük tüm değerler) veya bir ölçekteki değerlere dayanarak erişmek isteyebilirsiniz, örneğin; cinsiyeti Kadın olanlarin tüm yaş değerleri gibi. R’deki bir vektörün belirli değerlerine erişmek için, [] ile parantez kullanarak indeksleme kullanıyoruz. Genel olarak, parantezin içine ne koyduysanız, R’ye, istediğiniz vektör nesnesinin hangi değerlerini istediğinizi belirtir. Bir vektördeki veri alt kümelerine erişmek için indekslemeyi kullanmanın iki ana yolu vardır: sayısal ve mantıksal indeksleme.

Yukarıdaki tabloyu kullanarak örnekler yapalım.

# Tekne satışı. veri vektörlerini hazırlayalım
tekne.ismi <- c(“a”, “b”, “c”, “d”, “e”, “f”, “g”, “h”, “i”, “j”)
tekne.rengi <- c(“siyah”, “yesil”, “pembe”, “mavi”, “mavi”, “yesil”, “yesil”, “sari”, “siyah”, “siyah”)
tekne.yasi <- c(143, 53, 356, 23, 647, 24, 532, 43, 66, 86)
tekne.fiyati <- c(53, 87, 54, 66, 264, 32, 532, 58, 99, 132)
tekne.maliyeti <- c(52, 80, 20, 100, 189, 12, 520, 68, 80, 100)

# ilk teknenin fiyati neydi?
tekne.fiyati[1]
[1] 53

# Ilk 5 teknenin yaşları neydi?
tekne.yasi[1:5]
[1] 143 53 356 23 647

# Siyah teknelerin isimleri neydi?
tekne.ismi[tekne.rengi == “siyah”]
[1] “a” “i” “j”

# Yeşil ya da sarı teknelerin fiyatlari neydi?
tekne.fiyati[tekne.rengi == “yesil” | tekne.rengi == “sari”]
[1] 87 32 532 58

# “j” teknesinin fiyatini 100 olarak değiştir
tekne.fiyati[tekne.ismi == “j”] <- 100

# Yaşı 100 seneden az olan siyah teknelerin fiyat ortalaması nedir?
median(tekne.fiyati[tekne.rengi == “siyah” & tekne.yasi < 100])
[1] 99.5

# Kac tane pembe tekne var?
sum(tekne.rengi == “pembe”)
[1] 1

# yasi 100 seneden az olan teknelerin yüzdesi nedir?
mean(tekne.yasi < 100)
[1] 0.6

Sayısal indeksleme
Sayısal indeksleme ile, vektörde erişmek istediğiniz vektöre karşılık gelen bir tamsayıyı a[index] formunda girersiniz, burada a bir vektor ve index, indeks değerlerinin bir vektörüdür.

Yukarıdaki tablomuzla devam edecek olursak;
# ilk teknenin ismi ne?
tekne.ismi[1]
[1] “a”

# ilk bes teknenin renkleri neler?
tekne.rengi[1:5]
[1] “siyah” “yesil” “pembe” “mavi” “mavi”

# her ikinci teknenin yasi ne?
tekne.yasi[seq(1, 5, by = 2)]
## [1] 143 356 647

Tamsayı içerdiği sürece herhangi bir indeksleme vektörünü kullanabilirsiniz. Aynı öğelere birden çok kez bile erişebilirsiniz:

# ilk teknesin yasi kac? (3 kere)
tekne.yasi[c(1, 1, 1)]
[1] 143 143 143

Kodunuzu daha açık hale getirirse, gerçek dizinlemenizi yapmadan önce bir indeksleme nesnesi tanımlayabilirsiniz. Örneğin, my.index adında bir nesne tanımlayalım ve veri vektörünü dizine eklemek için bu nesneyi kullanalım:

my.index <- 3:5
tekne.ismi[my.index]
[1] “c” “d” “e”

Mantıksal indeksleme
Vektörleri indekslemenin ikinci yolu, mantıksal vektörlerdir. Mantıksal bir vektör, yalnızca DOĞRU ve YANLIŞ değerleri içeren bir vektördür. R’de, doğru değerler TRUE, yanlış değerler FALSE ile gösterilir. Bir vektörü mantıksal bir vektörle indekslediğinizde, R, indeksleme vektörünün TRUE olduğu vektörün değerlerini döndürür. Bu kafa karıştırıcıysa, şu şekilde düşünün: parantez [] ile birleştirilmiş mantıksal bir vektör, indekslediği vektör için bir filtre görevi görür. Sadece vektörün değerlerini, mantıksal vektörün doğru olduğu için TRUE geçmesine izin verir.
Mantıksal bir vektördeki FALSE-YANLIŞ değerler birçok mini-Gandolf’a benzer. Bu örnekte, x vektörünü bir mantıksal vektör y ile indeksliyorum (örneğin, x> 0 olabilir, bu yüzden x’in tüm pozitif değerleri TRUE, tüm negatif değerleri FALSE). Sonuç, mantıksal vektör y’nin doğru olduğu x’in değerleri olan 2 uzunluğunda bir vektördür. Gandolf, y için YANLIŞ olan tüm x değerlerini durdurdu.

Doğrudan c () kullanarak mantıksal vektörler oluşturabilirsiniz. Örneğin, aşağıdaki vektörün diğer tüm değerlerine aşağıdaki gibi erişebilirim:

a <- c(1, 2, 3, 4, 5)
a[c(TRUE, FALSE, TRUE, FALSE, TRUE)]
[1] 1 3 5

Gördüğünüz gibi, R, mantıksal vektörün TRUE olduğu bir vektörün tüm değerlerini döndürdü.

Ancak, c () kullanarak mantıksal vektörler oluşturmak zahmetlidir. Bunun yerine, <(daha küçük), == (eşittir) ve! = (Eşit değil) gibi karşılaştırma operatörlerini kullanarak mevcut vektörlerden mantıksal vektörler oluşturmak daha iyidir. En yaygın karşılaştırma operatörlerinin tam listesi:

Mantıksal bir vektördeki FALSE-YANLIŞ değerler birçok mini-Gandolf’a benzer. Bu örnekte, x vektörünü bir mantıksal vektör y ile indeksliyorum (örneğin, x> 0 olabilir, bu yüzden x’in tüm pozitif değerleri TRUE, tüm negatif değerleri FALSE). Sonuç, mantıksal vektör y’nin doğru olduğu x’in değerleri olan 2 uzunluğunda bir vektördür. Gandolf, y için YANLIŞ olan tüm x değerlerini durdurdu.

Doğrudan c () kullanarak mantıksal vektörler oluşturabilirsiniz. Örneğin, aşağıdaki vektörün diğer tüm değerlerine aşağıdaki gibi erişebilirim:

a <- c(1, 2, 3, 4, 5)
a[c(TRUE, FALSE, TRUE, FALSE, TRUE)]
[1] 1 3 5

Gördüğünüz gibi, R, mantıksal vektörün TRUE olduğu bir vektörün tüm değerlerini döndürdü.

Ancak, c () kullanarak mantıksal vektörler oluşturmak zahmetlidir. Bunun yerine, <(daha küçük), == (eşittir) ve! = (Eşit değil) gibi karşılaştırma operatörlerini kullanarak mevcut vektörlerden mantıksal vektörler oluşturmak daha iyidir. En yaygın karşılaştırma operatörlerinin tam listesi:

Örneğin, tekne.yasi vektörümüzden bazı mantıksal vektörler oluşturalım:

# hangi yaşlar > 100?
tekne.yasi > 100
[1] TRUE FALSE TRUE FALSE TRUE FALSE TRUE FALSE FALSE FALSE

#hangi yaşlar 23’e eşit?
tekne.yasi == 23
[1] FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE

# hangi tekne isimleri c’ye eşit?
tekne.yasi == “c”
[1] FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

TRUE dönen cevaplar doğru.

Bir vektörü aynı uzunluktaki başka bir vektörle karşılaştırarak da mantıksal vektörler oluşturabilirsiniz. Bunu yaptığınızda, R değerleri aynı pozisyonda karşılaştırır (örneğin; ilk değerler karşılaştırılır, ardından ikinci değerler vb.). Örneğin, hangi teknelerin maliyetlerinden daha yüksek fiyata satıldığını görmek için tekne.maliyeti ve tekne.fiyati vektörlerini karşılaştırabiliriz:

# Hangi teknelerin fiyati maliyetinden yüksek?
tekne.fiyati > tekne.maliyeti
[1] TRUE TRUE TRUE FALSE TRUE TRUE TRUE FALSE TRUE TRUE

# hangi teknelerin fiyati maliyetinden düşük?
tekne.fiyati < tekne.maliyeti
[1] FALSE FALSE FALSE TRUE FALSE FALSE FALSE TRUE FALSE FALSE

Karşılaştırma operatörü kullanarak bir mantıksal vektör oluşturduktan sonra, aynı uzunlukta herhangi bir vektörü indekslemek için kullanabilirsiniz. Burada, yaşları 100’den büyük olan teknelerin fiyatlarını almak için mantıksal vektörler kullanacağım:

# Yaşları 100’den büyük teknelerin fiyati ne?
tekne.fiyati[tekne.yasi > 100]
[1] 53 54 264 532

Mantıksal indekslemenin adım adım nasıl çalıştığını aşağıda bulabilirsiniz:

# hangilerinin yaşı 100’den büyük?
tekne.yasi > 100
[1] TRUE FALSE TRUE FALSE TRUE FALSE TRUE FALSE FALSE FALSE

# Mantıksal dizini elle yazmak (bunu asla yapmazsınız!)
# Mantıksal vektörün TRUE-DOĞRU olduğu tüm tekne fiyatlarını göster:
tekne.fiyati[c(TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE)]
[1] 53 54 264 532

# Hepsini tek adımda yaparak! Ayni cevabi bulursunuz:
tekne.fiyati[tekne.yasi > 100]
[1] 53 54 264 532

Mantıksal indekslemede mantıksal operatörler, & (and), | (or), %in%

Tek karşılaştırma operatörlerini kullanmanın yanı sıra, birden fazla mantıksal vektörü OR ya da AND ( OR | seklinde de görülür ve AND ise & seklinde de görülebilir) kullanarak birleştirebiliriz. OR | mantıksal vektörlerden herhangi biri TRUE ise işlem TRUE değerini döndürür, AND & sadece mantıksal vektörlerdeki tüm değerler TRUE ise TRUE döndürür. Bu, özellikle birden fazla vektörün ölçütlerine dayanan mantıksal bir vektör oluşturmak istediğinizde önemlidir.
Örneğin, hangi teknelerin 200’den yüksek VEYA 100’den düşük fiyatı olduğunu belirten bir mantıksal vektör oluşturalım ve sonra bu teknelerin adlarının ne olduğunu görmek için bu vektörü kullanalım:

# hangi teknelerin fiyatlari 200’den büyük VEYA 100’den küçük?
tekne.fiyati > 200 | boat.prices < 100
[1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE FALSE

# Bu teknelerin isimleri ne?
tekne.ismi[tekne.fiyati > 200 | boat.prices < 100]
[1] “a” “b” “c” “d” “e” “f” “g” “h” “i”

İstediğiniz kadar mantıksal vektörü bir araya getirebilirsiniz (hepsi aynı uzunlukta olduğu sürece!):

# tekne isimleri siyah renk ile fiyati 100’den büyük olanlar
Tekne.ismi[tekne.rengi == “black” | tekne.fiyati > 100]
[1] “a” “e” “g” “i” “j”

# mavi tekne isimleriyle fiyati 200’den büyük olanlar
tekne.ismi[tekne.rengi == “mavi” & tekne.fiyati > 200]
[1] “e”

Giderek daha karmaşık seçim kriterleri oluşturmak için istediğiniz kadar mantıksal vektörü birleştirebilirsiniz. Örneğin, aşağıdaki mantıksal vektör, tekne renklerinin siyah OR-VEYA kahverengi olduğu durumlarda OR-VEYA fiyatın 100’den az olduğu durumlarda TRUE döndürür.

# hangi tekneler siyah veya kahverengi VE fiyati 100’den az?
(tekne.rengi == “siyah” | tekne.rengi == “kahverengi”) & tekne.fiyati < 100
[1] TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE

# bu teknelerin isimleri ne?
tekne.ismi[(tekne.rengi == “siyah” | tekne.rengi == “kahverengi”) & tekne.fiyati < 100]
[1] “a” “i”

Birden çok ölçüt kullanırken, parantezleri doğru kullandığınızdan emin olun. Yukarıdaki parantezleri kullanmasaydım, farklı bir cevap alırdım.

%in% işlemi kolayca çoklu OR argümanları oluşturmanıza yardımcı olur. Birçok farklı değeri alabilen bir kategorik veri vektörünüz olduğunu hayal edin. Örneğin, insanların favori mektuplarını gösteren bir x vektörünüz olabilir.

x <- c(“a”, “t”, “a”, “b”, “z”)

Şimdi, hangi değerlerin a veya b veya c veya d olduğunu belirten bir mantıksal vektör oluşturmak istediğinizi varsayalım. Bu mantıksal vektörü çoklu | (OR-VEYA) komutları:

x == “a” | x == “b” | x == “c” | x == “d”
[1] TRUE FALSE TRUE TRUE FALSE

Ancak, bunu yazmak uzun zaman alıyor. Neyse ki, %n% işlemi, birden çok OR karşılaştırmasını çok daha hızlı bir şekilde birleştirmeye izin veriyor. %n% operatörünü kullanmak için, yalnızca orijinal vektörle olası değerlerin yeni bir vektörünün arasına yerleştirin. %n% fonksiyonu x vektöründeki her değerden geçer ve olası değerlerin vektöründe bulursa TRUE değerini döndürür – aksi takdirde FALSE döndürür.

x %in% c(“a”, “b”, “c”, “d”)
[1] TRUE FALSE TRUE TRUE FALSE

Mantıksal vektörlerden sayılar ve yüzdeler

Pek çok (tümü değilse bile) R fonksiyonları, TRUE değerlerini 1 ve FALSE değerini 0 olarak yorumlar. Bu, “Bir veri vektöründeki kaç değer 0’dan büyük?” veya “Toplam () veya mean () işlevini mantıksal bir vektöre uyguladığımızda hangi değerlerin yüzdesi 5’e eşittir?” sorularını kolay cevaplamanızı sağlar.

Pozitif 2 ve negatif 7 içeren x uzunluğunda bir 10 vektörüyle başlayalım.

x <- c(1, 2, 3, -7, -7, -7, -7, -7)

Hangi değerlerin 0’dan büyük olduğunu görmek için mantıksal bir vektör oluşturabiliriz:

x > 0
[1] TRUE TRUE TRUE FALSE FALSE FALSE FALSE FALSE

Şimdi, x’deki değerlerin kaçının pozitif olduğunu ve yüzdesini görmek için bu mantıksal vektörde sum () ve mean () yöntemini kullanacağız.

sum(x > 0)
[1] 3

mean(x>0)
[1] 0.375

Bu gerçekten güçlü bir araç, “Y’nin içinde kaç tane X’den olduğu” veya “X’in yüzde kaçının Y’de olduğu” gibi soruları yanıtlamak istediğinizde, argüman olarak mantıksal bir vektörle sum () veya mean () işlevini kullanırsınız.

Ek Mantıksal fonksiyonlar

R, vektörleri argüman olarak alan ve mantıksal vektörleri çoklu ölçütlere göre döndüren birçok özel fonksiyona sahiptir. Örneğin, bir vektörün hangi değerlerinin eksik olduğunu test etmek için is.na () işlevini kullanabilirsiniz. Tablo 7.1, sıklıkla kullanılan bazı fonksiyonları içermektedir:

Fonksiyon      Tanımı                                          Örnek                                            Sonuç
is.na(x)         x’in içinde hangi değerler NA?       is.na(c(2, NA, 5))                          FALSE,  TRUE, FALSE
is.finite(x)      x’in içinde hangi değerler sayi?     is.finite(c(NA, 89, 0))                    FALSE, TRUE, TRUE
duplicated(x) x’in içinde hangi değerler tekrar?  duplicated(c(1, 4, 1, 2))                FALSE, FALSE, TRUE, FALSE
which(x)        x’in içinde hangi değerler TRUE?  which(c(TRUE, FALSE, TRUE))  1, 3

Mantıksal vektörler sadece indeksleme için değil, bir vektördeki hangi değerlerin bazı kriterleri karşıladığını bulmak için de kullanabilirsiniz. Bunu yapmak için, which () fonksiyonunu kullanın. Which () fonksiyonunu mantıksal bir vektöre uygularsanız, R size indeksin hangi değerlerinin TRUE olduğunu söyleyecektir. Örneğin:

# cinsiyet bilgisini içeren bir vektör
sex <- c(“e”, “e”, “k”, “e”, “k”, “k”)

# hangi cinsiyet değerleri e?
which(sex == “e”)
[1] 1 2 4

# hangi cinsiyet değerleri k?
which(sex == “k”)
[1] 3 5 6

Geçersiz yanıtları düzeltme

Atama ve indeksleme, özellikle bir analiz yapmadan önce vektördeki geçersiz değerleri kaldırmak istediğinizde yararlı bir araçtır. Örneğin, 10 kişiye 1’den 5’e kadar ne kadar mutlu olduklarını sorduğunuzu ve şu yanıtları aldığınızı varsayalım:

mutlu <- c(1, 4, 2, 999, 2, 3, -2, 3, 2, 999)

Gördüğünüz gibi, bu vektörde bazı geçersiz değerlere (999 ve -2 gibi) sahibiz. Bunları kaldırmak için geçersiz değerleri (999 ve -2) NA olarak değiştirmek için mantıksal endeksleme kullanacağız. % in % kullanıldığında, hangi değerlerin mutluluğunun geçersiz olduğunu belirten bir mantıksal vektör oluşturacağız. Hangi değerlerin geçersiz olduğunu görmek istediğimiz için, == FALSE koşulunu ekleyeceğiz (yoksa, dizin bize hangi değerlerin geçerli olduğunu söyleyecektir).

# Mutluluğun hangi değerleri 1:5 setinin içinde değildir?
gecersiz <- (mutlu %in% 1:5) == FALSE
gecersiz
[1] FALSE FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE TRUE

Şimdi bize hangi değerlerin geçersiz olduğunu söyleyen mantıksal bir gecersiz indeksimiz var (yani, 1 ile 5 arasındaki setlerde olmayan), gecersiz ile mutlu’yu indeksleyeceğiz ve geçersiz değerleri NA olarak atayacağız:

# mutlu’daki geçersiz değerleri NA olarak ata
mutlu[gecersiz] <- NA
mutlu
[1] 1 4 2 NA 2 3 NA 3 2 NA

Aynı işlemi daha kısa olarak aşağıdaki gibi tek satırlık kod ile gerçekleştirebiliriz.

# mutlu’da 1’den 5’e kadar tamsayı olmayan tüm değerlerini NA olarak ata
mutlu[(mutlu %in% 1:5) == FALSE] <- NA

Gördüğünüz gibi, mutlu’da şimdi daha önce geçersiz olan değerler için NA var. Şimdi vektörün bir ortalamasını mean() alabilir ve geçerli yanıtların ortalamasını görebiliriz.

# NA değerlerini kaale almamak için na.rm = TRUE ekliyoruz
mean(mutlu, na.rm = TRUE)
[1] 2.428571

Matrix

Matrix, R’de satırlar ve sütunlar olarak iki boyut niteliğine sahip bir veri türü ve veri depolamanın çok yaygın bir yoludur. Matrisler basitçe boyut-dim özniteliği olan vektörlerdir ve isteğe bağlı olarak vektöre vektör isimleri-dimname’ler eklenebilir. Aynı sınıf tipi elemanlara sahiptir, yani bir matristeki tüm sütunlar aynı tarzda (sayısal, karakter vb.) ve aynı uzunlukta olmalıdır. R, birinci sütundan başlayarak sütunlara verilerin girilmesini ister.

Genel format:

matrisim <- matrix(vektor, nrow=r, ncol=c, byrow=FALSE,
dimnames=list(kar_vektor_siraisimleri, kar_vektor_kolonisimleri))

byrow = TRUE, matrisin satırlarla doldurulması gerektiğini belirtir. byrow = FALSE, matrisin sütunlarla doldurulması gerektiğini belirtir (varsayılandır). Dimnames ise sütunlar ve satırlar için isteğe bağlı etiketler verilmesini sağlar.

Kısaca matrix oluşturma örneği verelim:

m1 <- 1:4                 # m1, bir eleman dizisini içeren bir vektör nesnesi
dim(m1) <- c(2, 2) # bir matris yapmak için boyutunu 2X2 (2 satır, 2 sütun) olarak tanımlayın
m1                            # matrix’i yazdır

[,1] [,2]
[1,] 1    3
[2,] 2    4

Bir başka örnek:

A = matrix(
c(2, 4, 3, 1, 5, 7),    # veri elemanları
nrow=2,                 # satir sayısı
ncol=3,                   # kolon sayısı
byrow = TRUE)     # matrix’i satırlarla doldur

A                             #matrix’i yazdır

[,1] [,2] [,3]
[1,] 2    4     3
[2,] 1    5     7

Bir başka örnek:

mmat = matrix(1:12,ncol=3)
mmat #matrix’i yazdır

[,1] [,2] [,3]
[1,] 1     5     9
[2,] 2     6    10
[3,] 3     7    11
[4,] 4     8    12

Sütunlar yerine satırlara göre bir matris oluşturmak için, byrow = TRUE argümanı kullanılabilir:
mmat = matrix(1:12,ncol=3,byrow=TRUE)
mmat #matrix’i yazdır

[,1] [,2] [,3]
[1,] 1     2     3
[2,] 4     5     6
[3,] 7     8     9
[4,] 10   11   12

Verilerin bir dosyadan okunması gerekiyorsa, scan ile çağrılıp matris içine basitçe ekleyebilirsiniz.

matrix.dat dosyası aşağıdaki verileri içersin:
7 12 19 4
18 7 12 3
9 5 8 42

Aşağıdaki komutla bu veri dosyasından verileri alabiliriz.
mmat= matrix(scan(‘matrix.dat’),nrow=3,byrow=TRUE)
mmat #matrix’i yazdır

Bir matrisin tek bir öğesine erişmek için, ilgilendiğimiz hem satırı hem de sütunu belirtmemiz gerekir.

A = matrix( c(2, 4, 3, 1, 5, 7), nrow=2, ncol=3, byrow = TRUE)

A[2, 3]                           # 2ci sıra 3cü sütundaki eleman

[1] 7

m’inci sıranın tamamı A [m] olarak elde edilebilir.

A[2, ]                             # 2ci sıra
[1] 1 5 7

Benzer şekilde, n.ci sütununun tamamı A [, n] olarak elde edilebilir.

A[ ,3]                              # 3.cü sütun
[1] 3 7
Aynı anda birden fazla satır veya sütun da alabiliriz.
A[ ,c(1,3)]                      # 1.ci ve 3.cü sütun
[,1] [,2]
[1,] 2    3
[2,] 1    7

nrow(A)                         # matristeki satır sayısını verir
[1] 2

ncol(A)                           # matristeki sütun sayısını verir
[1] 3

dim(A)
[1] 2 3

Matrisin satır ve sütunlarına isimler atadıysak, elemanlara isimleri kullanarak erişebiliriz.

dimnames(A) = list( c(“row1”, “row2”), c(“col1”, “col2”, “col3”))
A

col1 col2 col3
row1 2     4      3
row2 1     5      7

A[“row2”, “col3”] # 2.ci satır 3.cu sütun elemanı
[1] 7

Martix oluşturma örneğimize geri dönersek, elemanların modunun tamsayı-integer olduğunu typeof() fonksiyonu ile görebiliriz.

typeof(m1) # elemanların modu. Burada, matriste saklanan elemanlar tamsayı tipidir.
[1] “integer”

m2 <- matrix(nrow = 2, ncol = 2) #matris değerlerini tanımlamadığımız için NA ile dolu matrisi alacağız
m2
[,1] [,2]
[1,] NA NA
[2,] NA NA

dim(m2)                                           # m2 matrix’in boyutu nedir?
[1] 2 2

is.matrix() fonksiyonu ile birşeyin matrix olup olmadığını sorgulayabiliriz. Cevap TRUE ise matrix FALSE ise matrix değil deriz.

is.matrix(m2)                                 # m2 Bir matris mi?
[1] TRUE

Matrix çeşitlerine bakacak olursak;

Birim Matrix,
     U <- matrix(1,3,2)
     U

         [,1] [,2]
     [1,] 1    1
     [2,] 1    1
     [3,] 1    1

Sıfır Matrix,
     Z <- matrix(0,3,2)
     Z

           [,1] [,2]
     [1,] 0      0
     [2,] 0      0
     [3,] 0      0

Kimlik Matrix.
     I <- diag(c(1,1,1))
     I

          [,1] [,2] [,3]
     [1,] 1     0     0
     [2,] 0     1     0
     [3,] 0     0     1

Simetrik Matrix,

     Matrix’te alt üçgen elemanlarıyla üst üçgen elemanlarını      değiştirdiğimizde o matrix’in simetrik matrix’ini elde ederiz. Aşağıdaki örnekte üst üçgen elemanları 2 3 -2’in ustunde kalan 1 4 ve 5, alt üçgen elemanları da aynen 1 4 ve 5. Matrix ve tersi – t(C) birbirine eşit.

     C <- matrix(c(2,1,5,1,3,4,5,4,-2),3,3)
     C

         [,1] [,2] [,3]
     [1,] 2    1     5
     [2,] 1    3     4
     [3,] 5    4    -2

     CT <- t(C)
     CT

         [,1] [,2] [,3]
     [1,] 2    1     5
     [2,] 1    3     4
     [3,] 5    4    -2

 

Karmaşık/Kompleks matrix,

     Her elementi karmaşık bir sayı ise, matrix, karmaşık matrix olarak adlandırılır.
     A <- matrix(c(1, 2, 2+3i, 5), ncol = 2) # Karmaşık/Kompleks matrix

Gerçek matrix,
     Her elementi gerçek sayı ise, matrix, gerçek matrix olarak adlandırılır.
     B <- matrix(1:4, ncol = 2)                     # gerçek matrix

Boolean matrix,

     Elemanları TRUE, FALSE veya 0, 1’lerden oluşan martix’tir.
     C <- matrix(c(TRUE, TRUE, FALSE, FALSE), ncol = 2) # boolean matrix

Karakter matrix,

     Elemanları karakterlerden oluşan martix’tir.
     D <- matrix(c(‘a’, ‘b’, ‘c’, ‘d’), ncol = 2)                             # karakter matrix

Tekil matrix
     E <- matrix(c(1,2+3i,’a’,TRUE),ncol=2)                           # tekil matrix

Şimdi biraz da matrix’lerle ilgili fonksiyonları gözden geçirelim;

cbind () ve rbind () fonksiyonları vektörleri sütun sütun ya da satır satır matrikslerle sıraya göre birleştirir.
v1 ve v2 iki vektör;
v1 <- 1:5
v2 <- 5:1

cbind(v1,v2)                                     #v1 ve v2 ile sütun matrix oluşuyor
     v1 v2
[1,] 1  5
[2,] 2  4
[3,] 3  3
[4,] 4  2
[5,] 5  1

rbind(v1,v2)                                       #v1 ve v2 ile satır matrix oluşuyor
    [,1] [,2] [,3] [,4] [,5]
v1 1     2     3     4     5
v2 5     4     3     2     1

t() fonksiyonu matrix’i tersine çevirir. Yani sütunlar satırlara, satırlar sütunlara dönüşür.

X <- matrix(data = 1:15, nrow = 5, ncol = 5, byrow = T)
X
     [,1] [,2] [,3] [,4] [,5]
[1,] 1     2     3     4     5
[2,] 6     7     8     9   10
[3,] 11   12  13   14  15
[4,] 1     2     3     4     5
[5,] 6     7     8     9    10

t(X)
     [,1] [,2] [,3] [,4] [,5]
[1,] 1     6    11    1     6
[2,] 2     7    12    2     7
[3,] 3     8    13    3     8
[4,] 4     9    14    4     9
[5,] 5   10    15    5   10

nrow(X)                                       # X kaç satır
[1] 5

ncol(X)
[1] 5                                               #X kaç sütun

R’da * öğe bazlı sabitle çarpma için operatör olarak kullanılır.

a = c(1,2,3)
b = c(2,4,6)
c = cbind(a,b)                  #a ve b vektörlerini c matrix’inde birleştirdik
x = c(2,2,2)                       #sabitimiz

Verimizi inceleyelim;
c
      a b
[1,] 1 2
[2,] 2 4
[3,] 3 6

x
[1] 2 2 2

y<- c*x
k<- x*c

y ve k nin aynı değerleri aldığını görelim;

y
      a b
[1,] 2 4
[2,] 4 8
[3,] 6 12

k
       a b
[1,] 2 4
[2,] 4 8
[3,] 6 12

Şimdi başka örneklerle devam edelim.

A <- matrix(c(2,3,-2,1,2,2),3,2)
     [,1] [,2]
[1,] 2     1
[2,] 3     2
[3,] -2    2

Bir sabit sayı ile çarpım;

c <- 3
c*A

     [,1] [,2]
[1,] 6     3
[2,] 9     6
[3,] -6    6

B <- matrix(c(1,4,-2,1,2,1),3,2)
B

    [,1] [,2]
[1,] 1    1
[2,] 4    2
[3,] -2   1

İki matrix ile toplama yapalım;

C <- A + B
C

    [,1] [,2]
[1,] 3    2
[2,] 7    4
[3,] -4   3

Bakalım çıkarma nasıl olacak;

D <- A – B
D

     [,1] [,2]
[1,] 1    0
[2,] -1   0
[3,] 0    1

Görüldüğü gibi birinci matrix’in birinci elemanından ikinci matrisin birinci elemanı çıkarıldı ve sonuç matrix D’ nin birinci elemanı olarak yerleşti.

Şimdi başka örneklerle devam edelim;

D <- matrix(c(2,-2,1,2,3,1),2,3)
D

     [,1] [,2] [,3]
[1,] 2     1     3
[2,] -2    2     1

Matrix’lerin çarpımına bakalım D ile bir önceki örnekteki A matrix’ini çarpalım;

Hatırlayalım;
A <- matrix(c(2,3,-2,1,2,2),3,2)
    [,1] [,2]
[1,] 2    1
[2,] 3    2
[3,] -2   2

R’da matrix’leri birbirleriyle carpmak icin %*% kullaniyoruz;
C <- D %*% A
C

     [,1] [,2]
[1,] 1    10
[2,] 0     4

Sonuç C matrix’in nasıl elde edildiğini görelim;
D matrix’in 1ci satiri ile A matrix’in 1ci sütunu çarpacağız önce
(2×2)+(3×1)+(-2×3)= 1 sonra D matrix’in birinci satırı ile A matrix’in ikinci sütununu çarpacağız; (2×1)+(1×2)+(3×2)= 10 böylece sonuç C matrix’in ilk satırı oluşmuş oldu. Devam edelim; D matrix’in 2ci satiri ile A matrix’in 1ci sütunu çarpacağız (-2×2)+(2×3)+(1x(-2))= 0 sonra D matrix’in ikinci satırı ile A matrix’in ikinci sütununu çarpalım; (-2×1)+(2×2)+(1×2)= 4 böylece sonuç C matrix’in ikinci satırı oluşmuş oldu ve çarpacak başka bir şey kalmadı. Böylece 2×3 boyutlu bir matrix ile 3×2 boyutlu matrix çarpım sonucunun 2×2 boyutlu bir matrix olduğunu aynı matematikteki gördük.

Tersini deneyelim;
C <- A %*% D
C

     [,1] [,2] [,3]
[1,] 2     4     7
[2,] 2     7    11
[3,] -8    2    -4
Sonuç C matrix’ini gözden geçirelim;
Bu durumda da yine ilk matrix’in ilk satırı ile ikinci matrix’in ilk sütunu çarpılacak ve böyle devam edilecek, çarpma işleminde fark yok. A matrix’in 1ci satırı ile D matrix’in 1ci sütununu çarpacağız önce; (2×2)+(1x(-2))= 2, sonra A matrix’in 1ci satırı ile D matrix’in 2ci sütununu çarpacağız (2×1)+(1×2)=4, sonra A matrix’in 1ci satırı ile D matrix’in 3ci sütununu çarpacağız (2×3)+(1×1)=7 böylece C matrix’in ilk satırı belirlenmiş oldu. C matrix’in ikinci satırı için; (3×2)+(2x(-2))=2, (3×1)+(2×2)=7, (3×3)+(2×1)=11, C matrix’in üçüncü satırı için; (-2×2)+(2x(-2))=-8, (-2×1)+(2×2)=2,(-2×3)+(2×1)=-4 belirlenecek.

Matematikten de bildiğimiz gibi matrix çarpımlarını hesaplayabilmek için ilk matrix’in sütun sayısı ile ikinci matrix’in satır sayısının aynı olması gerekiyor. Dolayısıyla aşağıdaki boyutlardaki matrix çarpımlarını hesaplamak mümkün değil, bunların çarpımı R’ da hata ile sonuçlanacaktır;

2x2 and 3x3
3x2 and 1x4
4x3 and 2x2
2x5 and 2x5
1x3 and 1x5


D <- matrix(c(2,1,3),1,3)
D

    [,1] [,2] [,3]
[1,] 2    1     3
Bu D matrix’ini elimizdeki A matrix’i ile çarpalım;
C <- D %*% A
C

     [,1] [,2]
[1,] 1    10
A matrix’i 3×2 boyutlu idi D ise şimdi 1×3 boyutunda, D %*% A buradan, 1×3 boyutlu matrix ile 3×2 boyutlu matrix sonucu 1×2 boyutlu matrix olacaktır.

A ile D yi çarpmayı deneyelim; yani 3×2 boyutlu matrix ile 1×3 boyutlu matrix çarpımını deneyeceğiz. A’nin sütun sayısı 2 iken D nin satır sayısı 1 olduğundan bu çarpım hata ile sonuçlanacaktır

C <- A %*% D

Error in A %*% D : non-conformable arguments

Bölme işlemine de bakalim.
A ve B asagıdaki gibi aynı boyutta sayısal iki matrix ise A/B
A <- matrix(1:4, 2, 2)
     [,1] [,2]
[1,] 1     3
[2,] 2     4

B <- matrix((1:4) * 2, 2, 2)
     [,1] [,2]
[1,] 2     6
[2,] 4     8

C <- A / B
      [,1] [,2]
[1,] 0.5  0.5
[2,] 0.5  0.5

B[i,j] == 0 oldugunda A[i,j] <- 0 olmali.

Eğer B’nin elemanları 0 ise A/B sonucu olarak NaN, Inf veya -Inf değerleri A’daki karşılığına göre geçerli olur.
Unutmadan;

0 / 0
[1] NA

1 / 0
[1] Inf

-1 / 0
[1] -Inf

Eğer sonucu 0 ile değiştirmek istersek;
C <- 1 / 0
C[!is.finite(C)] <- 0
C
[1] 0

is.infinite is.finite’in tersi değil, ama is.na’nin tersi. Bundan ötürü !is.finite kullandık.

R nasıl bir değerlendirme yapıyor bakalım;
x <- c(NA, NaN, Inf, -Inf)

is.finite(x)
[1] FALSE FALSE FALSE FALSE

is.infinite(x)
[1] FALSE FALSE TRUE TRUE

is.na(x)
[1] TRUE TRUE FALSE FALSE

is.nan(x)
[1] FALSE TRUE FALSE FALSE

Bir matrix’in tersi,
A kare matrix(aynı sayıda satır ve sütuna sahip matrix) ise tersi solve(A) ile hesaplanır.

A <- matrix(c(4,4,-2,2,6,2,2,8,4),3,3)
A

     [,1] [,2] [,3]
[1,] 4     2     2
[2,] 4     6     8
[3,] -2    2     4


AI <- solve(A)
AI

     [,1]   [,2]   [,3]
[1,] 1.0  -0.5   0.5
[2,] -4.0  2.5  -3.0
[3,] 2.5   -1.5  2.0

A %*% AI

    [,1] [,2] [,3]
[1,] 1    0     0
[2,] 0    1     0
[3,] 0    0     1

AI %*% A

     [,1] [,2] [,3]
[1,] 1     0     0
[2,] 0     1     0
[3,] 0     0     1

Devami gelecek…

İçindekiler

Last updated by at .

Leave a Reply