R-概要

Rは、統計分析、グラフィックス表現、およびレポート作成のためのプログラミング言語およびソフトウェア環境です。 Rは、ニュージーランドのオークランド大学でRoss IhakaとRobert Gentlemanによって作成され、現在R Development Core Teamによって開発されています。

Rのコアは、関数を使用したモジュール式プログラミングだけでなく、分岐とループを可能にするインタープリター型コンピューター言語です。 Rを使用すると、C、C＆plus;＆plus;、。Net、Python、またはFORTRAN言語で記述された手順と統合して効率を高めることができます。

RはGNU General Public Licenseの下で無料で入手でき、Linux、Windows、Macなどのさまざまなオペレーティングシステム用に、コンパイル済みのバイナリバージョンが提供されています。

Rは、GNUスタイルのコピーを残して配布されるフリーソフトウェアであり、 GNU S と呼ばれるGNUプロジェクトの公式部分です。

Rの進化

Rは、ニュージーランドのオークランドにあるオークランド大学統計学部の Ross Ihaka および Robert Gentleman によって最初に書かれました。 Rは1993年に初めて登場しました。

個人の大規模なグループは、コードとバグレポートを送信することでRに貢献しています。
1997年半ば以降、Rソースコードアーカイブを変更できるコアグループ（「Rコアチーム」）が存在します。

Rの特徴

前述のように、Rは、統計分析、グラフィックス表現、およびレポート用のプログラミング言語およびソフトウェア環境です。以下は、Rの重要な特徴です-

Rは、条件、ループ、ユーザー定義の再帰関数、入出力機能を含む、よく開発されたシンプルで効果的なプログラミング言語です。
Rには、効果的なデータ処理および保管機能があり、
Rは、配列、リスト、ベクトル、行列の計算のための一連の演算子を提供します。
Rは、データ分析のための大規模で一貫性のある統合されたツールのコレクションを提供します。
Rは、データ分析のためのグラフィック機能を提供し、コンピューターで直接表示するか、論文で印刷します。

結論として、Rは世界で最も広く使用されている統計プログラミング言語です。これはデータサイエンティストの第1位の選択肢であり、貢献者の活気に満ちた才能のあるコミュニティによってサポートされています。 Rは大学で教えられ、ミッションクリティカルなビジネスアプリケーションで展開されます。このチュートリアルでは、Rプログラミングと適切な例を簡単で簡単な手順で説明します。

R-環境設定

ローカル環境のセットアップ

引き続きRの環境をセットアップする場合は、以下の手順を実行できます。

Windowsインストール

RのWindowsインストーラーバージョンをhttps://cran.r-project.org/bin/windows/base/[R-3.2.2 for Windows（32/64ビット）]からダウンロードして、ローカルディレクトリに保存できます。。

「R-version-win.exe」という名前のWindowsインストーラー（.exe）です。ダブルクリックしてインストーラーを実行し、デフォルト設定を受け入れます。 Windowsが32ビットバージョンの場合、32ビットバージョンがインストールされます。ただし、Windowsが64ビットの場合、32ビットバージョンと64ビットバージョンの両方がインストールされます。

インストール後、Windows Program Filesの下のディレクトリ構造「R \ R3.2.2 \ bin \ i386 \ Rgui.exe」でプログラムを実行するアイコンを見つけることができます。このアイコンをクリックすると、Rプログラミングを行うためのRコンソールであるR-GUIが表示されます。

Linuxのインストール

Rは、https://cran.r-project.org/bin/linux/[R Binaries]からLinuxの多くのバージョンのバイナリとして入手できます。

Linuxのインストール手順は、フレーバーごとに異なります。これらの手順は、記載されているリンクのLinuxバージョンの各タイプの下に記載されています。ただし、急いでいる場合は、次のように yum コマンドを使用してRをインストールできます-

$ yum install R

上記のコマンドは、標準パッケージとともにRプログラミングのコア機能をインストールしますが、追加のパッケージが必要な場合は、次のようにRプロンプトを起動できます-

$ R
R version 3.2.0 (2015-04-16) -- "Full of  Ingredients"
Copyright (C) 2015 The R Foundation for Statistical Computing
Platform: x86_64-redhat-linux-gnu (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many  contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
>

これで、Rプロンプトでinstallコマンドを使用して、必要なパッケージをインストールできます。たとえば、次のコマンドは3Dチャートに必要な plotrix パッケージをインストールします。

> install.packages("plotrix")

R-基本的な構文

慣例として、「Hello、World！」と書くことでRプログラミングの学習を開始します。プログラム。ニーズに応じて、Rコマンドプロンプトでプログラムするか、Rスクリプトファイルを使用してプログラムを作成できます。両方を1つずつ確認しましょう。

Rコマンドプロンプト

R環境をセットアップしたら、コマンドプロンプトで次のコマンドを入力するだけでRコマンドプロンプトを簡単に起動できます-

$ R

これにより、Rインタプリタが起動し、プロンプトが表示されます。次のようにプログラムの入力を開始できます-

> myString <- "Hello, World!"
> print ( myString)
[1] "Hello, World!"

ここで、最初のステートメントは、ストリング変数myStringを定義します。ここで、ストリング「Hello、World！」を割り当てます。次に、次のステートメントprint（）を使用して、変数myStringに格納されている値を出力しています。

Rスクリプトファイル

通常、プログラムをスクリプトファイルに記述してプログラミングを行い、コマンドプロンプトで Rscript と呼ばれるRインタープリターを使用してそれらのスクリプトを実行します。だから、次のようにtest.Rと呼ばれるテキストファイルに次のコードを書くことから始めましょう-

# My first program in R Programming
myString <- "Hello, World!"

print ( myString)

上記のコードをファイルtest.Rに保存し、以下のようにLinuxコマンドプロンプトで実行します。 Windowsまたは他のシステムを使用している場合でも、構文は変わりません。

$ Rscript test.R

上記のプログラムを実行すると、次の結果が生成されます。

[1] "Hello, World!"

コメントは、Rプログラムのテキストを支援するようなものであり、実際のプログラムの実行中はインタープリターによって無視されます。単一のコメントは、次のようにステートメントの先頭に＃を使用して書き込まれます-

# My first program in R Programming

Rは複数行のコメントをサポートしていませんが、次のようなトリックを実行できます-

if(FALSE) {
   "This is a demo for multi-line comments and it should be put inside either a
      single OR double quote"
}

myString <- "Hello, World!"
print ( myString)

[1] "Hello, World!"

上記のコメントはRインタプリタによって実行されますが、実際のプログラムに干渉することはありません。このようなコメントは、一重引用符または二重引用符で囲む必要があります。

R-データ型

一般に、プログラミング言語でプログラミングを行う際には、さまざまな変数を使用してさまざまな情報を保存する必要があります。変数は、値を保存するために予約されたメモリの場所に他なりません。これは、変数を作成するときに、メモリの一部の領域を予約することを意味します。

文字、ワイド文字、整数、浮動小数点、二重浮動小数点、ブールなどのさまざまなデータ型の情報を保存することができます。変数のデータ型に基づいて、オペレーティングシステムはメモリを割り当て、予約メモリに保存できるものを決定します。

RのCやjavaなどの他のプログラミング言語とは対照的に、変数は何らかのデータ型として宣言されていません。変数にはRオブジェクトが割り当てられ、Rオブジェクトのデータ型は変数のデータ型になります。 Rオブジェクトには多くの種類があります。頻繁に使用されるものは-

ベクトル
リスト
行列
配列
要因
データフレーム

これらのオブジェクトの中で最も単純なものは* vectorオブジェクト*であり、これらのアトミックベクトルには6つのデータ型があり、6つのクラスのベクトルとも呼ばれます。他のRオブジェクトは、アトミックベクトルに基づいて構築されます。

Data Type	Example	Verify
Logical	TRUE, FALSE	`v <- TRUE print(class(v))` それは次の結果を生成します- `[1] "logical"`
Numeric	12.3, 5, 999	`v <- 23.5 print(class(v))` それは次の結果を生成します- `[1] "numeric"`
Integer	2L, 34L, 0L	`v <- 2L print(class(v))` それは次の結果を生成します- `[1] "integer"`
Complex	3 PLUS 2i	`v <- 2+5i print(class(v))` それは次の結果を生成します- `[1] "complex"`
Character	'a' , '"good", "TRUE", '23.4'	`v <- "TRUE" print(class(v))` それは次の結果を生成します- `[1] "character"`
Raw	"Hello" is stored as 48 65 6c 6c 6f	`v <- charToRaw("Hello") print(class(v))` それは次の結果を生成します- `[1] "raw"`

Rプログラミングでは、非常に基本的なデータ型は vectors と呼ばれるRオブジェクトであり、上記のように異なるクラスの要素を保持します。 Rでは、クラスの数が上記の6つのタイプだけに限定されないことに注意してください。たとえば、多くのアトミックベクトルを使用して、クラスが配列になる配列を作成できます。

ベクトル

複数の要素を含むベクターを作成する場合は、* c（）*関数を使用して、要素をベクターに結合する必要があります。

# Create a vector.
apple <- c('red','green',"yellow")
print(apple)

# Get the class of the vector.
print(class(apple))

上記のコードを実行すると、次の結果が生成されます-

[1] "red"    "green"  "yellow"
[1] "character"

行列

マトリックスは、2次元の長方形のデータセットです。行列関数へのベクトル入力を使用して作成できます。

# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

上記のコードを実行すると、次の結果が生成されます-

     [,1] [,2] [,3]
[1,] "a"  "a"  "b"
[2,] "c"  "b"  "a"

配列

行列は2次元に制限されていますが、配列は任意の次元数にすることができます。配列関数は、必要な次元数を作成するdim属性を取ります。以下の例では、それぞれ3x3のマトリックスである2つの要素を持つ配列を作成します。

# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)

上記のコードを実行すると、次の結果が生成されます-

, , 1

     [,1]     [,2]     [,3]
[1,] "green"  "yellow" "green"
[2,] "yellow" "green"  "yellow"
[3,] "green"  "yellow" "green"

, , 2

     [,1]     [,2]     [,3]
[1,] "yellow" "green"  "yellow"
[2,] "green"  "yellow" "green"
[3,] "yellow" "green"  "yellow"

要因

因子は、ベクトルを使用して作成されるrオブジェクトです。ラベルとしてベクトル内の要素の個別の値とともにベクトルを保存します。ラベルは、数値、文字、ブールなどに関係なく、常に文字です。入力ベクトル内。これらは統計モデリングに役立ちます。

因子は* factor（）関数を使用して作成されます。 *nlevels 関数は、レベルのカウントを提供します。

# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')

# Create a factor object.
factor_apple <- factor(apple_colors)

# Print the factor.
print(factor_apple)
print(nlevels(factor_apple))

上記のコードを実行すると、次の結果が生成されます-

[1] green  green  yellow red    red    red    green
Levels: green red yellow
[1] 3

データフレーム

データフレームは表形式のデータオブジェクトです。データフレームのマトリックスとは異なり、各列には異なるモードのデータを含めることができます。最初の列は数値、2番目の列は文字、3番目の列は論理値にすることができます。等しい長さのベクトルのリストです。

データフレームは、* data.frame（）*関数を使用して作成されます。

# Create the data frame.
BMI <-   data.frame(
   gender = c("Male", "Male","Female"),
   height = c(152, 171.5, 165),
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(BMI)

上記のコードを実行すると、次の結果が生成されます-

  gender height weight Age
1   Male  152.0     81  42
2   Male  171.5     93  38
3 Female  165.0     78  26

R-変数

変数は、プログラムが操作できる名前付きストレージを提供します。 Rの変数は、原子ベクトル、原子ベクトルのグループ、または多くのRobjectの組み合わせを格納できます。有効な変数名は、文字、数字、ドットまたは下線文字で構成されます。変数名は、文字で始まるか、数字が続かないドットで始まります。

Variable Name	Validity	Reason
var_name2.	valid	Has letters, numbers, dot and underscore
var_name%	Invalid	Has the character '%'. Only dot(.) and underscore allowed.
2var_name	invalid	Starts with a number
var_name,. var.name	valid	Can start with a dot(.) but the dot(.)should not be followed by a number.
.2var_name	invalid	The starting dot is followed by a number making it invalid.
_var_name	invalid	Starts with _ which is not valid

変数の割り当て

変数には、左向き、右向き、および等しい演算子を使用して値を割り当てることができます。変数の値は、* print（）または cat（）*関数を使用して出力できます。 * cat（）*関数は、複数のアイテムを連続印刷出力に結合します。

# Assignment using equal operator.
var.1 = c(0,1,2,3)

# Assignment using leftward operator.
var.2 <- c("learn","R")

# Assignment using rightward operator.
c(TRUE,1) -> var.3

print(var.1)
cat ("var.1 is ", var.1 ,"\n")
cat ("var.2 is ", var.2 ,"\n")
cat ("var.3 is ", var.3 ,"\n")

上記のコードを実行すると、次の結果が生成されます-

[1] 0 1 2 3
var.1 is  0 1 2 3
var.2 is  learn R
var.3 is  1 1

注-ベクトルc（TRUE、1）には、論理クラスと数値クラスが混在しています。したがって、論理クラスは数値クラスに強制され、TRUEが1になります。

変数のデータ型

Rでは、変数自体はどのデータ型でも宣言されず、R-オブジェクトに割り当てられたオブジェクトのデータ型を取得します。したがって、Rは動的に型指定された言語と呼ばれます。つまり、プログラムで変数を使用するときに、同じ変数の変数のデータ型を何度も変更できます。

var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"\n")

var_x <- 34.5
cat("  Now the class of var_x is ",class(var_x),"\n")

var_x <- 27L
cat("   Next the class of var_x becomes ",class(var_x),"\n")

上記のコードを実行すると、次の結果が生成されます-

The class of var_x is  character
   Now the class of var_x is  numeric
      Next the class of var_x becomes  integer

変数を見つける

ワークスペースで現在使用可能なすべての変数を知るには、* ls（）*関数を使用します。また、ls（）関数は、パターンを使用して変数名を照合できます。

print(ls())

上記のコードを実行すると、次の結果が生成されます-

[1] "my var"     "my_new_var" "my_var"     "var.1"
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"

注-環境で宣言されている変数に応じたサンプル出力です。

ls（）関数は、パターンを使用して変数名を照合できます。

# List the variables starting with the pattern "var".
print(ls(pattern = "var"))

上記のコードを実行すると、次の結果が生成されます-

[1] "my var"     "my_new_var" "my_var"     "var.1"
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"

dot（。）*で始まる変数は非表示になり、ls（）関数の「all.names = TRUE」引数を使用してリストできます。

print(ls(all.name = TRUE))

上記のコードを実行すると、次の結果が生成されます-

[1] ".cars"        ".Random.seed" ".var_name"    ".varname"     ".varname2"
[6] "my var"       "my_new_var"   "my_var"       "var.1"        "var.2"
[11]"var.3"        "var.name"     "var_name2."   "var_x"

変数を削除する

rm（）*関数を使用して、変数を削除できます。以下では、変数var.3を削除します。印刷時に、変数errorの値がスローされます。

rm(var.3)
print(var.3)

上記のコードを実行すると、次の結果が生成されます-

[1] "var.3"
Error in print(var.3) : object 'var.3' not found

すべての変数は、* rm（）関数と ls（）*関数を一緒に使用して削除できます。

rm(list = ls())
print(ls())

上記のコードを実行すると、次の結果が生成されます-

character(0)

R-演算子

演算子は、特定の数学的または論理的な操作を実行するようコンパイラーに指示する記号です。 R言語には組み込みの演算子が豊富で、次の種類の演算子が用意されています。

演算子の種類

Rプログラミングには次のタイプの演算子があります-

算術演算子
関係演算子
論理演算子
割り当て演算子
その他の演算子

算術演算子

次の表に、R言語でサポートされている算術演算子を示します。演算子は、ベクトルの各要素に作用します。

Operator	Description	Example
PLUS	Adds two vectors	`v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v+t)` それは次の結果を生成します- `[1] 10.0 8.5 10.0`
−	Subtracts second vector from the first	`v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v-t)` それは次の結果を生成します- `[1] -6.0 2.5 2.0`
*	Multiplies both vectors	`v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v*t)` それは次の結果を生成します- `[1] 16.0 16.5 24.0`
/	Divide the first vector with the second	`v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v/t)` 上記のコードを実行すると、次の結果が生成されます- `[1] 0.250000 1.833333 1.500000`
%%	Give the remainder of the first vector with the second	`v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v%%t)` それは次の結果を生成します- `[1] 2.0 2.5 2.0`
%/%	The result of division of first vector with second (quotient)	`v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v%/%t)` それは次の結果を生成します- `[1] 0 1 1`
^	The first vector raised to the exponent of second vector	`v <- c( 2,5.5,6) t <- c(8, 3, 4) print(v^t)` それは次の結果を生成します- `[1] 256.000 166.375 1296.000`

関係演算子

次の表に、R言語でサポートされている関係演算子を示します。最初のベクトルの各要素は、2番目のベクトルの対応する要素と比較されます。比較の結果はブール値です。

Operator	Description	Example
>	Checks if each element of the first vector is greater than the corresponding element of the second vector.	`v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v>t)` それは次の結果を生成します- `[1] FALSE TRUE FALSE FALSE`
<	Checks if each element of the first vector is less than the corresponding element of the second vector.	`v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v < t)` それは次の結果を生成します- `[1] TRUE FALSE TRUE FALSE`
==	Checks if each element of the first vector is equal to the corresponding element of the second vector.	`v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v == t)` それは次の結果を生成します- `[1] FALSE FALSE FALSE TRUE`
⇐	Checks if each element of the first vector is less than or equal to the corresponding element of the second vector.	`v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v<=t)` それは次の結果を生成します- `[1] TRUE FALSE TRUE TRUE`
>=	Checks if each element of the first vector is greater than or equal to the corresponding element of the second vector.	`v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v>=t)` それは次の結果を生成します- `[1] FALSE TRUE FALSE TRUE`
!=	Checks if each element of the first vector is unequal to the corresponding element of the second vector.	`v <- c(2,5.5,6,9) t <- c(8,2.5,14,9) print(v!=t)` それは次の結果を生成します- `[1] TRUE TRUE TRUE FALSE`

論理演算子

次の表に、R言語でサポートされる論理演算子を示します。論理型、数値型、または複素数型のベクトルにのみ適用できます。 1より大きいすべての数値は、論理値TRUEと見なされます。

最初のベクトルの各要素は、2番目のベクトルの対応する要素と比較されます。比較の結果はブール値です。

Operator Description Example

&

It is called Element-wise Logical AND operator. It combines each element of the first vector with the corresponding element of the second vector and gives a output TRUE if both the elements are TRUE.

v <- c(3,1,TRUE,2&plus;3i)
t <- c(4,1,FALSE,2&plus;3i)
print(v&t)

それは次の結果を生成します-

[1]  TRUE  TRUE FALSE  TRUE

It is called Element-wise Logical OR operator. It combines each element of the first vector with the corresponding element of the second vector and gives a output TRUE if one the elements is TRUE.

v <- c(3,0,TRUE,2&plus;2i)
t <- c(4,0,FALSE,2&plus;3i)
print(v

t) ----

それは次の結果を生成します-

[source,result,notranslate] ---- [1] TRUE FALSE TRUE TRUE ----

!

論理演算子&&および||ベクトルの最初の要素のみを考慮し、出力として単一要素のベクトルを与えます。

Operator	Description	Example
&&	Called Logical AND operator. Takes first element of both the vectors and gives the TRUE only if both are TRUE.	`v <- c(3,0,TRUE,2+2i) t <- c(1,3,TRUE,2+3i) print(v&&t)` それは次の結果を生成します- `[1] TRUE`

Called Logical OR operator. Takes first element of both the vectors and gives the TRUE if one of them is TRUE.	`v <- c(0,0,TRUE,2+2i) t <- c(0,3,TRUE,2+3i) print(v`

割り当て演算子

これらの演算子は、ベクトルに値を割り当てるために使用されます。

Operator Description Example

<−

or

=

or

<<−

Called Left Assignment

v1 <- c(3,1,TRUE,2&plus;3i)
v2 <<- c(3,1,TRUE,2&plus;3i)
v3 = c(3,1,TRUE,2&plus;3i)
print(v1)
print(v2)
print(v3)

それは次の結果を生成します-

[1] 3&plus;0i 1&plus;0i 1&plus;0i 2&plus;3i
[1] 3&plus;0i 1&plus;0i 1&plus;0i 2&plus;3i
[1] 3&plus;0i 1&plus;0i 1&plus;0i 2&plus;3i

a

→

or

→>

Called Right Assignment

c(3,1,TRUE,2&plus;3i) -> v1
c(3,1,TRUE,2&plus;3i) ->> v2
print(v1)
print(v2)

それは次の結果を生成します-

[1] 3&plus;0i 1&plus;0i 1&plus;0i 2&plus;3i
[1] 3&plus;0i 1&plus;0i 1&plus;0i 2&plus;3i

その他の演算子

これらの演算子は、一般的な数学的または論理的な計算ではなく、特定の目的に使用されます。

Operator	Description	Example
:	Colon operator. It creates the series of numbers in sequence for a vector.	`v <- 2:8 print(v)` それは次の結果を生成します- `[1] 2 3 4 5 6 7 8`
%in%	This operator is used to identify if an element belongs to a vector.	`v1 <- 8 v2 <- 12 t <- 1:10 print(v1 %in% t) print(v2 %in% t)` それは次の結果を生成します- `[1] TRUE [1] FALSE`
%*%	This operator is used to multiply a matrix with its transpose.	`M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE) t = M %*% t(M) print(t)` それは次の結果を生成します- `[,1] [,2] [1,] 65 82 [2,] 82 117`

R-意思決定

意思決定構造では、プログラマーは、プログラムが評価またはテストする1つ以上の条件を、条件が true であると判断された場合に実行されるステートメント、およびオプションで次の場合に実行されるステートメントとともに指定する必要があります。条件は false であると判断されます。

以下は、ほとんどのプログラミング言語で見られる典型的な意思決定構造の一般的な形式です-

意思決定

Rは、以下のタイプの意思決定ステートメントを提供します。詳細を確認するには、次のリンクをクリックしてください。

Sr.No.

Statement & Description

1

if statement

if* ステートメントは、ブール式とそれに続く1つ以上のステートメントで構成されます。

2

if…else statement

if* ステートメントの後にオプションの *else* ステートメントを続けることができます。これは、ブール式がfalseの場合に実行されます。

3

switch statement

switch* ステートメントを使用すると、変数を値のリストと等しいかどうかをテストできます。

R-ループ

コードのブロックを数回実行する必要がある場合があります。一般に、ステートメントは順番に実行されます。関数の最初のステートメントが最初に実行され、次に2番目のステートメントが実行されます。

プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。

ループステートメントを使用すると、ステートメントまたはステートメントのグループを複数回実行できます。次は、ほとんどのプログラミング言語でのループステートメントの一般的な形式です-

ループアーキテクチャ

Rプログラミング言語は、ループ要件を処理するために次の種類のループを提供します。詳細を確認するには、次のリンクをクリックしてください。

Sr.No.

Loop Type & Description

1

repeat loop

一連のステートメントを複数回実行し、ループ変数を管理するコードを短縮します。

2

while loop

特定の条件が真の間、ステートメントまたはステートメントのグループを繰り返します。ループ本体を実行する前に条件をテストします。

3

for loop

whileステートメントと似ていますが、ループ本体の最後で条件をテストします。

ループ制御ステートメント

ループ制御ステートメントは、通常のシーケンスから実行を変更します。実行がスコープを離れると、そのスコープで作成されたすべての自動オブジェクトが破棄されます。

Rは、次の制御ステートメントをサポートしています。詳細を確認するには、次のリンクをクリックしてください。

Sr.No.

Control Statement & Description

1

break statement

loop* ステートメントを終了し、ループの直後のステートメントに実行を転送します。

2

Next statement

next* ステートメントは、Rスイッチの動作をシミュレートします。

R-関数

関数は、特定のタスクを実行するためにまとめられた一連のステートメントです。 Rには多数の組み込み関数があり、ユーザーは独自の関数を作成できます。

Rでは、関数はオブジェクトであるため、Rインタープリターは、関数がアクションを実行するために必要な引数とともに、制御を関数に渡すことができます。

次に、関数はそのタスクを実行し、インタープリターに制御を返します。また、他のオブジェクトに格納される可能性のある結果を返します。

関数定義

R関数は、キーワード function を使用して作成されます。 R関数定義の基本的な構文は次のとおりです-

function_name <- function(arg_1, arg_2, ...) {
   Function body
}

機能コンポーネント

関数のさまざまな部分は-

関数名-これは関数の実際の名前です。この名前のオブジェクトとしてR環境に保存されます。
引数-引数はプレースホルダーです。関数が呼び出されると、引数に値を渡します。引数はオプションです。つまり、関数には引数が含まれない場合があります。また、引数にはデフォルト値を設定できます。
関数本体-関数本体には、関数の動作を定義するステートメントのコレクションが含まれています。
戻り値-関数の戻り値は、評価される関数本体の最後の式です。

Rには、最初に定義せずにプログラムで直接呼び出すことができる多くの*組み込み*関数があります。また、*ユーザー定義*関数と呼ばれる独自の関数を作成して使用することもできます。

組み込み関数

組み込み関数の簡単な例は、* seq（）、 mean（）、 max（）、 sum（x）、および paste（…）*などです。これらは、ユーザー作成プログラムによって直接呼び出されます。 https://cran.r-project.org/doc/contrib/Short-refcard.pdf [最も広く使用されているR関数]を参照できます。

# Create a sequence of numbers from 32 to 44.
print(seq(32,44))

# Find mean of numbers from 25 to 82.
print(mean(25:82))

# Find sum of numbers frm 41 to 68.
print(sum(41:68))

上記のコードを実行すると、次の結果が生成されます-

[1] 32 33 34 35 36 37 38 39 40 41 42 43 44
[1] 53.5
[1] 1526

ユーザー定義関数

Rでユーザー定義関数を作成できます。これらはユーザーが望むものに固有のものであり、一度作成すると組み込み関数のように使用できます。以下は、関数がどのように作成され使用されるかの例です。

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}

関数を呼び出す

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}

# Call the function new.function supplying 6 as an argument.
new.function(6)

上記のコードを実行すると、次の結果が生成されます-

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36

引数なしで関数を呼び出す

# Create a function without an argument.
new.function <- function() {
   for(i in 1:5) {
      print(i^2)
   }
}

# Call the function without supplying an argument.
new.function()

上記のコードを実行すると、次の結果が生成されます-

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25

引数値を使用した関数の呼び出し（位置および名前による）

関数呼び出しの引数は、関数で定義されているのと同じ順序で指定するか、別の順序で指定しますが、引数の名前に割り当てることができます。

# Create a function with arguments.
new.function <- function(a,b,c) {
   result <- a *b + c
   print(result)
}

# Call the function by position of arguments.
new.function(5,3,11)

# Call the function by names of the arguments.
new.function(a = 11, b = 5, c = 3)

上記のコードを実行すると、次の結果が生成されます-

[1] 26
[1] 58

デフォルト引数で関数を呼び出す

関数定義で引数の値を定義し、引数を指定せずに関数を呼び出してデフォルトの結果を取得できます。ただし、引数の新しい値を指定してこのような関数を呼び出し、デフォルト以外の結果を取得することもできます。

# Create a function with arguments.
new.function <- function(a = 3, b = 6) {
   result <- a* b
   print(result)
}

# Call the function without giving any argument.
new.function()

# Call the function with giving new values of the argument.
new.function(9,5)

上記のコードを実行すると、次の結果が生成されます-

[1] 18
[1] 45

関数の遅延評価

関数への引数は遅延評価されます。つまり、関数本体で必要な場合にのみ評価されます。

# Create a function with arguments.
new.function <- function(a, b) {
   print(a^2)
   print(a)
   print(b)
}

# Evaluate the function without supplying one of the arguments.
new.function(6)

上記のコードを実行すると、次の結果が生成されます-

[1] 36
[1] 6
Error in print(b) : argument "b" is missing, with no default

R-ストリング

Rの単一引用符または二重引用符のペア内に記述された値は、文字列として扱われます。内部的にRは、単一引用符で作成した場合でも、すべての文字列を二重引用符で囲んで保存します。

文字列の構築に適用されるルール

文字列の先頭と末尾の引用符は、両方とも二重引用符か両方とも単一引用符にする必要があります。それらを混在させることはできません。
二重引用符は、単一引用符で開始および終了する文字列に挿入できます。
単一引用符は、二重引用符で始まり、二重引用符で終わる文字列に挿入できます。
二重引用符で始まり、二重引用符で終わる文字列に二重引用符を挿入することはできません。
単一引用符は、単一引用符で始まり、単一引用符で終わる文字列に挿入できません。

有効な文字列の例

次の例は、Rでの文字列の作成に関するルールを明確にします。

a <- 'Start and end with single quote'
print(a)

b <- "Start and end with double quotes"
print(b)

c <- "single quote ' in between double quotes"
print(c)

d <- 'Double quotes " in between single quote'
print(d)

上記のコードを実行すると、次の出力が得られます-

[1] "Start and end with single quote"
[1] "Start and end with double quotes"
[1] "single quote ' in between double quote"
[1] "Double quote \" in between single quote"

無効な文字列の例

e <- 'Mixed quotes"
print(e)

f <- 'Single quote ' inside single quote'
print(f)

g <- "Double quotes " inside double quotes"
print(g)

スクリプトを実行すると、以下の結果が表示されて失敗します。

Error: unexpected symbol in:
"print(e)
f <- 'Single"
Execution halted

文字列操作

文字列の連結-paste（）関数

Rの多くの文字列は、* paste（）*関数を使用して結合されます。任意の数の引数を組み合わせて組み合わせることができます。

構文

貼り付け機能の基本的な構文は次のとおりです-

paste(..., sep = " ", collapse = NULL)

以下は、使用されるパラメータの説明です-

… は、結合される任意の数の引数を表します。
sep は、引数間の区切り文字を表します。オプションです。
collapse は、2つの文字列の間のスペースを削除するために使用されます。しかし、1つの文字列の2つの単語内のスペースではありません。

例

a <- "Hello"
b <- 'How'
c <- "are you? "

print(paste(a,b,c))

print(paste(a,b,c, sep = "-"))

print(paste(a,b,c, sep = "", collapse = ""))

上記のコードを実行すると、次の結果が生成されます-

[1] "Hello How are you? "
[1] "Hello-How-are you? "
[1] "HelloHoware you? "

数字と文字列のフォーマット-format（）関数

format（）*関数を使用して、数字と文字列を特定のスタイルにフォーマットできます。

構文

フォーマット機能の基本的な構文は次のとおりです-

format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))

以下は、使用されるパラメータの説明です-

x はベクトル入力です。
digits は、表示される合計桁数です。
nsmall は、小数点の右側の最小桁数です。
科学表記法を表示するには、 scientific をTRUEに設定します。
width は、先頭に空白を埋めることによって表示される最小幅を示します。
justify は、文字列を左、右、または中央に表示します。

例

# Total number of digits displayed. Last digit rounded off.
result <- format(23.123456789, digits = 9)
print(result)

# Display numbers in scientific notation.
result <- format(c(6, 13.14521), scientific = TRUE)
print(result)

# The minimum number of digits to the right of the decimal point.
result <- format(23.47, nsmall = 5)
print(result)

# Format treats everything as a string.
result <- format(6)
print(result)

# Numbers are padded with blank in the beginning for width.
result <- format(13.7, width = 6)
print(result)

# Left justify strings.
result <- format("Hello", width = 8, justify = "l")
print(result)

# Justfy string with center.
result <- format("Hello", width = 8, justify = "c")
print(result)

上記のコードを実行すると、次の結果が生成されます-

[1] "23.1234568"
[1] "6.000000e+00" "1.314521e+01"
[1] "23.47000"
[1] "6"
[1] "  13.7"
[1] "Hello   "
[1] " Hello  "

文字列の文字数を数える-nchar（）関数

この関数は、文字列内のスペースを含む文字数をカウントします。

構文

nchar（）関数の基本的な構文は次のとおりです-

nchar(x)

以下は、使用されるパラメータの説明です-

x はベクトル入力です。

例

result <- nchar("Count the number of characters")
print(result)

上記のコードを実行すると、次の結果が生成されます-

[1] 30

大文字と小文字の変更-toupper（）およびtolower（）関数

これらの関数は、文字列の文字の大文字と小文字を変更します。

構文

toupper（）およびtolower（）関数の基本的な構文は-

toupper(x)
tolower(x)

以下は、使用されるパラメータの説明です-

x はベクトル入力です。

例

# Changing to Upper case.
result <- toupper("Changing To Upper")
print(result)

# Changing to lower case.
result <- tolower("Changing To Lower")
print(result)

上記のコードを実行すると、次の結果が生成されます-

[1] "CHANGING TO UPPER"
[1] "changing to lower"

文字列の一部の抽出-substring（）関数

この関数は、文字列の一部を抽出します。

構文

substring（）関数の基本的な構文は次のとおりです-

substring(x,first,last)

以下は、使用されるパラメータの説明です-

x は文字ベクトル入力です。
first は、抽出される最初の文字の位置です。
last は、抽出される最後の文字の位置です。

例

# Extract characters from 5th to 7th position.
result <- substring("Extract", 5, 7)
print(result)

上記のコードを実行すると、次の結果が生成されます-

[1] "act"

R-ベクトル

ベクトルは最も基本的なRデータオブジェクトであり、6種類のアトミックベクトルがあります。論理、整数、倍精度、複素数、文字、および生です。

ベクター作成

単一要素ベクトル

Rに値を1つだけ記述しても、長さ1のベクトルになり、上記のベクトルタイプのいずれかに属します。

# Atomic vector of type character.
print("abc");

# Atomic vector of type double.
print(12.5)

# Atomic vector of type integer.
print(63L)

# Atomic vector of type logical.
print(TRUE)

# Atomic vector of type complex.
print(2+3i)

# Atomic vector of type raw.
print(charToRaw('hello'))

上記のコードを実行すると、次の結果が生成されます-

[1] "abc"
[1] 12.5
[1] 63
[1] TRUE
[1] 2+3i
[1] 68 65 6c 6c 6f

複数の要素のベクトル

数値データでコロン演算子を使用

# Creating a sequence from 5 to 13.
v <- 5:13
print(v)

# Creating a sequence from 6.6 to 12.6.
v <- 6.6:12.6
print(v)

# If the final element specified does not belong to the sequence then it is discarded.
v <- 3.8:11.4
print(v)

上記のコードを実行すると、次の結果が生成されます-

[1]  5  6  7  8  9 10 11 12 13
[1]  6.6  7.6  8.6  9.6 10.6 11.6 12.6
[1]  3.8  4.8  5.8  6.8  7.8  8.8  9.8 10.8

シーケンス（Seq。）演算子を使用

# Create vector with elements from 5 to 9 incrementing by 0.4.
print(seq(5, 9, by = 0.4))

上記のコードを実行すると、次の結果が生成されます-

[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0

c（）関数の使用 *

要素の1つが文字である場合、非文字値は文字タイプに強制されます。

# The logical and numeric values are converted to characters.
s <- c('apple','red',5,TRUE)
print(s)

上記のコードを実行すると、次の結果が生成されます-

[1] "apple" "red"   "5"     "TRUE"

ベクター要素へのアクセス

ベクターの要素には、インデックスを使用してアクセスします。* []角括弧*はインデックス作成に使用されます。インデックス作成は位置1から始まります。インデックスに負の値を指定すると、その要素がresultから削除されます。 TRUE 、 FALSE 、または 0 および 1 は、インデックス作成にも使用できます。

# Accessing vector elements using position.
t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
u <- t[c(2,3,6)]
print(u)

# Accessing vector elements using logical indexing.
v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
print(v)

# Accessing vector elements using negative indexing.
x <- t[c(-2,-5)]
print(x)

# Accessing vector elements using 0/1 indexing.
y <- t[c(0,0,0,0,0,0,1)]
print(y)

上記のコードを実行すると、次の結果が生成されます-

[1] "Mon" "Tue" "Fri"
[1] "Sun" "Fri"
[1] "Sun" "Tue" "Wed" "Fri" "Sat"
[1] "Sun"

ベクトル操作

ベクトル演算

同じ長さの2つのベクトルを加算、減算、乗算、または除算して、ベクトル出力として結果を得ることができます。

# Create two vectors.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)

# Vector addition.
add.result <- v1+v2
print(add.result)

# Vector subtraction.
sub.result <- v1-v2
print(sub.result)

# Vector multiplication.
multi.result <- v1*v2
print(multi.result)

# Vector division.
divi.result <- v1/v2
print(divi.result)

上記のコードを実行すると、次の結果が生成されます-

[1]  7 19  4 13  1 13
[1] -1 -3  4 -3 -1  9
[1] 12 88  0 40  0 22
[1] 0.7500000 0.7272727       Inf 0.6250000 0.0000000 5.5000000

ベクター要素のリサイクル

長さが等しくない2つのベクトルに算術演算を適用すると、短いベクトルの要素はリサイクルされて演算が完了します。

v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)
# V2 becomes c(4,11,4,11,4,11)

add.result <- v1+v2
print(add.result)

sub.result <- v1-v2
print(sub.result)

上記のコードを実行すると、次の結果が生成されます-

[1]  7 19  8 16  4 22
[1] -1 -3  0 -6 -4  0

ベクター要素の並べ替え

ベクトルの要素は、* sort（）*関数を使用してソートできます。

v <- c(3,8,4,5,0,11, -9, 304)

# Sort the elements of the vector.
sort.result <- sort(v)
print(sort.result)

# Sort the elements in the reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

# Sorting character vectors.
v <- c("Red","Blue","yellow","violet")
sort.result <- sort(v)
print(sort.result)

# Sorting character vectors in reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

上記のコードを実行すると、次の結果が生成されます-

[1]  -9   0   3   4   5   8  11 304
[1] 304  11   8   5   4   3   0  -9
[1] "Blue"   "Red"    "violet" "yellow"
[1] "yellow" "violet" "Red"    "Blue"

R-リスト

リストは、数、文字列、ベクトルなどのさまざまなタイプの要素を含むRオブジェクトです。リストには、要素として行列または関数を含めることもできます。リストは* list（）*関数を使用して作成されます。

リストを作成する

以下は、文字列、数値、ベクトル、論理値を含むリストを作成する例です。

# Create a list containing strings, numbers, vectors and a logical
# values.
list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1)
print(list_data)

上記のコードを実行すると、次の結果が生成されます-

[[Red"

[[Green"

[[TRUE

[[Naming List Elements

The list elements can be given names and they can be accessed using these names.

[source,prettyprint,notranslate]

＃ベクトル、マトリックス、リストを含むリストを作成します。 list_data ←list（c（ "Jan"、 "Feb"、 "Mar"）、matrix（c（3,9,5,1、-2,8）、nrow = 2）、list（ "green"、12.3 ））

＃リスト内の要素に名前を付けます。 names（list_data）←c（ "1st Quarter"、 "A_Matrix"、 "A内部リスト"）

＃リストを表示します。 print（list_data）

When we execute the above code, it produces the following result −

[source,result,notranslate]

$ 1st_Quarter [1] "Jan" "Feb" "Mar"

$ A_Matrix [、1] [、2] [、3] [1,] 3 5 -2 [2,] 9 1 8

$ A_Inner_list $ A_Inner_list [[green "

$ A_Inner_list [[リスト要素へのアクセス

リストの要素には、リスト内の要素のインデックスを使用してアクセスできます。名前付きリストの場合、名前を使用してアクセスすることもできます。

上記の例のリストを使用し続けます-

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Access the first element of the list.
print(list_data[1])

# Access the thrid element. As it is also a list, all its elements will be printed.
print(list_data[3])

# Access the list element using the name of the element.
print(list_data$A_Matrix)

上記のコードを実行すると、次の結果が生成されます-

$`1st_Quarter`
[1] "Jan" "Feb" "Mar"

$A_Inner_list
$A_Inner_list[[green"

$A_Inner_list[[Manipulating List Elements

We can add, delete and update list elements as shown below. We can add and delete elements only at the end of a list. But we can update any element.

[source,prettyprint,notranslate]

＃ベクトル、マトリックス、リストを含むリストを作成します。 list_data ←list（c（ "Jan"、 "Feb"、 "Mar"）、matrix（c（3,9,5,1、-2,8）、nrow = 2）、list（ "green"、12.3 ））

＃リスト内の要素に名前を付けます。 names（list_data）←c（ "1st Quarter"、 "A_Matrix"、 "A内部リスト"）

＃リストの最後に要素を追加します。 list_data [4] ←"新しい要素" print（list_data [4]）

＃最後の要素を削除します。 list_data [4] ←NULL

＃4番目の要素を印刷します。 print（list_data [4]）

＃3番目の要素を更新します。 list_data [3] ←"更新された要素" print（list_data [3]）

When we execute the above code, it produces the following result −

[source,result,notranslate]

[[新しい要素]

$ <NA> NULL

$ 内部リスト [1] "updated element"

=== Merging Lists

You can merge many lists into one list by placing all the lists inside one list() function.

[source,prettyprint,notranslate]

＃2つのリストを作成します。 list1 ←list（1,2,3）list2 ←list（ "Sun"、 "Mon"、 "Tue"）

＃2つのリストをマージします。 merged.list ←c（list1、list2）

＃結合リストを印刷します。 print（merged.list）

When we execute the above code, it produces the following result −

[source,result,notranslate]

[[太陽"

[[月]

[[火]

Converting List to Vector

A list can be converted to a vector so that the elements of the vector can be used for further manipulation. All the arithmetic operations on vectors can be applied after the list is converted into vectors. To do this conversion, we use the unlist() function. It takes the list as input and produces a vector.

＃リストを作成します。 list1 <-list（1：5）print（list1）

list2 <-list（10:14）print（list2）

＃リストをベクトルに変換します。 v1 <-unlist（list1）v2 <-unlist（list2）

print（v1）print（v2）

＃次にベクターの結果を追加<-v1 + v2 print（result）

When we execute the above code, it produces the following result −

[[

R-行列

行列は、要素が2次元の長方形のレイアウトで配置されているRオブジェクトです。それらには、同じ原子型の要素が含まれます。文字のみまたは論理値のみを含むマトリックスを作成できますが、あまり役に立ちません。数学的計算に使用される数値要素を含む行列を使用します。

マトリックスは、* matrix（）*関数を使用して作成されます。

構文

Rで行列を作成するための基本的な構文は次のとおりです-

matrix(data, nrow, ncol, byrow, dimnames)

以下は、使用されるパラメータの説明です-

data は、行列のデータ要素になる入力ベクトルです。
nrow は、作成される行の数です。
ncol は、作成される列の数です。
byrow は論理的な手がかりです。 TRUEの場合、入力ベクトル要素は行ごとに配置されます。
dimname は、行と列に割り当てられた名前です。

例

入力として数値のベクトルを取る行列を作成します。

# Elements are arranged sequentially by row.
M <- matrix(c(3:14), nrow = 4, byrow = TRUE)
print(M)

# Elements are arranged sequentially by column.
N <- matrix(c(3:14), nrow = 4, byrow = FALSE)
print(N)

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
print(P)

上記のコードを実行すると、次の結果が生成されます-

     [,1] [,2] [,3]
[1,]    3    4    5
[2,]    6    7    8
[3,]    9   10   11
[4,]   12   13   14
     [,1] [,2] [,3]
[1,]    3    7   11
[2,]    4    8   12
[3,]    5    9   13
[4,]    6   10   14
     col1 col2 col3
row1    3    4    5
row2    6    7    8
row3    9   10   11
row4   12   13   14

マトリックスの要素へのアクセス

行列の要素には、要素の列と行のインデックスを使用してアクセスできます。以下の特定の要素を見つけるために、上の行列Pを考慮します。

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

# Create the matrix.
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))

# Access the element at 3rd column and 1st row.
print(P[1,3])

# Access the element at 2nd column and 4th row.
print(P[4,2])

# Access only the  2nd row.
print(P[2,])

# Access only the 3rd column.
print(P[,3])

上記のコードを実行すると、次の結果が生成されます-

[1] 5
[1] 13
col1 col2 col3
   6    7    8
row1 row2 row3 row4
   5    8   11   14

行列計算

R演算子を使用して、行列に対してさまざまな数学演算が実行されます。演算の結果も行列です。

次元（行と列の数）は、操作に関係する行列で同じでなければなりません。

行列の加算と減算

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Add the matrices.
result <- matrix1 + matrix2
cat("Result of addition","\n")
print(result)

# Subtract the matrices
result <- matrix1 - matrix2
cat("Result of subtraction","\n")
print(result)

上記のコードを実行すると、次の結果が生成されます-

     [,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of addition
     [,1] [,2] [,3]
[1,]    8   -1    5
[2,]   11   13   10
Result of subtraction
     [,1] [,2] [,3]
[1,]   -2   -1   -1
[2,]    7   -5    2

行列の乗算と除算

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Multiply the matrices.
result <- matrix1 * matrix2
cat("Result of multiplication","\n")
print(result)

# Divide the matrices
result <- matrix1/matrix2
cat("Result of division","\n")
print(result)

上記のコードを実行すると、次の結果が生成されます-

     [,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of multiplication
     [,1] [,2] [,3]
[1,]   15    0    6
[2,]   18   36   24
Result of division
     [,1]      [,2]      [,3]
[1,]  0.6      -Inf 0.6666667
[2,]  4.5 0.4444444 1.5000000

R-配列

配列は、3次元以上でデータを保存できるRデータオブジェクトです。たとえば-次元の配列（2、3、4）を作成すると、それぞれ2行3列の4つの長方形行列が作成されます。配列はデータ型のみを保存できます。

配列は* array（）関数を使用して作成されます。入力としてベクトルを受け取り、 *dim パラメーターの値を使用して配列を作成します。

例

次の例では、それぞれ3行3列の2つの3x3行列の配列を作成します。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)

上記のコードを実行すると、次の結果が生成されます-

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

列と行の命名

*dimnames* パラメーターを使用して、配列内の行、列、および行列に名前を付けることができます。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
   matrix.names))
print(result)

上記のコードを実行すると、次の結果が生成されます-

, , Matrix1

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

, , Matrix2

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

配列要素へのアクセス

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,
   column.names, matrix.names))

# Print the third row of the second matrix of the array.
print(result[3,,2])

# Print the element in the 1st row and 3rd column of the 1st matrix.
print(result[1,3,1])

# Print the 2nd Matrix.
print(result[,,2])

上記のコードを実行すると、次の結果が生成されます-

COL1 COL2 COL3
   3   12   15
[1] 13
     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

配列要素の操作

配列は複数の次元のマトリックスで構成されているため、配列の要素に対する操作は、マトリックスの要素にアクセスすることで実行されます。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
array1 <- array(c(vector1,vector2),dim = c(3,3,2))

# Create two vectors of different lengths.
vector3 <- c(9,1,0)
vector4 <- c(6,0,11,3,14,1,2,6,9)
array2 <- array(c(vector1,vector2),dim = c(3,3,2))

# create matrices from these arrays.
matrix1 <- array1[,,2]
matrix2 <- array2[,,2]

# Add the matrices.
result <- matrix1+matrix2
print(result)

上記のコードを実行すると、次の結果が生成されます-

     [,1] [,2] [,3]
[1,]   10   20   26
[2,]   18   22   28
[3,]    6   24   30

配列要素全体の計算

apply（）*関数を使用して、配列内の要素間で計算を行うことができます。

構文

apply(x, margin, fun)

以下は、使用されるパラメータの説明です-

x は配列です。
margin は、使用されるデータセットの名前です。
fun は、配列の要素全体に適用される関数です。

例

以下のapply（）関数を使用して、すべてのマトリックスにわたる配列の行の要素の合計を計算します。

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
new.array <- array(c(vector1,vector2),dim = c(3,3,2))
print(new.array)

# Use apply to calculate the sum of the rows across all the matrices.
result <- apply(new.array, c(1), sum)
print(result)

上記のコードを実行すると、次の結果が生成されます-

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

[1] 56 68 60

R-要因

ファクターは、データを分類してレベルとして保存するために使用されるデータオブジェクトです。文字列と整数の両方を保存できます。これらは、限られた数の一意の値を持つ列で役立ちます。「男性、女性」、True、Falseなど。統計モデリングのデータ分析に役立ちます。

因子は、ベクトルを入力として* factor（）*関数を使用して作成されます。

例

# Create a vector as input.
data <- c("East","West","East","North","North","East","West","West","West","East","North")

print(data)
print(is.factor(data))

# Apply the factor function.
factor_data <- factor(data)

print(factor_data)
print(is.factor(factor_data))

上記のコードを実行すると、次の結果が生成されます-

[1] "East"  "West"  "East"  "North" "North" "East"  "West"  "West"  "West"  "East" "North"
[1] FALSE
[1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
[1] TRUE

データフレームの要因

テキストデータの列を持つデータフレームを作成すると、Rはテキスト列をカテゴリカルデータとして扱い、その列にファクターを作成します。

# Create the vectors for data frame.
height <- c(132,151,162,139,166,147,122)
weight <- c(48,49,66,53,67,52,40)
gender <- c("male","male","female","female","male","female","male")

# Create the data frame.
input_data <- data.frame(height,weight,gender)
print(input_data)

# Test if the gender column is a factor.
print(is.factor(input_data$gender))

# Print the gender column so see the levels.
print(input_data$gender)

上記のコードを実行すると、次の結果が生成されます-

  height weight gender
1    132     48   male
2    151     49   male
3    162     66 female
4    139     53 female
5    166     67   male
6    147     52 female
7    122     40   male
[1] TRUE
[1] male   male   female female male   female male
Levels: female male

レベルの順序を変更する

因子内のレベルの順序は、新しいレベルの順序で因子関数を再度適用することにより変更できます。

data <- c("East","West","East","North","North","East","West",
   "West","West","East","North")
# Create the factors
factor_data <- factor(data)
print(factor_data)

# Apply the factor function with required order of the level.
new_order_data <- factor(factor_data,levels = c("East","West","North"))
print(new_order_data)

上記のコードを実行すると、次の結果が生成されます-

 [1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
 [1] East  West  East  North North East  West  West  West  East  North
Levels: East West North

因子レベルの生成

gl（）*関数を使用して、因子レベルを生成できます。入力として2つの整数を取り、それはレベルの数と各レベルの回数を示します。

構文

gl(n, k, labels)

以下は、使用されるパラメータの説明です-

n はレベル数を示す整数です。
k は、レプリケーションの数を示す整数です。
labels は、結果の因子レベルのラベルのベクトルです。

例

v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston"))
print(v)

上記のコードを実行すると、次の結果が生成されます-

Tampa   Tampa   Tampa   Tampa   Seattle Seattle Seattle Seattle Boston
[10] Boston  Boston  Boston
Levels: Tampa Seattle Boston

R-データフレーム

データフレームはテーブルまたは2次元配列のような構造で、各列には1つの変数の値が含まれ、各行には各列の値のセットが1つ含まれます。

以下は、データフレームの特性です。

列名は空ではないはずです。
行名は一意である必要があります。
データフレームに格納されるデータは、数値、ファクタ、または文字タイプです。
各列には同じ数のデータ項目が含まれている必要があります。

データフレームの作成

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),

   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the data frame.
print(emp.data)

上記のコードを実行すると、次の結果が生成されます-

 emp_id    emp_name     salary     start_date
1     1     Rick        623.30     2012-01-01
2     2     Dan         515.20     2013-09-23
3     3     Michelle    611.00     2014-11-15
4     4     Ryan        729.00     2014-05-11
5     5     Gary        843.25     2015-03-27

データフレームの構造を取得する

データフレームの構造は、* str（）*関数を使用して確認できます。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),

   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Get the structure of the data frame.
str(emp.data)

上記のコードを実行すると、次の結果が生成されます-

'data.frame':   5 obs. of  4 variables:
 $ emp_id    : int  1 2 3 4 5
 $ emp_name  : chr  "Rick" "Dan" "Michelle" "Ryan" ...
 $ salary    : num  623 515 611 729 843
 $ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...

データフレームのデータの概要

統計の概要とデータの性質は、* summary（）*関数を適用することで取得できます。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),

   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the summary.
print(summary(emp.data))

上記のコードを実行すると、次の結果が生成されます-

     emp_id    emp_name             salary        start_date
 Min.   :1   Length:5           Min.   :515.2   Min.   :2012-01-01
 1st Qu.:2   Class :character   1st Qu.:611.0   1st Qu.:2013-09-23
 Median :3   Mode  :character   Median :623.3   Median :2014-05-11
 Mean   :3                      Mean   :664.4   Mean   :2014-01-14
 3rd Qu.:4                      3rd Qu.:729.0   3rd Qu.:2014-11-15
 Max.   :5                      Max.   :843.2   Max.   :2015-03-27

データフレームからデータを抽出する

列名を使用してデータフレームから特定の列を抽出します。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),

   start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract Specific columns.
result <- data.frame(emp.data$emp_name,emp.data$salary)
print(result)

上記のコードを実行すると、次の結果が生成されます-

  emp.data.emp_name emp.data.salary
1              Rick          623.30
2               Dan          515.20
3          Michelle          611.00
4              Ryan          729.00
5              Gary          843.25

最初の2行を抽出してから、すべての列を抽出します

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),

   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract first two rows.
result <- emp.data[1:2,]
print(result)

上記のコードを実行すると、次の結果が生成されます-

  emp_id    emp_name   salary    start_date
1      1     Rick      623.3     2012-01-01
2      2     Dan       515.2     2013-09-23

2 ^ nd ^および4 ^ th ^列で3 ^ rd ^および5 ^ th ^行を抽出します

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),

    start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Extract 3rd and 5th row with 2nd and 4th column.
result <- emp.data[c(3,5),c(2,4)]
print(result)

上記のコードを実行すると、次の結果が生成されます-

  emp_name start_date
3 Michelle 2014-11-15
5     Gary 2015-03-27

データフレームを展開

データフレームは、列と行を追加することで拡張できます。

列を追加

新しい列名を使用して列ベクトルを追加するだけです。

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),

   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Add the "dept" coulmn.
emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)

上記のコードを実行すると、次の結果が生成されます-

  emp_id   emp_name    salary    start_date       dept
1     1    Rick        623.30    2012-01-01       IT
2     2    Dan         515.20    2013-09-23       Operations
3     3    Michelle    611.00    2014-11-15       IT
4     4    Ryan        729.00    2014-05-11       HR
5     5    Gary        843.25    2015-03-27       Finance

行を追加する

既存のデータフレームに永続的に行を追加するには、既存のデータフレームと同じ構造で新しい行を取り込み、* rbind（）*関数を使用する必要があります。

以下の例では、新しい行を含むデータフレームを作成し、既存のデータフレームとマージして最終的なデータフレームを作成します。

# Create the first data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),

   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   dept = c("IT","Operations","IT","HR","Finance"),
   stringsAsFactors = FALSE
)

# Create the second data frame
emp.newdata <-   data.frame(
   emp_id = c (6:8),
   emp_name = c("Rasmi","Pranab","Tusar"),
   salary = c(578.0,722.5,632.8),
   start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
   dept = c("IT","Operations","Fianance"),
   stringsAsFactors = FALSE
)

# Bind the two data frames.
emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)

上記のコードを実行すると、次の結果が生成されます-

  emp_id     emp_name    salary     start_date       dept
1      1     Rick        623.30     2012-01-01       IT
2      2     Dan         515.20     2013-09-23       Operations
3      3     Michelle    611.00     2014-11-15       IT
4      4     Ryan        729.00     2014-05-11       HR
5      5     Gary        843.25     2015-03-27       Finance
6      6     Rasmi       578.00     2013-05-21       IT
7      7     Pranab      722.50     2013-07-30       Operations
8      8     Tusar       632.80     2014-06-17       Fianance

R-パッケージ

Rパッケージは、R関数、コンパイルされたコード、およびサンプルデータのコレクションです。これらは、R環境の "library" というディレクトリに保存されます。デフォルトでは、Rはインストール中に一連のパッケージをインストールします。いくつかの特定の目的で必要になったときに、後でパッケージが追加されます。 Rコンソールを起動すると、デフォルトではデフォルトのパッケージのみが利用可能です。既にインストールされている他のパッケージは、それらを使用するRプログラムで使用するために明示的にロードする必要があります。

R言語で利用可能なすべてのパッケージは、https://cran.r-project.org/web/packages/available_packages_by_namel [R Packages。]にリストされています。

以下は、Rパッケージをチェック、検証、使用するために使用するコマンドのリストです。

利用可能なRパッケージを確認する

Rパッケージを含むライブラリの場所を取得する

.libPaths()

上記のコードを実行すると、次の結果が生成されます。 PCのローカル設定によって異なる場合があります。

[2] "C:/Program Files/R/R-3.2.2/library"

インストールされているすべてのパッケージのリストを取得します

library()

上記のコードを実行すると、次の結果が生成されます。 PCのローカル設定によって異なる場合があります。

Packages in library ‘C:/Program Files/R/R-3.2.2/library’:

base                    The R Base Package
boot                    Bootstrap Functions (Originally by Angelo Canty
                        for S)
class                   Functions for Classification
cluster                 "Finding Groups in Data": Cluster Analysis
                        Extended Rousseeuw et al.
codetools               Code Analysis Tools for R
compiler                The R Compiler Package
datasets                The R Datasets Package
foreign                 Read Data Stored by 'Minitab', 'S', 'SAS',
                        'SPSS', 'Stata', 'Systat', 'Weka', 'dBase', ...
graphics                The R Graphics Package
grDevices               The R Graphics Devices and Support for Colours
                        and Fonts
grid                    The Grid Graphics Package
KernSmooth              Functions for Kernel Smoothing Supporting Wand
                        & Jones (1995)
lattice                 Trellis Graphics for R
MASS                    Support Functions and Datasets for Venables and
                        Ripley's MASS
Matrix                  Sparse and Dense Matrix Classes and Methods
methods                 Formal Methods and Classes
mgcv                    Mixed GAM Computation Vehicle with GCV/AIC/REML
                        Smoothness Estimation
nlme                    Linear and Nonlinear Mixed Effects Models
nnet                    Feed-Forward Neural Networks and Multinomial
                        Log-Linear Models
parallel                Support for Parallel computation in R
rpart                   Recursive Partitioning and Regression Trees
spatial                 Functions for Kriging and Point Pattern
                        Analysis
splines                 Regression Spline Functions and Classes
stats                   The R Stats Package
stats4                  Statistical Functions using S4 Classes
survival                Survival Analysis
tcltk                   Tcl/Tk Interface
tools                   Tools for Package Development
utils                   The R Utils Package

R環境に現在ロードされているすべてのパッケージを取得します

search()

上記のコードを実行すると、次の結果が生成されます。 PCのローカル設定によって異なる場合があります。

[1] ".GlobalEnv"        "package:stats"     "package:graphics"
[4] "package:grDevices" "package:utils"     "package:datasets"
[7] "package:methods"   "Autoloads"         "package:base"

新しいパッケージをインストールする

新しいRパッケージを追加するには2つの方法があります。 1つはCRANディレクトリから直接インストールする方法、もう1つはローカルシステムにパッケージをダウンロードして手動でインストールする方法です。

CRANから直接インストールする

次のコマンドは、CRAN Webページからパッケージを直接取得し、R環境にパッケージをインストールします。最も近いミラーを選択するように求められる場合があります。あなたの場所に適したものを選択してください。

 install.packages("Package Name")

# Install the package named "XML".
 install.packages("XML")

パッケージを手動でインストールする

リンクhttps://cran.r-project.org/web/packages/available_packages_by_namel[R Packages]にアクセスして、必要なパッケージをダウンロードします。パッケージを .zip ファイルとしてローカルシステムの適切な場所に保存します。

これで、次のコマンドを実行して、このパッケージをR環境にインストールできます。

install.packages(file_name_with_path, repos = NULL, type = "source")

# Install the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

パッケージをライブラリにロード

パッケージをコードで使用する前に、現在のR環境にロードする必要があります。また、既にインストールされているが現在の環境では利用できないパッケージをロードする必要があります。

パッケージは、次のコマンドを使用してロードされます-

library("package Name", lib.loc = "path to library")

# Load the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

R-データの形状変更

Rでのデータの再形成とは、データを行と列に編成する方法を変更することです。 Rでのデータ処理のほとんどは、入力データをデータフレームとして取得することによって行われます。データフレームの行と列からデータを抽出するのは簡単ですが、受信した形式とは異なる形式のデータフレームが必要な場合があります。 Rには、データフレーム内で行を列に、またはその逆に分割、マージ、および変更するための多くの機能があります。

データフレーム内の列と行の結合

cbind（）*関数を使用して、複数のベクトルを結合してデータフレームを作成できます。また、 rbind（）*関数を使用して2つのデータフレームをマージできます。

# Create vector objects.
city <- c("Tampa","Seattle","Hartford","Denver")
state <- c("FL","WA","CT","CO")
zipcode <- c(33602,98104,06161,80294)

# Combine above three vectors into one data frame.
addresses <- cbind(city,state,zipcode)

# Print a header.
cat("# # # # The First data frame\n")

# Print the data frame.
print(addresses)

# Create another data frame with similar columns
new.address <- data.frame(
   city = c("Lowry","Charlotte"),
   state = c("CO","FL"),
   zipcode = c("80230","33949"),
   stringsAsFactors = FALSE
)

# Print a header.
cat("# # # The Second data frame\n")

# Print the data frame.
print(new.address)

# Combine rows form both the data frames.
all.addresses <- rbind(addresses,new.address)

# Print a header.
cat("# # # The combined data frame\n")

# Print the result.
print(all.addresses)

上記のコードを実行すると、次の結果が生成されます-

# # # # The First data frame
     city       state zipcode
[1,] "Tampa"    "FL"  "33602"
[2,] "Seattle"  "WA"  "98104"
[3,] "Hartford" "CT"   "6161"
[4,] "Denver"   "CO"  "80294"

# # # The Second data frame
       city       state   zipcode
1      Lowry      CO      80230
2      Charlotte  FL      33949

# # # The combined data frame
       city      state zipcode
1      Tampa     FL    33602
2      Seattle   WA    98104
3      Hartford  CT     6161
4      Denver    CO    80294
5      Lowry     CO    80230
6     Charlotte  FL    33949

データフレームの結合

merge（）*関数を使用して、2つのデータフレームをマージできます。データフレームには、マージが発生する列名が同じである必要があります。

以下の例では、ライブラリ名「MASS」で利用可能なピマインド女性の糖尿病に関するデータセットを検討します。血圧（ "bp"）とボディマスインデックス（ "bmi"）の値に基づいて2つのデータセットをマージします。マージのためにこれらの2つの列を選択すると、これら2つの変数の値が両方のデータセットで一致するレコードが結合されて、単一のデータフレームが形成されます。

library(MASS)
merged.Pima <- merge(x = Pima.te, y = Pima.tr,
   by.x = c("bp", "bmi"),
   by.y = c("bp", "bmi")
)
print(merged.Pima)
nrow(merged.Pima)

上記のコードを実行すると、次の結果が生成されます-

   bp  bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y
1  60 33.8       1   117     23 0.466    27     No       2   125     20 0.088
2  64 29.7       2    75     24 0.370    33     No       2   100     23 0.368
3  64 31.2       5   189     33 0.583    29    Yes       3   158     13 0.295
4  64 33.2       4   117     27 0.230    24     No       1    96     27 0.289
5  66 38.1       3   115     39 0.150    28     No       1   114     36 0.289
6  68 38.5       2   100     25 0.324    26     No       7   129     49 0.439
7  70 27.4       1   116     28 0.204    21     No       0   124     20 0.254
8  70 33.1       4    91     32 0.446    22     No       9   123     44 0.374
9  70 35.4       9   124     33 0.282    34     No       6   134     23 0.542
10 72 25.6       1   157     21 0.123    24     No       4    99     17 0.294
11 72 37.7       5    95     33 0.370    27     No       6   103     32 0.324
12 74 25.9       9   134     33 0.460    81     No       8   126     38 0.162
13 74 25.9       1    95     21 0.673    36     No       8   126     38 0.162
14 78 27.6       5    88     30 0.258    37     No       6   125     31 0.565
15 78 27.6      10   122     31 0.512    45     No       6   125     31 0.565
16 78 39.4       2   112     50 0.175    24     No       4   112     40 0.236
17 88 34.5       1   117     24 0.403    40    Yes       4   127     11 0.598
   age.y type.y
1     31     No
2     21     No
3     24     No
4     21     No
5     21     No
6     43    Yes
7     36    Yes
8     40     No
9     29    Yes
10    28     No
11    55     No
12    39     No
13    39     No
14    49    Yes
15    49    Yes
16    38     No
17    28     No
[1] 17

溶解と鋳造

Rプログラミングの最も興味深い側面の1つは、データの形状を複数のステップで変更して、目的の形状にすることです。これを行うために使用される関数は、* melt（）および cast（）*と呼ばれます。

「MASS」というライブラリに存在する「ships」というデータセットを検討します。

library(MASS)
print(ships)

上記のコードを実行すると、次の結果が生成されます-

     type year   period   service   incidents
1     A   60     60        127         0
2     A   60     75         63         0
3     A   65     60       1095         3
4     A   65     75       1095         4
5     A   70     60       1512         6
.............
.............
8     A   75     75       2244         11
9     B   60     60      44882         39
10    B   60     75      17176         29
11    B   65     60      28609         58
............
............
17    C   60     60      1179          1
18    C   60     75       552          1
19    C   65     60       781          0
............
............

データを溶かす

次に、データを融解して整理し、タイプと年以外のすべての列を複数の行に変換します。

molten.ships <- melt(ships, id = c("type","year"))
print(molten.ships)

上記のコードを実行すると、次の結果が生成されます-

      type year  variable  value
1      A   60    period      60
2      A   60    period      75
3      A   65    period      60
4      A   65    period      75
............
............
9      B   60    period      60
10     B   60    period      75
11     B   65    period      60
12     B   65    period      75
13     B   70    period      60
...........
...........
41     A   60    service    127
42     A   60    service     63
43     A   65    service   1095
...........
...........
70     D   70    service   1208
71     D   75    service      0
72     D   75    service   2051
73     E   60    service     45
74     E   60    service      0
75     E   65    service    789
...........
...........
101    C   70    incidents    6
102    C   70    incidents    2
103    C   75    incidents    0
104    C   75    incidents    1
105    D   60    incidents    0
106    D   60    incidents    0
...........
...........

溶融データのキャスト

溶融データを新しい形式にキャストして、各年の各タイプの船舶の集合体を作成できます。 * cast（）*関数を使用して行われます。

recasted.ship <- cast(molten.ships, type+year~variable,sum)
print(recasted.ship)

上記のコードを実行すると、次の結果が生成されます-

     type year  period  service  incidents
1     A   60    135       190      0
2     A   65    135      2190      7
3     A   70    135      4865     24
4     A   75    135      2244     11
5     B   60    135     62058     68
6     B   65    135     48979    111
7     B   70    135     20163     56
8     B   75    135      7117     18
9     C   60    135      1731      2
10    C   65    135      1457      1
11    C   70    135      2731      8
12    C   75    135       274      1
13    D   60    135       356      0
14    D   65    135       480      0
15    D   70    135      1557     13
16    D   75    135      2051      4
17    E   60    135        45      0
18    E   65    135      1226     14
19    E   70    135      3318     17
20    E   75    135       542      1

R-CSVファイル

Rでは、R環境の外部に保存されているファイルからデータを読み取ることができます。また、オペレーティングシステムによって保存およびアクセスされるファイルにデータを書き込むこともできます。 Rは、csv、excel、xmlなどのさまざまなファイル形式を読み書きできます。

この章では、csvファイルからデータを読み取り、csvファイルにデータを書き込む方法を学習します。 Rが読み取れるように、ファイルは現在の作業ディレクトリに存在する必要があります。もちろん、独自のディレクトリを設定し、そこからファイルを読み取ることもできます。

作業ディレクトリの取得と設定

getwd（）*関数を使用して、Rワークスペースが指しているディレクトリを確認できます。 setwd（）関数を使用して、新しい作業ディレクトリを設定することもできます。

# Get and print current working directory.
print(getwd())

# Set current working directory.
setwd("/web/com")

# Get and print current working directory.
print(getwd())

上記のコードを実行すると、次の結果が生成されます-

[1] "/web/com/1441086124_2016"
[1] "/web/com"

この結果は、使用しているOSと現在のディレクトリによって異なります。

CSVファイルとして入力

csvファイルは、列の値がコンマで区切られたテキストファイルです。 input.csv という名前のファイルに存在する次のデータを考えてみましょう。

このデータをコピーして貼り付けることにより、Windowsのメモ帳を使用してこのファイルを作成できます。メモ帳の[すべてのファイルとして保存（。）]オプションを使用して、ファイルを input.csv として保存します。

id,name,salary,start_date,dept
1,Rick,623.3,2012-01-01,IT
2,Dan,515.2,2013-09-23,Operations
3,Michelle,611,2014-11-15,IT
4,Ryan,729,2014-05-11,HR
5,Gary,843.25,2015-03-27,Finance
6,Nina,578,2013-05-21,IT
7,Simon,632.8,2013-07-30,Operations
8,Guru,722.5,2014-06-17,Finance

CSVファイルの読み取り

以下は、現在の作業ディレクトリで使用可能なCSVファイルを読み取る* read.csv（）*関数の簡単な例です-

data <- read.csv("input.csv")
print(data)

上記のコードを実行すると、次の結果が生成されます-

      id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

CSVファイルの分析

デフォルトでは、* read.csv（）*関数は出力をデータフレームとして提供します。これは次のように簡単に確認できます。また、列と行の数を確認できます。

data <- read.csv("input.csv")

print(is.data.frame(data))
print(ncol(data))
print(nrow(data))

上記のコードを実行すると、次の結果が生成されます-

[1] TRUE
[1] 5
[1] 8

データフレームのデータを読み取った後、次のセクションで説明するように、データフレームに適用可能なすべての機能を適用できます。

最高給与を取得

# Create a data frame.
data <- read.csv("input.csv")

# Get the max salary from data frame.
sal <- max(data$salary)
print(sal)

上記のコードを実行すると、次の結果が生成されます-

[1] 843.25

最高給与の人の詳細を取得する

SQLのwhere句に似た特定のフィルター基準を満たす行をフェッチできます。

# Create a data frame.
data <- read.csv("input.csv")

# Get the max salary from data frame.
sal <- max(data$salary)

# Get the person detail having max salary.
retval <- subset(data, salary == max(salary))
print(retval)

上記のコードを実行すると、次の結果が生成されます-

      id    name  salary  start_date    dept
5     NA    Gary  843.25  2015-03-27    Finance

IT部門で働くすべての人々を獲得する

# Create a data frame.
data <- read.csv("input.csv")

retval <- subset( data, dept == "IT")
print(retval)

上記のコードを実行すると、次の結果が生成されます-

       id   name      salary   start_date   dept
1      1    Rick      623.3    2012-01-01   IT
3      3    Michelle  611.0    2014-11-15   IT
6      6    Nina      578.0    2013-05-21   IT

給与が600を超えるIT部門の人を取得する

# Create a data frame.
data <- read.csv("input.csv")

info <- subset(data, salary > 600 & dept == "IT")
print(info)

上記のコードを実行すると、次の結果が生成されます-

       id   name      salary   start_date   dept
1      1    Rick      623.3    2012-01-01   IT
3      3    Michelle  611.0    2014-11-15   IT

2014年以降に参加した人を取得する

# Create a data frame.
data <- read.csv("input.csv")

retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
print(retval)

上記のコードを実行すると、次の結果が生成されます-

       id   name     salary   start_date    dept
3      3    Michelle 611.00   2014-11-15    IT
4      4    Ryan     729.00   2014-05-11    HR
5     NA    Gary     843.25   2015-03-27    Finance
8      8    Guru     722.50   2014-06-17    Finance

CSVファイルへの書き込み

Rは、既存のデータフレームからCSVファイルを作成できます。 * write.csv（）*関数を使用して、csvファイルを作成します。このファイルは作業ディレクトリに作成されます。

# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))

# Write filtered data into a new file.
write.csv(retval,"output.csv")
newdata <- read.csv("output.csv")
print(newdata)

上記のコードを実行すると、次の結果が生成されます-

  X      id   name      salary   start_date    dept
1 3      3    Michelle  611.00   2014-11-15    IT
2 4      4    Ryan      729.00   2014-05-11    HR
3 5     NA    Gary      843.25   2015-03-27    Finance
4 8      8    Guru      722.50   2014-06-17    Finance

ここで、列Xはデータセットnewperに由来します。これは、ファイルの書き込み中に追加のパラメーターを使用して削除できます。

# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))

# Write filtered data into a new file.
write.csv(retval,"output.csv", row.names = FALSE)
newdata <- read.csv("output.csv")
print(newdata)

上記のコードを実行すると、次の結果が生成されます-

      id    name      salary   start_date    dept
1      3    Michelle  611.00   2014-11-15    IT
2      4    Ryan      729.00   2014-05-11    HR
3     NA    Gary      843.25   2015-03-27    Finance
4      8    Guru      722.50   2014-06-17    Finance

R-Excelファイル

Microsoft Excelは、最も広く使用されているスプレッドシートプログラムで、データを.xlsまたは.xlsx形式で保存します。 Rは、Excel固有のパッケージを使用してこれらのファイルから直接読み取ることができます。そのようなパッケージはほとんどありません-XLConnect、xlsx、gdataなど。 xlsxパッケージを使用します。 Rは、このパッケージを使用してExcelファイルに書き込むこともできます。

xlsxパッケージをインストールする

Rコンソールで次のコマンドを使用して、「xlsx」パッケージをインストールできます。このパッケージが依存するいくつかの追加パッケージをインストールするように求められる場合があります。必要なパッケージ名を指定して同じコマンドを実行し、追加のパッケージをインストールします。

install.packages("xlsx")

「xlsx」パッケージの確認とロード

次のコマンドを使用して、「xlsx」パッケージを確認およびロードします。

# Verify the package is installed.
any(grepl("xlsx",installed.packages()))

# Load the library into R workspace.
library("xlsx")

スクリプトを実行すると、次の出力が得られます。

[1] TRUE
Loading required package: rJava
Loading required package: methods
Loading required package: xlsxjars

xlsxファイルとして入力

Microsoft Excelを開きます。次のデータをコピーして、sheet1という名前のワークシートに貼り付けます。

id  name      salary    start_date  dept
1   Rick        623.3     1/1/2012     IT
2   Dan       515.2     9/23/2013    Operations
3   Michelle  611        11/15/2014 IT
4   Ryan        729      5/11/2014     HR
5   Gary        43.25     3/27/2015     Finance
6   Nina        578       5/21/2013    IT
7   Simon       632.8     7/30/2013    Operations
8   Guru        722.5     6/17/2014    Finance

また、次のデータをコピーして別のワークシートに貼り付け、このワークシートの名前を「city」に変更します。

name        city
Rick        Seattle
Dan       Tampa
Michelle  Chicago
Ryan        Seattle
Gary        Houston
Nina        Boston
Simon       Mumbai
Guru        Dallas

Excelファイルを「input.xlsx」として保存します。 Rワークスペースの現在の作業ディレクトリに保存する必要があります。

Excelファイルの読み取り

input.xlsxは、以下に示すように* read.xlsx（）*関数を使用して読み取られます。結果は、データフレームとしてR環境に保存されます。

# Read the first worksheet in the file input.xlsx.
data <- read.xlsx("input.xlsx", sheetIndex = 1)
print(data)

上記のコードを実行すると、次の結果が生成されます-

      id,   name,     salary,   start_date,   dept
1      1    Rick      623.30    2012-01-01    IT
2      2    Dan       515.20    2013-09-23    Operations
3      3    Michelle  611.00    2014-11-15    IT
4      4    Ryan      729.00    2014-05-11    HR
5     NA    Gary      843.25    2015-03-27    Finance
6      6    Nina      578.00    2013-05-21    IT
7      7    Simon     632.80    2013-07-30    Operations
8      8    Guru      722.50    2014-06-17    Finance

R-バイナリファイル

バイナリファイルは、ビットとバイトの形式でのみ格納された情報を含むファイルです（0と1）。その中のバイトは、他の多くの印刷不可能な文字を含む文字や記号に変換されるため、人間が読むことはできません。テキストエディターを使用してバイナリファイルを読み取ろうとすると、Øやðなどの文字が表示されます。

バイナリファイルを使用するには、特定のプログラムで読み取る必要があります。たとえば、Microsoft Wordプログラムのバイナリファイルは、Wordプログラムでのみ人間が読み取れる形式に読み取ることができます。これは、人間が読めるテキストの他に、文字やページ番号などの書式設定など、英数字とともに保存される情報がはるかに多いことを示しています。最後に、バイナリファイルは連続したバイトシーケンスです。テキストファイルに表示される改行は、最初の行を次の行に結合する文字です。

他のプログラムによって生成されたデータは、Rによってバイナリファイルとして処理される必要がある場合があります。また、Rは他のプログラムと共有できるバイナリファイルを作成するために必要です。

Rには、バイナリファイルを作成および読み取るための2つの関数* WriteBin（）および readBin（）*があります。

構文

writeBin(object, con)
readBin(con, what, n )

以下は、使用されるパラメータの説明です-

con は、バイナリファイルを読み書きする接続オブジェクトです。
object は書き込まれるバイナリファイルです。
what は、文字、整数などのモードです。読み込むバイトを表します。
n は、バイナリファイルから読み取るバイト数です。

例

Rの組み込みデータ「mtcars」を考慮します。まず、csvファイルを作成してバイナリファイルに変換し、OSファイルとして保存します。次に、Rに作成されたこのバイナリファイルを読み取ります。

バイナリファイルの作成

データフレーム「mtcars」をcsvファイルとして読み取り、バイナリファイルとしてOSに書き込みます。

# Read the "mtcars" data frame as a csv file and store only the columns
   "cyl", "am" and "gear".
write.table(mtcars, file = "mtcars.csv",row.names = FALSE, na = "",
   col.names = TRUE, sep = ",")

# Store 5 records from the csv file as a new data frame.
new.mtcars <- read.table("mtcars.csv",sep = ",",header = TRUE,nrows = 5)

# Create a connection object to write the binary file using mode "wb".
write.filename = file("/web/com/binmtcars.dat", "wb")

# Write the column names of the data frame to the connection object.
writeBin(colnames(new.mtcars), write.filename)

# Write the records in each of the column to the file.
writeBin(c(new.mtcars$cyl,new.mtcars$am,new.mtcars$gear), write.filename)

# Close the file for writing so that it can be read by other program.
close(write.filename)

バイナリファイルの読み取り

上記で作成されたバイナリファイルは、すべてのデータを連続したバイトとして保存します。したがって、列の値と同様に列名の適切な値を選択して読み取ります。

# Create a connection object to read the file in binary mode using "rb".
read.filename <- file("/web/com/binmtcars.dat", "rb")

# First read the column names. n = 3 as we have 3 columns.
column.names <- readBin(read.filename, character(),  n = 3)

# Next read the column values. n = 18 as we have 3 column names and 15 values.
read.filename <- file("/web/com/binmtcars.dat", "rb")
bindata <- readBin(read.filename, integer(),  n = 18)

# Print the data.
print(bindata)

# Read the values from 4th byte to 8th byte which represents "cyl".
cyldata = bindata[4:8]
print(cyldata)

# Read the values form 9th byte to 13th byte which represents "am".
amdata = bindata[9:13]
print(amdata)

# Read the values form 9th byte to 13th byte which represents "gear".
geardata = bindata[14:18]
print(geardata)

# Combine all the read values to a dat frame.
finaldata = cbind(cyldata, amdata, geardata)
colnames(finaldata) = column.names
print(finaldata)

上記のコードを実行すると、次の結果とグラフが生成されます-

 [1]    7108963 1728081249    7496037          6          6          4
 [7]          6          8          1          1          1          0
[13]          0          4          4          4          3          3

[1] 6 6 4 6 8

[1] 1 1 1 0 0

[1] 4 4 4 3 3

     cyl am gear
[1,]   6  1    4
[2,]   6  1    4
[3,]   4  1    4
[4,]   6  0    3
[5,]   8  0    3

ご覧のとおり、Rのバイナリファイルを読み取ることで元のデータを取得しました。

R-XMLファイル

XMLは、ファイル形式とWorld Wide Web、イントラネット、および標準ASCIIテキストを使用する他の場所のデータの両方を共有するファイル形式です。 Extensible Markup Language（XML）の略です。 HTMLと同様に、マークアップタグが含まれています。しかし、マークアップタグがページの構造を記述するHTMLとは異なり、xmlではマークアップタグはファイルに含まれるデータの意味を記述します。

「XML」パッケージを使用して、Rでxmlファイルを読み取ることができます。このパッケージは、次のコマンドを使用してインストールできます。

install.packages("XML")

入力データ

以下のデータをメモ帳などのテキストエディターにコピーして、XMlファイルを作成します。 .xml 拡張子を付けてファイルを保存し、* all files（。）*としてファイルタイプを選択します。

<RECORDS>
   <EMPLOYEE>
      <ID>1</ID>
      <NAME>Rick</NAME>
      <SALARY>623.3</SALARY>
      <STARTDATE>1/1/2012</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>

   <EMPLOYEE>
      <ID>2</ID>
      <NAME>Dan</NAME>
      <SALARY>515.2</SALARY>
      <STARTDATE>9/23/2013</STARTDATE>
      <DEPT>Operations</DEPT>
   </EMPLOYEE>

   <EMPLOYEE>
      <ID>3</ID>
      <NAME>Michelle</NAME>
      <SALARY>611</SALARY>
      <STARTDATE>11/15/2014</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>

   <EMPLOYEE>
      <ID>4</ID>
      <NAME>Ryan</NAME>
      <SALARY>729</SALARY>
      <STARTDATE>5/11/2014</STARTDATE>
      <DEPT>HR</DEPT>
   </EMPLOYEE>

   <EMPLOYEE>
      <ID>5</ID>
      <NAME>Gary</NAME>
      <SALARY>843.25</SALARY>
      <STARTDATE>3/27/2015</STARTDATE>
      <DEPT>Finance</DEPT>
   </EMPLOYEE>

   <EMPLOYEE>
      <ID>6</ID>
      <NAME>Nina</NAME>
      <SALARY>578</SALARY>
      <STARTDATE>5/21/2013</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>

   <EMPLOYEE>
      <ID>7</ID>
      <NAME>Simon</NAME>
      <SALARY>632.8</SALARY>
      <STARTDATE>7/30/2013</STARTDATE>
      <DEPT>Operations</DEPT>
   </EMPLOYEE>

   <EMPLOYEE>
      <ID>8</ID>
      <NAME>Guru</NAME>
      <SALARY>722.5</SALARY>
      <STARTDATE>6/17/2014</STARTDATE>
      <DEPT>Finance</DEPT>
   </EMPLOYEE>

</RECORDS>

XMLファイルの読み取り

xmlファイルは、関数* xmlParse（）*を使用してRによって読み取られます。 Rにリストとして保存されます。

# Load the package required to read XML files.
library("XML")

# Also load the other required package.
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Print the result.
print(result)

上記のコードを実行すると、次の結果が生成されます-

1
Rick
623.3
1/1/2012
IT

2
Dan
515.2
9/23/2013
Operations

3
Michelle
611
11/15/2014
IT

4
Ryan
729
5/11/2014
HR

5
Gary
843.25
3/27/2015
Finance

6
Nina
578
5/21/2013
IT

7
Simon
632.8
7/30/2013
Operations

8
Guru
722.5
6/17/2014
Finance

XMLファイルに存在するノードの数を取得する

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Find number of nodes in the root.
rootsize <- xmlSize(rootnode)

# Print the result.
print(rootsize)

上記のコードを実行すると、次の結果が生成されます-

output
[1] 8

最初のノードの詳細

解析されたファイルの最初のレコードを見てみましょう。これにより、最上位ノードに存在するさまざまな要素がわかります。

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Print the result.
print(rootnode[1])

上記のコードを実行すると、次の結果が生成されます-

$EMPLOYEE
   1
   Rick
   623.3
   1/1/2012
   IT


attr(,"class")
[1] "XMLInternalNodeList" "XMLNodeList"

ノードのさまざまな要素を取得する

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Get the first element of the first node.
print(rootnode[[Get the fifth element of the first node.
print(rootnode[[Get the second element of the third node.
print(rootnode[[When we execute the above code, it produces the following result −

[source,result,notranslate]

1 ITミシェル

=== XML to Data Frame

To handle the data effectively in large files we read the data in the xml file as a data frame. Then process the data frame for data analysis.

[source,prettyprint,notranslate]

＃XMLファイルの読み取りに必要なパッケージをロードします。 library（ "XML"）library（ "methods"）

＃入力xmlファイルをデータフレームに変換します。 xmldataframe ←xmlToDataFrame（ "input.xml"）print（xmldataframe）

When we execute the above code, it produces the following result −

[source,result,notranslate]

ID名給与開始日DEPT 1 1 Rick 623.30 2012-01-01 IT 2 2 Dan 515.20 2013-09-23 Operations 3 3 Michelle 611.00 2014-11-15 IT 4 4 Ryan 729.00 2014-05-11 HR 5 NA Gary 843.25 2015 -03-27ファイナンス6 6ニーナ578.00 2013-05-21 IT 7 7サイモン632.80 2013-07-30オペレーション8 8グル722.50 2014-06-17ファイナンス

As the data is now available as a dataframe we can use data frame related function to read and manipulate the file.

R-JSONファイル

JSONファイルは、データを人間が読める形式のテキストとして保存します。 JsonはJavaScript Object Notationの略です。 Rは、rjsonパッケージを使用してJSONファイルを読み取ることができます。

rjsonパッケージをインストールする

Rコンソールで、次のコマンドを発行してrjsonパッケージをインストールできます。

install.packages("rjson")

入力データ

以下のデータをメモ帳などのテキストエディターにコピーして、JSONファイルを作成します。 .json 拡張子を付けてファイルを保存し、* all files（。）*としてファイルタイプを選択します。

{
   "ID":["1","2","3","4","5","6","7","8" ],
   "Name":["Rick","Dan","Michelle","Ryan","Gary","Nina","Simon","Guru" ],
   "Salary":["623.3","515.2","611","729","843.25","578","632.8","722.5" ],

   "StartDate":[ "1/1/2012","9/23/2013","11/15/2014","5/11/2014","3/27/2015","5/21/2013",
      "7/30/2013","6/17/2014"],
   "Dept":[ "IT","Operations","IT","HR","Finance","IT","Operations","Finance"]
}

JSONファイルを読む

JSONファイルは、* JSON（）*の関数を使用してRによって読み取られます。 Rにリストとして保存されます。

# Load the package required to read JSON files.
library("rjson")

# Give the input file name to the function.
result <- fromJSON(file = "input.json")

# Print the result.
print(result)

上記のコードを実行すると、次の結果が生成されます-

$ID
[1] "1"   "2"   "3"   "4"   "5"   "6"   "7"   "8"

$Name
[1] "Rick"     "Dan"      "Michelle" "Ryan"     "Gary"     "Nina"     "Simon"    "Guru"

$Salary
[1] "623.3"  "515.2"  "611"    "729"    "843.25" "578"    "632.8"  "722.5"

$StartDate
[1] "1/1/2012"   "9/23/2013"  "11/15/2014" "5/11/2014"  "3/27/2015"  "5/21/2013"
   "7/30/2013"  "6/17/2014"

$Dept
[1] "IT"         "Operations" "IT"         "HR"         "Finance"    "IT"
   "Operations" "Finance"

JSONをデータフレームに変換する

as.data.frame（）*関数を使用して、上記の抽出データをさらに分析するためにRデータフレームに変換できます。

# Load the package required to read JSON files.
library("rjson")

# Give the input file name to the function.
result <- fromJSON(file = "input.json")

# Convert JSON file to a data frame.
json_data_frame <- as.data.frame(result)

print(json_data_frame)

上記のコードを実行すると、次の結果が生成されます-

      id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

R-Webデータ

多くのWebサイトは、ユーザーが使用するデータを提供しています。たとえば、世界保健機関（WHO）は、CSV、txt、およびXMLファイルの形式で健康および医療情報に関するレポートを提供しています。 Rプログラムを使用すると、このようなWebサイトから特定のデータをプログラムで抽出できます。 Webからデータをスクラップするために使用されるRのパッケージには、「RCurl」、「XML」、および「stringr」があります。 URLに接続し、ファイルに必要なリンクを特定して、ローカル環境にダウンロードするために使用されます。

Rパッケージをインストールする

URLとファイルへのリンクを処理するには、次のパッケージが必要です。 R環境で使用できない場合は、次のコマンドを使用してインストールできます。

install.packages("RCurl")
install.packages("XML")
install.packages("stringr")
install.packages("plyr")

入力データ

URL 天気データにアクセスし、2015年のRを使用してCSVファイルをダウンロードします。

例

関数* getHTMLLinks（）を使用して、ファイルのURLを収集します。次に、関数 download.file（）*を使用して、ファイルをローカルシステムに保存します。同じコードを複数のファイルに何度も適用するため、複数回呼び出される関数を作成します。ファイル名は、Rリストオブジェクトの形式でパラメーターとしてこの関数に渡されます。

# Read the URL.
url <- "http://www.geos.ed.ac.uk/~weather/jcmb_ws/"

# Gather the html links present in the webpage.
links <- getHTMLLinks(url)

# Identify only the links which point to the JCMB 2015 files.
filenames <- links[str_detect(links, "JCMB_2015")]

# Store the file names as a list.
filenames_list <- as.list(filenames)

# Create a function to download the files by passing the URL and filename list.
downloadcsv <- function (mainurl,filename) {
   filedetails <- str_c(mainurl,filename)
   download.file(filedetails,filename)
}

# Now apply the l_ply function and save the files into the current R working directory.
l_ply(filenames,downloadcsv,mainurl = "http://www.geos.ed.ac.uk/~weather/jcmb_ws/")

ファイルのダウンロードを確認する

上記のコードを実行すると、現在のR作業ディレクトリで次のファイルを見つけることができます。

"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv"
   "JCMB_2015_Mar.csv"

R-データベース

データは、リレーショナルデータベースシステムが正規化された形式で保存されます。したがって、統計計算を実行するには、非常に高度で複雑なSqlクエリが必要になります。しかし、RはMySql、Oracle、Sqlサーバーなどの多くのリレーショナルデータベースに簡単に接続できます。それらからレコードをデータフレームとして取得します。 R環境でデータが使用可能になると、通常のRデータセットになり、すべての強力なパッケージと機能を使用して操作または分析できます。

このチュートリアルでは、Rに接続するための参照データベースとしてMySqlを使用します。

RMySQLパッケージ

Rには「RMySQL」という名前の組み込みパッケージがあり、MySqlデータベースとのネイティブ接続を提供します。次のコマンドを使用して、このパッケージをR環境にインストールできます。

install.packages("RMySQL")

RをMySqlに接続する

パッケージをインストールしたら、Rに接続オブジェクトを作成してデータベースに接続します。ユーザー名、パスワード、データベース名、ホスト名を入力として受け取ります。

# Create a connection Object to MySQL database.
# We will connect to the sampel database named "sakila" that comes with MySql installation.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila',
   host = 'localhost')

# List the tables available in this database.
 dbListTables(mysqlconnection)

上記のコードを実行すると、次の結果が生成されます-

 [1] "actor"                      "actor_info"
 [3] "address"                    "category"
 [5] "city"                       "country"
 [7] "customer"                   "customer_list"
 [9] "film"                       "film_actor"
[11] "film_category"              "film_list"
[13] "film_text"                  "inventory"
[15] "language"                   "nicer_but_slower_film_list"
[17] "payment"                    "rental"
[19] "sales_by_film_category"     "sales_by_store"
[21] "staff"                      "staff_list"
[23] "store"

テーブルのクエリ

関数* dbSendQuery（）*を使用して、MySqlのデータベーステーブルをクエリできます。クエリはMySqlで実行され、R * fetch（）*関数を使用して結果セットが返されます。最後に、データフレームとしてRに保存されます。

# Query the "actor" tables to get all the rows.
result = dbSendQuery(mysqlconnection, "select *from actor")

# Store the result in a R data frame object. n = 5 is used to fetch first 5 rows.
data.frame = fetch(result, n = 5)
print(data.fame)

上記のコードを実行すると、次の結果が生成されます-

        actor_id   first_name    last_name         last_update
1        1         PENELOPE      GUINESS           2006-02-15 04:34:33
2        2         NICK          WAHLBERG          2006-02-15 04:34:33
3        3         ED            CHASE             2006-02-15 04:34:33
4        4         JENNIFER      DAVIS             2006-02-15 04:34:33
5        5         JOHNNY        LOLLOBRIGIDA      2006-02-15 04:34:33

フィルター句を使用したクエリ

有効な選択クエリを渡して結果を取得できます。

result = dbSendQuery(mysqlconnection, "select* from actor where last_name = 'TORN'")

# Fetch all the records(with n = -1) and store it as a data frame.
data.frame = fetch(result, n = -1)
print(data)

上記のコードを実行すると、次の結果が生成されます-

        actor_id    first_name     last_name         last_update
1        18         DAN            TORN              2006-02-15 04:34:33
2        94         KENNETH        TORN              2006-02-15 04:34:33
3       102         WALTER         TORN              2006-02-15 04:34:33

テーブルの行を更新する

更新クエリをdbSendQuery（）関数に渡すことで、Mysqlテーブルの行を更新できます。

dbSendQuery(mysqlconnection, "update mtcars set disp = 168.5 where hp = 110")

上記のコードを実行すると、MySql環境で更新されたテーブルを確認できます。

テーブルへのデータの挿入

dbSendQuery(mysqlconnection,
   "insert into mtcars(row_names, mpg, cyl, disp, hp, drat, wt, qsec, vs, am, gear, carb)
   values('New Mazda RX4 Wag', 21, 6, 168.5, 110, 3.9, 2.875, 17.02, 0, 1, 4, 4)"
)

上記のコードを実行すると、MySql環境のテーブルに挿入された行が表示されます。

MySqlでテーブルを作成する

関数* dbWriteTable（）*を使用して、MySqlにテーブルを作成できます。テーブルが既に存在する場合は上書きし、データフレームを入力として受け取ります。

# Create the connection object to the database where we want to create the table.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila',
   host = 'localhost')

# Use the R data frame "mtcars" to create the table in MySql.
# All the rows of mtcars are taken inot MySql.
dbWriteTable(mysqlconnection, "mtcars", mtcars[, ], overwrite = TRUE)

上記のコードを実行すると、MySql環境で作成されたテーブルが表示されます。

MySqlでのテーブルの削除

テーブルからデータをクエリするのに使用したのと同じ方法で、ドロップテーブルステートメントをdbSendQuery（）に渡して、MySqlデータベースのテーブルをドロップできます。

dbSendQuery(mysqlconnection, 'drop table if exists mtcars')

上記のコードを実行すると、MySql環境でテーブルが削除されていることがわかります。

R-円グラフ

Rプログラミング言語には、チャートやグラフを作成するための多数のライブラリがあります。円グラフは、異なる色の円のスライスとしての値の表現です。スライスにはラベルが付けられ、各スライスに対応する番号もチャートに表示されます。

Rでは、円グラフは、ベクトル入力として正の数を取る* pie（）*関数を使用して作成されます。追加のパラメーターは、ラベル、色、タイトルなどを制御するために使用されます。

構文

Rを使用して円グラフを作成するための基本的な構文は次のとおりです-

pie(x, labels, radius, main, col, clockwise)

以下は、使用されるパラメータの説明です-

x は、円グラフで使用される数値を含むベクトルです。
labels は、スライスの説明に使用されます。
radius は、円グラフの円の半径を示します（-1から＆plus; 1までの値）。
main はチャートのタイトルを示します。
col はカラーパレットを示します。
clockwise は、スライスが時計回りに描かれるか反時計回りに描かれるかを示す論理値です。

例

入力ベクトルとラベルだけを使用して、非常に単純な円グラフが作成されます。以下のスクリプトは、現在のR作業ディレクトリに円グラフを作成して保存します。

# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

# Give the chart file a name.
png(file = "city.jpg")

# Plot the chart.
pie(x,labels)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rを使用してChatrをパイ

円グラフのタイトルと色

関数にさらにパラメーターを追加することで、チャートの機能を拡張できます。パラメーター main を使用してチャートにタイトルを追加し、別のパラメーターは col で、チャートの描画中にレインボーカラーパレットを使用します。パレットの長さは、チャートの値の数と同じにする必要があります。したがって、length（x）を使用します。

例

以下のスクリプトは、現在のR作業ディレクトリに円グラフを作成して保存します。

# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

# Give the chart file a name.
png(file = "city_title_colours.jpg")

# Plot the chart with title and rainbow color pallet.
pie(x, labels, main = "City pie chart", col = rainbow(length(x)))

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

タイトルと色付きの円グラフ

スライスの割合とグラフの凡例

追加のグラフ変数を作成して、スライスの割合とグラフの凡例を追加できます。

# Create data for the graph.
x <-  c(21, 62, 10,53)
labels <-  c("London","New York","Singapore","Mumbai")

piepercent<- round(100*x/sum(x), 1)

# Give the chart file a name.
png(file = "city_percentage_legends.jpg")

# Plot the chart.
pie(x, labels = piepercent, main = "City pie chart",col = rainbow(length(x)))
legend("topright", c("London","New York","Singapore","Mumbai"), cex = 0.8,
   fill = rainbow(length(x)))

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

割合とラベルを含む円グラフ

立体円グラフ

追加のパッケージを使用して、3次元の円グラフを描画できます。パッケージ plotrix には、これに使用される* pie3D（）*という関数があります。

# Get the library.
library(plotrix)

# Create data for the graph.
x <-  c(21, 62, 10,53)
lbl <-  c("London","New York","Singapore","Mumbai")

# Give the chart file a name.
png(file = "3d_pie_chart.jpg")

# Plot the chart.
pie3D(x,labels = lbl,explode = 0.1, main = "Pie Chart of Countries ")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

3D円グラフ

R-棒グラフ

棒グラフは、変数の値に比例する棒の長さを持つ長方形の棒でデータを表します。 Rは、関数* barplot（）*を使用して棒グラフを作成します。 Rは、棒グラフに垂直バーと水平バーの両方を描画できます。棒グラフでは、各棒に異なる色を付けることができます。

構文

Rで棒グラフを作成するための基本的な構文は次のとおりです-

barplot(H,xlab,ylab,main, names.arg,col)

以下は、使用されるパラメータの説明です-

H は、棒グラフで使用される数値を含むベクトルまたは行列です。
xlab はx軸のラベルです。
ylab はy軸のラベルです。
main は棒グラフのタイトルです。
names.arg は、各バーの下に表示される名前のベクトルです。
col は、グラフのバーに色を付けるために使用されます。

例

入力ベクトルと各バーの名前だけを使用して、単純な棒グラフが作成されます。

以下のスクリプトは、現在のR作業ディレクトリに棒グラフを作成して保存します。

# Create the data for the chart
H <- c(7,12,28,3,41)

# Give the chart file a name
png(file = "barchart.png")

# Plot the bar chart
barplot(H)

# Save the file
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rを使用した棒グラフ

棒グラフのラベル、タイトル、色

棒グラフの機能は、パラメーターを追加することで拡張できます。 main パラメーターは、 title を追加するために使用されます。 col パラメーターは、バーに色を追加するために使用されます。 args.name は、各バーの意味を説明する入力ベクトルと同じ数の値を持つベクトルです。

例

以下のスクリプトは、現在のR作業ディレクトリに棒グラフを作成して保存します。

# Create the data for the chart
H <- c(7,12,28,3,41)
M <- c("Mar","Apr","May","Jun","Jul")

# Give the chart file a name
png(file = "barchart_months_revenue.png")

# Plot the bar chart
barplot(H,names.arg=M,xlab="Month",ylab="Revenue",col="blue",
main="Revenue chart",border="red")

# Save the file
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rを使用したタイトル付きの棒グラフ

グループ棒グラフと積み上げ棒グラフ

入力値として行列を使用することで、棒のグループと各棒のスタックで棒グラフを作成できます。

3つ以上の変数は、グループ棒グラフと積み上げ棒グラフの作成に使用されるマトリックスとして表されます。

# Create the input vectors.
colors = c("green","orange","brown")
months <- c("Mar","Apr","May","Jun","Jul")
regions <- c("East","West","North")

# Create the matrix of the values.
Values <- matrix(c(2,9,3,11,9,4,8,7,3,12,5,2,8,10,11), nrow = 3, ncol = 5, byrow = TRUE)

# Give the chart file a name
png(file = "barchart_stacked.png")

# Create the bar chart
barplot(Values, main = "total revenue", names.arg = months, xlab = "month", ylab = "revenue", col = colors)

# Add the legend to the chart
legend("topleft", regions, cex = 1.3, fill = colors)

# Save the file
dev.off()

Rを使用した積み上げ棒グラフ

R-ボックスプロット

箱ひげ図は、データセット内のデータがどれだけ適切に分散されているかの尺度です。データセットを3つの四分位数に分割します。このグラフは、データセットの最小値、最大値、中央値、最初の四分位数、3番目の四分位数を表します。また、データセットごとに箱ひげ図を描くことにより、データセット全体でデータの分布を比較するのにも役立ちます。

ボックスプロットは、* boxplot（）*関数を使用してRで作成されます。

構文

Rで箱ひげ図を作成するための基本的な構文は次のとおりです-

boxplot(x, data, notch, varwidth, names, main)

以下は、使用されるパラメータの説明です-

x はベクトルまたは数式です。
data はデータフレームです。
notch は論理値です。ノッチを描画するにはTRUEに設定します。
varwidth は論理値です。サンプルサイズに比例してボックスの幅を描画するには、trueに設定します。
names は、各箱ひげ図の下に印刷されるグループラベルです。
main は、グラフにタイトルを付けるために使用されます。

例

R環境で使用可能なデータセット「mtcars」を使用して、基本的な箱ひげ図を作成します。 mtcarsの「mpg」列と「cyl」列を見てみましょう。

input <- mtcars[,c('mpg','cyl')]
print(head(input))

上記のコードを実行すると、次の結果が生成されます-

                   mpg  cyl
Mazda RX4         21.0   6
Mazda RX4 Wag     21.0   6
Datsun 710        22.8   4
Hornet 4 Drive    21.4   6
Hornet Sportabout 18.7   8
Valiant           18.1   6

Boxplotの作成

以下のスクリプトは、mpg（1ガロンあたりのマイル数）とcyl（シリンダーの数）の関係を表す箱ひげ図を作成します。

# Give the chart file a name.
png(file = "boxplot.png")

# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, xlab = "Number of Cylinders",
   ylab = "Miles Per Gallon", main = "Mileage Data")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rを使用した箱ひげ図

ノッチ付きボックスプロット

ノッチ付きの箱ひげ図を描画して、異なるデータグループの中央値が互いにどのように一致するかを調べることができます。

以下のスクリプトは、データグループごとにノッチ付きの箱ひげ図グラフを作成します。

# Give the chart file a name.
png(file = "boxplot_with_notch.png")

# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars,
   xlab = "Number of Cylinders",
   ylab = "Miles Per Gallon",
   main = "Mileage Data",
   notch = TRUE,
   varwidth = TRUE,
   col = c("green","yellow","purple"),
   names = c("High","Medium","Low")
)
# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rを使用したノッチ付きボックスプロット

R-ヒストグラム

ヒストグラムは、範囲にバケット化された変数の値の頻度を表します。ヒストグラムはバーチャットに似ていますが、違いは値を連続した範囲にグループ化することです。ヒストグラムの各バーは、その範囲に存在する値の数の高さを表します。

Rは、* hist（）*関数を使用してヒストグラムを作成します。この関数は、ベクトルを入力として受け取り、いくつかのパラメーターを使用してヒストグラムをプロットします。

構文

Rを使用してヒストグラムを作成するための基本的な構文は次のとおりです-

hist(v,main,xlab,xlim,ylim,breaks,col,border)

以下は、使用されるパラメータの説明です-

v は、ヒストグラムで使用される数値を含むベクトルです。
main はチャートのタイトルを示します。
col はバーの色を設定するために使用されます。
border は各バーの境界線の色を設定するために使用されます。
xlab は、x軸の説明に使用されます。
xlim は、x軸の値の範囲を指定するために使用されます。
ylim は、y軸の値の範囲を指定するために使用されます。
breaks は、各バーの幅を示すために使用されます。

例

入力ベクトル、ラベル、列および境界線パラメーターを使用して、単純なヒストグラムが作成されます。

以下のスクリプトは、現在のR作業ディレクトリにヒストグラムを作成して保存します。

# Create data for the graph.
v <-  c(9,13,21,8,36,22,12,41,31,33,19)

# Give the chart file a name.
png(file = "histogram.png")

# Create the histogram.
hist(v,xlab = "Weight",col = "yellow",border = "blue")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Vのヒストグラム

XおよびY値の範囲

X軸とY軸で許可される値の範囲を指定するには、xlimパラメーターとylimパラメーターを使用できます。

各バーの幅は、ブレークを使用して決定できます。

# Create data for the graph.
v <- c(9,13,21,8,36,22,12,41,31,33,19)

# Give the chart file a name.
png(file = "histogram_lim_breaks.png")

# Create the histogram.
hist(v,xlab = "Weight",col = "green",border = "red", xlim = c(0,40), ylim = c(0,5),
   breaks = 5)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

ヒストグラムの改行

R-折れ線グラフ

折れ線グラフは、一連のポイントの間に線セグメントを描画することで、それらを接続するグラフです。これらのポイントは、座標（通常はx座標）値の1つで順序付けられます。通常、折れ線グラフは、データの傾向を識別するために使用されます。

Rの* plot（）*関数は、折れ線グラフを作成するために使用されます。

構文

Rで折れ線グラフを作成するための基本的な構文は次のとおりです-

plot(v,type,col,xlab,ylab)

以下は、使用されるパラメータの説明です-

v は数値を含むベクトルです。
type は、値 "p"を使用して点のみを描画し、 "l"を使用して線のみを描画し、 "o"を使用して点と線の両方を描画します。
xlab はx軸のラベルです。
ylab はy軸のラベルです。
main はチャートのタイトルです。
col は、ポイントとラインの両方に色を付けるために使用されます。

例

入力ベクトルと「O」としての型パラメーターを使用して、単純な折れ線グラフが作成されます。以下のスクリプトは、現在のR作業ディレクトリに折れ線グラフを作成して保存します。

# Create the data for the chart.
v <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "line_chart.jpg")

# Plot the bar chart.
plot(v,type = "o")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rを使用した折れ線グラフ

折れ線グラフのタイトル、色、ラベル

追加のパラメーターを使用して、折れ線グラフの機能を拡張できます。ポイントとラインに色を追加し、チャートにタイトルを付け、軸にラベルを追加します。

例

# Create the data for the chart.
v <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "line_chart_label_colored.jpg")

# Plot the bar chart.
plot(v,type = "o", col = "red", xlab = "Month", ylab = "Rain fall",
   main = "Rain fall chart")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rのタイトルでラベル付けされた折れ線グラフ

折れ線グラフの複数の線

lines（）**関数を使用して、同じチャートに複数の線を描画できます。

最初の線がプロットされた後、lines（）関数は追加のベクトルを入力として使用して、チャートに2番目の線を描画できます。

# Create the data for the chart.
v <- c(7,12,28,3,41)
t <- c(14,7,6,19,3)

# Give the chart file a name.
png(file = "line_chart_2_lines.jpg")

# Plot the bar chart.
plot(v,type = "o",col = "red", xlab = "Month", ylab = "Rain fall",
   main = "Rain fall chart")

lines(t, type = "o", col = "blue")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rに複数の線がある折れ線グラフ

R-散布図

散布図には、デカルト平面にプロットされた多くの点が表示されます。各ポイントは、2つの変数の値を表します。 1つの変数は水平軸で選択され、別の変数は垂直軸で選択されます。

単純な散布図は、* plot（）*関数を使用して作成されます。

構文

Rで散布図を作成するための基本的な構文は次のとおりです-

plot(x, y, main, xlab, ylab, xlim, ylim, axes)

以下は、使用されるパラメータの説明です-

x は、値が水平座標であるデータセットです。
y は、値が垂直座標であるデータセットです。
main はグラフのタイルです。
xlab は水平軸のラベルです。
ylab は垂直軸のラベルです。
xlim は、プロットに使用されるxの値の制限です。
ylim は、プロットに使用されるyの値の制限です。
axes は、両方の軸をプロットに描画するかどうかを示します。

例

R環境で使用可能なデータセット "mtcars" を使用して、基本的な散布図を作成します。 mtcarsの「wt」列と「mpg」列を使用してみましょう。

input <- mtcars[,c('wt','mpg')]
print(head(input))

上記のコードを実行すると、次の結果が生成されます-

                    wt      mpg
Mazda RX4           2.620   21.0
Mazda RX4 Wag       2.875   21.0
Datsun 710          2.320   22.8
Hornet 4 Drive      3.215   21.4
Hornet Sportabout   3.440   18.7
Valiant             3.460   18.1

散布図の作成

以下のスクリプトは、wt（weight）とmpg（miles per gallon）の関係の散布図グラフを作成します。

# Get the input values.
input <- mtcars[,c('wt','mpg')]

# Give the chart file a name.
png(file = "scatterplot.png")

# Plot the chart for cars with weight between 2.5 to 5 and mileage between 15 and 30.
plot(x = input$wt,y = input$mpg,
   xlab = "Weight",
   ylab = "Milage",
   xlim = c(2.5,5),
   ylim = c(15,30),
   main = "Weight vs Milage"
)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rを使用した散布図

散布図行列

3つ以上の変数があり、1つの変数と残りの変数との相関を見つけたい場合、散布図行列を使用します。 * pairs（）*関数を使用して、散布図の行列を作成します。

構文

Rで散布図行列を作成するための基本的な構文は次のとおりです-

pairs(formula, data)

以下は、使用されるパラメータの説明です-

*式*は、ペアで使用される一連の変数を表します。
data は、変数が取得されるデータセットを表します。

例

各変数は、残りの各変数とペアになっています。散布図が各ペアに対してプロットされます。

# Give the chart file a name.
png(file = "scatterplot_matrices.png")

# Plot the matrices between 4 variables giving 12 plots.

# One variable with 3 others and total 4 variables.

pairs(~wt+mpg+disp+cyl,data = mtcars,
   main = "Scatterplot Matrix")

# Save the file.
dev.off()

上記のコードを実行すると、次の出力が得られます。

Rを使用した散布図行列

R-平均、中央値、モード

Rの統計分析は、多くの組み込み関数を使用して実行されます。これらの関数のほとんどは、Rベースパッケージの一部です。これらの関数は、引数とともにRベクトルを入力として受け取り、結果を返します。

この章で説明する関数は、平均値、中央値、モードです。

Mean

値の合計を取り、データ系列の値の数で割ることによって計算されます。

関数* mean（）*は、Rでこれを計算するために使用されます。

構文

Rの平均を計算するための基本的な構文は次のとおりです-

mean(x, trim = 0, na.rm = FALSE, ...)

以下は、使用されるパラメータの説明です-

x は入力ベクトルです。
trim は、ソートされたベクトルの両端からいくつかの観測値を削除するために使用されます。
na.rm は、入力ベクトルから欠損値を削除するために使用されます。

例

# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find Mean.
result.mean <- mean(x)
print(result.mean)

上記のコードを実行すると、次の結果が生成されます-

[1] 8.22

トリムオプションの適用

トリムパラメーターを指定すると、ベクトルの値が並べ替えられ、必要な観測数が平均の計算から除外されます。

trim = 0.3の場合、各端から3つの値が計算から除外されて平均が求められます。

この場合、ソートされたベクトルは（-21、-5、2、3、4.2、7、8、12、18、54）であり、平均を計算するためにベクトルから削除された値は（-21、-5、2）です。左から（12,18,54）右から。

# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find Mean.
result.mean <-  mean(x,trim = 0.3)
print(result.mean)

上記のコードを実行すると、次の結果が生成されます-

[1] 5.55

NAオプションの適用

欠損値がある場合、平均関数はNAを返します。

計算から欠損値を削除するには、na.rm = TRUEを使用します。つまり、NA値を削除します。

# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5,NA)

# Find mean.
result.mean <-  mean(x)
print(result.mean)

# Find mean dropping NA values.
result.mean <-  mean(x,na.rm = TRUE)
print(result.mean)

上記のコードを実行すると、次の結果が生成されます-

[1] NA
[1] 8.22

中央値

データ系列の中央の値は中央値と呼ばれます。 * median（）*関数は、この値を計算するためにRで使用されます。

構文

Rの中央値を計算するための基本的な構文は次のとおりです-

median(x, na.rm = FALSE)

以下は、使用されるパラメータの説明です-

x は入力ベクトルです。
na.rm は、入力ベクトルから欠損値を削除するために使用されます。

例

# Create the vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find the median.
median.result <- median(x)
print(median.result)

上記のコードを実行すると、次の結果が生成されます-

[1] 5.6

Mode

モードは、一連のデータ内で発生回数が最も多い値です。 Unikeの平均値と中央値、モードには数値データと文字データの両方が含まれます。

Rには、モードを計算するための標準の組み込み関数はありません。そこで、Rのデータセットのモードを計算するユーザー関数を作成します。この関数は、ベクトルを入力として受け取り、モード値を出力として提供します。

例

# Create the function.
getmode <- function(v) {
   uniqv <- unique(v)
   uniqv[which.max(tabulate(match(v, uniqv)))]
}

# Create the vector with numbers.
v <- c(2,1,2,3,1,2,3,4,1,5,5,3,2,3)

# Calculate the mode using the user function.
result <- getmode(v)
print(result)

# Create the vector with characters.
charv <- c("o","it","the","it","it")

# Calculate the mode using the user function.
result <- getmode(charv)
print(result)

上記のコードを実行すると、次の結果が生成されます-

[1] 2
[1] "it"

R-線形回帰

回帰分析は、2つの変数間の関係モデルを確立するために非常に広く使用されている統計ツールです。これらの変数の1つは予測変数と呼ばれ、その変数の値は実験によって収集されます。もう1つの変数は応答変数と呼ばれ、その変数の値は予測変数から派生します。

線形回帰では、これらの2つの変数は方程式を介して関連付けられます。これらの変数の指数（パワー）は1です。数学的に線形関係は、グラフとしてプロットされたときに直線を表します。変数の指数が1に等しくない非線形の関係は、曲線を作成します。

線形回帰の一般的な数学方程式は-

y = ax + b

以下は、使用されるパラメータの説明です-

y は応答変数です。
x は予測変数です。
a および b は、係数と呼ばれる定数です。

回帰を確立する手順

回帰の簡単な例は、身長がわかっているときに人の体重を予測することです。これを行うには、身長と体重の関係が必要です。

関係を作成する手順は次のとおりです-

身長と対応する体重の観測値のサンプルを収集する実験を実行します。
Rの* lm（）*関数を使用して関係モデルを作成します。
作成されたモデルから係数を見つけ、これらを使用して数式を作成します 関係モデルの概要を取得して、予測の平均誤差を把握します。 残差*とも呼ばれます。
新しい人の体重を予測するには、Rで* predict（）*関数を使用します。

入力データ

以下は、観測を表すサンプルデータです-

# Values of height
151, 174, 138, 186, 128, 136, 179, 163, 152, 131

# Values of weight.
63, 81, 56, 91, 47, 57, 76, 72, 62, 48

lm（）関数

この関数は、予測変数と応答変数の間の関係モデルを作成します。

構文

線形回帰の* lm（）*関数の基本的な構文は-

lm(formula,data)

以下は、使用されるパラメータの説明です-

*式*は、xとyの関係を表す記号です。
data は、式が適用されるベクトルです。

関係モデルを作成して係数を取得する

x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

print(relation)

上記のコードを実行すると、次の結果が生成されます-

Call:
lm(formula = y ~ x)

Coefficients:
(Intercept)            x
   -38.4551          0.6746

関係の概要を取得する

x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

print(summary(relation))

上記のコードを実行すると、次の結果が生成されます-

Call:
lm(formula = y ~ x)

Residuals:
    Min      1Q     Median      3Q     Max
-6.3002    -1.6629  0.0412    1.8944  3.9775

Coefficients:
             Estimate Std. Error t value Pr(>|t|)
(Intercept) -38.45509    8.04901  -4.778  0.00139 * *
x             0.67461    0.05191  12.997 1.16e-06* **
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 3.253 on 8 degrees of freedom
Multiple R-squared:  0.9548,    Adjusted R-squared:  0.9491
F-statistic: 168.9 on 1 and 8 DF,  p-value: 1.164e-06

predict（）関数

構文

線形回帰のpredict（）の基本的な構文は-

predict(object, newdata)

以下は、使用されるパラメータの説明です-

object は、lm（）関数を使用して既に作成されている式です。
newdata は、予測変数の新しい値を含むベクトルです。

新しい人の体重を予測する

# The predictor vector.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)

# The resposne vector.
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

# Find weight of a person with height 170.
a <- data.frame(x = 170)
result <-  predict(relation,a)
print(result)

上記のコードを実行すると、次の結果が生成されます-

       1
76.22869

回帰をグラフィカルに視覚化する

# Create the predictor and response variable.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)
relation <- lm(y~x)

# Give the chart file a name.
png(file = "linearregression.png")

# Plot the chart.
plot(y,x,col = "blue",main = "Height & Weight Regression",
abline(lm(x~y)),cex = 1.3,pch = 16,xlab = "Weight in Kg",ylab = "Height in cm")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

Rの線形回帰

R-重回帰

重回帰は、3つ以上の変数間の関係への線形回帰の拡張です。単純な線形関係では1つの予測変数と1つの応答変数がありますが、重回帰では複数の予測変数と1つの応答変数があります。

重回帰の一般的な数学方程式は-

y = a &plus; b1x1 &plus; b2x2 &plus;...bnxn

以下は、使用されるパラメータの説明です-

y は応答変数です。
a、b1、b2 … bn は係数です。
x1、x2、… xn は予測変数です。

Rの* lm（）*関数を使用して回帰モデルを作成します。モデルは、入力データを使用して係数の値を決定します。次に、これらの係数を使用して、予測変数の特定のセットの応答変数の値を予測できます。

lm（）関数

この関数は、予測変数と応答変数の間の関係モデルを作成します。

構文

重回帰の* lm（）*関数の基本的な構文は次のとおりです-

lm(y ~ x1&plus;x2&plus;x3...,data)

以下は、使用されるパラメータの説明です-

*式*は、応答変数と予測変数の間の関係を表す記号です。
data は、式が適用されるベクトルです。

例

入力データ

R環境で使用可能なデータセット「mtcars」を検討してください。ガロンあたりの走行距離（mpg）、シリンダー変位（ "disp"）、馬力（ "hp"）、車の重量（ "wt"）およびその他のパラメーターに関して、さまざまな車のモデルを比較します。

モデルの目標は、予測変数として「disp」、「hp」および「wt」と応答変数として「mpg」の関係を確立することです。この目的のために、mtcarsデータセットからこれらの変数のサブセットを作成します。

input <- mtcars[,c("mpg","disp","hp","wt")]
print(head(input))

上記のコードを実行すると、次の結果が生成されます-

                   mpg   disp   hp    wt
Mazda RX4          21.0  160    110   2.620
Mazda RX4 Wag      21.0  160    110   2.875
Datsun 710         22.8  108     93   2.320
Hornet 4 Drive     21.4  258    110   3.215
Hornet Sportabout  18.7  360    175   3.440
Valiant            18.1  225    105   3.460

関係モデルを作成して係数を取得する

input <- mtcars[,c("mpg","disp","hp","wt")]

# Create the relationship model.
model <- lm(mpg~disp+hp+wt, data = input)

# Show the model.
print(model)

# Get the Intercept and coefficients as vector elements.
cat("# # # # The Coefficient Values # # # ","\n")

a <- coef(model)[1]
print(a)

Xdisp <- coef(model)[2]
Xhp <- coef(model)[3]
Xwt <- coef(model)[4]

print(Xdisp)
print(Xhp)
print(Xwt)

上記のコードを実行すると、次の結果が生成されます-

Call:
lm(formula = mpg ~ disp &plus; hp &plus; wt, data = input)

Coefficients:
(Intercept)         disp           hp           wt
  37.105505      -0.000937        -0.031157    -3.800891

# # # # The Coefficient Values # # #
(Intercept)
   37.10551
         disp
-0.0009370091
         hp
-0.03115655
       wt
-3.800891

回帰モデルの方程式を作成

上記の切片と係数の値に基づいて、数学的な方程式を作成します。

Y = a&plus;Xdisp.x1&plus;Xhp.x2&plus;Xwt.x3
or
Y = 37.15&plus;(-0.000937)*x1&plus;(-0.0311)*x2&plus;(-3.8008)*x3

新しい値を予測する方程式を適用

上記で作成した回帰式を使用して、排気量、馬力、体重の値の新しいセットが提供されたときの燃費を予測できます。

disp = 221、hp = 102、wt = 2.91の車の場合、予測走行距離は-

Y = 37.15&plus;(-0.000937)*221&plus;(-0.0311)*102&plus;(-3.8008)*2.91 = 22.7104

R-ロジスティック回帰

ロジスティック回帰は、応答変数（従属変数）がTrue/Falseまたは0/1などのカテゴリ値を持つ回帰モデルです。実際には、予測変数に関連付けられた数式に基づいて、応答変数の値としてバイナリ応答の確率を測定します。

ロジスティック回帰の一般的な数学方程式は-

y = 1/(1&plus;e^-(a&plus;b1x1&plus;b2x2&plus;b3x3&plus;...))

以下は、使用されるパラメータの説明です-

y は応答変数です。
x は予測変数です。
a および b は、数値定数である係数です。

回帰モデルの作成に使用される関数は* glm（）*関数です。

構文

ロジスティック回帰の* glm（）*関数の基本的な構文は次のとおりです-

glm(formula,data,family)

以下は、使用されるパラメータの説明です-

*式*は、変数間の関係を表す記号です。
data は、これらの変数の値を提供するデータセットです。
family は、モデルの詳細を指定するRオブジェクトです。ロジスティック回帰の値は二項です。

例

組み込みのデータセット「mtcars」は、さまざまなエンジン仕様を持つ自動車のさまざまなモデルを記述しています。「mtcars」データセットでは、伝送モード（自動または手動）は、バイナリ値（0または1）である列amによって記述されます。「am」列と他の3つの列（hp、wt、cyl）の間でロジスティック回帰モデルを作成できます。

# Select some columns form mtcars.
input <- mtcars[,c("am","cyl","hp","wt")]

print(head(input))

上記のコードを実行すると、次の結果が生成されます-

                  am   cyl  hp    wt
Mazda RX4          1   6    110   2.620
Mazda RX4 Wag      1   6    110   2.875
Datsun 710         1   4     93   2.320
Hornet 4 Drive     0   6    110   3.215
Hornet Sportabout  0   8    175   3.440
Valiant            0   6    105   3.460

回帰モデルを作成する

glm（）*関数を使用して回帰モデルを作成し、分析のためにその要約を取得します。

input <- mtcars[,c("am","cyl","hp","wt")]

am.data = glm(formula = am ~ cyl &plus; hp &plus; wt, data = input, family = binomial)

print(summary(am.data))

上記のコードを実行すると、次の結果が生成されます-

Call:
glm(formula = am ~ cyl &plus; hp &plus; wt, family = binomial, data = input)

Deviance Residuals:
     Min        1Q      Median        3Q       Max
-2.17272     -0.14907  -0.01464     0.14116   1.27641

Coefficients:
            Estimate Std. Error z value Pr(>|z|)
(Intercept) 19.70288    8.11637   2.428   0.0152 *
cyl          0.48760    1.07162   0.455   0.6491
hp           0.03259    0.01886   1.728   0.0840 .
wt          -9.14947    4.15332  -2.203   0.0276 *
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for binomial family taken to be 1)

    Null deviance: 43.2297  on 31  degrees of freedom
Residual deviance:  9.8415  on 28  degrees of freedom
AIC: 17.841

Number of Fisher Scoring iterations: 8

結論

最後の列のp値が変数「cyl」および「hp」の0.05を超えるため、要約では、変数「am」の値に寄与することは重要ではないと考えます。この回帰モデルでは、重み（wt）のみが「am」値に影響します。

R-正規分布

独立したソースからのデータのランダムな収集では、通常、データの分布は正常であることが観察されています。つまり、水平軸の変数の値と垂直軸の値のカウントを使用してグラフをプロットすると、釣鐘型の曲線が得られます。曲線の中心は、データセットの平均を表します。グラフでは、値の50％が平均の左側にあり、残りの50％がグラフの右側にあります。これは、統計では正規分布と呼ばれます。

Rには正規分布を生成する組み込み関数が4つあります。以下に説明します。

dnorm(x, mean, sd)
pnorm(x, mean, sd)
qnorm(p, mean, sd)
rnorm(n, mean, sd)

以下は、上記の機能で使用されるパラメータの説明です-

x は数値のベクトルです。
p は確率のベクトルです。
n は観測数（サンプルサイズ）です。
mean は、サンプルデータの平均値です。デフォルト値はゼロです。
sd は標準偏差です。デフォルト値は1です。

dnorm（）

この関数は、与えられた平均と標準偏差の各点での確率分布の高さを与えます。

# Create a sequence of numbers between -10 and 10 incrementing by 0.1.
x <- seq(-10, 10, by = .1)

# Choose the mean as 2.5 and standard deviation as 0.5.
y <- dnorm(x, mean = 2.5, sd = 0.5)

# Give the chart file a name.
png(file = "dnorm.png")

plot(x,y)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

dnorm（）graph

pnorm（）

この関数は、正規分布された乱数が特定の数値よりも小さくなる確率を与えます。「累積分布関数」とも呼ばれます。

# Create a sequence of numbers between -10 and 10 incrementing by 0.2.
x <- seq(-10,10,by = .2)

# Choose the mean as 2.5 and standard deviation as 2.
y <- pnorm(x, mean = 2.5, sd = 2)

# Give the chart file a name.
png(file = "pnorm.png")

# Plot the graph.
plot(x,y)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

pnorm（）グラフ

qnorm（）

この関数は、確率値を受け取り、累積値が確率値と一致する数値を提供します。

# Create a sequence of probability values incrementing by 0.02.
x <- seq(0, 1, by = 0.02)

# Choose the mean as 2 and standard deviation as 3.
y <- qnorm(x, mean = 2, sd = 1)

# Give the chart file a name.
png(file = "qnorm.png")

# Plot the graph.
plot(x,y)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

qnorm（）graph

rnorm（）

この関数は、分布が正規の乱数を生成するために使用されます。サンプルサイズを入力として受け取り、その数の乱数を生成します。ヒストグラムを作成して、生成された数値の分布を示します。

# Create a sample of 50 numbers which are normally distributed.
y <- rnorm(50)

# Give the chart file a name.
png(file = "rnorm.png")

# Plot the histogram for this sample.
hist(y, main = "Normal DIstribution")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

rnorm（）graph

R-二項分布

二項分布モデルは、一連の実験で可能な結果が2つしかないイベントの成功確率を見つけることを扱います。たとえば、コインを投げると、常に頭または尾になります。コインを10回繰り返し投げることで正確に3つの頭を見つける確率は、二項分布の間に推定されます。

Rには、2項分布を生成する4つの組み込み関数があります。以下に説明します。

dbinom(x, size, prob)
pbinom(x, size, prob)
qbinom(p, size, prob)
rbinom(n, size, prob)

以下は、使用されるパラメータの説明です-

x は数値のベクトルです。
p は確率のベクトルです。
n は観測数です。
*サイズ*は試行回数です。
prob は、各試行の成功確率です。

dbinom（）

この関数は、各点の確率密度分布を提供します。

# Create a sample of 50 numbers which are incremented by 1.
x <- seq(0,50,by = 1)

# Create the binomial distribution.
y <- dbinom(x,50,0.5)

# Give the chart file a name.
png(file = "dbinom.png")

# Plot the graph for this sample.
plot(x,y)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

dbinom（）graph

pbinom（）

この関数は、イベントの累積確率を提供します。これは、確率を表す単一の値です。

# Probability of getting 26 or less heads from a 51 tosses of a coin.
x <- pbinom(26,51,0.5)

print(x)

上記のコードを実行すると、次の結果が生成されます-

[1] 0.610116

qbinom（）

この関数は、確率値を受け取り、累積値が確率値と一致する数値を提供します。

# How many heads will have a probability of 0.25 will come out when a coin
# is tossed 51 times.
x <- qbinom(0.25,51,1/2)

print(x)

上記のコードを実行すると、次の結果が生成されます-

[1] 23

rbinom（）

この関数は、指定されたサンプルから指定された確率の必要な数の乱数値を生成します。

# Find 8 random values from a sample of 150 with probability of 0.4.
x <- rbinom(8,150,.4)

print(x)

上記のコードを実行すると、次の結果が生成されます-

[1] 58 61 59 66 55 60 61 67

R-ポアソン回帰

ポアソン回帰には、応答変数が小数ではなくカウントの形式である回帰モデルが含まれます。たとえば、サッカーの試合シリーズでの出生数または勝利数のカウント。また、応答変数の値はポアソン分布に従います。

ポアソン回帰の一般的な数学方程式は-

log(y) = a &plus; b1x1 &plus; b2x2 &plus; bnxn.....

以下は、使用されるパラメータの説明です-

y は応答変数です。
a および b は数値係数です。
x は予測変数です。

ポアソン回帰モデルの作成に使用される関数は* glm（）*関数です。

構文

ポアソン回帰の* glm（）*関数の基本的な構文は次のとおりです-

glm(formula,data,family)

以下は、上記の機能で使用されるパラメータの説明です-

*式*は、変数間の関係を表す記号です。
data は、これらの変数の値を提供するデータセットです。
family は、モデルの詳細を指定するRオブジェクトです。ロジスティック回帰の値は「ポアソン」です。

例

ウールのタイプ（AまたはB）と張力（低、中、または高）が織機ごとの経糸破断の数に与える影響を記述する組み込みデータセット「経糸破断」があります。「ブレーク」を、ブレークの数のカウントである応答変数として考えてみましょう。ウールの「タイプ」と「テンション」は、予測変数として使用されます。

入力データ *

input <- warpbreaks
print(head(input))

上記のコードを実行すると、次の結果が生成されます-

      breaks   wool  tension
1     26       A     L
2     30       A     L
3     54       A     L
4     25       A     L
5     70       A     L
6     52       A     L

回帰モデルを作成する

output <-glm(formula = breaks ~ wool&plus;tension, data = warpbreaks,
   family = poisson)
print(summary(output))

上記のコードを実行すると、次の結果が生成されます-

Call:
glm(formula = breaks ~ wool + tension, family = poisson, data = warpbreaks)

Deviance Residuals:
    Min       1Q     Median       3Q      Max
  -3.6871  -1.6503  -0.4269     1.1902   4.2616

Coefficients:
            Estimate Std. Error z value Pr(>|z|)
(Intercept)  3.69196    0.04541  81.302  < 2e-16* **
woolB       -0.20599    0.05157  -3.994 6.49e-05 ***
tensionM    -0.32132    0.06027  -5.332 9.73e-08 ***
tensionH    -0.51849    0.06396  -8.107 5.21e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for poisson family taken to be 1)

    Null deviance: 297.37  on 53  degrees of freedom
Residual deviance: 210.39  on 50  degrees of freedom
AIC: 493.06

Number of Fisher Scoring iterations: 4

要約では、応答変数に対する予測変数の影響を考慮するために、最後の列のp値が0.05未満になるようにします。ご覧のように、張力タイプMおよびHのウールタイプBは、破断回数に影響を与えます。

R-共分散分析

回帰分析を使用して、予測変数の変動が応答変数に与える影響を記述するモデルを作成します。 Yes/NoやMale/Femaleなどの値を持つカテゴリ変数がある場合、時々単純回帰分析では、カテゴリー変数の各値に対して複数の結果が得られます。このようなシナリオでは、予測変数と一緒に使用し、カテゴリ変数の各レベルの回帰直線を比較することにより、カテゴリ変数の効果を調べることができます。このような分析は、 ANCOVA とも呼ばれる Analysis of Covariance と呼ばれます。

例

Rに組み込まれたデータセットmtcarsについて考えます。その中で、フィールド「am」は伝送のタイプ（自動または手動）を表していることがわかります。値0および1のカテゴリ変数です。馬力（ "hp"）の値に加えて、車のガロンあたりのマイル値（mpg）もそれに依存します。

「mpg」と「hp」の間の回帰に対する「am」の値の影響を研究します。これは、* aov（）関数の後に anova（）*関数を使用して、重回帰を比較することにより行われます。

入力データ

データセットmtcarsからフィールド「mpg」、「hp」、および「am」を含むデータフレームを作成します。ここでは、応答変数として「mpg」、予測変数として「hp」、カテゴリ変数として「am」を使用します。

input <- mtcars[,c("am","mpg","hp")]
print(head(input))

上記のコードを実行すると、次の結果が生成されます-

                   am   mpg   hp
Mazda RX4          1    21.0  110
Mazda RX4 Wag      1    21.0  110
Datsun 710         1    22.8   93
Hornet 4 Drive     0    21.4  110
Hornet Sportabout  0    18.7  175
Valiant            0    18.1  105

ANCOVA分析

「am」と「hp」の間の相互作用を考慮して、予測変数として「hp」、応答変数として「mpg」を使用する回帰モデルを作成します。

カテゴリ変数と予測変数の間の相互作用があるモデル

# Get the dataset.
input <- mtcars

# Create the regression model.
result <- aov(mpg~hp*am,data = input)
print(summary(result))

上記のコードを実行すると、次の結果が生成されます-

            Df Sum Sq Mean Sq F value   Pr(>F)
hp           1  678.4   678.4  77.391 1.50e-09 ***
am           1  202.2   202.2  23.072 4.75e-05 ***
hp:am        1    0.0     0.0   0.001    0.981
Residuals   28  245.4     8.8
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

この結果は、両方の場合のp値が0.05未満であるため、馬力と伝達タイプの両方がガロンあたりのマイル数に大きな影響を与えることを示しています。ただし、p値が0.05を超えるため、これら2つの変数間の相互作用は重要ではありません。

カテゴリ変数と予測変数間の相互作用のないモデル

# Get the dataset.
input <- mtcars

# Create the regression model.
result <- aov(mpg~hp&plus;am,data = input)
print(summary(result))

上記のコードを実行すると、次の結果が生成されます-

            Df  Sum Sq  Mean Sq   F value   Pr(>F)
hp           1  678.4   678.4   80.15 7.63e-10 ***
am           1  202.2   202.2   23.89 3.46e-05 ***
Residuals   29  245.4     8.5
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

この結果は、両方の場合のp値が0.05未満であるため、馬力と伝達タイプの両方がガロンあたりのマイル数に大きな影響を与えることを示しています。

2つのモデルの比較

ここで、2つのモデルを比較して、変数の相互作用が本当に重要でないかどうかを結論付けることができます。このために、* anova（）*関数を使用します。

# Get the dataset.
input <- mtcars

# Create the regression models.
result1 <- aov(mpg~hp*am,data = input)
result2 <- aov(mpg~hp+am,data = input)

# Compare the two models.
print(anova(result1,result2))

上記のコードを実行すると、次の結果が生成されます-

Model 1: mpg ~ hp * am
Model 2: mpg ~ hp &plus; am
  Res.Df    RSS Df  Sum of Sq     F Pr(>F)
1     28 245.43
2     29 245.44 -1 -0.0052515 6e-04 0.9806

p値が0.05より大きいため、馬力と伝達タイプの相互作用は重要ではないと結論付けます。したがって、ガロンあたりの走行距離は、自動および手動変速モードの両方で、同様に自動車の馬力に依存します。

R-時系列分析

時系列は、各データポイントがタイムスタンプに関連付けられている一連のデータポイントです。簡単な例は、特定の日のさまざまな時点での株式市場の株価です。別の例は、1年の異なる月の地域の降雨量です。 R言語では、多くの関数を使用して、時系列データを作成、操作、およびプロットします。時系列のデータは、*時系列オブジェクト*と呼ばれるRオブジェクトに保存されます。また、ベクトルまたはデータフレームのようなRデータオブジェクトでもあります。

時系列オブジェクトは、* ts（）*関数を使用して作成されます。

構文

時系列分析の* ts（）*関数の基本的な構文は次のとおりです-

timeseries.object.name <-  ts(data, start, end, frequency)

以下は、使用されるパラメータの説明です-

data は、時系列で使用される値を含むベクトルまたは行列です。
start は、時系列の最初の観測の開始時間を指定します。
end は、時系列の最後の観測の終了時刻を指定します。
frequency は、単位時間あたりの観測数を指定します。

パラメーター「data」を除き、他のすべてのパラメーターはオプションです。

例

2012年1月から始まる場所の年間降雨量の詳細を考慮してください。 12か月間のR時系列オブジェクトを作成し、プロットします。

# Get the data points in form of a R vector.
rainfall <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)

# Convert it to a time series object.
rainfall.timeseries <- ts(rainfall,start = c(2012,1),frequency = 12)

# Print the timeseries data.
print(rainfall.timeseries)

# Give the chart file a name.
png(file = "rainfall.png")

# Plot a graph of the time series.
plot(rainfall.timeseries)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果とグラフが生成されます-

Jan    Feb    Mar    Apr    May     Jun    Jul    Aug    Sep
2012  799.0  1174.8  865.1  1334.6  635.4  918.5  685.5  998.6  784.2
        Oct    Nov    Dec
2012  985.0  882.8 1071.0

時系列チャート-

Rを使用した時系列

異なる時間間隔

ts（）関数の frequency パラメーターの値は、データポイントが測定される時間間隔を決定します。 12の値は、時系列が12か月であることを示します。他の値とその意味は以下のとおりです-

frequency = 12 は、1年の各月のデータポイントを固定します。
frequency = 4 は、1年の各四半期のデータポイントを固定します。
frequency = 6 は、1時間の10分ごとにデータポイントを固定します。
frequency = 24 6 *は、1日の10分ごとにデータポイントを固定します。

複数の時系列

両方の系列を行列に結合することにより、1つのチャートに複数の時系列をプロットできます。

# Get the data points in form of a R vector.
rainfall1 <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)
rainfall2 <-
           c(655,1306.9,1323.4,1172.2,562.2,824,822.4,1265.5,799.6,1105.6,1106.7,1337.8)

# Convert them to a matrix.
combined.rainfall <-  matrix(c(rainfall1,rainfall2),nrow = 12)

# Convert it to a time series object.
rainfall.timeseries <- ts(combined.rainfall,start = c(2012,1),frequency = 12)

# Print the timeseries data.
print(rainfall.timeseries)

# Give the chart file a name.
png(file = "rainfall_combined.png")

# Plot a graph of the time series.
plot(rainfall.timeseries, main = "Multiple Time Series")

# Save the file.
dev.off()

上記のコードを実行すると、次の結果とグラフが生成されます-

           Series 1  Series 2
Jan 2012    799.0    655.0
Feb 2012   1174.8   1306.9
Mar 2012    865.1   1323.4
Apr 2012   1334.6   1172.2
May 2012    635.4    562.2
Jun 2012    918.5    824.0
Jul 2012    685.5    822.4
Aug 2012    998.6   1265.5
Sep 2012    784.2    799.6
Oct 2012    985.0   1105.6
Nov 2012    882.8   1106.7
Dec 2012   1071.0   1337.8

複数時系列チャート-

結合時系列はRを使用しています

R-非線形最小二乗

回帰分析のために実世界のデータをモデル化するとき、モデルの方程式が線形グラフを与える線形方程式であるということはめったにないことがわかります。ほとんどの場合、実世界のデータのモデルの方程式には、3の指数やsin関数などの高度な数学関数が含まれます。このようなシナリオでは、モデルのプロットは直線ではなく曲線を示します。線形回帰と非線形回帰の両方の目標は、モデルのパラメーターの値を調整して、データに最も近い直線または曲線を見つけることです。これらの値を見つけると、応答変数を高い精度で推定できます。

最小二乗回帰では、回帰曲線からの異なる点の垂直距離の平方の合計が最小化される回帰モデルを確立します。通常、定義済みのモデルから始めて、係数の値を想定します。次に、Rの* nls（）*関数を適用して、信頼区間とともにより正確な値を取得します。

構文

Rで非線形最小二乗検定を作成するための基本的な構文は次のとおりです-

nls(formula, data, start)

以下は、使用されるパラメータの説明です-

*式*は、変数とパラメータを含む非線形モデル式です。
data は、式の変数を評価するために使用されるデータフレームです。
start は、名前付きリストまたは開始推定の名前付き数値ベクトルです。

例

係数の初期値を仮定した非線形モデルを検討します。次に、これらの値がモデルにどれだけうまく反映されているかを判断できるように、これらの想定値の信頼区間を確認します。

だから、この目的のために以下の方程式を考えてみましょう-

a = b1*x^2+b2

初期係数を1と3とし、これらの値をnls（）関数に適合させてみましょう。

xvalues <- c(1.6,2.1,2,2.23,3.71,3.25,3.4,3.86,1.19,2.21)
yvalues <- c(5.19,7.43,6.94,8.11,18.75,14.88,16.06,19.12,3.21,7.58)

# Give the chart file a name.
png(file = "nls.png")


# Plot these values.
plot(xvalues,yvalues)


# Take the assumed values and fit into the model.
model <- nls(yvalues ~ b1*xvalues^2+b2,start = list(b1 = 1,b2 = 3))

# Plot the chart with new data by fitting it to a prediction from 100 data points.
new.data <- data.frame(xvalues = seq(min(xvalues),max(xvalues),len = 100))
lines(new.data$xvalues,predict(model,newdata = new.data))

# Save the file.
dev.off()

# Get the sum of the squared residuals.
print(sum(resid(model)^2))

# Get the confidence intervals on the chosen values of the coefficients.
print(confint(model))

上記のコードを実行すると、次の結果が生成されます-

[1] 1.081935
Waiting for profiling to be done...
       2.5%    97.5%
b1 1.137708 1.253135
b2 1.497364 2.496484

非線形最小二乗R

b1の値は1に近く、b2の値は3ではなく2に近いと結論付けることができます。

R-決定木

デシジョンツリーは、選択肢とその結果をツリー形式で表すグラフです。グラフのノードはイベントまたは選択を表し、グラフのエッジは決定ルールまたは条件を表します。 Rを使用した機械学習およびデータマイニングアプリケーションで主に使用されます。

意思決定要素の使用例は、電子メールをスパムまたはスパムではないと予測する、腫瘍の癌を予測する、またはこれらのそれぞれの要因に基づいて融資を良いまたは悪い信用リスクとして予測するなどです。一般に、モデルはトレーニングデータとも呼ばれる観測データで作成されます。次に、検証データのセットを使用して、モデルを検証および改善します。 Rには、決定木の作成と視覚化に使用されるパッケージがあります。新しい予測変数のセットでは、このモデルを使用して、データのカテゴリ（yes/no、spam/not spam）の決定に到達します。

Rパッケージ "party" は、決定木を作成するために使用されます。

Rパッケージをインストールする

Rコンソールで以下のコマンドを使用して、パッケージをインストールします。また、依存パッケージがある場合はインストールする必要があります。

install.packages("party")

パッケージ「party」には、決定ツリーの作成と分析に使用される関数* ctree（）*が含まれています。

構文

Rで決定木を作成するための基本的な構文は次のとおりです-

ctree(formula, data)

以下は、使用されるパラメータの説明です-

*式*は、予測変数と応答変数を記述する式です。
data は、使用されるデータセットの名前です。

入力データ

*readingSkills* という名前のR組み込みデータセットを使用して、意思決定ツリーを作成します。 変数 "age"、 "shoesize"、 "score"がわかっている場合、およびその人がネイティブスピーカーであるかどうかを知っている場合、それは誰かのreadingSkillsのスコアを表します。

これがサンプルデータです。

# Load the party package. It will automatically load other
# dependent packages.
library(party)

# Print some records from data set readingSkills.
print(head(readingSkills))

上記のコードを実行すると、次の結果とグラフが生成されます-

  nativeSpeaker   age   shoeSize      score
1           yes     5   24.83189   32.29385
2           yes     6   25.95238   36.63105
3            no    11   30.42170   49.60593
4           yes     7   28.66450   40.28456
5           yes    11   31.88207   55.46085
6           yes    10   30.07843   52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................

例

ctree（）*関数を使用して決定木を作成し、グラフを表示します。

# Load the party package. It will automatically load other
# dependent packages.
library(party)

# Create the input data frame.
input.dat <- readingSkills[c(1:105),]

# Give the chart file a name.
png(file = "decision_tree.png")

# Create the tree.
  output.tree <- ctree(
  nativeSpeaker ~ age + shoeSize + score,
  data = input.dat)

# Plot the tree.
plot(output.tree)

# Save the file.
dev.off()

上記のコードを実行すると、次の結果が生成されます-

null device
          1
Loading required package: methods
Loading required package: grid
Loading required package: mvtnorm
Loading required package: modeltools
Loading required package: stats4
Loading required package: strucchange
Loading required package: zoo

Attaching package: ‘zoo’

The following objects are masked from ‘package:base’:

   as.Date, as.Date.numeric

Loading required package: sandwich

Rを使用したデシジョンツリー

結論

上記の決定ツリーから、readingSkillsスコアが38.3未満で、年齢が6歳を超える人はネイティブスピーカーではないと結論付けることができます。

R-ランダムフォレスト

ランダムフォレストアプローチでは、多数の決定木が作成されます。すべての観測は、すべての決定ツリーに送られます。各観測の最も一般的な結果が最終出力として使用されます。新しい観測がすべてのツリーに入力され、各分類モデルに対して多数決が行われます。

ツリーの構築中に使用されなかったケースのエラー推定が行われます。これは* OOB（Out-of-bag）*エラー推定値と呼ばれ、パーセンテージで示されます。

Rパッケージ "randomForest" は、ランダムフォレストを作成するために使用されます。

Rパッケージをインストールする

Rコンソールで以下のコマンドを使用して、パッケージをインストールします。また、依存パッケージがある場合はインストールする必要があります。

install.packages("randomForest)

パッケージ「randomForest」には、ランダムフォレストの作成と分析に使用される関数* randomForest（）*が含まれています。

構文

Rでランダムフォレストを作成するための基本的な構文は次のとおりです-

randomForest(formula, data)

以下は、使用されるパラメータの説明です-

*式*は、予測変数と応答変数を記述する式です。
data は、使用されるデータセットの名前です。

入力データ

readingSkillsという名前のR組み込みデータセットを使用して、意思決定ツリーを作成します。変数 "age"、 "shoesize"、 "score"がわかっている場合、およびその人がネイティブスピーカーかどうかを知っている場合、その人のreadingSkillsのスコアを示します。

これがサンプルデータです。

# Load the party package. It will automatically load other
# required packages.
library(party)

# Print some records from data set readingSkills.
print(head(readingSkills))

上記のコードを実行すると、次の結果とグラフが生成されます-

  nativeSpeaker   age   shoeSize      score
1           yes     5   24.83189   32.29385
2           yes     6   25.95238   36.63105
3            no    11   30.42170   49.60593
4           yes     7   28.66450   40.28456
5           yes    11   31.88207   55.46085
6           yes    10   30.07843   52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................

例

randomForest（）*関数を使用して決定木を作成し、グラフを表示します。

# Load the party package. It will automatically load other
# required packages.
library(party)
library(randomForest)

# Create the forest.
output.forest <- randomForest(nativeSpeaker ~ age &plus; shoeSize &plus; score,
           data = readingSkills)

# View the forest results.
print(output.forest)

# Importance of each predictor.
print(importance(fit,type = 2))

上記のコードを実行すると、次の結果が生成されます-

Call:
 randomForest(formula = nativeSpeaker ~ age &plus; shoeSize &plus; score,
                 data = readingSkills)
               Type of random forest: classification
                     Number of trees: 500
No. of variables tried at each split: 1

        OOB estimate of  error rate: 1%
Confusion matrix:
    no yes class.error
no  99   1        0.01
yes  1  99        0.01
         MeanDecreaseGini
age              13.95406
shoeSize         18.91006
score            56.73051

結論

上記のランダムフォレストから、誰かがネイティブスピーカーかどうかを決定する重要な要因はシューサイズとスコアであると結論付けることができます。また、モデルには1％の誤差しかないため、99％の精度で予測できます。

R-生存分析

生存分析では、特定のイベントが発生する時間を予測します。また、故障時間分析または死亡までの時間の分析としても知られています。たとえば、がん患者の生存日数を予測したり、機械システムが故障する時間を予測したりします。

*survival* という名前のRパッケージは、生存分析の実行に使用されます。 このパッケージには、入力データをRフォーミュラとして受け取り、分析用に選択された変数の中で生存オブジェクトを作成する関数* Surv（）*が含まれています。 次に、関数* survfit（）*を使用して、分析用のプロットを作成します。

パッケージをインストール

install.packages("survival")

構文

Rで生存分析を作成するための基本的な構文は次のとおりです-

Surv(time,event)
survfit(formula)

以下は、使用されるパラメータの説明です-

time は、イベントが発生するまでのフォローアップ時間です。
event は、予想されるイベントの発生状況を示します。
*式*は、予測変数間の関係です。

例

上記でインストールされたサバイバルパッケージに存在する「pbc」という名前のデータセットを検討します。肝臓の原発性胆汁性肝硬変（PBC）に罹患した人々に関する生存データポイントについて説明します。データセットに存在する多くの列の中で、主にフィールド「時間」と「ステータス」に関心があります。時間は、患者の登録から、肝移植を受ける患者または患者の死までの間のイベントの前の日数を表します。

# Load the library.
library("survival")

# Print first few rows.
print(head(pbc))

上記のコードを実行すると、次の結果とグラフが生成されます-

  id time status trt      age sex ascites hepato spiders edema bili chol
1  1  400      2   1 58.76523   f       1      1       1   1.0 14.5  261
2  2 4500      0   1 56.44627   f       0      1       1   0.0  1.1  302
3  3 1012      2   1 70.07255   m       0      0       0   0.5  1.4  176
4  4 1925      2   1 54.74059   f       0      1       1   0.5  1.8  244
5  5 1504      1   2 38.10541   f       0      1       1   0.0  3.4  279
6  6 2503      2   2 66.25873   f       0      1       0   0.0  0.8  248
  albumin copper alk.phos    ast trig platelet protime stage
1    2.60    156   1718.0 137.95  172      190    12.2     4
2    4.14     54   7394.8 113.52   88      221    10.6     3
3    3.48    210    516.0  96.10   55      151    12.0     4
4    2.54     64   6121.8  60.63   92      183    10.3     4
5    3.53    143    671.0 113.15   72      136    10.9     3
6    3.98     50    944.0  93.00   63       NA    11.0     3

上記のデータから、分析の時間とステータスを検討しています。

Surv（）およびsurvfit（）関数の適用

次に、上記のデータセットに* Surv（）*関数を適用し、傾向を示すプロットを作成します。

# Load the library.
library("survival")

# Create the survival object.
survfit(Surv(pbc$time,pbc$status == 2)~1)

# Give the chart file a name.
png(file = "survival.png")

# Plot the graph.
plot(survfit(Surv(pbc$time,pbc$status == 2)~1))

# Save the file.
dev.off()

上記のコードを実行すると、次の結果とグラフが生成されます-

Call: survfit(formula = Surv(pbc$time, pbc$status == 2) ~ 1)

      n  events  median 0.95LCL 0.95UCL
    418     161    3395    3090    3853

Rを使用した生存分析

上記のグラフの傾向は、特定の日数の終わりに生存する確率を予測するのに役立ちます。

R-カイ二乗検定

カイ2乗検定*は、2つのカテゴリ変数に有意な相関があるかどうかを判断する統計的手法です。これらの変数は両方とも同じ母集団からのものでなければならず、-はい/いいえ、男性/女性、赤/緑などのようにカテゴリー的でなければなりません。

たとえば、人々のアイスクリーム購入パターンに関する観察結果を含むデータセットを構築し、人の性別と好みのアイスクリームのフレーバーとの相関をとることができます。相関関係が見つかった場合、訪問する人々の性別を知ることにより、適切なフレーバーの在庫を計画できます。

構文

カイ二乗検定の実行に使用される関数は* chisq.test（）*です。

Rでカイ二乗検定を作成するための基本的な構文は次のとおりです-

chisq.test(data)

以下は、使用されるパラメータの説明です-

data は、観測の変数のカウント値を含むテーブル形式のデータです。

例

1993年の自動車のさまざまなモデルの販売を表す「MASS」ライブラリのCars93データを取得します。

library("MASS")
print(str(Cars93))

上記のコードを実行すると、次の結果が生成されます-

'data.frame':   93 obs. of  27 variables:
 $ Manufacturer      : Factor w/32 levels "Acura","Audi",..: 1 1 2 2 3 4 4 4 4 5 ...
 $ Model             : Factor w/93 levels "100","190E","240",..: 49 56 9 1 6 24 54 74 73 35 ...
 $ Type              : Factor w/6 levels "Compact","Large",..: 4 3 1 3 3 3 2 2 3 2 ...
 $ Min.Price         : num  12.9 29.2 25.9 30.8 23.7 14.2 19.9 22.6 26.3 33 ...
 $ Price             : num  15.9 33.9 29.1 37.7 30 15.7 20.8 23.7 26.3 34.7 ...
 $ Max.Price         : num  18.8 38.7 32.3 44.6 36.2 17.3 21.7 24.9 26.3 36.3 ...
 $ MPG.city          : int  25 18 20 19 22 22 19 16 19 16 ...
 $ MPG.highway       : int  31 25 26 26 30 31 28 25 27 25 ...
 $ AirBags           : Factor w/3 levels "Driver & Passenger",..: 3 1 2 1 2 2 2 2 2 2 ...
 $ DriveTrain        : Factor w/3 levels "4WD","Front",..: 2 2 2 2 3 2 2 3 2 2 ...
 $ Cylinders         : Factor w/6 levels "3","4","5","6",..: 2 4 4 4 2 2 4 4 4 5 ...
 $ EngineSize        : num  1.8 3.2 2.8 2.8 3.5 2.2 3.8 5.7 3.8 4.9 ...
 $ Horsepower        : int  140 200 172 172 208 110 170 180 170 200 ...
 $ RPM               : int  6300 5500 5500 5500 5700 5200 4800 4000 4800 4100 ...
 $ Rev.per.mile      : int  2890 2335 2280 2535 2545 2565 1570 1320 1690 1510 ...
 $ Man.trans.avail   : Factor w/2 levels "No","Yes": 2 2 2 2 2 1 1 1 1 1 ...
 $ Fuel.tank.capacity: num  13.2 18 16.9 21.1 21.1 16.4 18 23 18.8 18 ...
 $ Passengers        : int  5 5 5 6 4 6 6 6 5 6 ...
 $ Length            : int  177 195 180 193 186 189 200 216 198 206 ...
 $ Wheelbase         : int  102 115 102 106 109 105 111 116 108 114 ...
 $ Width             : int  68 71 67 70 69 69 74 78 73 73 ...
 $ Turn.circle       : int  37 38 37 37 39 41 42 45 41 43 ...
 $ Rear.seat.room    : num  26.5 30 28 31 27 28 30.5 30.5 26.5 35 ...
 $ Luggage.room      : int  11 15 14 17 13 16 17 21 14 18 ...
 $ Weight            : int  2705 3560 3375 3405 3640 2880 3470 4105 3495 3620 ...
 $ Origin            : Factor w/2 levels "USA","non-USA": 2 2 2 2 2 1 1 1 1 1 ...
 $ Make              : Factor w/93 levels "Acura Integra",..: 1 2 4 3 5 6 7 9 8 10 ...

上記の結果は、データセットにカテゴリ変数と見なすことができる多くの因子変数があることを示しています。このモデルでは、変数「AirBags」と「Type」を考慮します。ここでは、販売されている車の種類と、所有しているエアバッグの種類との間に有意な相関関係を見つけることを目指しています。相関関係が観察される場合、どのタイプの車がどのタイプのエアバッグでよりよく売れるかを推定できます。

# Load the library.
library("MASS")

# Create a data frame from the main data set.
car.data <- data.frame(Cars93$AirBags, Cars93$Type)

# Create a table with the needed variables.
car.data = table(Cars93$AirBags, Cars93$Type)
print(car.data)

# Perform the Chi-Square test.
print(chisq.test(car.data))

上記のコードを実行すると、次の結果が生成されます-

                     Compact Large Midsize Small Sporty Van
  Driver & Passenger       2     4       7     0      3   0
  Driver only              9     7      11     5      8   3
  None                     5     0       4    16      3   6

         Pearson's Chi-squared test

data:  car.data
X-squared = 33.001, df = 10, p-value = 0.0002723

Warning message:
In chisq.test(car.data) : Chi-squared approximation may be incorrect

結論

結果は、0.05未満のp値を示し、文字列相関を示します。 R-interview-questions

R-quick-guide

R-概要

Rの進化

Rの特徴

R-環境設定

ローカル環境のセットアップ

Windowsインストール

Linuxのインストール

R-基本的な構文

Rコマンドプロンプト

Rスクリプトファイル

コメント

R-データ型

ベクトル

リスト

行列

配列

要因

データフレーム

R-変数

変数の割り当て

変数のデータ型

変数を見つける

変数を削除する

R-演算子

演算子の種類

算術演算子

関係演算子

論理演算子

割り当て演算子

その他の演算子

R-意思決定

R-ループ

ループ制御ステートメント

R-関数

関数定義

機能コンポーネント

組み込み関数

ユーザー定義関数

関数を呼び出す

引数なしで関数を呼び出す

引数値を使用した関数の呼び出し（位置および名前による）

デフォルト引数で関数を呼び出す

関数の遅延評価

R-ストリング

文字列の構築に適用されるルール

有効な文字列の例

無効な文字列の例

文字列操作

文字列の連結-paste（）関数

構文

例

数字と文字列のフォーマット-format（）関数

構文

例

文字列の文字数を数える-nchar（）関数

構文

例

大文字と小文字の変更-toupper（）およびtolower（）関数

構文

例

文字列の一部の抽出-substring（）関数

構文

例

R-ベクトル

ベクター作成

単一要素ベクトル

複数の要素のベクトル

ベクター要素へのアクセス

ベクトル操作

ベクトル演算

ベクター要素のリサイクル

ベクター要素の並べ替え

R-リスト

リストを作成する

[[火]

Converting List to Vector

R-行列

構文

例