mmpc演算法程序

① mm-pc19865-1p怎麼安裝驅動程序

不清楚

② IBM-PC匯編語言程序設計第二版（清華大學的）

IBM-PC匯編，關鍵是掌握思想演算法，再將其應用於另外的單片機。
例如：裡面的2進制-->16進制，掌握了演算法；若碰到MCS51單片機+數碼管，便可迎刃而解

③ 進程調度演算法模擬程序設計

public class PrivilegeProcess {
public static void main(String[] args) {
MyQueue myqueue = new MyQueue();//聲明隊列
PCB[] pcb = {new PCB(001,8,1),new PCB(002,7,9),new PCB(003,3,8),new PCB(004,1,7),new PCB(005,7,4)};
PCB para = new PCB();
for(int i=0;i<pcb.length;i++){//初始化後首先執行一次排序，這里使用的是選擇排序，優先順序高的先入隊
for(int j=i;j<pcb.length;j++){
if(pcb[i].privilege < pcb[j].privilege){
para = pcb[i];
pcb[i] = pcb[j];
pcb[j] = para;
}
}
}
System.out.println("初次入隊後各進程的順序：");
for(int i=0;i<pcb.length;i++){
System.out.println("初次入隊後 # processname : " + pcb[i].name + " totaltime : " + pcb[i].totaltime + " privilege :" + pcb[i].privilege);
}
System.out.println();
myqueue.start(pcb);
}
}

class MyQueue {
int index = 0;
PCB[] pc = new PCB[5];
PCB[] pc1 = new PCB[4];
PCB temp = new PCB();

public void enQueue(PCB process){//入隊演算法
if(index==5){
System.out.println("out of bounds !");
return;
}
pc[index] = process;
index++;
}

public PCB deQueue(){//出隊演算法
if(index==0)
return null;
for(int i=0;i<pc1.length;i++){
pc1[i] = pc[i+1];
}
index--;
temp = pc[0];
for(int i=0;i<pc1.length;i++){
pc[i] = pc1[i];
}
return temp;
}

public void start(PCB[] pc){//顯示進程表演算法
while(pc[0].isNotFinish==true||pc[1].isNotFinish==true||pc[2].isNotFinish==true||pc[3].isNotFinish==true||pc[4].isNotFinish==true){
//*注意：||運算符，所有表達式都為false結果才為false,否則為true
for(int i=0;i<pc.length;i++){
pc[i].run(this);
}
System.out.println();
for(int i=0;i<pc.length;i++){//所有進程每執行完一次時間片長度的運行就重新按優先順序排列一次
for(int j=i;j<pc.length;j++){
if(pc[i].privilege < pc[j].privilege){
temp = pc[i];
pc[i] = pc[j];
pc[j] = temp;
}
}
}
}
}
}

class PCB {//聲明進程類
int name,totaltime,runtime,privilege;
boolean isNotFinish;

public PCB(){

}

public PCB(int name, int totaltime, int privilege){
this.name = name;//進程名
this.totaltime = totaltime;//總時間
this.privilege = privilege;//優先順序別
this.runtime = 2;//時間片，這里設值為2
this.isNotFinish = true;//是否執行完畢
System.out.println("初始值： processname : " + name + " totaltime : " + totaltime + " privilege :" + privilege );
System.out.println();
}

public void run (MyQueue mq){//進程的基於時間片的執行演算法
if(totaltime>1){
totaltime-=runtime;//在總時間大於1的時候，總時間=總時間-時間片
privilege--;
System.out.println(" processname : " + name + " remaintime : " + totaltime + " privilege :" + privilege );
}else if(totaltime==1){
totaltime--;//在總時間為1時，執行時間為1
privilege--;
System.out.println(" processname : " + name + " remaintime : " + totaltime + " privilege :" + privilege );
}else{
isNotFinish = false;//總時間為0，將isNotFinish標記置為false
}
if(isNotFinish==true){
mq.deQueue();
mq.enQueue(this);
}
}
}

④ 計算機執行指令過程圖

計算機執行指令過程圖？
順其自然~
關注
計算機指令執行過程詳解 轉載
2018-10-26 22:22:13
24點贊

順其自然~

碼齡13年

關注
一、計算機的基本組成
馮·諾依曼計算機的特點（機器以運算器為中心）

1. 計算機由控制器（分析和執行機器指令並控制各部件的協同工作）、運算器（根據控制信號對數據進行算術運算和邏輯運算）、存儲器（內存存儲中間結果，外存存儲需要長期保存的信息）、輸入設備（接收外界信息）和輸出設備（向外界輸送信息）五大部件組成
2. 指令(程序)和數據以二進制不加區別地存儲在存儲器中
3. 程序自動運行

現代計算機由三大部分組成（已經轉化為以存儲器為中心）

1. CPU(Central Processing Unit) 中央處理器，核心部件為ALU(Arithmetic Logic Unit,算術邏輯單元)和CU(Control Unit,控制單元)
2. I/O設備(受CU控制)
3. 主存儲器(Main Memory,MM)，分為RAM(隨機存儲器)和ROM(只讀存儲器)
//CPU與MM合成主機，I/O設備可稱為外部設備

二、一條指令在CPU的執行過程

// 專業術語
1. Ad(Address) 形式地址
2. DR(Data Register) 數據寄存器
3. AR(Address Register) 地址寄存器(MAR)
4. IR(Instruction Register) 指令寄存器
5. BR(Buffer Register) 緩沖寄存器(MBR)
5. ID(Instruction Decoder) 指令解碼器
6. PC(ProgramCounter) 程序計數器

過程詳述：

幾乎所有的馮·諾伊曼型計算機的CPU，其工作都可以分為5個階段：

取指令

指令解碼

執行指令

訪存取數

結果寫回

1.取指令階段
取指令（Instruction Fetch，IF）階段是將一條指令從主存中取到指令寄存器的過程。
程序計數器PC中的數值，用來指示當前指令在主存中的位置。當一條指令被取出後，PC中的數值將根據指令字長度而自動遞增：若為單字長指令，則(PC)+1àPC；若為雙字長指令，則(PC)+2àPC，依此類推。
//PC -> AR -> Memory
//Memory -> IR
2.指令解碼階段
取出指令後，計算機立即進入指令解碼（Instruction Decode，ID）階段。
在指令解碼階段，指令解碼器按照預定的指令格式，對取回的指令進行拆分和解釋，識別區分出不同的指令類別以及各種獲取操作數的方法。
在組合邏輯控制的計算機中，指令解碼器對不同的指令操作碼產生不同的控制電位，以形成不同的微操作序列；在微程序控制的計算機中，指令解碼器用指令操作碼來找到執行該指令的微程序的入口，並從此入口開始執行。
// { 1.Ad
//Memory -> IR -> ID -> { 2.PC變化
// { 3.CU（Control Unit）
3.訪存取數階段
根據指令需要，有可能要訪問主存，讀取操作數，這樣就進入了訪存取數（Memory，MEM）階段。
此階段的任務是：根據指令地址碼，得到操作數在主存中的地址，並從主存中讀取該操作數用於運算。
//Ad -> AR -> AD -> Memory
4.執行指令階段
在取指令和指令解碼階段之後，接著進入執行指令（Execute，EX）階段。
此階段的任務是完成指令所規定的各種操作，具體實現指令的功能。為此，CPU的不同部分被連接起來，以執行所需的操作。
例如，如果要求完成一個加法運算，算術邏輯單元ALU將被連接到一組輸入和一組輸出，輸入端提供需要相加的數值，輸出端將含有最後的運算結果。
//Memory -> DR -> ALU
5.結果寫回階段
作為最後一個階段，結果寫回（Writeback，WB）階段把執行指令階段的運行結果數據「寫回」到某種存儲形式：結果數據經常被寫到CPU的內部寄存器中，以便被後續的指令快速地存取；在有些情況下，結果數據也可被寫入相對較慢、但較廉價且容量較大的主存。許多指令還會改變程序狀態字寄存器中標志位的狀態，這些標志位標識著不同的操作結果，可被用來影響程序的動作。
//DR -> Memory
6.循環階段
在指令執行完畢、結果數據寫回之後，若無意外事件（如結果溢出等）發生，計算機就接著從程序計數器PC中取得下一條指令地址，開始新一輪的循環，下一個指令周期將順序取出下一條指令。
//重復 1~5
//遇hlt(holt on)停止

原文鏈接：

⑤ 51單片機與PC串口通信程序，求指導 ！ 具體要求如下：

功能如下：
1、程序燒進去，串口接收顯示一個菜單！《如圖》A、B、……分別代表一定的功能
例如：A項，代表修改ds1302的時間的數組
2、按照菜單的提示，如：發送A就進入了修改ds1302的時間函數，串口接收界面顯
示 A，像圖片那種，並顯示修改ds1302的操作方法，如從串口發送界面發送
0162115347就表示10年10月16日21時15分34秒星期7，
3、正如第二所說，馬上輸入1010162115347，就成功的修改了ds1302相關數據，
並返回change success！到串口界面！
4、設置一個功能就是返回主菜單界面。然後又可以就行第二、三步的操作！
5、通過串口，讀取單片機裡面相關的數據，如時鍾的數據
6、說明：可以不要ds1320相關的程序，可以用發光二極體亮來代表修改功能！

⑥ 電腦程序是什麼

計算機程序（Computer Program），港、台譯做電腦程式。計算機程序是一組計算機能識別和執行的指令，運行於電子計算機上，滿足人們某種需求的信息化工具。程序，香港和台灣對英文procere的中文翻譯，編程語言中的procere在大陸翻譯為「過程」，在港台和其他領域則翻譯為「程序」。在大陸於計算機科學、電腦工程、電子工程、電機工程、機器人工程學、機械工程領域中的英文術語program的中文譯名也是「程序」，在港台則翻譯為「程式」。

(6)mmpc演算法程序擴展閱讀：

程序演算法擁有以下特點：

1、有窮性：演算法必須保證在執行有限步驟後結束。

2、可行性：演算法是確切可行的，即使在數學中，該演算法可行，但若在實際應用中，程序不可以被執行，那麼 ，該演算法也是不具有可行性的。

3、確切性：演算法的每一個步驟必須具有明確的意義。

4、輸入：一個演算法必須要有0個或多個輸入。

5、輸出：一個演算法必須要有1個或多個輸出。

⑦ 加拿大pc演算法教程

1.三級流水線：其實對於PC = PC +8這個問題很簡單，這兩個PC其實代表著不同的意義，第一個PC是對於CPU而言，而第二個PC而言是我們通過編譯器看到的PC（PC指向程序正在運行的那一條指令），但是對於CPU的PC是永遠指向取指那個步，故PC = PC +8。

2.五級流水線; ARM9流水線包括取指（fetch）、解碼（decode）、執行（excute）、緩沖/數據（buffer/data）、回寫（write-back）寄存器堆。ARM9流水線在解碼階段已經開始讀取操作數寄存器，因此解碼階段的PC值和取指階段的PC值關系為：PC（decode）=PC（fetch）+4。因此執行階段的PC值和解碼階段的PC值關系為：PC（excute）=PC（decode）+4。

3.對於軟中斷函數的返回時的PC：如下

ARM Thumb

SWI PC-8 PC-4

xxx 》 PC -4 PC-2 （異常返回將執行這條指令）

yyy PC PC

因此返回指令為： MOV PC , LR

原因：異常是由指令本身引起的，因此內核在計算LR時的PC值並沒有被更新。對於ARM狀態，因為SWI指令表示將跳到異常處理函數，此時SWI這條指令的PC = PC -8，當進入異常處理函數之前，硬體會自動把PC-4保存到LR寄存器中，所以異常處理函數結束後直接MOV PC, LR就行，就會跳到xxx這一條指令去執行。對於Thumb狀態同理。

4.對於IRQ和FIQ中斷函數返回時的PC：

ARM Thumb

xxx PC-12 PC-6 （程序在運行這條代碼時就產生了中斷信號）

yyy 》 PC-8 PC-4 （異常返回將執行這條指令）

zzz PC-4 PC-2

www PC PC

返回指令為： SUBS PC, LR, #4

原因：異常在當前指令執行完成後才會被響應，因此內核在計算LR時的PC值已被更新。對於ARM狀態，程序在執行xxx這條指令時，中斷信號產生，但是由於中斷必須在這一條指令執行完之後才會被響應，執行完後，則此時對於CPU的PC已經指向了www這條指令的取指，在中斷函數函數時應該執行yyy這條指令，雖然硬體會把PC-4的值賦值給LR寄存器，但是這是指向zzz這條指令的，所以返回時應該SUBS PC, LR, #4。對於Thumb狀態同理。

⑧ matlab程序，哪位大神可以優化演算法節省時間，這個程序耗時太長了T^T

修改演算法。。。這一大串的代碼有多少人會仔細看啊，說明/注釋都沒有。
找出問題自己想辦法改吧
大致看了下，主要時間大概還是在多重循環那了。想縮減時間的話，簡化一下那部分
也可以調用matlab自帶的計時工具，看那個函數佔用時間做多。

⑨ matlab遺傳演算法代碼

我發一些他們的源程序你，都是我在文獻中搜索總結出來的：
% 下面舉例說明遺傳演算法 %
% 求下列函數的最大值 %
% f(x)=10*sin(5x)+7*cos(4x) x∈[0,10] %
% 將 x 的值用一個10位的二值形式表示為二值問題，一個10位的二值數提供的解析度是每為 (10-0)/(2^10-1)≈0.01 。 %
% 將變數域 [0,10] 離散化為二值域 [0,1023], x=0+10*b/1023, 其中 b 是 [0,1023] 中的一個二值數。 %
% %
%--------------------------------------------------------------------------------------------------------------%
%--------------------------------------------------------------------------------------------------------------%

% 編程
%-----------------------------------------------
% 2.1初始化(編碼)
% initpop.m函數的功能是實現群體的初始化，popsize表示群體的大小，chromlength表示染色體的長度(二值數的長度)，
% 長度大小取決於變數的二進制編碼的長度(在本例中取10位)。
%遺傳演算法子程序
%Name: initpop.m
%初始化
function pop=initpop(popsize,chromlength)
pop=round(rand(popsize,chromlength)); % rand隨機產生每個單元為 {0,1} 行數為popsize，列數為chromlength的矩陣，
% roud對矩陣的每個單元進行圓整。這樣產生的初始種群。

% 2.2.2 將二進制編碼轉化為十進制數(2)
% decodechrom.m函數的功能是將染色體(或二進制編碼)轉換為十進制，參數spoint表示待解碼的二進制串的起始位置
% (對於多個變數而言，如有兩個變數，採用20為表示，每個變數10為，則第一個變數從1開始，另一個變數從11開始。本例為1)，
% 參數1ength表示所截取的長度（本例為10）。
%遺傳演算法子程序
%Name: decodechrom.m
%將二進制編碼轉換成十進制
function pop2=decodechrom(pop,spoint,length)
pop1=pop(:,spoint:spoint+length-1);
pop2=decodebinary(pop1);

% 2.4 選擇復制
% 選擇或復制操作是決定哪些個體可以進入下一代。程序中採用賭輪盤選擇法選擇，這種方法較易實現。
% 根據方程 pi=fi/∑fi=fi/fsum ，選擇步驟：
% 1） 在第 t 代，由（1）式計算 fsum 和 pi
% 2） 產生 {0,1} 的隨機數 rand( .)，求 s=rand( .)*fsum
% 3） 求 ∑fi≥s 中最小的 k ，則第 k 個個體被選中
% 4） 進行 N 次2）、3）操作，得到 N 個個體，成為第 t=t+1 代種群
%遺傳演算法子程序
%Name: selection.m
%選擇復制
function [newpop]=selection(pop,fitvalue)
totalfit=sum(fitvalue); %求適應值之和
fitvalue=fitvalue/totalfit; %單個個體被選擇的概率
fitvalue=cumsum(fitvalue); %如 fitvalue=[1 2 3 4]，則 cumsum(fitvalue)=[1 3 6 10]
[px,py]=size(pop);
ms=sort(rand(px,1)); %從小到大排列
fitin=1;
newin=1;
while newin<=px
if(ms(newin))<fitvalue(fitin)
newpop(newin)=pop(fitin);
newin=newin+1;
else
fitin=fitin+1;
end
end

% 2.5 交叉
% 交叉(crossover)，群體中的每個個體之間都以一定的概率 pc 交叉，即兩個個體從各自字元串的某一位置
% （一般是隨機確定）開始互相交換，這類似生物進化過程中的基因分裂與重組。例如，假設2個父代個體x1，x2為：
% x1=0100110
% x2=1010001
% 從每個個體的第3位開始交叉，交又後得到2個新的子代個體y1，y2分別為：
% y1＝0100001
% y2＝1010110
% 這樣2個子代個體就分別具有了2個父代個體的某些特徵。利用交又我們有可能由父代個體在子代組合成具有更高適合度的個體。
% 事實上交又是遺傳演算法區別於其它傳統優化方法的主要特點之一。
%遺傳演算法子程序
%Name: crossover.m
%交叉
function [newpop]=crossover(pop,pc)
[px,py]=size(pop);
newpop=ones(size(pop));
for i=1:2:px-1
if(rand<pc)
cpoint=round(rand*py);
newpop(i,:)=[pop(i,1:cpoint),pop(i+1,cpoint+1:py)];
newpop(i+1,:)=[pop(i+1,1:cpoint),pop(i,cpoint+1:py)];
else
newpop(i,:)=pop(i);
newpop(i+1,:)=pop(i+1);
end
end

% 2.6 變異
% 變異(mutation)，基因的突變普遍存在於生物的進化過程中。變異是指父代中的每個個體的每一位都以概率 pm 翻轉，即由「1」變為「0」，
% 或由「0」變為「1」。遺傳演算法的變異特性可以使求解過程隨機地搜索到解可能存在的整個空間，因此可以在一定程度上求得全局最優解。
%遺傳演算法子程序
%Name: mutation.m
%變異
function [newpop]=mutation(pop,pm)
[px,py]=size(pop);
newpop=ones(size(pop));
for i=1:px
if(rand<pm)
mpoint=round(rand*py);
if mpoint<=0
mpoint=1;
end
newpop(i)=pop(i);
if any(newpop(i,mpoint))==0
newpop(i,mpoint)=1;
else
newpop(i,mpoint)=0;
end
else
newpop(i)=pop(i);
end
end

很多哈，也很麻煩，但是設計程序就是如此！得耐心點才行。 最近又作了些總結，要有興趣網路HI我吧。我有M文件，運行成功

⑩ 算術表達式求值演算法

#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<string.h>

#define DEBUG

#define NULL 0
#define ERROR -1
#define STACKSIZE 20

/* 定義字元類型棧 */
typedef struct{
char stackname[20];
char *base;
char *top;
} Stack;

/* ----------------- 全局變數--------------- */
Stack OPTR, OPND; /* 定義前個運算符棧，後個操作數棧 */
char expr[255] = ""; /* 存放表達式串 */
char *ptr = expr;
int step = 0; /* 計算的步次 */

int InitStack(Stack *s, char *name)
{
s->base=(char *)malloc(STACKSIZE*sizeof(char));
if(!s->base) exit (ERROR);
strcpy(s->stackname, name);
s->top=s->base;
return 1;
}

int In(char ch)
{
return(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#');
}

void OutputStatus(void)
{
char *s;

/* step */
printf("\n%-8d", ++step);

/* OPTR */
for(s = OPTR.base; s < OPTR.top; s++)
printf("%c", *s);
printf("\t");

/* OPND */
for(s = OPND.base; s < OPND.top; s++)
printf("%d ", *s);

/* input char */
printf("\t\t%c", *ptr);
}

int Push(Stack *s,char ch)
{
#ifdef DEBUG
char *name = s->stackname;
OutputStatus();
if(strcmp(name, "OPND") == 0)
printf("\tPUSH(%s, %d)", name, ch);
else
printf("\tPUSH(%s, %c)", name, ch);
#endif
*s->top=ch;
s->top++;
return 0;
}

char Pop(Stack *s)
{
char p;
#ifdef DEBUG
OutputStatus();
printf("\tPOP(%s)", s->stackname);
#endif
s->top--;
p=*s->top;
return (p);
}

char GetTop(Stack s)
{
char p=*(s.top-1);
return (p);
}

/* 判斷運算符優先權，返回優行權高的 */
char Precede(char c1,char c2)
{
int i=0,j=0;
static char array[49]={ '>', '>', '<', '<', '<', '>', '>',
'>', '>', '<', '<', '<', '>', '>',
'>', '>', '>', '>', '<', '>', '>',
'>', '>', '>', '>', '<', '>', '>',
'<', '<', '<', '<', '<', '=', '!',
'>', '>', '>', '>', '!', '>', '>',
'<', '<', '<', '<', '<', '!', '='};

switch(c1)
{
/* i為下面array的橫標 */
case '+' : i=0;break;
case '-' : i=1;break;
case '*' : i=2;break;
case '/' : i=3;break;
case '(' : i=4;break;
case ')' : i=5;break;
case '#' : i=6;break;
}
switch(c2)
{
/* j為下面array的縱標 */
case '+' : j=0;break;
case '-' : j=1;break;
case '*' : j=2;break;
case '/' : j=3;break;
case '(' : j=4;break;
case ')' : j=5;break;
case '#' : j=6;break;
}
return (array[7*i+j]); /* 返回運算符 */
}

/*操作函數 */
int Operate(int a,char op,int b)
{
#ifdef DEBUG
OutputStatus();
printf("\tOPERATE(%d, %c, %d)", a, op, b);
#endif

switch(op)
{
case '+' : return (a+b);
case '-' : return (a-b);
case '*' : return (a*b);
case '/' : return (a/b);
}
return 0;
}

int EvalExpr(void)
{
char c,theta,x,m,ch;
int a,b;

c = *ptr++;
while(c!='#'||GetTop(OPTR)!='#')
if(!In(c))
{
m=atoi(&c);
Push(&OPND,m);
c = *ptr++;
}
else
switch(Precede(GetTop(OPTR),c))
{
case '<':
Push(&OPTR,c);
c = *ptr++;
break;
case '=':
x=Pop(&OPTR);
c = *ptr++;
break;
case '>':
theta=Pop(&OPTR);
b=Pop(&OPND); a=Pop(&OPND);
Push(&OPND,Operate(a,theta,b));
break;
}

return GetTop(OPND);
}

int main(void)
{
/*
printf("Input the expression(end with \"#\" sign):");
do{
gets(expr);
}while(!*expr); */

//strcpy(expr, "2*(2+3)#");
char *pc;
printf("Input the expression(end with \"#\" sign):");
gets(expr);
pc=expr;
if(expr[0]=='\0')
{
printf("Please input a valid expression!\n");
printf("Input the expression again(end with \"#\" sign):");
gets(expr);
}
else
{
while(*pc!='\0')
pc++;
pc--;
if(*pc!='#')
{
printf("Please asure the expression end with \"#\" sign!\n");
printf("Input the expression again(end with \"#\" sign):");
gets(expr);
}
}

InitStack(&OPTR, "OPTR"); /* 初始化運算符棧 */
Push(&OPTR,'#'); /* 將#壓入運算符棧 */
InitStack(&OPND, "OPND"); /* 初始化操作數棧 */

printf("\n\nresult:%d\n", EvalExpr());
system("pause");

return 0;
}