函数 - MartinChau

函数

例子:将频率为266,333,400的内存的价格分别增加10%,15%,12%

for (count in 1:length(MemInfo$Price))
    {
     if (MemInfo$Frequency[count]=="266")
         case<-1
     else if(MemInfo$Frequency[count]=="333")
         case<-2
     else
         case<-3
     switch(case,
        {
            MemInfo$Price[count]<-MemInfo$Price[count]*1.1
        },
        {
            MemInfo$Price[count]<-MemInfo$Price[count]*1.15
        },
        {
            MemInfo$Price[count]<-MemInfo$Price[count]*1.12
        })
    }

 for (count in 1:length(MemInfo$Price))
    {
     if (MemInfo$Frequency[count]==266)
          case<-1
　 else if(MemInfo$Frequency[count]==333)
          case<-2
     else
          case<-4
     
     switch(case,
        "1"={
            MemInfo$Price[count]<-MemInfo$Price[count]*1.1
        },
        "2"={
            MemInfo$Price[count]<-MemInfo$Price[count]*1.15
        },
        "4"={
            MemInfo$Price[count]<-MemInfo$Price[count]*1.12
        })
    }

函数

•作为一种对象模式,函数和操作符在R语言内部以一种特殊的方式保存,这些函数和操作符可以在R语言中被调用

•在使用R语言的过程中我们可以调用R语言各种包中携带的函数,也可以根据实际需要定义自己的函数

函数的定义和调用格式

函数的定义格式

function_name<-function(arg_1,arg_2,…)
  {
     expression         
  }

函数的调用格式

function_name(arg_1,arg_2,…)

例子:

xor <- function(x, y) { (x | y) & !(x & y) }

> x<-c(T,T,F,F)
> y<-c(T,F,T,F)
> xor(x,y)
[1] FALSE  TRUE  TRUE FALSE

　　异或:相异返回TRUE,相同返回FALSE.

例子:冒泡法排序

•冒泡法排序算法:从第i个元素开始两两进行比较,并将较大的数值往后推移

65，97，76，13，27，49，58

1： [65，76，13，27，49，58，] 97 第一次扫描后的数据

2： [65，13，27，49，58，] 76，97 第二次扫描后的数据

3： [13，27，49，58，] 65，76，97 第三次扫描后的数据

4： [13，27，49，] 58，65，76，97 第三次扫描后的数据

BubbleSort<-function(Datas,bDesc)    #定义冒泡法排序函数bubbleSort()
   {
     if (!is.atomic(Datas))
       {
         stop("'Datas' must be atomic'")
       }
     i=length(Datas)-1
     while (i>0)
       {
         nLastExchangeIndex=0
         j=0
         for (j in 1:i)
            {
               if ((bDesc && Datas[j]>Datas[j+1])||(!bDesc && Datas[j]<Datas[j+1]))
                 {
                    TempData=Datas[j]
                    Datas[j]=Datas[j+1]
                    Datas[j+1]=TempData
                    nLastExchangeIndex=j
                 }
            }
         i=nLastExchangeIndex
       }
     Datas
   }B

调用BubbleSort函数

> x<-rnorm(100,1,1)
> y<-BubbleSort(x,TRUE)
> plot(x)
> plot(y)

练习

•编写一个函数，给出两个数之后，直接给出这两个数的平方和。

定义二元操作符

在R语言中，可以将函数定义成一个操作符以方便地使用。形式为： %anything%

•%% 余数

•%*% 矩阵内积

•%/% 整除

•%in% 交集

•%o% 数组外积

•%x% Kronecker Products on Arrays

例子：交换向量中的两个数据

"%<->%"<-function(x,y)
  {
    TempData=Datas[x]
    Datas[x]<<-Datas[y]
    Datas[y]<<-TempData
    Datas
  }

Datas=c(65,97,76,13,27,49,58)

2%<->%4->datas
Datas
[1] 65 13 76 97 27 49 58

R语言中个操作符号的优先级别

1 　　:: 显示调用各包的共同函数

2 　　$ @　　　　　　数据列表子集操作符号

3 　　^ 　　　　求幂操作　　　

4 　　- +　　　　　　　一元操作符

5 　　:　　　　　　　　序列操作符号

6 　　%xyz%　　　　　各种定义操作符号,包括R语言系统固有的定义符号 %x%,%%,%/%,%*%,%o%,%in%等

7 　　* /　　　　　　　二元操作符,算术运算符号

8 　　+ -　　　　　　　算术运输符号

9 　　> >= < <= == !=　逻辑运输符号

10 　　!　　　　　　　　逻辑运算符号,取反操作

11 　　& &&　　　　　　逻辑运算符号

12 　　 | ||　　　　　　逻辑运算符号

13 　　 -> ->> 移位操作符

14 　　 =　　　　　　　　赋值操作符

15 　　<- <<-　　　　　　移位操作符

参数名和参数缺省定义

•调用函数时，可以按照参数表的定义顺次给参数逐一地设值，也可以通过参数名直接应用。

•采用参数名调用函数时，参数名应用的顺序可以同函数参数定义的顺序无关。

•在定义函数时可以设定一些缺省值的参数，当调用函数时，如果不设定某个参数，则这个参数将按缺省值进行处理。

函数：

fun1<-function(data,data.frame,graph,limmit){
     expression
}

调用函数的形式：

ans<-fun1(d,df,TRUE,20)
ans<-fun1(d,df,graph=TRUE,limit=20)
ans<-fun1(data=d,limit=20,graph=TRUE,data.frame=df)

冒泡排序法：

BubbleSort<-function(Datas,bDesc=TRUE)

调用：

ans<-BubbleSort(Datas) #按降序处理

函数和变量的作用范围

•函数中使用的变量可以分为三种类型：参数变量、局部变量、自由变量。

•参数变量即函数的参数，调用函数时将参数的数值传递给参数变量。

•局部变量是指函数内部声明的变量，退出函数时这些局部变量将被清除。

•参数变量和局部变量以外的变量都为自由变量。在R语言中自由变量逐级往上寻找相同名字的变量来赋值；如果没找到则产生新的自由变量。

例子：

f<-function(x){
     y<-2*x
     print(x)　　＃x为参数变量
     print(y)　　＃y为局部变量
     print(z)　　＃z为自由变量
  }

例子：

cube<-function(n){
     sq<-function() n*n
     n*sq()
  }

调试

•R语言不具有单步跟踪、设置断点、观察表达式等调试功能

•可以用print(), cat()函数实时显示需要调试的信息

•可以用browser()函数暂停程序，并进入单步执行状态

例子：调试larger()函数，显示两个自变量及中间变量的值

larger<-function(x,y)
  {
    cat("x=",x,"\n")
    cat("y=",y,"\n")
    y.is.bigger<-(y>x)
    cat("y.is.bigger=",y.is.bigger,"\n")
    x[y.is.bigger]<-y[y.is.bigger]
    x
  }

> x<-1:4
> y<-4:1
> larger(x,y)
x= 1 2 3 4 
y= 4 3 2 1 
y.is.bigger= TRUE TRUE FALSE FALSE 
[1] 4 3 3 4

例子：寻找向量X在某段范围(a,b)内的最大值和对应的下标

max.Info<-function(X,a,b,max.start=-10000){
    for (j in a:b)
     {
        if (X[j]<=max.start)
           {
              max.start=X[j]
              max.count=j
           }
    }
   c(max.start,max.count)
}

例子：寻找向量X在某段范围(a,b)内的最小值和对应的下标

min.Info<-function(X,a,b,min.start=10000){
    for (j in a:b)
     {
        if (X[j]<=min.start)
           {
              min.start=X[j]
              min.count=j
           }
    }
   c(min.start,min.count)
}

例子：小鼠下丘听觉诱发电位在麻醉过程中的变化情况

•要求：提取每个记录时段对应AEP波形的N0、P1、N1波对应的极值和时间

read.table("D:/work/average AEP.csv",header=TRUE,sep=",")->averageAEP
 first.max<--10000，first.max.count<-0，second.max<--10000，second.max.count<-0，　first.min<-0，first.min.count<-0

for (i in 1:17)　{
    result<-max.Info(averageAEP[,i],60,180)   #the first maxmum
    first.max[i]<- result[1]
    first.max.count[i]<-result[2]

    result<-max.Info(averageAEP[,i],200,600)   #the second maxmum
    second.max[i]<- result[1]
    second.max.count[i]<-result[2]

    result<-min.Info(averageAEP[,i],150,400)   #the first minmum
    first.min[i]<- result[1]
    first.min.count[i]<-result[2]
    browser()　　　　　　　　　　　　　　　#跟踪信息 　
}
latency.P1<-first.min.count/12.2                           #p1 latency
latency.P1.N0<-(first.min.count-first.max.count)/12.2      #n0-P1 latency
latency.N1.P1<-(second.max.count-first.min.count)/12.2     #p1-N1 latency
amplitude.N1.P1<-(second.max-first.min)/10                       #p1-n1 amplitude
AEP.character<-data.frame(RecordingTime=1:17,latency.P1,latency.P1.N0,latency.N1.P1,amplitude.N1.P1)

作业2：利用sample函数设计算法，把下面16个demo公平地分配给15个组，并提交原程序

Base: is.things
Base: recursion
Graphics: Hershey
Graphics: Japanese
Graphics: graphics
Graphics: image
Graphics: persp
Graphics: plotmath
Lattice: intervals
Lattice: labels
Lattice: lattice
Lattice: panel
Stats: glm.vr
Stats: lm.glm
Stats: nlm
Stats: smooth

练习

•查看demo:

Base: is.things

Base: recursion

posted on 2016-04-05 09:53 MartinChau 阅读(408) 评论(0) 编辑收藏举报

刷新页面返回顶部

Martin

函数

导航

公告