R语言应用

文章参考  << R 数据分析   —— 方法与案例详解   >>

R的官方网站是http://www.r-project.org，

 在R官方主页点击download R，而后选择对应的镜像后，在右侧下载和安装包栏目里会

出现三种操做系统的R版本（Linux、(Mac) OS X、Windows），选择点击相应的操做系

统后，再选择点击base就会进入R的下载页面，在页面上会出现R的最新版本和安装说明等

不过，要使用RStudio，除了安装R开发环境后，还须要到

http://www.rstudio.org/download/desktop/

 上下载适合你电脑的RStudio版本并安装。

R的安装包有几种方法，这里主要介绍其中两种方法：

（1）在线安装。

好比须要安装”class”这个扩展包，输入命令install.packages(“class”)执行便可。

也能够同时安装多个包，好比需同时安装“class”,“cluster”两个包，输入命

令install.packages(c(“class”,”cluster”) )。

（2）利用Rstudio安装。

Rstudio在下一节将会详细介绍。

在Rstudio右下角栏目里点

击“packages”而后再点击 “install

packages”, 会出现如图的对话框，

在packages对话框里输入须要安装的

包名，好比输入 class，就能够安装包

工做路径设置的函数

函数  功能

getwd()  显示当前工做目录

setwd(“mydir”)  修改当前工做目录

ls()  列出当前工做空间的全部对象

rm()  删除一个或多个对象

help(options)  显示可用选项的说明

save.image(“myfile”)  保存工做空间到文件myfile.RData中

load(“myfile”)  读取一个工做空间myfile.RData

q()  退出。并询问是否保存当前工做空间

二.R数据结构和基本运算

R语言的数据类型主要有:包括数值型、逻辑型、字符型、复数型，原型 。此外，也能够

是缺省值。

一、数值型（numeric）

这种数据的形式是实数。能够写成整数（integers），小数（decimal fractions），或

科学记数（scientific notation）的方式。数值型其实是两种独立模式的混合说法，即整数

型（integers）和双精度型（double－precision）。该种类型数据默认是双精度型数

据（double－precision）。

二、字符型（character）

这种数据的形式是夹在双引号“”或单引号‘ ’之间的字符串，如“MR”。

三、逻辑型（logical）

这种数据只能取T（TRUE）或F（FALSE）值。

 

四、复数型（complex）

这种数据是形如a+bi形式的复数。

五、原味(原始)型（raw）

这种类型以二进制形式保存数据。

六、缺省值（missing value）

有些统计资料是不完整的。当一个元素或值在统计的时候是“不可获得”（not

available）或“缺失值”（missing value）的时候，相关位置可能会被保留而且赋予一个

特定的NA（not available）值。任何NA的运算结果都是NA。is.na()用来检测数据是否缺失

，若是数据缺失，则返回TRUE，不然，返回FALSE。

 

例如：

> z<-c(1:5,NA) #生成向量z

> z #返回z向量的结果

[1] 1 2 3 4 5 NA

> is.na(z) #识别z向量的值是否有缺失值

[1] FALSE FALSE FALSE FALSE FALSE TRUE

上面，咱们用c()函数首先生成了向量z, c()函数的具体使用方法详见2.2.1。is.na()返回的结果

是前面5个元素都FALSE，最后1个是TRUE，这说明前面5个都不是缺失值，最后1个是缺失值。

 

数据类型  辨别函数  转换函数

numeric  is.numeric()  as.numeric()

character  is.character()  as.character()

complex  is.complex()  as.complex()

double  is.double()  as.double()

integer  is. integer()  as. integer()

logical  is. logical()  as. logical()

NA  is.na()  as.na()

常见的辨别和转换对象类型的函数以下表：

表2-1 辨别和转换数据对象类型的函数

R语言里的数据对象主要有六种结构：

l 向量（vector）

l 矩阵（matrix）

l 数组（array）

l 因子（factor）

l 列表（list）

l 数据框（data frames）

不过在这以前，咱们先了解一下R在浮点运算中的一些精度问题。

例如：（0.6>0.6？）

> x <- seq(0, 1, by = 0.2) #seq()生成序列的函数，详见2.2.1部分

> y <- seq(0, 1, by = 0.2)

> y[4]

[1] 0.6

> x[3]

[1] 0.4

> 1 - x[3]

[1] 0.6

> y[4] > 1 - x[3]

[1] TRUE

  注意：这也是在计算机运算里面常常出现的一个问题（不过表示出来结果这样其实应该

算是R的缺陷，稍微高级的数学运算软件通常都会经过一些方法来克服），简单来讲就是浮点

数在计算机中的表达有限制，不能以任意精度存储，因此尤为是微小的数字或巨大的数字在

运算时常常会有些意外状况。

所以有时候在处理R里面的数据的时候，特别是在判断的时候，须要特别注意精度问题。

  （1）向量赋值

向量（vector）是由有相同基本类型元素组成的序列，至关于一维数组。

例：> x <-c(1,3,5,7,9) #用c( )构建向量

这是一个用函数c( )完成的赋值语句。这里的函数c( )能够有任意多个参数，而它输出的

值是一个把这些参数首尾相连造成的一个向量。

“#”符号后面跟的是注释，在写程序的时候清楚代表程序工做的注释能大大提升程序的可

读性。

“<-”是赋值符号，表示把<-后面的内容赋值给<-前面的内容，R的赋值符号除了“<-”外,

还有“->”、“=”， ->的用法和<-的用法正好相反。

注意：R也容许“=”赋值，但不是标准语法，有些状况下用“=”有可能会出现问题，所以一

般状况不建议使用“=”。

例如：

> c(1,3,5,7,9) -> y #将c()生成的数值向量赋值给y

> y

[1] 1 3 5 7 9

> z <- c("Male","Female","Female","Male","Male") #将c()生成的字符向量赋值给z

> z

[1] "Male" "Female" "Female" "Male" "Male"

> u=c(TRUE,FALSE,TRUE,FALSE,FALSE) #将c()生成的逻辑向量赋值给u

> u

[1] TRUE FALSE TRUE FALSE FALSE

此处，y是数值向量，z是字符型向量，u是逻辑型向量。

  注意：单个向量中的数据要求是相同类型，同一贯量中没法混杂不一样类型的数据。

对于字符向量，一个很重要的函数paste（）能够把自变量对应元素连成一个字符串，长

度不相同时，较短的向量被重复使用。

例如：

> v<-paste("x",1:5,sep="")

> v

[1] "x1" "x2" "x3" "x4" "x5“

此外，也能够用assign（）函数对向量进行赋值。例如：

> assign("w",c(1,3,5,7,9))

> w

[1] 1 3 5 7 9

（2）向量运算

对于向量的乘法，除法，乘方运算，其方法是对应向量的每一个份量作乘法、除法和乘方运算。

例如：>x <-c(1,3,5,7,9)

> c(1,3,5,7,9) -> y

> x * y #对应元素相乘

[1] 1 9 25 49 81

> x / y

[1] 1 1 1 1 1

> x^2

[1] 1 9 25 49 81

> y^x

[1] 1 27 3125 823543 387420489

  （2）向量运算

此外，”%/%”表示整数除法(5%/%3为1)，”%%”表示求余数(5%%3为2)。

向量运算会对该向量的每个元素都进行一样的运算。出如今同一个表达式的向量最好

同一长度。若是长度不一，表达式中短的向量将会被循环使用，表达式的值将是一个和最长

的向量等长的向量。

例如：

> c(1,3,5)+c(2,4,6,8,10)

[1] 3 7 11 9 13

第一个向量的长度小于第二个向量，循环补齐第一贯量的长度，即为c(1,3,5,1,3)

  （3）生成有规则序列

l R能够产生正则序列，最简单的是用“:：”符号，就能够产生有规律的正则序列。例如：

> (t <- 1:10)

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

> (r <- 5:1)

[1] 5 4 3 2 1

> 2*1:5

[1] 2 4 6 8 10

其中，5:1表示逆向序列, 而且在表达式运算中，“：”的运算级别最高，即上面的2*1:5

，R是先生成1-5的向量，而后再乘上2。这里在表达式外面套()的意思把结果直接打印出来，

好比>t <- 1:10而不套括号，则R将运算结果保存在t对象里，可是不会把t的结果打印出来。

2.2.1 向量

  （3）生成有规则序列

l 能够用函数seq（）产生有规律的各类序列，其句法是：seq(from, to, by)，from表示序列的

起始值，to表示序列的终止值，by表示步长。其中，by参数（参数by）省略时，默认步长为1

。而且函数seq（）也能够产生降序数列。例如：

> seq(1,10,2) #生成从1开始，10结束，步长为2的序列

[1] 1 3 5 7 9

> seq(1,10) #默认步长为1

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

> seq(10,1,-1) #步长为-1

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

2.2.1 向量

  （3）生成有规则序列

有时候咱们须要关注的是数列的长度，这时咱们能够操做以下：

> seq(1,by=2,length=10)

[1] 1 3 5 7 9 11 13 15 17 19

  （3）生成有规则序列

l rep()函数能够用各类复杂的方式重复一个对象。其命令是：rep(x, times, ...)，其中x表示要

重复的对象，times表示重复的次数。

> rep(c(1,3),4) #将c(1,3)向量重复4次

[1] 1 3 1 3 1 3 1 3

> rep(c(1,3),each=4)

[1] 1 1 1 1 3 3 3 3

> rep(1:3,rep(2,3))

[1] 1 1 2 2 3 3

第一个是向量c(1,3)重复4次的状况，也能够用第二个对每一个元素进行重复，第三个是函

数rep( )的嵌套使用，里层的rep(2,3)实际就等价于向量c(2,2,2)。

2.2.1 向量

（4）向量的常见函数

向量里元素的个数称为向量的长度（length）。长度为1的向量就是常数（或标量）。函

数length()能够返回向量的长度，mode()能够返回向量的数据类型，min()返回向量的最小值

，max()返回向量的最大值，range()返回向量的范围，which.min()、which.max()返回在第几

个份量求到最小、最大值。例如：

>x <-c(1,3,5,7,9)

> length(x)

[1] 5

> min(x)

[1] 1

> range(x)

[1] 1 9

（4）向量的常见函数

R提供了不少的函数能够对向量进行运算，这里不一 一列举，下面列出几个经常使用函数表。

函数  用途  函数  用途

sum（）  求和  rev（）  反排序

max（）  求最大值  rank（）  求秩

min（）  求最小值  append（）  添加

range（）  求极差（全矩） replace（）  替换

mean（）  求均值  match（）  匹配

median （）  求中位数  pmatch（） 部分匹配

var（）  求方差  all（）  判断全部

sd（）  求标准差  any（）  判断部分

sort（）  排序  prod（）  积

表2-2 对向量运算常见函数表

 

  （5）向量的索引

l 在R中提供了灵活的向量下标运算。取出向量的某一个元素能够用x[i]。也能够经过赋值语

句来改变一个或多个元素的值。例如：

> x <- c(1,3,5)

> x[2] #返回x向量的第2元素

[1] 3

>(c(1,2,3)+4)[2]

#先进行向量运算c(1,2,3)+4，再返回该

向量的第2个元素

[1] 6

> x[2] <- 10 #将10赋值给x向量的第2个

元素，,即替换掉原来的值

> x

[1] 1 10 5

> x[c(1,3)] <- c(9,11) #将9和11赋值给x

向量的第1和第3个元素

> x

[1] 9 10 11

2.2.1 向量

  > x <- c(1,3,5)

  > x < 4

  #返回逻辑结果，即x向量的元素是否小于4

  [1] TRUE TRUE FALSE

  > x[x<4] #返回x向量里小于4的元素

 [1] 1 3

  > z <- c(-1,1:3,NA)

  > z

  [1] -1 1 2 3 NA

> z[is.na(z)] <- 0 #将0赋值给z向量里的N

A值

> z

[1] -1 1 2 3 0

> z <- c(-1,1:3,NA)

y <- z[!is.na(z)]

#将z里的非缺失值赋值给y

> y

[1] -1 1 2 3

l  把i换成逻辑语句也能够对向量进行逻辑运算。例如：

2.2.1 向量

  > x<-c(-3,-2,-1,0,5,7)

  > y <- numeric(length(x))

  #生成于x向量长度相同的数值型向量

 > y

  [1] 0 0 0 0 0 0

  > y[x<0] <- 1-x[x<0]

  #求出x中小于0元素对应位置，y对应位

置的值用1-x[x<0]替代

> y

[1] 4 3 2 0 0 0

>y[x>=0] <- 1+x[x>=0]

#求出x中大等于0元素对应位置，y对应位

置的元素用1-x[x<0]赋值

> y

[1] 4 3 2 1 6 8

第二章  数据结构与基本运算

l  这种方法能够用在对分段函数的定义上。例如：

l  若是x[i]，i取值是小于0的负整数，则表示删除相应位置的元素。

  矩阵（matrix）是将数据用行和列排列的长方形表格，它是二维的数组，其单元必须是

相同的数据类型。一般用列来表示不一样的变量，用行表示各个对象。R语言生成矩阵的函数

是matrix ( )，其句法是：

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)

其中，data 项为必要的矩阵元素,nrow 为行数,ncol 为列数,注意 nrow 与 ncol 的乘积应为

矩阵元素个数, dimnames 给定行和列的名称，byrow 项控制排列元素时是否按行进行,默

认byrow=FALSE，即按列顺序排列。

例如：> matrix(1:12,nrow=4,ncol=3) #默认按列填充

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

[1,] 1 5 9

[2,] 2 6 10

[3,] 3 7 11

[4,] 4 8 12

> matrix(1:12,nrow=4,ncol=3,byrow=T) #按行填充

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

[1,] 1 2 3

[2,] 4 5 6

[3,] 7 8 9

[4,] 10 11 12

  矩阵的运算种类多，方法多，此处做简要介绍。

l 矩阵的转置能够用函数t()来计算，相似的，若将函数 t()做用于一个向量x,则当作x为列向量,

返回结果为一个行向量。若想获得一个列向量,可用 t(t(x))。

> (A <- matrix(1:12,nrow=3,ncol=4))

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

[1,] 1 4 7 10

[2,] 2 5 8 11

[3,] 3 6 9 12

> t(A)

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

[1,] 1 2 3

[2,] 4 5 6

[3,] 7 8 9

[4,] 10 11 12

  矩阵的运算种类多，方法多，此处做简要介绍。

l 矩阵的加减法

>A <- B <- matrix(1:12,nrow=3)

#将生成的矩阵赋给B，同时又赋给A

> A+B

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

[1,] 2 8 14 20

[2,] 4 10 16 22

[3,] 6 12 18 24

l 矩阵的数乘

> 3*A

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

[1,] 3 12 21 30

[2,] 6 15 24 33

[3,] 9 18 27 36

  矩阵的运算种类多，方法多，此处做简要介绍。

l 矩阵的乘法，除了矩阵须要知足能够相乘的要求以外，在R中须要用运算符“%*%”来进行

计算。“*”运算只是对应的元素相乘。若是要计算t(A)%*%B还能够用函数crossprod(A,B),

这种计算的效率更高。

> B <- t(A)

> A%*%B

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

[1,] 166 188 210

[2,] 188 214 240

[3,] 210 240 270

l R中还能够对矩阵的对角元素进行计算，例如要取一个方阵的对角元素:

> (A <- matrix(1:16,nrow=4))

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

[1,] 1 5 9 13

[2,] 2 6 10 14

[3,] 3 7 11 15

[4,] 4 8 12 16

> diag(A)

[1] 1 6 11 16

另外，对一个向量应用diag()函数能够产生以这样向量的元素为对角元的对角矩阵

> diag(diag(A))

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

[1,] 1 0 0 0

[2,] 0 6 0 0

[3,] 0 0 11 0

[4,] 0 0 0 16

若是输入只有一个正整数的话，diag()函数将会生成一个对应维数的单位阵。

> diag(3)

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

[1,] 1 0 0

[2,] 0 1 0

[3,] 0 0 1

l 求逆，在R中使用solve()函数能够计算，若是是solve(a,b)的话是解线性方程组ax=b，b默

认为单位矩阵。

> (A <- matrix(rnorm(16),4,4)) #rnorm()是生成16个标准正态分布随机数

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

[1,] 0.44576927 -0.9841294 -0.1291554 0.18165406

[2,] 1.04034856 1.3658480 -0.6905046 0.06254394

[3,] -0.02689138 -0.5389127 -0.1356344 1.71923910

[4,] -0.05693438 1.4905866 -0.2479709 0.03399939

> solve(A)

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

[1,] -4.538443 2.6321129 0.4872459 -5.232100

[2,] -1.936148 0.7670728 0.2011416 -1.237585

[3,] -10.806250 4.0894901 1.1996337 -10.448150

[4,] -1.530421 0.6042453 0.7469654 -1.294048

l 求特征值和特征向量的运算，在R中能够经过函数eigen()来获得。

> (A <- diag(4)+1)

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

[1,] 2 1 1 1

[2,] 1 2 1 1

[3,] 1 1 2 1

[4,] 1 1 1 2

> (A.eigen <- eigen(A,symmetric=T))

$values #此处返回的结果是列表格式，具体详见2.2.5

[1] 5 1 1 1

$vectors

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

[1,] -0.5 0.8660254 0.0000000 0.0000000

[2,] -0.5 -0.2886751 -0.5773503 -0.5773503

[3,] -0.5 -0.2886751 -0.2113249 0.7886751

[4,] -0.5 -0.2886751 0.7886751 -0.2113249

l 对于正定矩阵A，能够对其进行Choleskey分解，即A=P T P，其中P为上三角矩阵，在R中

能够用函数chol()进行Choleskey分解。

> chol(A)

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

[1,] 1.414214 0.7071068 0.7071068 0.7071068

[2,] 0.000000 1.2247449 0.4082483 0.4082483

[3,] 0.000000 0.0000000 1.1547005 0.2886751

[4,] 0.000000 0.0000000 0.0000000 1.1180340

若矩阵为对称正定阵，则能够利用Choleskey分解来求行列式的值以及矩阵的逆，而且这

种用法更有效。

> prod(diag(chol(A))^2)#求出A矩阵的对角元素，而后求平方，再求连乘积

[1] 5

> det(A) #求A矩阵行列式

[1] 5

> chol2inv(chol(A)) 求Choleskey分解后的逆

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

[1,] 0.8 -0.2 -0.2 -0.2

[2,] -0.2 0.8 -0.2 -0.2

[3,] -0.2 -0.2 0.8 -0.2

[4,] -0.2 -0.2 -0.2 0.8

l 奇异值分解：

若A为m行n列矩阵，秩为r，则矩阵能够进行奇异值分解获得A=UDV T 。在R中能够经过svd(

)函数进行计算。  $u

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

[1,] -0.5290354 0.74394551 0.4082483

[2,] -0.5760715 0.03840487 -0.8164966

[3,] -0.6231077 -0.66713577 0.4082483

$v

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

[1,] -0.07736219 -0.71960032 -0.4076688

[2,] -0.19033085 -0.50893247 0.5745647

[3,] -0.30329950 -0.29826463 -0.0280114

[4,] -0.41626816 -0.08759679 0.2226621

[5,] -0.52923682 0.12307105 -0.6212052

[6,] -0.64220548 0.33373889 0.2596585

> (A <- matrix(1:18,3,6))

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

[1,] 1 4 7 10 13 16

[2,] 2 5 8 11 14 17

[3,] 3 6 9 12 15 18

>(A.svd <- svd(A))

#求矩阵A的svd分解，并将结果赋值给A.svd

$d

[1] 4.589453e+01 1.640705e+00 1.366522e-15

l  QR分解：

实数矩阵A的QR分解是把A分为A=QR，这里的Q是正交矩阵，而R是上三角矩阵。QR分

解在R中能够用函数qr()计算.其中，rank项返回矩阵的秩，qr项包含了矩阵Q和R的信息，

要获得对应矩阵，能够用函数qr.R()，qr.Q()计算。

2.2.2 矩阵

第二章  数据结构与基本运算

l  QR分解。例如：

> B <- matrix(1:16,4,4)

> qr(B)

$qr

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

[1,] -5.4772256 -12.7801930 -2.008316e+01 -2.738613e+01

[2,] 0.3651484 -3.2659863 -6.531973e+00 -9.797959e+00

[3,] 0.5477226 -0.3781696 1.601186e-15 2.217027e-15

[4,] 0.7302967 -0.9124744 -5.547002e-01 -1.478018e-15

$rank #矩阵的秩

[1] 2

$qraux #Q中的额外信息

[1] 1.182574e+00 1.156135e+00 1.832050e+00 1.478018e-15

$pivot #分解过程当中的旋转信息

[1] 1 2 3 4

attr(,"class") #返回属性

[1] "qr"

l  QR分解。

例如：

> qr.R(qr(B)) #提取R矩阵

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

[1,] -5.477226 -12.780193 -2.008316e+01 -2.738613e+01

[2,] 0.000000 -3.265986 -6.531973e+00 -9.797959e+00

[3,] 0.000000 0.000000 1.601186e-15 2.217027e-15

[4,] 0.000000 0.000000 0.000000e+00 -1.478018e-15

> qr.Q(qr(B)) #提取Q矩阵

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

[1,] -0.1825742 -8.164966e-01 -0.4000874 -0.37407225

[2,] -0.3651484 -4.082483e-01 0.2546329 0.79697056

[3,] -0.5477226 -1.665335e-16 0.6909965 -0.47172438

[4,] -0.7302967 4.082483e-01 -0.5455419 0.04882607

l 可用kronecker()来计算矩阵的Kronecker积。

m×n

> (A <- matrix(1:4,2,2))

[,1] [,2]

[1,] 1 3

[2,] 2 4

> kronecker(A,B)

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

[1,] 1 1 3 3

[2,] 1 1 3 3

[3,] 2 2 4 4

[4,] 2 2 4 4

> (B <- matrix(rep(1,4),2,2))

[,1] [,2]

[1,] 1 1

[2,] 1 1

l 在R中可以使用dim()获得矩阵的维数，nrow()求行数，ncol()求列数； rowSums()求各行和，

rowMeans()求行均值， colSums()求各列和， colMeans()求列均值。

l 计算X T X这样的矩阵逆，例如OLS中的系数矩阵。在R的strucchange包里面有函

数solveCrossprod()函数能够很方便的计算。其具体形式以下：

solveCrossprod(X, method = c("qr", "chol", "solve"))

对于method中的求逆方法，qr效率最高，chol精度最高，而solve与solve(crossprod(x,x)

)的效果相同。例如：

> A <- matrix(rnorm(16),4)

> solveCrossprod(A,method="qr") #利用qr分解方法求逆矩阵

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

[1,] 1.5752935 0.3617794 -1.269400 1.5530569

[2,] 0.3617794 0.2996626 -0.139547 0.4616545

[3,] -1.2694003 -0.1395470 1.741550 -1.1275450

[4,] 1.5530569 0.4616545 -1.127545 2.1345205

l  计算X T X这样的矩阵逆 ，在R的strucchange包里面有函数solveCrossprod()函数能够很

方便的计算。

续例：

> solveCrossprod(A,method="chol") #利用Choleskey分解方法求逆矩阵

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

[1,] 1.5752935 0.3617794 -1.269400 1.5530569

[2,] 0.3617794 0.2996626 -0.139547 0.4616545

[3,] -1.2694003 -0.1395470 1.741550 -1.1275450

[4,] 1.5530569 0.4616545 -1.127545 2.1345205

l  计算X T X这样的矩阵逆 ，在R的strucchange包里面有函数solveCrossprod()函数能够很

方便的计算。

续例：

> solveCrossprod(A,method="solve")

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

[1,] 1.5752935 0.3617794 -1.269400 1.5530569

[2,] 0.3617794 0.2996626 -0.139547 0.4616545

[3,] -1.2694003 -0.1395470 1.741550 -1.1275450

[4,] 1.5530569 0.4616545 -1.127545 2.1345205

> solve(crossprod(A,A))

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

[1,] 1.5752935 0.3617794 -1.269400 1.5530569

[2,] 0.3617794 0.2996626 -0.139547 0.4616545

[3,] -1.2694003 -0.1395470 1.741550 -1.1275450

[4,] 1.5530569 0.4616545 -1.127545 2.1345205

l 可以使用lower.tri()，upper.tri()提取到矩阵的上三角和下三角矩阵。结果返回为逻辑矩阵，

其中diag为T时包含对角元，默认不含对角元。

lower.tri(x, diag = FALSE)

upper.tri(x, diag = FALSE)

例如：

> lower.tri(A,diag=T)

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

[1,] TRUE FALSE FALSE FALSE

[2,] TRUE TRUE FALSE FALSE

[3,] TRUE TRUE TRUE FALSE

[4,] TRUE TRUE TRUE TRUE

> A[lower.tri(A)]=0

> A

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

[1,] 1 5 9 13

[2,] 0 6 10 14

[3,] 0 0 11 15

[4,] 0 0 0 16

> A <- matrix(1:16,4)

> lower.tri(A)

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

[1,] FALSE FALSE FALSE FALSE

[2,] TRUE FALSE FALSE FALSE

[3,] TRUE TRUE FALSE FALSE

[4,] TRUE TRUE TRUE FALSE

l 在R中定义了row()和col()函数用来返回矩阵的行列下标。另外，也能够经过使

用x[row(x)<col(x)]=0等语句来获得矩阵的上下三角矩阵。

例如：

> col(A)

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

[1,] 1 2 3 4

[2,] 1 2 3 4

[3,] 1 2 3 4

[4,] 1 2 3 4

> A[row(A)<col(A)]=0

> A

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

[1,] 1 0 0 0

[2,] 2 6 0 0

[3,] 3 7 11 0

[4,] 4 8 12 16

> A <- matrix(1:16,4)

> row(A)

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

[1,] 1 1 1 1

[2,] 2 2 2 2

[3,] 3 3 3 3

[4,] 4 4 4 4

l 矩阵中计算行列式的值可使用函数det()来计算,例如对上面的下三角矩阵求行列式：

> det(A)

[1] 1056

l 在R的使用过程当中，常常须要将矩阵转化为向量化算子，编写一个小函数便可实现。

例如：

> vec(A)

[,1]

[1,] 1

[2,] 2

[3,] 3

[4,] 4

[5,] 5

[6,] 6

> vec <- function(x){

+ t(t(as.vector(x)))

+ }

#函数编写详细请见3.4

> (A <- matrix(1:6,2,3))

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

[1,] 1 3 5

[2,] 2 4 6

l 在时间序列分析中，经常须要用到滞后序列，R中的fMultivar包中的函数tslag()能够实现

。首先，咱们须要安装fMultivar，而后再载入该包。 tslag的用法为

tslag(x, k = 1, trim = FALSE)

其中，x为一个向量，k为滞后期数，trim默认返回序列与原序列长度相同，但包含NA值，

若trim=T，则返回不含NA值。例如：

> tslag(x,1:4,trim=T)

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

[1,] 4 3 2 1

[2,] 5 4 3 2

> x <- 1:6

> tslag(x,1:4,trim=F)

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

[1,] NA NA NA NA

[2,] 1 NA NA NA

[3,] 2 1 NA NA

[4,] 3 2 1 NA

[5,] 4 3 2 1

[6,] 5 4 3 2

 l 对于矩阵的运算，咱们还可使用apply()函数来进行各类计算，其用法为

apply(X, MARGIN, FUN, ...) 。其中，X表示须要处理的数据，MARGIN表示函数的做用

范围，1为对行运算，2为对列运算。FUN为须要运用的函数。例如：

A <- matrix(1:12,3,4)

> apply(A,2,sum) #矩阵的列求和

[1] 6 15 24 33

> apply(A,2,mean) #矩阵的列求均值

[1] 2 5 8 11

> apply(A,2,var) #矩阵的列求方差

[1] 1 1 1 1

> apply(A,2,sd) #矩阵的列求标准差

[1] 1 1 1 1

l 矩阵合并可使用rbind()和cbind()函数来对矩阵按照行和列进行合并。例如：

> B=matrix(c(1,1,1,1),2,2) #生成2×2的矩阵

> rbind(B,B) #将B和B矩阵按行合并

[,1] [,2]

[1,] 1 1

[2,] 1 1

[3,] 1 1

[4,] 1 1

> cbind(B,B) #将B和B矩阵按列合并

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

[1,] 1 1 1 1

[2,] 1 1 1 1

l 对于获得的矩阵，可使用A[i,j]获得A矩阵第i行第j列的元素，A[i,]和A[,j]分别表示返回第i

行和第j列的全部元素。也可使用A[i:k,j:l]的形式来得到多行多列的子矩阵。

例如：

> A=matrix(1:12,3,4)

> A[2,3] #返回矩阵第2行第3列元素

[1] 8

> A[2,] #返回矩阵第2行全部元素

[1] 2 5 8 11

> A[,3] #返回矩阵第3列全部元素

[1] 7 8 9

> A[1:3,2] #返回矩阵第1到3行，且是第2列的元素

[1] 4 5 6

l 使用as.matrix()把非矩阵格式的转换成矩阵格式，函数is.matrix()能够辨别是否矩阵。

  数组（array）能够看做是带有多个下标的类型相同的元素的集合。也能够看做是向量和

矩阵的推广，一维数组就是向量，二维数组就是矩阵。数组的生成函数是array()，其句法是：

array(data = NA, dim = length(data), dimnames = NULL)

其中data表示数据，能够为空，dim表示维数，dimnames能够更改数组的维度的名称。例如:

> (xx <- array(1:24,c(3,4,2))) # 产生维数为(3,4,2)的3维数组

, , 1

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

[1,] 1 4 7 10

[2,] 2 5 8 11

[3,] 3 6 9 12

, , 2

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

[1,] 13 16 19 22

[2,] 14 17 20 23

[3,] 15 18 21 24

  索引数组相似于索引矩阵，索引向量能够利用下标位置来定义；其中dim()函数能够返回

数组的维数，dim()还能够用来将向量转化成数组或矩阵(见下例)。数组也能够

用“+”、“-”、“*”、“/”以及函数等进行运算，其方法和矩阵相相似，这里再也不详述。

> xx[2,3,2]

[1] 20

> xx[2,1:3,2]

[1] 14 17 20

> xx[,2,]

[,1] [,2]

[1,] 4 16

[2,] 5 17

[3,] 6 18

> dim(xx)

[1] 3 4 2

>zz=c(2,5,6,8,1,4,6,9,10,7,3,5)

>dim(zz)=c(2,2,3)

#将向量转成维度为（2,2,3）

的数组

> zz

, , 1

[,1] [,2]

[1,] 2 6

[2,] 5 8

, , 2

[,1] [,2]

[1,] 1 6

[2,] 4 9

, , 3

[,1] [,2]

[1,] 10 3

[2,] 7 5

  分类型数据（category data）常常要把数据分红不一样的水平或因子（factor）。好比，

学生的性别包含男和女两个因子。因子表明变量的不一样可能的水平（即便在数据中不出现）

。在统计模型统计分析中十分有用，例如将0，1转换为’yes’,’no’就很方便，在R里能够

使用factor函数来建立因子，函数形式以下：

factor(x = character(), levels, labels = levels, exclude = NA, ordered = is.ordered(x))

其中，levels用来指定因子的水平；labels用来指定水平的名字；exclude表示在x中须要

排除的水平；ordered用来决定因子的水平是否有次序。

例如一组学生数据：

> y <- c("女","男","男","女","女","女","男")

> (f <- factor(y)) #生成因子

[1] 女 男 男 女 女 女 男

Levels: 女 男

> levels(f) #提取因子的水平

[1] "女" "男"

假若要表示因子之间有大小顺序（考虑因子之间的顺序），则能够利用ordered（）函数产生。

> score <- c("B","C","D","B","A","D","A")

> (score_o <- ordered(score,levels=c("D","C","B","A"))) #生成有序因子

[1] B C D B A D A

Levels: D < C < B < A

向量、矩阵和数组的元素都单元必须是同一类型的数据。若是一个数据对象须要含有不

同的数据类型，能够采用列表（list）这种数据对象的形式（数据对象形式）。列表是一个对

象的有序集合构成的对象，列表中包含的对象又称为它的份量（components），份量能够

是不一样的模式或类型，如一个列表能够包括数值向量、逻辑向量、矩阵、字符、数组等。创

建列表的函数是list()，其句法是：list（变量1=份量1，变量2=份量2，….）。

例如：下面是某校部分学生的状况，其中，x、y、z分别表示班级、性别和成绩。

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

> y <- c("女","男","男","女","女","女","男")

> z <- c(80,85,92,76,61,95,83)

> (LST <- list(class=x,sex=y,score=z))

$class

[1] 1 1 2 2 3 3 3

$sex

[1] "女" "男" "男" "女" "女" "女" "男"

$score

[1] 80 85 92 76 61 95 83

l 若要访问列表的某一成分，能够用LST[[1]],LST[[2]]的形式访问，要访问第二个份量的前三

个元素能够用LST[[2]][1:3]：

> LST[[3]] #返回列表的第三个成分的值

[1] 80 85 92 76 61 95 83

> LST[[2]][1:3] #返回列表第二个成分的第1到3元素

[1] "女" "男" "男“

因为份量能够被命名，这时，咱们能够在列表名称后加$符号，再写上成分名称来访问列

表份量。其中成分名能够简写到能够与其它成分可以区分的最短程度，如LST$sc与LS

T$score表示一样的份量。例如：

> LST$score #返回socre值

[1] 80 85 92 76 61 95 83

> LST$sc #返回socre值

[1] 80 85 92 76 61 95 83

l 函数length（）、mode（）、names（）能够分别返回列表的长度（份量的数目）、数

据类型、列表里成分的名字。

l 在这里要注意LST[[1]]和LST[1]的差异，[[…]]是选择单个元素的操做符，而[…]是一个通常

通用的下标操做符。所以前者获得的是LST中的第一个对象，而且包含份量名字的命名列

表中的份量名字会被排除在外的1；然后者获得的则是LST中仅仅由第一个元素构成的子

列表。

  一、数据框的生成

数据框（data frame）是一种矩阵形式的数据，但数据框中各列能够是不一样类型的数据

。数据框每列是一个变量，每行是一个观测。数据框能够当作是矩阵（matrix）的推广，也

能够看做是一种特殊的列表对象（list）。数据框是R语言特有的数据类型，也是进行统计分

析最为有用的数据类型。不过对于可能列入数据框中的列表有以下一些限制：

l 份量必须是向量（数值，字符，逻辑），因子，数值矩阵，列表或者其余数据框。

l 矩阵，列表和数据框为新的数据框提供了尽量多的变量，由于它们各自拥有列、元素或者

变量。

l 数值向量、逻辑值、因子保持原有格式，而字符向量会被强制转换成因子而且它的水平就是

向量中出现的独立值。

l 在数据框中以变量形式出现的向量结构必须长度一致，矩阵结构必须有同样的行数。

  R语言中用函数data.frame ( )生成数据框，其句法是：

data.frame(..., row.names = NULL, check.rows = FALSE, ...)

数据框的列名默认为变量名，也能够对列名、行名进行从新命名。例如：

> (student <- data.frame(class=x,sex=y,score=z))

class sex score

1 1 女 80

2 1 男 85

3 2 男 92

4 2 女 76

5 3 女 61

6 3 女 95

7 3 男 83

> (student <- data.frame(x,y,z))

x y z

1 1 女 80

2 1 男 85

3 2 男 92

4 2 女 76

5 3 女 61

6 3 女 95

7 3 男 83

  固然，咱们也能够对数据框的行名进行修改，例如：

> row.names(student) <- c("王x","张x","赵x","刘x","黄x","孙x","李x")

> student

class sex score

王x 1 女 80

张x 1 男 85

赵x 2 男 92

刘x 2 女 76

黄x 3 女 61

孙x 3 女 95

李x 3 男 83

  二、数据框的引用

l 以数组形式访问。数据框能够看做是特殊的数组。数组是储存数据的有效方法，能够按行或

列访问，就像电子表格同样，但输入的数据必须是同一类型。数据框能够看做数组是由于数

据框的列表示变量、行表示样本观察数，所以咱们能够访问指定的行或列。

例如：

> student[,"score"] #返回y变量的全部样本观察数

[1] 80 85 92 76 61 95 83

> student[,3]

[1] 80 85 92 76 61 95 83

> student[1:5,1:3] #返回第1至第5行，第1至第3列的观察数

> student[,] #返回全部行全部列数据

  二、数据框的引用

l 以列表形式访问数据框。列表比数据框更为通常、更为普遍。列表是对象的集合，并且这些

对象能够是不一样类型的。数据框是特殊的列表，数据框的列看做向量，并且要求是同一类型

对象。以列表形式访问数据框，只要在列表名称后面加$符号，再写上变量名便可。例如：

> student$score

[1] 80 85 92 76 61 95 83

除了用$形式访问外，还能够用列表名[[变量名(号)]]形式访问：

> student[["score"]]

[1] 80 85 92 76 61 95 83

> student[[3]]

[1] 80 85 92 76 61 95 83

  二、数据框的引用

还能够筛选出符合咱们条件的数据，好比对上面的数据要获得成绩大于80分的学生，可

以按以下的方法获得。例如：

> student[student$score>80,]

class sex score

张x 1 男 85

赵x 2 男 92

孙x 3 女 95

李x 3 男 83

  三、数据框绑定Attach()函数

数据框的主要用途是保存统计建模的数据。R软件的统计建模功能都须要以数据框为输入

数据。可把数据框当成一种矩阵来处理。在使用数据框的变量时能够用“数据框名$变量名”

的记法。但这样使用较麻烦，R软件提供了attach()函数能够把数据框中的变量“连接”到内

存中，将数据框“链接（绑定）”入当前的名字空间，从而能够直接用数据框中的变量名访

问而没必要用“数据框名$变量名”这种格式。要取消链接，用函数detach（）便可。

  三、数据框绑定Attach()函数

例如上面student数据框有三个变量，对于数据框里的变量咱们不能直接引用，能够用“

数据框名$变量名”的格式，或是利用attach( )把数据框“链接（绑定）”入当前的名字空间。

> score

错误: 找不到对象'score'

> student$score

[1] 80 85 92 76 61 95 83

> attach(student)

> score

[1] 80 85 92 76 61 95 83

要取消链接，用函数detach（）便可。