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 ortamı 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 detaylı 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 oluşur. 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 kullanılan fonksiyonun bar grafiğini görebilirsiniz ve grafiği yayınlayabilir ya da dışarı 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 yazıp 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 skaler 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ındaki “+” üzerinde tıklayarak yeni bir R script dosyası açınız. “Kaynak”(Source) paneline yukarıdaki üç satırı yazın 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 dışında 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 dönüşü olacaktır.
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. Sağdaki 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 mesajını 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 () fonksiyonunun 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ğişiklik 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 yapıların 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ı olsa da, bunlar TRUE ve FALSE atanmış ayrılmamış değişkenlerdir. Yani kullanıcı T ve F değişkenlerine istediği atamayı yapabilir, bu sebeple karışıklığa sebep olmamak için 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

Vektör 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 rakam 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 kaç adet var?
[1] 2

max(ceket)                                                   #maksimum kaç 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 vektörler gibi sınıflanmış nesneler üzerinde çalışır.

Q_i(p)= (1−γ)x_j + γx_j + 1

1≤ i≤ 9, (j−m)/n ≤ p <(j−m+1)/n , x_j 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 tanımı: 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 Qⁱ(p) p’nin sürekli bir fonksiyonudur. Örnek quantile’ ler, (p_k,x_k)                  (x_k  k’inci sıralı istatistik olmak üzere) noktalar arasındaki doğrusal ara değeri bulma-interpolasyon ile eşdeğer olarak elde edilebilir.

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

Tip 5 : m=½, p_k=(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, p_k=k/(n+1) olduğundan p_k= E[F(x_k)] bu Minitab ve SPSS tarafından kullanılmıştır.

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

Tip 8 : m=(1+p)/3, p_k= ((k-1)/3)/((n+1)/3) sonra p_k≈median[F(x_k)] 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, p_k=(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 şarkı 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ı. şarkı numaraları 1 ila 12 arasındayken, tırmanma 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 olanların 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 fiyatı 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 fiyatları neydi?
tekne.fiyati[tekne.rengi == “yesil” | tekne.rengi == “sari”]
[1] 87 32 532 58

# “j” teknesinin fiyatını 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

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

# yaşı 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 vektör 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 beş 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 yaşı kaç? (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 fiyatı maliyetinden yüksek?
tekne.fiyati > tekne.maliyeti
[1] TRUE TRUE TRUE FALSE TRUE TRUE TRUE FALSE TRUE TRUE

# hangi teknelerin fiyatı 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 fiyatları 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 fiyatı 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 fiyatı 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 sayı?     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?
geçersiz <- (mutlu %in% 1:5) == FALSE
geçersiz
[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 geçersiz 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[geçersiz] <- 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

Matris

Matris, 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 tipini tamsayı-integer olduğunu typeof() fonksiyonu ile görebiliriz. R’de kullanılan en yaygın iki sayısal sınıf tamsayı(integer) ve çifttir(double) (çift-double- duyarlıklı kayan noktalı sayılar için). R, matematiksel amaçlar için ihtiyaç duyulduğunda bu iki sınıf arasında otomatik olarak dönüşüm sağlar.

typeof(m1) # elemanların tipi. 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;

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

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

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

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

Köşegen matrix,

    Köşegen matrisler zaten kare matris olmak zorundadır. Ancak köşegenlerindeki elemanlar hariç diğer tüm elemanlar sıfırdır. Köşegen ilk satırın en solundan başlar, çapraz bir şekilde son satırın en sağındaki sayıya kadar iner.

   A <- diag(c(1,2,3))
   A

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

     Köşegen elemanları birbirine eşit olan köşegen matrise skalar matris denir.

Ortogonal matrix,
      Ortogonal bir matris, satırları karşılıklı olarak ortonormal ve sütunları karşılıklı olarak ortonormal olan bir kare matristir.

      A <- matrix( c(cos(0), sin(0), -sin(0), cos(0)), nrow=2, ncol=2, byrow = TRUE)
      A

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

      AT<- t(A) ## AT = matrix( c(cos(0), -sin(0), sin(0), cos(0)), nrow=2, ncol=2, byrow = T)
      AT

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

      C <- A*AT     ## C = matrix((cos(0)*cos(0)+(−sin(0))*(−sin(0))), (cos(0)*sin(0)+(−sin(0))*cos(0)), (sin(0)*cos(0)+cos(0)*(−sin(0))), (sin(0)*sin(0)+cos(0)*cos(0)), nrow=2, ncol=2, byrow = TRUE)
      C
          [,1] [,2]
      [1,] 1    0
      [2,] 0    1  

Üçgen matrix,

      Bir kare matriste asal köşegenin üstünde ya da altında kalan tüm elemanlar sıfır ise bu matrise üçgen matris denir. Üçgen bir matris, yalnızca köşegeninin hiçbir elemanı sıfır değilse ters çevrilebilir.

      A <- matrix( c(2, 3, 1, 0,1, 3, 0, 0, 4), nrow=3, ncol=3, byrow = TRUE)
      A
          [,1] [,2] [,3]
      [1,] 2    3    1
      [2,] 0    1    3
      [3,] 0    0    4

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(transpoze) – 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)  ## C’nin tersi, transpozesi
     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 matrislerle 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() transpoze 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 çarpmak için %*% kullanıyoruz;
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 bakalım.
A ve B aşağı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 olduğunda A[i,j] <- 0 olmalı.

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

Bir matrisin tersi ile çarpımı birim matrisi verir.

Diziler

R’ da diziler matrislere benzer ancak ikiden fazla boyuta sahip olabilirler. Aslında bir matris, iki boyutlu bir dizinin özel durumudur. Basitçe, dizi boyutları (“dim” niteliği) verilebilen ve isteğe bağlı olarak bu boyutlar için isimler (“dimnames” özelliği) atanabilen ek niteliklerle depolanan bir vektördür. 

R’da dizi array() fonksiyonu ile tanımlanabilir. 

# 1 ile 18 arasında değişen değerlere sahip tek boyutlu bir dizi
birdizi <- c(1:18)
birdizi

  [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# Birden fazla boyuta sahip bir dizi
cokludizi <- array (birdizi, dim = c (4, 3, 2))
cokludizi
, , 1

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

, , 2

      [,1] [,2] [,3]
[1,] 13  17    3
[2,] 14  18    4
[3,] 15    1    5
[4,] 16    2    6

dim=c(4,3,2)  parantez içindeki birinci ve ikinci sayı, satır ve sütunların miktarını belirtir. Köşeli parantez içindeki son sayı, kaç boyut istediğimizi belirtir.

Yani, sözdizimi şu şekildedir:

array (satır konumu, sütun konumu, matris düzeyi)

# Birinci satırdaki tüm öğelere erişim
cokludizi <- array (birdizi, dim = c (4, 3, 2))
cokludizi [c (1) ,, 1]
  [1] 1 5 9

# Birinci sütundaki tüm öğelere erişim
cokludizi <- array (birdizi, dim = c (4, 3, 2))
cokludizi [, c (1), 1]
  [1] 1 2 3 4

Yani, cokludiziyi çağırıken c() den sonraki virgül satıra erişmek istediğimiz anlamına gelir. Eğer virgülü c() den önce yerleştirirsek sütuna erişiriz. Yukarıdaki iki örnekte sırasıyla birinci satıra ve sonrakinde birinci sütuna erişiliyor.

Bir dizideki satır ve sütunların adedini bulmak için dim () işlevini kullanırız.

dim(cokludizi)
  [1] 4 3 2

Bir dizinin boyutunu bulmak için length () işlevini kullanırız.

length(cokludizi)
  [1] 24

as.array, diziye zorlamak için genel bir işlevdir. Örneğin harflerdden bir dizi oluşturmak istersek aşağıdaki örnekte olduğu gibi bu işlevi kullanabiliriz. 

harfdizi <- as.array(letters)
harfdizi
  [1] “a” “b” “c” “d” “e” “f” “g” “h” “i” “j” “k” “l” “m” “n” “o” “p” “q” “r”
  [19] “s” “t” “u” “v” “w” “x” “y” “z”

dim(harfdizi)
  [1] 26

ya da

dim(as.array(letters))
  [1] 26

is.array ise  bağımsız değişkeninin bir dizi olup olmamasına (yani, pozitif uzunlukta bir dim özelliğine sahip olmasına) bağlı olarak DOĞRU veya YANLIŞ değerini döndürür. 

is.array(harfdizi)
  [1] TRUE
is.array(letters)
  [1] FALSE

Dizi içinde %in% ile arama da yapabiliriz;

2 %in% cokludizi
  [1] TRUE
“f” %in% harfdizi
  [1] TRUE

Basit bir örnek daha verelim;

#vektörle başlıyoruz
x <- c(1,2,3,4)
# 2 kolon ve 2 satırlı dizi yapmak için
x_dizi <- array(x, dim=c(2,2))
x_dizi
      [,1] [,2]
  [1,] 1    3
  [2,] 2    4  

Tabii typeof() gibi pekçok diğer işlevi dizi ile kullanmak mümkün;

#dizimizin öğe türleri

typeof(x_dizi)
  [1] “double”
typeof(harfdizi)
  [1] “character”

Satır (rowSums() işlevi) ve sütun (colSums() işlevi) toplamlarını kolayca bulabilmek de mümkün;

#satır toplamları
rowSums(cokludizi)
  [1] 48 54 42 48
#sütun toplamları
colSums(cokludizi)
        [,1]  [,2]
  [1,] 10   58
  [2,] 26   38
  [3,] 42   18

Dizin konumuna bakarak dizi elemanlarına erişebilirsiniz. Bir dizinin istenilen öğelerine erişmek için [] köşeli parantezleri kullanırız. Sözdizimi şu şekildedir:

array [satır konumu, sütun konumu, matris düzeyi]

cokludizi[2, 2, 2]
  [1] 18

Bu örnekte cokludizinin 2ci düzeyinde, 2ci sütun 2ci satırdaki elemanına bakıyoruz; 18

cokludizi[4, 2, 2]
[1] 2

Bu örnekte cokludizinin 2ci düzeyinde, 2ci sütun 4cü satırdaki elemanına bakıyoruz; 2

Diziyi döngüde -loop- kullanmak da mümkün:

for(x in cokludizi){
     print(x)
  }
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10
[1] 11
[1] 12
[1] 13
[1] 14
[1] 15
[1] 16
[1] 17
[1] 18
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6 
Örnekte döngü ile dizinin tüm elemanlarını yazdırdık.

Dizinin elemanlarında değişiklik yapmak istersek;

cokludizi[1,1,2] <- 5
cokludizi
, , 1

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

, , 2

      [,1] [,2] [,3]
[1,]  5    17    3
[2,]  14  18    4
[3,]  15    1    5
[4,]  16    2    6

Böylece dizinin 2ci düzeyinde ilk satır, ilk sütun elemanını 5 yapmış olduk.

cokludizi[2,2,1] <- 8
cokludizi
, , 1

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

, , 2

[,1] [,2] [,3]
[1,] 5 17 3
[2,] 14 18 4
[3,] 15 1 5
[4,] 16 2 6

Bu örnekte de dizinin 1ci düzeyinde ikinci satır, ikinci sütun elemanını 8 yaptık.

Diziler üzerinde önemli bir işlem, dış çarpımdır. A ve b iki sayısal dizi ise, bunların dış çarpımı, boyut vektörü iki boyut vektörünün birleştirilmesiyle elde edilen (sıra önemlidir) ve veri vektörü, ilk veri vektörünün elemanlarının ikincikilerle tüm olası çarpımlarını  oluşturarak elde edilir. Dış ürün % o% özel operatör ile ya da outer() işlevi ile oluşturulur:

a <- 1:9
a
  [1] 1 2 3 4 5 6 7 8 9
b <- 2:8
b
  [1] 2 3 4 5 6 7 8
outer(a, b, FUN = “*”)
      [,1]   [,2]   [,3]   [,4]   [,5]   [,6]   [,7]
  [1,] 2      3      4      5      6      7      8
  [2,] 4      6      8    10    12    14    16
  [3,] 6      9    12    15    18    21    24
  [4,] 8     12   16    20    24    28    32
  [5,] 10   15   20    25    30    35    40
  [6,] 12   18   24    30    36    42    48
  [7,] 14   21   28    35    42    49    56
  [8,] 16   24   32    40    48    56    64
  [9,] 18   27   36    45    54    63    72

a %o% b
      [,1] [,2] [,3] [,4] [,5] [,6] [,7]
  [1,] 2    3    4    5    6    7    8
  [2,] 4    6    8  10  12  14  16
  [3,] 6    9  12  15  18  21  24
  [4,] 8  12  16  20  24  28  32
  [5,]10 15  20  25  30  35  40
  [6,]12 18  24  30  36  42  48
  [7,]14 21  28  35  42  49  56
  [8,]16 24  32  40  48  56  64
  [9,]18 27  36  45  54  63  72

outer(a, b, FUN = “^“)
        [,1]           [,2]           [,3]           [,4]           [,5]           [,6]            [,7]
  [1,]   1              1              1              1              1              1               1
  [2,]   4              8            16            32            64           128           256 
  [3,]   9            27            81          243          729         2187         6561
  [4,] 16            64          256        1024        4096       16384       65536
  [5,] 25          125          625        3125      15625       78125     390625
  [6,] 36         216         1296        7776      46656     279936   1679616
  [7,] 49         343         2401      16807    117649     823543   5764801
  [8,] 64         512         4096      32768    262144   2097152 16777216
  [9,] 81         729         6561      59049    531441   4782969 43046721

Örneklerde de gördüğünüz gibi outer() işlevi kullanımı; 

outer(X, Y, FUN=”*”, …) 

ya da 

x %o% y

şeklindedir. 

Biraz da açıklayacak olursak;  X  ve Y Birer vektör veya dizi. FUN dış ürünlerde kullanılacak bir işlev, tırnaklı bir dizge olabilir. … (3 nokta) FUN’a iletilecek isteğe bağlı bağımsız değişkenler.

Yukarıdaki son örneğimizde ^ yani üs operatörünü kullandık. Yani, a^b hesapladık, böylece işleve istediğimiz operatörleri göndererek dizlerlei-array çalışabiliriz.

outer(month.abb, 1999:2003, FUN = “paste”)
           [,1]                   [,2]              [,3]                [,4]            [,5]
[1,] “Jan 1999”      “Jan 2000”   “Jan 2001”   “Jan 2002”  “Jan 2003”
[2,] “Feb 1999”     “Feb 2000”  “Feb 2001”  “Feb 2002”  “Feb 2003”
[3,] “Mar 1999”    “Mar 2000”  “Mar 2001” “Mar 2002”  “Mar 2003”
[4,] “Apr 1999”     “Apr 2000”  “Apr 2001”  “Apr 2002”   “Apr 2003”
[5,] “May 1999”   “May 2000” “May 2001” “May 2002” “May 2003”
[6,] “Jun 1999”      “Jun 2000”  “Jun 2001”   “Jun 2002”  “Jun 2003”
[7,] “Jul 1999”        “Jul 2000”    “Jul 2001”   “Jul 2002”    “Jul 2003”
[8,] “Aug 1999”   “Aug 2000”  “Aug 2001” “Aug 2002” “Aug 2003”
[9,] “Sep 1999”    “Sep 2000”   “Sep 2001” “Sep 2002”  “Sep 2003”
[10,] “Oct 1999”   “Oct 2000”   “Oct 2001”  “Oct 2002”  “Oct 2003”
[11,] “Nov 1999” “Nov 2000”  “Nov 2001” “Nov 2002” “Nov 2003”
[12,] “Dec 1999”  “Dec 2000”  “Dec 2001”  “Dec 2002”  “Dec 2003”

Bu örnekte de 1999 ile 2003 senesi arası ayları işleve “paste”-yapıştır yollayarak yazdırdık.

a %o% b %o% b[1:3]
, , 1

       [,1]  [,2]  [,3]  [,4]  [,5]  [,6]  [,7]
  [1,] 4      6     8   10   12   14   16
  [2,] 8    12   16   20   24   28   32
  [3,] 12  18   24   30   36   42   48
  [4,] 16  24   32   40   48   56   64
  [5,] 20  30   40   50   60   70   80
  [6,] 24  36   48   60   72   84   96
  [7,] 28  42   56   70   84   98 112
  [8,] 32  48   64   80   96 112 128
  [9,] 36  54   72   90 108 126 144

, , 2

      [,1]  [,2]  [,3]  [,4]  [,5]  [,6]  [,7]
  [1,] 6      9   12   15   18   21   24
  [2,] 12  18   24   30   36   42   48
  [3,] 18  27   36   45   54   63   72
  [4,] 24  36   48   60   72   84   96
  [5,] 30  45   60   75   90 105 120
  [6,] 36  54   72   90 108 126 144
  [7,] 42  63   84 105 126 147 168
  [8,] 48  72   96 120 144 168 192
  [9,] 54  81 108 135 162 189 216

, , 3

       [,1]  [,2]  [,3]  [,4]  [,5]  [,6]  [,7]
  [1,]   8   12   16   20   24   28   32
  [2,] 16   24   32   40   48   56   64
  [3,] 24   36   48   60   72   84   96
  [4,] 32   48   64   80   96 112 128
  [5,] 40   60   80 100 120 140 160
  [6,] 48   72   96 120 144 168 192
  [7,] 56   84 112 140 168 196 224
  [8,] 64   96 128 160 192 224 256
  [9,] 72 108 144 180 216 252 288

Bu örnekte;

a
[1] 1 2 3 4 5 6 7 8 9

b
[1] 2 3 4 5 6 7 8

ve

b[1:3]
[1] 2 3 4

idi.. 

Bu çarpımın nasıl çalıştığını anlayabilmek için wikipedia ya göz atabilirsiniz.

Harflerle ilgi ilginç bir örnek ise;

outer( letters, letters,FUN=paste ,sep=””)
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13]
[1,] “aa” “ab” “ac” “ad” “ae” “af” “ag” “ah” “ai” “aj” “ak” “al” “am”
[2,] “ba” “bb” “bc” “bd” “be” “bf” “bg” “bh” “bi” “bj” “bk” “bl” “bm”
[3,] “ca” “cb” “cc” “cd” “ce” “cf” “cg” “ch” “ci” “cj” “ck” “cl” “cm”
[4,] “da” “db” “dc” “dd” “de” “df” “dg” “dh” “di” “dj” “dk” “dl” “dm”
[5,] “ea” “eb” “ec” “ed” “ee” “ef” “eg” “eh” “ei” “ej” “ek” “el” “em”
[6,] “fa” “fb” “fc” “fd” “fe” “ff” “fg” “fh” “fi” “fj” “fk” “fl” “fm”
[7,] “ga” “gb” “gc” “gd” “ge” “gf” “gg” “gh” “gi” “gj” “gk” “gl” “gm”
[8,] “ha” “hb” “hc” “hd” “he” “hf” “hg” “hh” “hi” “hj” “hk” “hl” “hm”
[9,] “ia” “ib” “ic” “id” “ie” “if” “ig” “ih” “ii” “ij” “ik” “il” “im”
[10,] “ja” “jb” “jc” “jd” “je” “jf” “jg” “jh” “ji” “jj” “jk” “jl” “jm”
[11,] “ka” “kb” “kc” “kd” “ke” “kf” “kg” “kh” “ki” “kj” “kk” “kl” “km”
[12,] “la” “lb” “lc” “ld” “le” “lf” “lg” “lh” “li” “lj” “lk” “ll” “lm”
[13,] “ma” “mb” “mc” “md” “me” “mf” “mg” “mh” “mi” “mj” “mk” “ml” “mm”
[14,] “na” “nb” “nc” “nd” “ne” “nf” “ng” “nh” “ni” “nj” “nk” “nl” “nm”
[15,] “oa” “ob” “oc” “od” “oe” “of” “og” “oh” “oi” “oj” “ok” “ol” “om”
[16,] “pa” “pb” “pc” “pd” “pe” “pf” “pg” “ph” “pi” “pj” “pk” “pl” “pm”
[17,] “qa” “qb” “qc” “qd” “qe” “qf” “qg” “qh” “qi” “qj” “qk” “ql” “qm”
[18,] “ra” “rb” “rc” “rd” “re” “rf” “rg” “rh” “ri” “rj” “rk” “rl” “rm”
[19,] “sa” “sb” “sc” “sd” “se” “sf” “sg” “sh” “si” “sj” “sk” “sl” “sm”
[20,] “ta” “tb” “tc” “td” “te” “tf” “tg” “th” “ti” “tj” “tk” “tl” “tm”
[21,] “ua” “ub” “uc” “ud” “ue” “uf” “ug” “uh” “ui” “uj” “uk” “ul” “um”
[22,] “va” “vb” “vc” “vd” “ve” “vf” “vg” “vh” “vi” “vj” “vk” “vl” “vm”
[23,] “wa” “wb” “wc” “wd” “we” “wf” “wg” “wh” “wi” “wj” “wk” “wl” “wm”
[24,] “xa” “xb” “xc” “xd” “xe” “xf” “xg” “xh” “xi” “xj” “xk” “xl” “xm”
[25,] “ya” “yb” “yc” “yd” “ye” “yf” “yg” “yh” “yi” “yj” “yk” “yl” “ym”
[26,] “za” “zb” “zc” “zd” “ze” “zf” “zg” “zh” “zi” “zj” “zk” “zl” “zm”
[,14] [,15] [,16] [,17] [,18] [,19] [,20] [,21] [,22] [,23] [,24] [,25]
[1,] “an” “ao” “ap” “aq” “ar” “as” “at” “au” “av” “aw” “ax” “ay”
[2,] “bn” “bo” “bp” “bq” “br” “bs” “bt” “bu” “bv” “bw” “bx” “by”
[3,] “cn” “co” “cp” “cq” “cr” “cs” “ct” “cu” “cv” “cw” “cx” “cy”
[4,] “dn” “do” “dp” “dq” “dr” “ds” “dt” “du” “dv” “dw” “dx” “dy”
[5,] “en” “eo” “ep” “eq” “er” “es” “et” “eu” “ev” “ew” “ex” “ey”
[6,] “fn” “fo” “fp” “fq” “fr” “fs” “ft” “fu” “fv” “fw” “fx” “fy”
[7,] “gn” “go” “gp” “gq” “gr” “gs” “gt” “gu” “gv” “gw” “gx” “gy”
[8,] “hn” “ho” “hp” “hq” “hr” “hs” “ht” “hu” “hv” “hw” “hx” “hy”
[9,] “in” “io” “ip” “iq” “ir” “is” “it” “iu” “iv” “iw” “ix” “iy”
[10,] “jn” “jo” “jp” “jq” “jr” “js” “jt” “ju” “jv” “jw” “jx” “jy”
[11,] “kn” “ko” “kp” “kq” “kr” “ks” “kt” “ku” “kv” “kw” “kx” “ky”
[12,] “ln” “lo” “lp” “lq” “lr” “ls” “lt” “lu” “lv” “lw” “lx” “ly”
[13,] “mn” “mo” “mp” “mq” “mr” “ms” “mt” “mu” “mv” “mw” “mx” “my”
[14,] “nn” “no” “np” “nq” “nr” “ns” “nt” “nu” “nv” “nw” “nx” “ny”
[15,] “on” “oo” “op” “oq” “or” “os” “ot” “ou” “ov” “ow” “ox” “oy”
[16,] “pn” “po” “pp” “pq” “pr” “ps” “pt” “pu” “pv” “pw” “px” “py”
[17,] “qn” “qo” “qp” “qq” “qr” “qs” “qt” “qu” “qv” “qw” “qx” “qy”
[18,] “rn” “ro” “rp” “rq” “rr” “rs” “rt” “ru” “rv” “rw” “rx” “ry”
[19,] “sn” “so” “sp” “sq” “sr” “ss” “st” “su” “sv” “sw” “sx” “sy”
[20,] “tn” “to” “tp” “tq” “tr” “ts” “tt” “tu” “tv” “tw” “tx” “ty”
[21,] “un” “uo” “up” “uq” “ur” “us” “ut” “uu” “uv” “uw” “ux” “uy”
[22,] “vn” “vo” “vp” “vq” “vr” “vs” “vt” “vu” “vv” “vw” “vx” “vy”
[23,] “wn” “wo” “wp” “wq” “wr” “ws” “wt” “wu” “wv” “ww” “wx” “wy”
[24,] “xn” “xo” “xp” “xq” “xr” “xs” “xt” “xu” “xv” “xw” “xx” “xy”
[25,] “yn” “yo” “yp” “yq” “yr” “ys” “yt” “yu” “yv” “yw” “yx” “yy”
[26,] “zn” “zo” “zp” “zq” “zr” “zs” “zt” “zu” “zv” “zw” “zx” “zy”
[,26]
[1,] “az”
[2,] “bz”
[3,] “cz”
[4,] “dz”
[5,] “ez”
[6,] “fz”
[7,] “gz”
[8,] “hz”
[9,] “iz”
[10,] “jz”
[11,] “kz”
[12,] “lz”
[13,] “mz”
[14,] “nz”
[15,] “oz”
[16,] “pz”
[17,] “qz”
[18,] “rz”
[19,] “sz”
[20,] “tz”
[21,] “uz”
[22,] “vz”
[23,] “wz”
[24,] “xz”
[25,] “yz”
[26,] “zz”

26 stünlu bir çıktı bu, 26 adet harf ile 26 adet harfin dış çarpımı sonucudur.

Bir de kendi fonksiyonumuz ile bir örnek daha vereyim. Örneğin; f (x; y) = cos (y) / (1 + x ^ 2) fonksiyonunu, sırasıyla x ve y R vektörleri tarafından tanımlanan x ve y koordinatlarına sahip normal bir değerler ızgarası üzerinde değerlendirmek istersek aşağıdaki gibi ilerleyebiliriz:

f <- function(x, y) cos(y)/(1 + x^2)
f
  function(x, y) cos(y)/(1 + x^2)

ve bu f işlevini, a ve b vektörlerine uygularsak; 

z <- outer(a, b, f)
z
               [,1]                [,2]                 [,3]                [,4]                [,5]             [,6]
[1,] -0.208073418 -0.49499625 -0.326821810 0.141831093 0.48008514 0.37695113
[2,] -0.083229367 -0.19799850 -0.130728724 0.056732437 0.19203406 0.15078045
[3,] -0.041614684 -0.09899925 -0.065364362 0.028366219 0.09601703 0.07539023
[4,] -0.024479226 -0.05823485 -0.038449625 0.016686011 0.05648061 0.04434719
[5,] -0.016005648 -0.03807663 -0.025140139 0.010910084 0.03692963 0.02899624
[6,] -0.011247212 -0.02675655 -0.017666044 0.007666546 0.02595055 0.02037574
[7,] -0.008322937 -0.01979985 -0.013072872 0.005673244 0.01920341 0.01507805
[8,] -0.006402259 -0.01523065 -0.010056056 0.004364034 0.01477185 0.01159850
[9,] -0.005074961 -0.01207308 -0.007971264 0.003459295 0.01170939 0.00919393
[,7]
[1,] -0.072750017
[2,] -0.029100007
[3,] -0.014550003
[4,] -0.008558826
[5,] -0.005596155
[6,] -0.003932433
[7,] -0.002910001
[8,] -0.002238462
[9,] -0.001774391

Bir de dizinin transpoze edilmesi ihtiyacı olabiliyor bazen, ondan da söz etmeden geçmeyelim. Boyutlarını değiştirerek ve isteğe bağlı olarak yeniden boyutlandırarak bir diziyi transpoze edebiliriz. Transpoze; satırları ve sütunları ters çevirmek.

Hemen yukarıdaki diziden devam edelim;

t <- aperm(z, c(2,1))
t
           [,1]                [,2]                 [,3]                  [,4]                [,5]
[1,] -0.20807342 -0.08322937 -0.04161468 -0.024479226 -0.016005648
[2,] -0.49499625 -0.19799850 -0.09899925 -0.058234853 -0.038076634
[3,] -0.32682181 -0.13072872 -0.06536436 -0.038449625 -0.025140139
[4,]   0.14183109  0.05673244   0.02836622  0.016686011  0.010910084
[5,]   0.48008514  0.19203406   0.09601703  0.056480605  0.036929626
[6,]   0.37695113  0.15078045   0.07539023  0.044347191  0.028996241
[7,] -0.07275002 -0.02910001 -0.01455000 -0.008558826 -0.005596155
              [,6]                    [,7]                  [,8]                  [,9]
[1,] -0.011247212 -0.008322937 -0.006402259  -0.005074961
[2,] -0.026756554 -0.019799850 -0.015230654  -0.012073079
[3,] -0.017666044 -0.013072872 -0.010056056  -0.007971264
[4,]   0.007666546  0.005673244   0.004364034   0.003459295
[5,]   0.025950548  0.019203406   0.014771851   0.011709394
[6,]   0.020375737  0.015078045   0.011598496   0.009193930
[7,] -0.003932433 -0.002910001  -0.002238462 -0.001774391

Bir de t() işlevi var tranpoze için. t() işlevi ile matris ve veri kümeleri de transpoze etmek(satırları ve sütunları ters çevirmek) mümkün. 

Artık bir sonraki konu Veri Kümelerine geçebiliriz. Faydalandığım tüm linkleri bitince en alta yazacağım. 

Veri Kümeleri

Karşılaşacağımız veri kümelerinin(dataset) çoğu, R’de veri çerçevelerinin(dataframe) nesnelerdir. Daha sonra R-Kodlama’ da kütüphanelerden(packages) söz edeceğiz. R kütüphaneleri ya da paketleri, R topluluğu tarafından geliştirilen işlevler ve veri kümelerini içeren koleksiyonlarıdır, bunlar R’ın işlevselliğini geliştirir ve iyileştirirler. Kütüphanalerin nasıl RStudio’da kurulup ortama kullanmak üzere yükleneceğini ilerleyen konularda R-Kodlama altında göreceğiz.

Kütüphaneleri kurup oratama yükledikten sonra calışma dizinini de ayarlayıp yerleşik veri kümelerini kullanmak mümkün. 

En çok kullanılan R yerleşik veri setlerinden bahsetmeden önce halihazırda yüklü hangi veri setleri var bakalım;

Kaynak panelindeki sekmeye bakacak olursak ismini “R data sets” olarak görürüz. Menü barda View(görünüm), Panes(bölmeler) sonra Zoom Packages(kütüphanelere- paketlere yakınlaş) seçince hangi paketlerin yüklü olduğunu görmek mümkün. Datasets paketine bakalım. Aşağılarda System Library altında datasets paketini-kütüphanesini bulabilirsiniz.

Konsol görüntüsü önümüze gelecek ve aşağıdaki komutu göreceğiz. Bu konutu Pakages sekmesini görüntülemeden direk olarak konsolda yazarak da aynı işlemi geröekleştirebiliriz.

library(datasets, lib.loc = “C:/Program Files/R/R-3.6.3/library”)

library() işleviyle kütüphanenin ya da paketin bulunduğu yeri de(lib.loc ile) belirterek R ortamımıza paketi ekleyebiliriz. Tekrar menü çubuğunda View/Panes/Show All Panes tıklayalım.

En çok kullanılan yerleşik veri setleri datasets kütüphanesinden: mtcars, iris, toothgrowth, plantgrowth, USArrest, Longley, mlbench kütüphanesinden: BostonHousing, BreastCancer, Glass, Ionosphere, PimaIndiansDiabetes, Sonar, Soybean. Bunlar sadece birkaç örnek, bazılarını ileride kullanabiliriz. Tabii daha pek çok veri seti var.

Kendi veri setlerimizi de çeşitli kaynaklarda R’a aktarmak mümkün, Aşağıda  Veriyi İçe Aktar(Import Dataset) menüsünü görmektesiniz.

Tabii bunlar kodlama ile de yapılabilir. Kodlama farklı şekillerde yapılabilir R’da, Konsol’da(Console) kod yazılabilir, ya da text dosyasına kod/kodlar yazılır sonra Kodlama(Code) menüsü altından Kaynak Dosya(Source File) seçilerek R ortamına aktarılır, RStudio ile Kodlama(Code) menüsü altından Kaynak(Source) seçilerek Kaynak(Source) panelinde kod/kodlar yazılabilir ve daha sonra tekrar kullanmak üzere kayıt edilebilir.

Sanırım herkese hitap edebilecek veri aktarma işlemi bir Excel örneği olabilir. Bu sebeple excel ile ilerleyeceğim.

Daha önce Covid başladığında bir takım istatistikler yapabilmek için Excel’de bir tablo hazırlamıştım. R’ı daha iyi öğrenmek amacıyla sonra o tabloyu R’a aktardım.

R’de kullanılan en yaygın iki sayısal sınıf tamsayı(integer) ve çifttir(double) (çift-double- duyarlıklı kayan noktalı sayılar için). R, matematiksel amaçlar için ihtiyaç duyulduğunda bu iki sınıf arasında otomatik olarak dönüşüm sağlar. Dolayısıyla Excel’den sayıları Çift(double) olarak aktarır.

Herşeyin atkarılmaya uygun olduğunu gördükten sonra, bu pencerede Kod Görüntüsü(Code Preview) penceresine baktım. Orada bu Excel Verisini Aktar(Import Excel Data) penceresinde yaptığım tüm ayarlar neticesinde oluşan kodlama parçasını gördüm. Bu kodlamayı önce Ctrl-C ile kopyaladım, ileride bu kodu kullanacağım. Şimdi eğer bu pencerede sol alt köşedeki Aktar(Import) tıklarsam aktarma işlemi gerçekleşecek ve veri seti R’da ortamımda hazırlanmış olacak.

Gördüğünüz gibi R’da bir işi yapmanın pek çok yolu olabiliyor, zaman içinde kendinize en uygun gelen yolu seçip devam edebilirsiniz.

Veri seti aktarımı ve biraz da kod(script) dosyası ile ilgili bilgi verdikten sonra konumuza geri dönelim.

Bir veri kümesi (data set or dataset), genellikle tablo biçiminde sunulan bir toplanmış verilerdir. Her sütun belirli bir değişkeni temsil ederken her satır, söz konusu veri kümesinin belirli bir üyesine ya da değişkenlerle ilgili gözlemlere karşılık gelir.

R’ da Kendi veri kümelerimizi hazırlamak istiyorsak o zaman veri çerçevesini(data.frame()) kullanmalıyız.

Ogrenci_ismi <- c(“Ayşe”, “Bekir”, “Ceyhun”, “Dilek”, “Elif”, “Faruk”, “Gencal”, “Hale”)
Yasi <- c(27, 55, 34, 42, 20, 27, 34, 42)
Cinsiyeti <- c(“K”, “E”, “E”, “K”, “K”, “E”, “E”, “K”)
GPA <- c(3.26, 3.75, 2.98, 3.40, 2.75, 3.32, 3.68, 3.97)
Ogrenci_veriseti <- data.frame(Ogrenci_ismi, Yasi, Cinsiyeti, GPA) # data.frame()’e veri setimizin ismini verdik

Konsol’ da

Ogrenci_veriseti # veri setimizi listeleyelim

Ogrenci_ismi Yasi Cinsiyeti GPA
1 Ayşe 27 K 3.26
2 Bekir 55 E 3.75
3 Ceyhun 34 E 2.98
4 Dilek 42 K 3.40
5 Elif 20 K 2.75
6 Faruk 27 E 3.32
7 Gencal 34 E 3.68
8 Hale 42 K 3.97

Veri setleri ya da veri çerçeveleri(data.frame) için, tıpkı bir veri kümesindeki(dataset) gibi farklı özellikli sütunları bir araya getirebilirsiniz. Burada, Öğrenci_Adı ve Cinsiyet değişkenlerinin ikisi de kategori modundayken Yaş ve GPA değişkenlerinin niceldir.

Sadece sütun isimlerini listelemek için:

names(Ogrenci_veriseti) #unutmalayım büyük/küçük harf R’da önemli, names(ogrenci_veriseti) yazdığımızda veri setimizi bulamayacaktır.
[1] “Ogrenci_ismi” “Yasi” “Cinsiyeti” “GPA”

“Yasi” stütunu değerlerini listelemek için:

Ogrenci_veriseti[c(“Yasi”)]
Yasi
1 27
2 55
3 34
4 42
5 20
6 27
7 34
8 42

R’ da aynı işlem için pek çok yol var, aynı sütun için:

Ogrenci_veriseti[2]
Yasi
1 27
2 55
3 34
4 42
5 20
6 27
7 34
8 42

Aşağıda Konsol(Console) paneline yakınlaşınca yazdıklarımı daha rahat görebiliyorum.

Devam edelim;

Ogrenci_veriseti[2:3] # 2ci ve 3cü sütunlar listelenecek

Ogrenci_veriseti[c(“Yasi”, “Cinsiyeti”)] #aynı sütunları isimlerini kullanarak da listeleyebiliriz.

İçindekiler

• • R-ortamı
  • Veri tipleri
  •       Skaler
  •               Karakter
  •               Nümerik
  •               Fonksiyonlar
  •                         a:b
  •                         seq()
  •                         rep()
  •       Vektör
  •             Karakter
  •              Nümerik
  •              Mantıksal
  •             Vektör aritmetiği
  •                    Operatörler
  •                    Aritmetik
  •                    Operatörlerin sıralaması
  •                    Fonksiyonlar
  •                       Özet istatistikler
  •                       Sayma istatistikleri
  •                       Standardizasyon
  •                    İndeksleme vektörleri
  •       Matrix
  •       Dizi
  •       Veri kümeleri
  •       Liste
  •       Faktor
  • R ile kodlama
  •       Kütüphane – library
  •       Girdi -input
  •       Döngü -loop
  •       Yeni kayıt ekleme
  • Grafikler
  •    Çizgi grafik
  •    Bar grafik
  •    Eğri 
  •    Karma grafik
  • Örnek çalışmalar
  •    Covid19 grafikleri
  •        Girdi alarak – getting user input
  •         İnternetten csv dosyası ile 

Faydalanılan kaynaklar

Cran R Project

R Markdown from RStudio

R Documentation

W3schools R tutorial

Quick-R by datacamp R tutorial

Wikipedia

Courses taken by me

Coursera R programming by Johns Hopkins University

Linkedin Learning – Learning R

Last updated by oyasanli at May 16, 2021.