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】