RR的算法例题

Ⅰ Y-rr概率怎么算生物

生物遗传概率的六种计算方法。
概率是对某一可能发生事件的估计，是指总事件与特定事件的比例，其范围介于0和1之间。相关概率计算方法介绍如下：
一、某一事件出现的概率计算法例题1：杂合子（Aa）自交，求自交后代某一个体是杂合体的概率。
解析：对此问题首先必须明确该个体是已知表现型还是未知表现型。（1）若该个体表现型为显性性状，它的基因型有两种可能：AA和Aa。且比例为1∶2，所以它为杂合子的概率为2/3。（2）若该个体为未知表现型，那么该个体基因型为AA、Aa和aa，且比例为1∶2∶1，因此它为杂合子的概率为1/2。正确答案：2/3或1/2
二、亲代的基因型在未肯定的情况下，其后代某一性状发生的概率计算法例题2：一对夫妇均正常，且他们的双亲也都正常，但双方都有一白化病的兄弟，求他们婚后生白化病孩子的概率是多少？
解析：（1）首先确定该夫妇的基因型及其概率？由前面例题1的分析可推知该夫妇均为Aa的概率为2/3，AA的概率为1/3。（2）假设该夫妇为Aa，后代患病的概率为1/4。（3）最后将该夫妇均为Aa的概率（2/3×2/3）与假设该夫妇均为Aa情况下生白化病患者的概率1/4相乘，其乘积1/9，即为该夫妇后代中出现白化病患者的概率。正确答案：1/9
三、利用不完全数学归纳法例题3：自交系第一代基因型为Aa的玉米，自花传粉，逐代自交，到自交系第n代时，其杂合子的几率为 。解析：第一代 Aa第二代 1AA 2Aa 1aa 杂合体几率为 1/2第三代 纯 1AA 2Aa 1aa 纯杂合体几率为（1/2）2第n代 杂合体几率为（1/2）n-1
正确答案：杂合体几率为 （1/2）n-1
四、利用棋盘法例题4：人类多指基因（T）是正常指（t）的显性，白化基因（a）是正常（A）的隐性，都在常染色体上，而且都是独立遗传。一个家庭中，父亲是多指，母亲正常，他们有一个白化病和正常指的的孩子，则生下一个孩子只患有一种病和患有两种病以及患病的概率分别是（）A.1/2、1/8、5/8 B.3/4、1/4、5/8 C.1/4、1/4、1/2 D.1/4，1/8，1/2解析：据题意分析，先推导出双亲的基因型为TtAa（父），ttAa（母）。然后画棋盘如下：配子
正确答案：A
五、利用加法原理和乘法原理的概率计算法
例题5（同上例题4）：解析：（1）据题意分析，先推导出双亲的基因型为TtAa（父亲），ttAa（母亲）。据单基因分析法（每对基因单独分析），若他们再生育后代，则Tt×tt→1/2Tt，即多指的概率是1/2；Aa×Aa→1/4aa，即白化病的概率是1/4。（2）生下一个孩子同时患两种病的概率：P多指（1/2Tt）又白化（1/4aa）=1/2×1/4=1/8（乘法原理）。（3）生下一个孩子只患一种病的概率=1/2 +1/4—1/8×2=1/2或1/2×3/4+1/4× 1/2=1/2（加法原理和乘法原理）。 ⑷生下一个孩子患病的概率=1/2 +1/4—1/8×1=5/8（加法原理和乘法原理）。正确答案：A
六、数学中集合的方法例题6：一对夫妇的子代患遗传病甲的概率是a，不患遗传病甲的概率是b；患遗传病乙的概率是c，不患遗传病乙的概率是d。那么下列表示这对夫妇生出只患甲、乙两种病之一的概率的表达式正确的是：A、ad＋bc B、1－ac－bd C、a＋c－2ac D、b＋d －2bd解析：该题若用遗传病系谱图来解比较困难，若从数学的集合角度入手，用作图法分析则会化难为易。下面我们先做出图1来验证A表达式，其中大圆表示整个后代，左小圆表示患甲病，右小圆表示患乙病，则两小圆的交集部分表示患甲、乙两种病（ac）两小圆除去交集部分表示只患甲病（ad）或乙病（bc），则只患一种病的概率为ad+bc。依次类推，可以用此方法依次验证余下三个表达式的正确性。正确答案：ABCD。

Ⅱ 相对危险度怎么计算

相对危险度（relative risk,RR）：亦称危险度比,是暴露组的危险度（测量指标是累积发病率）与对照组的危险度之比.暴露组与对照组的发病密度之比称为率比（rate ratio）.危险度比与率比都是反映暴露于发病（死亡）关联强度的指标. RR=暴露组累积发病率（或死亡率）/对照组累积发病率（或死亡率）相对危险度表明暴露组发病率或死亡率是对照组发病率或死亡率的多少倍.说明暴露组发病或者死亡的危险性是非暴露组的倍数.RR值越大,表明暴露的效应越大,暴露与结局的关联的强度越大.其数值意义：

1.RR为0.1或1.1.1,说明暴露因素与疾病无关联；

2.RR为0.0.8或1.1.4,说明暴露因素与疾病有弱的关联；

3.RR为0.0.6或1.2.9,说明暴露因素与疾病有中的关联；

4.RR为0.0.3或3.9.9,说明暴露因素与疾病有强的关联；

5.RR小于0.1或大于10,说明暴露因素与疾病关联很强.

Ⅲ RR的分类

为了改进RR算法的时延特性和其在变长分组环境下的不公平性，人们又提出了一些改进算法，如加权轮询（WRR，Weight RR），差额轮询（DRR，Defict RR），紧急轮询（URR，Urgency-based RR）。这些算法都力图在尽量保持RR算法实现简单性的同时，从不同的方面改进RR算法的时延特性和其在可变长分组环境下的不公平性。 URR算法是为改善RR算法时延特性而提出的另一种算法。URR个紧急性指数算法为每个队列分配U；在每个调度循环前，算法首先计算各队列的U值，然后按照U的大小顺序为各队列提供服务。尽管URR算法改善了时延特性，但其原有的公平性问题仍然存在。

Ⅳ 时间片轮转算法（RR）能不能用在作业调度上还是只能用在进程调度上

导师给出的答案是不能，但是吧友似乎有一些别的看法。
先来看作业调度的定义，高级调度又称长程调度或作业调度，他的调度对象是作业。主要功能是根据算法，决定将外存处于后备队列的哪几个作业调入内存，为他们创建进程，分配必要的资源，并将它们放入就绪队列。分时和实时系统不设置高级调度。
其次简单的叙述一下低级调度（进程调度）：对象为进程，功能是决定就绪队列中的哪个进程应获得处理机，并分配。
最后来看一下RR的核心，进程切换：在RR调度算法中，应在合适进行进程的切换，可分为两种情况：1，若一个时间片尚未用完，正在运行的进程便已经完成，立刻激活调度程序，将他从就绪队列中删除，再调度就绪队列中对手的进程运行，并启动一个新的时间片。2.在一个时间片用完时，计时调度器中断处理程序被激活。如果进程尚未运行完毕，调度程序将把它送往就绪队列的末尾。
可见，RR算法在切换进程时只涉及了就绪队列的c、a、o作，也就是只有低级调度参与，并没有从外存将作业调入内存，另外，RR算法常用于分时系统，分时系统也是不设置作业调度的。

Ⅳ 模拟短作业优先算法、时间片轮转算法（RR）和优先数算法的执行情况

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define LENsizeof(struct job)

struct job
{
char name[2];
int cometime;
int runtime;
int priority;
int finishtime;
int state;
struct job *next;
};

void readtxt();
void SJF();
void (structjob *,struct job *);
void RR(int);
void FPF();
void print1(structjob *);
void print2(structjob *);

int n=0;
struct job*head=NULL;
struct job*end=NULL;
FILE*fp=NULL;

void main()
{
if((fp=fopen("JOB1.txt","rb"))==NULL){
printf("can not find file\n");
exit(0);
}
while(!feof(fp)){
readtxt();
}
fclose(fp);

int x,y;
printf("请选择进程调度算法：\n");
printf("1.短作业优先算法 2.时间片轮转算法 3.优先数算法\n");
printf("选择序号：");
scanf("%d",&x);
if((x!=1)&&(x!=2)&&(x!=3))printf("序号不存在！\n");
else{
switch(x){
case 1: SJF(); break;
case 2: {
printf("输入时间片：");
scanf("%d",&y);
RR(y);
break;
}
case 3: FPF(); break;
}
}
}

void readtxt(){
struct job *p1;
p1=(struct job *)malloc(LEN);
fscanf(fp,"%s %d %d%d",(*p1).name,&((*p1).cometime),&((*p1).runtime),&((*p1).priority));
(*p1).state=0;
(*p1).finishtime=0;
if(n==0){
head=p1;
end=p1;
(*end).next=NULL;
n++;
}
else{
(*end).next=p1;
end=p1;
(*end).next=NULL;
n++;
}
}

void SJF(){
struct job *shead,*send,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).runtime<(*p1).runtime)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
shead=p;
send=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).runtime<(*p1).runtime)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*send).next=p;
send=p;
}
(*send).next=NULL;
printf("%s\n","短作业优先算法执行结果：");
printf("%s\n","进程执行顺序 周转时间");
print1(shead);
}

void RR(intpertime){
structjob *rhead,*rend,*rrhead,*rrend,*p1,*p2,*p;
int i,curtime=0,m=0,temp1=0,temp2;
while(m!=n){
p1=head;
temp2=temp1;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).runtime!=0)&&((*p1).state!=1)){temp1++;break;}
else p1=(*p1).next;
}
if(p1!=NULL){
p2=(*p1).next;
for(i=i+1;i<n;i++){
if((((*p2).cometime<(*p1).cometime)&&((*p2).runtime!=0)&&((*p2).state!=1))||
(((*p2).cometime==(*p1).cometime)&&((*p2).priority<(*p1).priority)&&((*p2).runtime!=0)&&((*p2).state!=1)))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
}

if(temp2!=temp1){
(*p1).state=1;
p=(struct job *)malloc(LEN);
(p,p1);
if(temp1==1) {rhead=p;rend=p;}
else{
(*rend).next=p;
rend=(*rend).next;
}
}
else{
if((temp1==1)&&(m==0)){
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
}
p=(struct job *)malloc(LEN);
(p,rhead);
rrhead=p;
rrend=p;
}
else{
if(strcmp((*rhead).name,(*rrend).name)==0){
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}

}
else{
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}
}
}
}
}
(*rrend).next=NULL;
printf("%s%d%s\n","时间片轮转算法执行结果(时间片",pertime,")：");
print2(rrhead);
}

void FPF(){
structjob *fhead,*fend,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).priority<(*p1).priority)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
fhead=p;
fend=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).priority<(*p1).priority)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*fend).next=p;
fend=p;
}
(*fend).next=NULL;
printf("%s\n","最高优先权优先算法执行结果(非抢占方式)：");
printf("%s\n","进程执行顺序 周转时间");
print1(fhead);
}

void (structjob *p,struct job *p1){
strcpy((*p).name,(*p1).name);
(*p).cometime=(*p1).cometime;
(*p).runtime=(*p1).runtime;
(*p).priority=(*p1).priority;
(*p).finishtime=(*p1).finishtime;
(*p).state=(*p1).state;
}

void print1(structjob *p){
while(p!=NULL){
printf("%-14s%d\n",(*p).name,(*p).finishtime-(*p).cometime);
p=(*p).next;
}
}

void print2(structjob *p){
struct job *head;
head=p;
printf("%s\n","进程执行顺序");
while(head!=NULL){
printf("%3s",(*head).name);
head=(*head).next;
}
printf("\n%s\n","进程周转时间");
head=p;
while(head!=NULL){
if(((*head).finishtime-(*head).cometime)>0)
printf("%-4s%d\n",(*head).name,(*head).finishtime-(*head).cometime);
head=(*head).next;
}
}

网上找的，自己看着办

Ⅵ 双色球rr和值是什么怎么算法

就是前6个数相加的和

Ⅶ 考虑一种RR(时间片轮转)调度算法的变种,算法中就绪队列中存放的是指向各个进程控

#include “stdio.h”
#define running 1 // 用running表示进程处于运行态
#define aready 2 // 用aready表示进程处于就绪态
#define blocking 3 // 用blocking表示进程处于阻塞态
#define sometime 5 // 用sometime表示时间片大小
#define n 10 //假定系统允许进程个数为n
struct
{
int name; //进程标识符
int status; //进程状态
int ax,bx,cx,dx ; //进程现场信息，通用寄存器内容
int pc ; //进程现场信息，程序计数器内容
int psw; //进程现场信息，程序状态字内容
int next; //下一个进程控制块的位置
}pcbarea[n]; //模拟进程控制块区域的数组
int PSW, AX,BX,CX,DX , PC ,TIME ; //模拟寄存器
int run; //定义指向正在运行进程的进程控制块的指针
struct
{
int head;
int tail;
}ready; //定义就绪队列的头指针head和尾指针tail
int pfree; //定义指向空闲进程控制块队列的指针

scheling( ) //进程调度函数
{
int i;
if (ready.head==-1) //空闲进程控制块队列为空，退出
{
printf(“无就绪进程\n”);
return;
}
i=ready.head; //就绪队列头指针赋给i
ready.head=pcbarea[ready.head].next; //就绪队列头指针后移
if(ready.head==-1) ready.tail=-1; //就绪队列为空，修正尾指针ready.tail
pcbarea[i].status=running; //修改进程控制块状态
TIME=sometime; //设置相对时钟寄存器
//恢复该进程现场信息
AX=pcbarea[run].ax;
BX=pcbarea[run].bx;
CX=pcbarea[run].cx;
DX=pcbarea[run].dx;
PC=pcbarea[run].pc;
PSW=pcbarea[run].psw;
run=i;
}//进程调度函数结束

create(int x) //进程创建函数
{
int i;
if(pfree==-1) //空闲进程控制块队列为空
{
printf(“无空闲进程控制块，进程创建失败\n”);
return;
}
i=pfree; //取空闲进程控制块队列的第一个
pfree=pcbarea[pfree].next; // pfree后移
//填写该进程控制块的内容
pcbarea[i].name=x;
pcbarea[i].status=aready;
pcbarea[i].ax=x;
pcbarea[i].bx=x;
pcbarea[i].cx=x;
pcbarea[i].dx=x;
pcbarea[i].pc=x;
pcbarea[i].psw=x;
if (ready.head!=-1) //就绪队列不为空时，挂入就绪队列的方式
{
pcbarea[ready.tail].next=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
else //就绪队列为空时，挂入就绪队列的方式
{
ready.head=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
}//进程创建函数结束

main()
{ //系统初始化
int num,i,j;
run=ready.head=ready.tail =-1;
pfree=0;
for(j=0;j<n-1;j++)
pcbarea[j].next=j+1;
pcbarea[n-1].next=-1;
printf(“输入进程编号（避免编号冲突，以负数输入结束，最多可以创建10个进程）：\n”);
scanf(“%d”,num);
while(num>=0)
{
create(num) ;
scanf(“%d”,num) ;
}
scheling(); //进程调度
if(run!=-1)
{
printf(“进程标识符 进程状态 寄存器内容：ax bx cx dx pc psw:\n”);
printf(“%8d%10d%3d%3d%3d%3d%3d%3d\n”, pcbarea[run].name, pcbarea[run].status, pcbarea[run].ax, pcbarea[run].bx, pcbarea[run].cx, pcbarea[run].dx, pcbarea[run].pc, pcbarea[run].psw);
}
}//main()结束
我用的是vc++6.0的，你可以试试，有不懂得在和我交流吧

Ⅷ 风险收益率的计算方法

Rr=β* V

式中：Rr为风险收益率；

β为风险价值系数；

V为标准离差率。

Rr=β*（Km-Rf）

式中：Rr为风险收益率；

β为风险价值系数；

Km为市场组合平均收益率；

Rf为无风险收益率

（Km-Rf）为市场组合平均风险报酬率

风险收益率是投资收益率与无风险收益率之差；

风险收益率是风险价值系数与标准离差率的乘积；

(8)RR的算法例题扩展阅读：

风险收益率，就是由投资者承担风险而额外要求的风险补偿率。风险收益率包括违约风险收益率，流动性风险收益率和期限风险收益率。

影响因素：

风险大小和风险价格。在风险市场上，风险价格的高低取决于投资者对风险的偏好程度。

风险收益率包括违约风险收益率，流动性风险收益率和期限风险收益率。

Ⅸ 操作系统习题 为什么要引入高响应比优先调度算法，它有何优点

高响应比优先调度算法的基本思想是把CPU分配给就绪队列中响应比最高的进程。
既考虑作业的执行时间也考虑作业的等待时间，综合了先来先服务和最短作业优先两种算法的特点。

该算法中的响应比是指作业等待时间与运行比值，响应比公式定义如下：
响应比 =（等待时间+要求服务时间）/ 要求服务时间,即RR=（w+s）/s=1+w/s，因此响应比一定是大于1的。

短作业与先后次序的兼顾，且不会使长作业长期得不到服务
响应比计算系统开销，增加系统开销

适用于批处理系统

Ⅹ 请说明RR、OR、AR、AR%的计算方法以及意义。

相对危险度（relative risk，RR）。指暴露于某因素发生某事件的风险，即A/(A+B)，除以未暴露人群发生的该事件的风险，即C/(C+D)，所得的比值，即RR=［A/(A+B)］/［C/(C+D)］，RR适用于队列研究或随机对照试验。回顾性研究中无法计算发病率等，故无法计算RR，此时可以用OR 代替RR.
AR又叫特异危险度、率差（ratedifference, RD）和超额危险度（excessrisk），是暴露组发病率与对照组发病率相差的绝对值，它表示危险特异地归因于暴露因素的程度。相对危险度指暴露组发病率与非暴露组的发病率之比，它反映了暴露与疾病的关联强度，说明暴露使个体发病的危险比不暴露高多少倍，或者说暴露组的发病危险是非暴露组的多少倍。暴露对疾病的病因学意义大。
AR%归因危险度百分比：又称病因分值EF;是指暴露人群中发病或死亡归因于该暴露的部分占全部发病或死亡的百分比。AR%=（Ie-Io）/ Ie
=(RR-1)/RR
PAR人群归因危险度：指总人群发病率中归因于该暴露的部分。PAR=It-Io，It为全人群发病率Io为非暴露组发病率；
PAR%人群归因危险度百分比也称人群病因分值，指PAR占总人群发病率的百分比。=PAR/It=【Pe(RR-1)】/【(Pe(RR-1))+1】