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;
}