一、基本操作与控制
1.1通过以下方式获取帮助
help(函数名)
help(mean)
??关键词
??mean
apropos('关键词')
apropos('mean')
[1] ".colMeans" ".rowMeans" "colMeans" "kmeans" "mean"
[6] "mean.Date" "mean.default" "mean.difftime" "mean.POSIXct" "mean.POSIXlt"
[11] "rowMeans" "weighted.mean"#搜索出该包对应的信息及其所包含的函数列表
library(help='包的名称')
library(help='stats')
#搜索与关键词相关的文档索引
RSiteSearch('关键词')
RSiteSearch('integrate')
- 工作空间的保存与加载
除了可以使用文件菜单中的保存菜单项实现，还可通过终端命令实现
save.image('mywork.Rdata') #保存工作空间映像
unlink('mywork.Rdata') #取消关联
load('mywork.Rdata') #载入工作空间映像1.2管理变量列表
#搜索变量列表，以此来明确工作空间中的变量列表
ls(all=TRUE); ls() #列出工作空间中的所有变量
[1] ".Random.seed" "C_X" "C_XY" "C_Y" "colx"
[6] "i" "m" "mat" "n" "rowx"
[11] "X" "Y"
[1] "C_X" "C_XY" "C_Y" "colx" "i" "m" "mat" "n" "rowx" "X" "Y"
ls(pattern = 'a',all.names = TRUE) #列出含a的所有变量
[1] ".Random.seed" "mat"
ls(pat='^a') #列出以‘a’开头的所有变量
character(0)
ls.str() #列出所有变量的详细的内部信息
C_X : Named num [1:4] -0.0372 0.8725 0.9341 -0.0144
C_XY : Named num [1:2] 0.0228 0.0248
C_Y : Named num [1:4] -0.0232 0.9701 0.9849 0.0682
colx : num [1:10] 0 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09
i : int 43
m : int 10
mat : num [1:43, 1:10] 0.5 0.54 0.579 0.618 0.655 ...
n : int 43
rowx : num [1:43] 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 ...
X : num [1:100] -0.326 0.552 -0.675 0.214 0.311 ...
Y : num [1:100] 0.286 -0.345 0.326 -1.697 -1.285 ...
ls.str(pat='a') #列出含‘a’的所有变量的详细的内部信息
mat : num [1:43, 1:10] 0.5 0.54 0.579 0.618 0.655 ...#为了避免重复定义，将变量列表保存在文件中
save(x,y,z,file = 'mywork.RData') #仅保存三个变量到文件中
save(list=ls(all=TRUE),file = 'mywork.Rdata') #功能同save.image
save(list=ls(pat='a',file='myworl.RData') #保存名称中含a的变量到文件1.3执行外部程序
system('ipconfig')
Windows IP 配置
以太网适配器 以太网:
媒体状态 . . . . . . . . . . . . : 媒体已断开连接
连接特定的 DNS 后缀 . . . . . . . :
以太网适配器 以太网 2:
媒体状态 . . . . . . . . . . . . : 媒体已断开连接
连接特定的 DNS 后缀 . . . . . . . :
无线局域网适配器 本地连接* 1:
媒体状态 . . . . . . . . . . . . : 媒体已断开连接
连接特定的 DNS 后缀 . . . . . . . :
无线局域网适配器 本地连接* 2:
媒体状态 . . . . . . . . . . . . : 媒体已断开连接
连接特定的 DNS 后缀 . . . . . . . :shell.exec可以实现的功能比System更加丰富，例如下列代码可以打开外部程序word
#注意：R中索引用/不能用\，否则会出现错误
shell.exec("C:/ProgramData/Microsoft/Windows/Start Menu/Programs/Word")计算程序代码的执行时间
#Sys.time()为无参函数，给出当前的系统时间，通过设置options(digits.secs=6)可以精确到毫秒/微秒
T1=Sys.time()
n=100
N=(1:n)*100
means=numeric(n)
for (i in 1:n)
means[i]=mean(rnorm(N[i]))
plot(1:n,means,type = 'l')
abline(h=0)
Sys.time()-T1
Time difference of 0.05984116 secs
#proc.time()为无参函数，给出【用户/系统/流逝】的三个时间，以秒为单位
T2=proc.time()
n=100
N=(1:n)*100
means=numeric(n)
for (i in 1:n)
means[i]=mean(rnorm(N[i]))
plot(1:n,means,type = 'l')
abline(h=0)
proc.time()-T2
用户 系统 流逝
0.06 0.00 0.06
#system.time(R表达式)，针对R表达式计算其执行【用户/系统/流逝】的三个时间
system.time({
n=100;
N=(1:n)*100;
means=numeric(n);
for (i in 1:n)
means[i]=mean(rnorm(N[i]))
plot(1:n,means,type='l');
abline(h=0)
})
用户 系统 流逝
0.05 0.00 0.05
二、语法与数据类型
2.1赋值语句
#使用=赋值
Age11=10; 年龄_12 = 10
print(Age11)
print(年龄_12)
#使用<- <<-赋值
Age21<-10; 年龄22<-20; Age22<<-10
print(Age21)
print(年龄22)
print(Age22)
#使用->赋值
30->Age31; 30->年龄_32
print(Age31)
print(年龄_32)
#使用assign函数赋值
assign('Age41',40)
print(Age41)
2.2基本数据类型
#R语言提供对字符型/数值型/逻辑型/复数等类型的支持
#并且可以通过class和mode两个函数看出变量的类型和模式
#字符型
X='10'
print(X);print(class(X));print(mode(X))
#转换
print(as.numeric(X));print(as.logical(X))
#数值型
X=10
print(X);print(class(X));print(mode(X))
#转换
print(as.character(X));print(as.logical(X))
#逻辑型
X=TRUE
print(X);print(class(X));print(mode(X))
#转换
print(as.character(X));print(as.numeric(X))
#复数
X=complex(1,1)
print(X);print(class(X));print(mode(X))
#转换
print(as.character(X));print(as.numeric(X))> X='10'
> print(X);print(class(X));print(mode(X))
[1] "10"
[1] "character"
[1] "character"
> print(as.numeric(X));print(as.logical(X))
[1] 10
[1] NA
> X=10
> print(X);print(class(X));print(mode(X))
[1] 10
[1] "numeric"
[1] "numeric"
> print(as.character(X));print(as.logical(X))
[1] "10"
[1] TRUE
> X=TRUE
> print(X);print(class(X));print(mode(X))
[1] TRUE
[1] "logical"
[1] "logical"
> print(as.character(X));print(as.numeric(X))
[1] "TRUE"
[1] 1
> X=complex(1,1)
> print(X);print(class(X));print(mode(X))
[1] 1+0i
[1] "complex"
[1] "complex"
> print(as.character(X));print(as.numeric(X))
[1] "1+0i"
[1] 12.3复杂数据类型
向量的生成
#向量：是一种具有相同类型的数据的一个容器，下标总是从1开始
#1.直接赋值拼接生成。数据类型：所有
V1=c(1,2,3)
c(V1,10,V1)
#[1] 1 2 3 10 1 2 3
#2等差序列。数据类型：数值型
V1=1:5;V2=5:1;V1;V2
#[1] 1 2 3 4 5
#[1] 5 4 3 2 1
#3等间隔序列。数值类型：数值型
seq(from=1,to=4,by=0.5)
#[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0
#4重复函数。数据类型：所有
rep(c(1,2),each=2,times=3)
#[1] 1 1 2 2 1 1 2 2 1 1 2 2
#5串尾函数。数据类型：数值型。以1开始，以序列元素结尾的连续整数向量
sequence(3:4)
#[1] 1 2 3 1 2 3 4
#6字符连接，连接符由sep指定
paste('X',1:5,sep = '')
#[1] "X1" "X2" "X3" "X4" "X5"
paste(c('X','Y'),1:6,sep='')
#[1] "X1" "Y2" "X3" "Y4" "X5" "Y6"
paste(1:5,collapse = '.')
#[1] "1.2.3.4.5"
#7向量长度,整数
vec=10
length(vec)
#[1] 1
#8引用
vec[1];vec[1:4]
#[1] 10
#[1] 10 NA NA NA多维数组的生成
#数组：带有多个下标的类型相同的元素的集合或容器，通过设置维数向量dim改变数组的结构
#各维的下标总是从1开始
#1由向量改变维数生成
M=c(1,2,3,4);dim(M)=c(2,2);M
# [,1] [,2]
#[1,] 1 3
#[2,] 2 4
#2由array函数生成
array(0,dim=c(2,3))
# [,1] [,2] [,3]
#[1,] 0 0 0
#[2,] 0 0 0
#3三维数组,通过dim变成三维数组
Arr=array(1:36,dim=c(2,3,6))
#4数组维数，数组总长度
dim(Arr)
length(Arr)
#[1] 2 3 6
#[1] 36
#5引用
Arr[1,1,1]
Arr[1,,];Arr[,1,];Arr[,,1]矩阵的生成
#矩阵：以二维表行列式构造的数据类型
#1直接生成
matrix(0,nrow = 2,ncol = 3)#生成2行3列全部为0的矩阵
matrix(c(1,2,3,4,5,6),nrow = 3,ncol = 2,byrow=TRUE)#生成3行两列的矩阵
#2向量生成
vec=1:8
matrix(vec,nrow=2,ncol=4,byrow=TRUE)
#3矩阵合并
rbind(mat1,mat2)#以行方式合并，列需要相等
cbind(mat1,mat2)#以列方式合并，行需要相等
mat1=matrix(1:12,3,4)
mat2=matrix(-1:-12,3,4)
rbind(mat1,mat2);cbind(mat1,mat2)
#4矩阵维数，矩阵行列数
dim(mat1)
nrow(mat1); ncol(mat1)
#5引用
mat1[1,]; mat1[1:3,]#引用第1行向量，第1到3行子矩阵
mat1[,1]; mat1[,1:3]#引用第1列向量，第1到3列子矩阵rbind(mat1,mat2);cbind(mat1,mat2)
因子的生成
#离散变量由各种不同的表达方式，在R中通过因子统一表示
#解决有关于名义变量、有序变量的内部表示，常用于计数，分类等
#1 转化成因子
S=c('A','B','A','C','B','D','A','C')
SF=factor(S)#默认按照数据的不同取值得到因子的水平
print(SF)
#[1] A B A C B D A C
#Levels: A B C D
#2 gl()函数生成
gl(n,k,length=n*k,labels = 1:n,ordered = FALSE)
#n为水平数，k为重复次数，length为结果长度，labels是n维向量表示因子水平
#ordered逻辑变量，表示是否有序
gl(3,2)
#[1] 1 1 2 2 3 3
#Levels: 1 2 3
gl(3,1,9)#9个1/2/3交叉
#[1] 1 2 3 1 2 3 1 2 3
#Levels: 1 2 3
gl(2,1,20)#20个1/2交叉
#[1] 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2
#Levels: 1 2
gl(2, 2, 20)
#[1] 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
#Levels: 1 2
# 3基于水平进行计数
table(SF)
#SF
#A B C D
#3 2 2 1
# 4获取水平
levels(SF)
#[1] "A" "B" "C" "D"
Tall=rnorm(10,170,10);
#随机抽样sample(x, size, replace = FALSE, prob = NULL)
#size是 10即抽取个数,replace选择TRUE表示可以重复，即有放回抽样
#参数prob，也就是“probability”（概率）的缩写，即代表某元素被抽取的概率
Sex=sample(c('男','女'),10,prob=c(0.5,0.5),replace=TRUE)
tapply(Tall,Sex,mean);#求均值
tapply(Tall,Sex,sd)#求标准差
> tapply(Tall,Sex,mean);#求均值
男 女
166.7138 163.7173
> tapply(Tall,Sex,sd)#求标准差
男 女
3.332216 8.001746列表的生成
#列表：是一种对象集合，各对象由下标或者名字加以区分和引用
#对象可以是任意类型，任意长度
#1 list定义列表
A=list(x=c(1,2,3),y=c('A','B')); A
#$x
#[1] 1 2 3
#$y
#[1] "A" "B"
#2 修改列表
A$x=c(1,2,3,4) #修改x列表
A$x=NULL #删除x元素
A$z=c(11,22) #增加z元素
#$y
#[1] "A" "B"
#$z
#[1] 11 22数据框的生成
#数据框：是一种特殊的列表对象
#每列为1个变量，由向量构成，类似数据库的表格，下标从1开始
# 1函数生成
df=data.frame(
name=c("jack","rose","mary"),
math=c(70,80,85),
eng=c(90,97,96)
);
df
"name math eng
1 jack 70 90
2 rose 80 97
3 mary 85 96"
"注意：df[[1]],df$name,df[["name"]],df[,1]四种方式等价，均返回第一列变量"
# 2列表转化，数组转化
as.data.frame(list) #list各元素长度必须相等
as.data.frame(array) #array必须是二维数组或者矩阵
# 3修改数据框
df$music=c(34,78,90) #增加一列变量
df$name=NULL #删除一列变量
#df=df[-c(1,2),];df=df[,-c(1,2)]#删除第1/2行，删除第1/2列
df$music=c(12,45,57) #修改第一列变量
colnames(df)=c("X1","X2","X3") #修改每列标题
rownames(df)=10:12 #修改每行标题
# 4可视化编辑
fix(df) #直接将修改的数据保存至df中
df=edit(df) #返回一个副本，没有保存至df中
# 5提取子数据
subset(df,select = -c(name,math))#提取除name和math以外的列
subset(df,math>=80 & eng>85)
# 6内联合并
df1=data.frame(x1=1:5,x2=2:6)
df2=data.frame(x2=3:6,x3=10:13)
merge(df1,df2,by='x2')
x1 x2
1 1 2
2 2 3
3 3 4
4 4 5
5 5 6表格编辑窗口，由fix调用弹出
> df=data.frame(
+ name=c("jack","rose","mary"),
+ math=c(70,80,85),
+ eng=c(90,97,96)
+ );
> fix(df)
三、输入与输出
3.1读取剪贴板数据
x=read.table("clipboard",header=TRUE)3.2读取文本文件数据
#1列表形式读取数据成对读取,从键盘上读取数据不加任何参数直接掉用scan函数即可
scan(text='1 2 3 4 3 4 5 6 4 5 6 7',what=list(id=0,value=0))
frtab=scan(what = list(name="",score=0))
A=read.table('test.data',header=TRUE)3.3读取数据库数据-基于windows的RODBC包
四、流程控制
x=1:10;y=seq(1,5.5,0.5);x+y
# 1ifelse(condition,expression1,expression2)
x=sample(1:100,1)
ifelse(x>=60,'及格','不及格')
# 2 switch(expression,list)
#expr为表达式，其值或为一个整数值或为一个字符串
#list为一个列表,是罗列出来的多个数据，各个数据的类型不限
x=sample(1:5,1);
switch (x,10,TRUE,'及格',FALSE,'不及格')
# 3 循环结构
#for(name in expr1) expr2
sum=0
for(i in 1:100) sum=sum+i;
sum
#5050
#while(condition) expr
sum=0;i=1;
while (i!=100) {sum=sum+i;i=i+1;}
sum
#4950
#repeat expr
sum=0;i=1;
repeat{
sum=sum+i;i=i+1;
if(i>100) break;
}
#5050
#求1-100不能被5整除的数
sum=0
for (i in 1:100) {
if(i%%5==0) next
sum=sum+i
}
#4000
sum(1:100)-sum(seq(5,100,5))
#4000
A=1:100
sum(A[A%%5!=0])
#4000
#括号的作用，命令格式（var=value),表明对var赋值为value的同时，输出var的结果
#等价于var=value;var
plot((x=1:100),sqrt(x))
五、函数与数据集
strsplit('ab cd efg',NULL)
#[[1]]
#[1] "a" "b" " " "c" "d" " " "e" "f" "g"
strsplit("a.b.c","\\.")
strsplit("a.b.c",".",fixed = TRUE)#与上一句代码结果相同
#[[1]]
#[1] "a" "b" "c"
strsplit(c(x1="asfefg",x2="qwerty"),"e")
#$x1
#[1] "asf" "fg"
#$x2
#[1] "qw" "rty"
#模式匹配
grep('[a-b]x[a-e]',c('axc','bxd','zy','oem'))
#[1] 1 2
text = c("We are the world", "we are the children")
grep("We", text) #向量text中的哪些元素匹配了单词'We'
#[1] 1
grep("We", text, invert = T) #向量text中的哪些元素没有匹配单词'We'
#[1] 2
grep("we", text, ignore.case = T) #匹配时忽略大小写
#[1] 1 2
#sub搜索并替换
sub('[a-b]x[a-e]','zz',c('axc','bxd','zy','oem'))
#[1] "zz" "zz" "zy" "oem"
#批量运算函数 apply() apply函数经常用来计算矩阵中行或列的均值、和值的函数
Data=data.frame(hei=rnorm(30,170,9),wei=rnorm(30,55,16))
apply(Data,2,mean) #计算各列均值
#hei wei
#170.45638 56.90765
apply(Data,2,mean,trim=0.1) #计算各列截尾均值
#hei wei
#170.19419 57.37628
mymedian=function(x) return(median(x))
apply(Data,2,mymedian) #传递自行编写的函数
#hei wei
#168.95539 54.10133
stu=c('LV Shulong','LTU Wenli','LIANG Feibao','XIONG xianzhu')
names=strsplit(stu,' ')
First=sapply(names,'[',1)
Last=sapply(names,'[',2)
names;First;Last
sapply(Last,nchar)
#> First
#[1] "LV" "LTU" "LIANG" "XIONG"
#> Last
#[1] "Shulong" "Wenli" "Feibao" "xianzhu"
#> sapply(Last,nchar)
#Shulong Wenli Feibao xianzhu
# 7 5 6 7
#其他常用函数
#any()和all()函数比较两个对象是否相等
X=1:10; Y=c(1:5,10:14); Z=c(X,Y)
any(X!=Y);any(X==Y) #部分相等都返回TRUE
all(X!=Y);all(X==Y) #不完全相等都返回FALSE
identical(X,Y) #不完全相等返回FALSE
unique(Z) #剔除了重复值返回
#[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14
Z[duplicated(Z)] #返回重复值1 2 3 4 5 10
which(X!=Y) #返回不相等元素所在下标 6 7 8 9 10
"^"(8,1/3) #返回8的立方根 2
#表达式运算
#字符串转换成表达式求值，用到parse()和eval（)两个函数
A=1:15;eval（parse(text='sum(A)'))
#字符串’sum(A)‘通过parse变成expression，再由eval求值
#120
#内置函数 is.primitive()测试一个函数是否为内置函数
is.primitive(mean)
#[1] FALSE
#methods函数,可以通过Methods获取函数列表
#再直接输入函数名称，则可以看到函数的内部实现代码
methods(mean)
mean.default
# > methods(mean)
# [1] mean.Date mean.default mean.difftime mean.POSIXct mean.POSIXlt
# see '?methods' for accessing help and source code
# > mean.default
# function (x, trim = 0, na.rm = FALSE, ...)
# {
# if (!is.numeric(x) && !is.complex(x) && !is.logical(x)) {
# warning("argument is not numeric or logical: returning NA")
# return(NA_real_)
# }
# if (na.rm)
# x <- x[!is.na(x)]
# if (!is.numeric(trim) || length(trim) != 1L)
# stop("'trim' must be numeric of length one")
# n <- length(x)
# if (trim > 0 && n) {
# if (is.complex(x))
# stop("trimmed means are not defined for complex data")
# if (anyNA(x))
# return(NA_real_)
# if (trim >= 0.5)
# return(stats::median(x, na.rm = FALSE))
# lo <- floor(n * trim) + 1
# hi <- n + 1 - lo
# x <- sort.int(x, partial = unique(c(lo, hi)))[lo:hi]
# }
# .Internal(mean(x))
# }
# <bytecode: 0x0000011a9f3ec040>
# <environment: namespace:base>
#排序函数sort和order
#区别：sort函数只能对单个向量进行简单的升降序
#order函数可以对多个变量数据进行排序
x=matrix(1:25,5,5)#创建一个5行5列的矩阵，对其进行排序，使用order()函数
# > matrix(1:25,5,5)
# [,1] [,2] [,3] [,4] [,5]
# [1,] 1 6 11 16 21
# [2,] 2 7 12 17 22
# [3,] 3 8 13 18 23
# [4,] 4 9 14 19 24
# [5,] 5 10 15 20 25
x[order(x[,1],decreasing = T),]
# > x[order(x[,1],decreasing = T),]
# [,1] [,2] [,3] [,4] [,5]
# [1,] 5 10 15 20 25
# [2,] 4 9 14 19 24
# [3,] 3 8 13 18 23
# [4,] 2 7 12 17 22
# [5,] 1 6 11 16 21
#分组统计函数aggregate函数
aggregate(iris[,1:4],by=list(Species=iris$Species),mean)
# Species Sepal.Length Sepal.Width Petal.Length Petal.Width
# 1 setosa 5.006 3.428 1.462 0.246
# 2 versicolor 5.936 2.770 4.260 1.326
# 3 virginica 6.588 2.974 5.552 2.026
Fun=function(x) colMeans(x)
by(iris[,1:4],iris$Species,Fun)
# iris$Species: setosa
# Sepal.Length Sepal.Width Petal.Length Petal.Width
# 5.006 3.428 1.462 0.246
# ---------------------------------------------------------------
# iris$Species: versicolor
# Sepal.Length Sepal.Width Petal.Length Petal.Width
# 5.936 2.770 4.260 1.326
# ---------------------------------------------------------------
# iris$Species: virginica
# Sepal.Length Sepal.Width Petal.Length Petal.Width
# 6.588 2.974 5.552 2.026
#数据的引用attach(),detach(),with(),within()
Species=1:10
attach(iris);Species;detach(iris)
#[1] 1 2 3 4 5 6 7 8 9 10
with(iris,levels(Species))
with(iris,{plot(Sepal.Length);levels(Species)})
# > with(iris,levels(Species))
# [1] "setosa" "versicolor" "virginica"
# > with(iris,{plot(Sepal.Length);levels(Species)})
# [1] "setosa" "versicolor" "virginica"
#数据集，通过data()函数可以得到R系统提供的内置数据集
Nile#引用数据Nile
# Time Series:
# Start = 1871
# End = 1970
# Frequency = 1
# [1] 1120 1160 963 1210 1160 1160 813 1230 1370 1140 995 935 1110 994 1020
# [16] 960 1180 799 958 1140 1100 1210 1150 1250 1260 1220 1030 1100 774 840
# [31] 874 694 940 833 701 916 692 1020 1050 969 831 726 456 824 702
# [46] 1120 1100 832 764 821 768 845 864 862 698 845 744 796 1040 759
# [61] 781 865 845 944 984 897 822 1010 771 676 649 846 812 742 801
# [76] 1040 860 874 848 890 744 749 838 1050 918 986 797 923 975 815
# [91] 1020 906 901 1170 912 746 919 718 714 740六、自定义函数
#1定义二元运算 "%any%"=function(x,y){statements;return(object)}
#统计一个因子向量中每个元素在另一个因子向量中分别出现的次数
"%@%"=function(x,y){
z=factor(y,levels=x)
z=table(z)
list(x=x,sum=z)
}
#函数的调用
X=c(1,2,3)
Y=c(1,2,2,1,3,2,1,2,5,3,3,2)
X%@%Y
# $x
# [1] 1 2 3
#
# $sum
# z
# 1 2 3
# 3 5 3
#2 一般形式funname=function(arg1,arg2,arg3,.....){statements;return(object)}
#定义一个函数，对输入的矩阵数据，返回指定列的平均数和中位数
stat_mat_cola=function(mat,col){
m1=mean(mat[,col])
m2=median(mat[,col])
return(c(mean=m1,median=m2))
}
stat_mat_cola=function(mat,col)
c(mean=mean(mat[,col],median=median(mat[,col])))
#3 缺省值和命名参数
#求偏导函数及导数值
fxy = expression(sin(x)*y+cos(y)*x)
dxy = deriv(fxy, c("x", "y"), func = TRUE)
# dxy(1,3)
# [1] 1.53442
# attr(,"gradient")
# x y
# [1,] 0.6309144 0.700351
#4 省略号参数
#参数中含有省略号表示无限的参数
atest=function(x,...){
print(x)
list(...)
}
atest(10,y=1,z=2)
# [1] 10
# $y
# [1] 1
#
# $z
# [1] 2
#5嵌套函数
#从1-10中随机有放回抽取30个构成10行3列矩阵，然后计算任意两行对应位置出现相同数字的个数
myfun=function(x,dat){
subfun=function(x,y) return(sum(x==y))
apply(dat, 1, subfun, x)
}
mat=matrix(sample(1:10,30,replace=TRUE),nrow = 10,byrow=TRUE)
apply(mat,1,myfun,mat)
# [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
# [1,] 3 0 0 0 0 0 1 0 1 0
# [2,] 0 3 1 0 0 0 0 0 1 0
# [3,] 0 1 3 0 0 0 0 0 2 1
# [4,] 0 0 0 3 0 1 0 0 0 0
# [5,] 0 0 0 0 3 0 0 1 0 1
# [6,] 0 0 0 1 0 3 0 0 0 0
# [7,] 1 0 0 0 0 0 3 0 1 0
# [8,] 0 0 0 0 1 0 0 3 0 1
# [9,] 1 1 2 0 0 0 1 0 3 1
# [10,] 0 0 1 0 1 0 0 1 1 3
#6递归函数
fun=function(n,a){
ifelse(n==1,a/2,(fun(n-1,a)+a/fun(n-1,a))/2)
}
sapply(1:5,fun,a=3)
#[1] 1.500000 1.750000 1.732143 1.732051 1.732051
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
