精华内容
下载资源
问答
  • 本文以某型导弹景象匹配制导系统实时DSP图像采集为例,论述了基于PCI总线和DSP的嵌入式图像采集系统的优点,并详细阐明了系统的硬件结构和基于VxWorks操作平台的软件实现,实现了图像的实时采集、传输和处理。
  • 本文从实时性和大容量两方面介绍了在某型导弹景象匹配制导系统中通用计算机上加入DSP加速卡实现的图像采集系统。利用DSP芯片的高速处理特性完成大部分的图像处理工作,上位机只完成辅助操作和存储系统。这种方法发挥...
  • 系统地研究了一些图像可匹配性检验参数,定义了图像的自匹配性能参数,设计了该参数的计算方法,进而提出一种新的基准图选定准则。基于理论分析与仿真实验,指出了常用准则存在的局限性,说明了本方法的优越性;通过...
  • 基于景象匹配制导的飞行器飞行前需要进行航迹规划, 就是在飞行区域中选择出一些匹配概率高的匹配 区, 作为相关匹配制导的基准, 由此提出了估计匹配区匹配概率的问题本文模拟飞行中匹配定位的过程定义了匹 配概率, 并...
  • 基于三角制导和约束的特征匹配
  • 图像制导的目标匹配算法与系统设计.pdf 图像制导的目标匹配算法与系统设计.pdf
  • 针对光电成像末制导景象匹配中图像存在尺度、旋转、灰度和3D视角差异的问题,构造了一种基于均匀模式的特征描述符,并基于该特征描述符和最稳定极值区域(MSER)提出了一种新的景象匹配算法。算法首先提取基准图像和实时...
  • 文中研究了简易制导火箭的制导控制系统,在基于自动驾驶仪与制导律相匹配原则的基础上,研究并仿真了速度矢量自动驾驶仪积分比例导引的制导控制系统方案。仿真结果表明,该方案是可行的。
  • 为了实现景象匹配制导应用中对图像数据源质量的客观评价,针对卫星图像的模糊效应,研究了影响图像质量的清晰度评价指标,通过分析比较其对图像匹配过程的影响,挑选出有效指标作为评价因子;通过对大量实验数据特性...
  • 为实现光电成像末端制导中的自适应目标初始化, 针对末端制导景象匹配中图像存在尺度、旋转、灰度和3D视角差异, 及传统方法运算量较大的问题, 基于随机蕨分类器构造了一种新的景象匹配算法。算法首先利用基准图像进行...
  • 1.以S属性的语法制导定义为基础,将下表的语义规则嵌套在语法分析的过程中,即实现语法制导的翻译过程。 产 生 式  语 义 规 则   L -> E n  print (E.val) ...

    要求

    1.以S属性的语法制导定义为基础,将下表的语义规则嵌套在语法分析的过程中,即实现语法制导的翻译过程。

         

           

      L -> E n

      print (E.val)

      E-> E1 + T 

      E.val := E1 .val + T.val 

      E ->T 

      E.val := T.val 

      T-> T1 * F 

      T.val := T1.val * F.val 

      T ->F 

      T.val := F.val 

      F->(E)

      F.val := E.val 

      F ->digit

      F.val := digit.lexval

    2.以词法分析和语法分析部分的上机结果为基础,添加语义分析部分。即以LR文法为基础。当进行产生式归约时执行对应的语义动作。

    3.输入:

    5+3+8*2

    输出:24

    注:只能完成加法和乘法的运算,相对于之前上传的LR文法只是添加了把数字变成符号的过程(即把(2+5)*5变成(a+a)*a)再定义一个数字栈,与符号栈的动作对应,最后取出数据栈栈顶就是结果

    #include <iostream>
    #include <string.h>
    #include<stack>
    using namespace std;
    /*
    E->E+T
    E->T
    T->T*F
    T->F
    F->(E)
    F->id
    */
    /*初始化分析表*/
    void Initial(string analysis[12][9]){
    	/*移进规约*/
    	analysis[0][0] = "s5"; analysis[0][3] = "s4"; analysis[0][6] = "1"; analysis[0][7] = "2"; analysis[0][8] = "3";
    	analysis[1][1] = "s6"; analysis[1][5] = "acc";
    	analysis[2][1] = "r2"; analysis[2][2] = "s7"; analysis[2][4] = "r2"; analysis[2][5] = "r2";
    	analysis[3][1] = "r4"; analysis[3][2] = "r4"; analysis[3][4] = "r4"; analysis[3][5] = "r4";
    	analysis[4][0] = "s5"; analysis[4][3] = "s4"; analysis[4][6] = "8"; analysis[4][7] = "2"; analysis[4][8] = "3";
    	analysis[5][1] = "r6"; analysis[5][2] = "r6"; analysis[5][4] = "r6"; analysis[5][5] = "r6";
    	analysis[6][0] = "s5"; analysis[6][3] = "s4"; analysis[6][7] = "9"; analysis[6][8] = "3";
    	analysis[7][0] = "s5"; analysis[7][3] = "s4"; analysis[7][8] = "10";
    	analysis[8][1] = "s6"; analysis[8][4] = "ss";//表示s11
    	analysis[9][1] = "r1"; analysis[9][2] = "s7"; analysis[9][4] = "r1"; analysis[9][5] = "r1";
    	analysis[10][1] = "r3"; analysis[10][2] = "r3"; analysis[10][4] = "r3"; analysis[10][5] = "r3";
    	analysis[11][1] = "r5"; analysis[11][2] = "r5"; analysis[11][4] = "r5"; analysis[11][5] = "r5";
    	/*出现错误*/
    	analysis[0][1] = analysis[0][2] = analysis[0][5] = analysis[4][1] = analysis[4][2] = analysis[4][5] = "e1";
    	analysis[6][1] = analysis[6][2] = analysis[6][5] = analysis[7][1] = analysis[7][2] = analysis[7][5] = "e1";
    	analysis[0][4] = analysis[1][4] = analysis[4][4] = analysis[6][4] = analysis[7][4] = "e2";
    	analysis[1][0] = analysis[1][2] = analysis[1][3] = analysis[8][0] = analysis[8][2] = analysis[8][3] = "e3";
    	analysis[8][5] = "e4";
    	analysis[2][0] = analysis[2][3] = "r2";
    	analysis[3][2] = analysis[3][3] = "r4";
    	analysis[5][0] = analysis[5][3] = "r6";
    	analysis[9][0] = analysis[9][3] = "r1";
    	analysis[10][0] = analysis[10][3] = "r3";
    	analysis[11][0] = analysis[11][3] = "r5";
    
    }
    /*输出移进还是规约,规约的话输出用到的产生式*/
    void print(int into)
    {
    	if (into == 0)
    	{
    		cout << "--移进--" << endl;
    		return;
    	}
    	cout << "--按";
    	switch (into)
    	{
    	case 1:cout << "E->E+T"; break;
    	case 2:cout << "E->T"; break;
    	case 3:cout << "T->T*F"; break;
    	case 4:cout << "T->F"; break;
    	case 5:cout << "F->(E)"; break;
    	case 6:cout << "F->id"; break;
    	}
    	cout << "规约--" << endl;
    }
    /*为终结符合非终结符编号*/
    int NumOfSymbols(char c){
    	/*switch (c){
    	case 'a':return 0;
    	case '+':return 1;
    	case '*':return 2;
    	case '(':return 3;
    	case ')':return 4;
    	case '#':return 5;
    	case 'E':return 6;
    	case 'T':return 7;
    	case 'F':return 8;
    	}*/
    	if (c == 'a'){ return 0; }
    	if (c == '+'){ return 1; }
    	if (c == '*'){ return 2; }
    	if (c == '('){ return 3; }
    	if (c == ')'){ return 4; }
    	if (c == '$'){ return 5; }
    	if (c == 'E'){ return 6; }
    	if (c == 'T'){ return 7; }
    	if (c == 'F'){ return 8; }
    }
    char GetSymbol(int num){
    	if (num == 0){ return 'a'; }
    	if (num == 1){ return '+'; }
    	if (num == 2){ return '*'; }
    	if (num == 3){ return '('; }
    	if (num == 4){ return ')'; }
    	if (num == 5){ return '$'; }
    	if (num == 6){ return 'E'; }
    	if (num == 7){ return 'T'; }
    	if (num == 8){ return 'F'; }
    }
    int Num[10];//存储数
    char *Change(char*a){
    	int len = strlen(a);//字符串a的长度	
    	char *b = new char[len];//存储字符
    	int charnum = 0;//记录b中实际有多少字符串
    	int cur1 = 0;//Num[]的角标
    	int cur2 = 0;//b[]的角标
    	for (int i = 0; i < len; i++){
    		if (a[i] <= 59 && a[i] >= 48){
    			int num_len = 1;//大于一位数的这个数的长度
    			int num = 0;//最后记录这个数的大小
    			b[cur1] = 'a';//遇见的数字,把a放进栈
    			charnum++;
    			cur1++;//b的角标向后挪
    			int curr = i + 1;//curr指向当前处理字符的下一个字符,如果依然是数字那么就值个多位数
    			/*记录这个多位数的位数*/
    			while (a[curr] <= 59 && a[curr] >= 48){
    				num_len++;
    				curr++;
    			}
    			int acc = num_len;//记录循环次数,百位*10*10,千位*10*10*10
    			for (int j = i; j < i + num_len; j++){
    				int tempsum = 1;
    				for (int k = 0; k < acc - 1; k++){
    					tempsum *= 10;
    				}
    				acc--;
    				num += (a[j] - 48)*tempsum;
    			}
    			Num[cur2] = num;//把得到的这个数(或多位数或一位数放入数组)
    			cur2++;//Num角标后挪
    			for (int l = 0; l < num_len - 1; l++){ i++; }//多位数有几位就向后挪几位,一位数不用挪
    		}
    		else{//不是数字的话直接放入b中
    			b[cur1] = a[i];
    			charnum++;
    			cur1++;
    		}
    	}
    	cout << "该式的原型为:" << endl;
    	char *c = new char[charnum];//重新存储一下b,因为长度不准确
    	for (int i = 0; i < charnum; i++){
    		c[i] = b[i];
    		cout << c[i] << " ";
    	}
    	cout << endl;
    	cout << "---------------" << endl;
    	return c;
    }
    void main(){
    	string analysis[12][9];
    	stack<int> s;//字符栈
    	stack<int> val;//数字栈
    	int curr = 0;//记录Num中还未放入数字栈的角标
    	char* input = "(20+6)*5+8$";	
    	cout << "输入表达式:" << input << endl;
    	char* str = Change(input);
    	/*cin >> str;*/
    	int len = strlen(str);
    	Initial(analysis);
    	s.push(0);
    	/*循环中i表示当前处理得输入串中的角标*/
    	for (int i = 0; i < len;){
    		int stack_top = s.top();//记录栈顶状态
    		cout <<"此时栈定状态为:"<< stack_top;
    		cout << "  此时输入字符为:"<< str[i] << endl;
    		int lookahead = NumOfSymbols(str[i]);//记录当前输入串中,正在被处理的字符的标号
    		    /*移进*/
    			if (analysis[stack_top][lookahead][0] == 's'){
    				if (analysis[stack_top][lookahead][1] == 's'){
    					print(0);
    					s.push(lookahead);
    					s.push(11);
    					cout << "将状态11移进栈。" << endl;
    					i++;
    				}
    				else{
    					print(0);
    					s.push(lookahead);
    					s.push(analysis[stack_top][lookahead][1] - '0');
    					cout << "将状态" << analysis[stack_top][lookahead][1] - '0' << "移进栈。" << endl;
    					i++;//移进了一个后,就可以看下一个字符了
    				}
    			}
    			/*规约*/
    			else if (analysis[stack_top][lookahead][0] == 'r'){
    				int times;//如需规约,弹栈的次数
    				int NumofNon_Terminal;//需要移进栈的终结符的编号
    				print(analysis[stack_top][lookahead][1] - '0');//输出规约的式子
    				switch (analysis[stack_top][lookahead][1] - '0'){
    				case 1: times = 6; NumofNon_Terminal = NumOfSymbols('E'); break;
    				case 2: times = 2; NumofNon_Terminal = NumOfSymbols('E'); break;
    				case 3: times = 6; NumofNon_Terminal = NumOfSymbols('T'); break;
    				case 4: times = 2; NumofNon_Terminal = NumOfSymbols('T'); break;
    				case 5: times = 6; NumofNon_Terminal = NumOfSymbols('F'); break;
    				case 6: times = 2; NumofNon_Terminal = NumOfSymbols('F'); break;
    				}
    				for (int j = 0; j < times; j++){
    					s.pop();
    				}				
    				int pre_top=s.top();//记录此时的栈顶
    				cout << "弹栈" << times << "次后,栈顶状态为"<< pre_top << endl;
    				s.push(NumofNon_Terminal);
    				char c = GetSymbol(NumofNon_Terminal);//为了输出字符,通过序号找到
    				cout << "放入"<< c << endl;
    				/*处理数字栈中的树*/
    				if (analysis[pre_top][NumofNon_Terminal].size() == 1){
    					s.push(analysis[pre_top][NumofNon_Terminal][0] - '0');
    					cout << "将状态" << analysis[pre_top][NumofNon_Terminal][0] - '0' << "移进栈。" << endl;
    				}
    					
    				else{
    					s.push(10);
    					cout << "将状态10移进栈。" << endl;
    				}
    				if (analysis[stack_top][lookahead][1] - '0' == 1){
    					int temp1 = val.top();
    					val.pop();
    					int temp2 = val.top();
    					val.pop();
    					val.push(temp1 + temp2);
    					cout << "弹出了" << temp1 << "  " << temp2 << ",放入" << val.top() << endl;
    				}
    				if (analysis[stack_top][lookahead][1] - '0' == 3){
    					int temp1 = val.top();
    					val.pop();
    					int temp2 = val.top();
    					val.pop();
    					val.push(temp1 * temp2);
    					cout << "弹出了" << temp1 << "  " << temp2 << ",放入" << val.top() << endl;
    				}
    				if (analysis[stack_top][lookahead][1] - '0' == 6){
    					val.push(Num[curr]);
    					curr++;
    					cout << "放入" << val.top() << endl;
    				}
    			}
    			/*错误恢复*/
    			else if (analysis[stack_top][lookahead][0] == 'e'){
    				cout << "出现错误" << endl;
    				switch (analysis[stack_top][lookahead][1]){
    				case '1':{   //期望遇到a,那就把a放进去
    							 s.push(0);
    							 s.push(5);
    							 cout << "缺少运算符,加入a" << endl;
    							 break;
    				}
    				case '2':{
    							 //遇见右括号,没有左括号,说明右括号错误
    							 i++;
    							 cout << "不匹配的右括号,将忽略该字符" << endl;
    							 break;
    				}
    				case '3':{
    							 //期望遇见运算符,加进+
    							 s.push(1);
    							 s.push(6);
    							 cout << "缺少运算符,加入a" << endl;
    							 break;
    				}
    				case '4':{
    							 //提前结束,但期望遇见右括号,那就加入有括号
    							 s.push(4);
    							 s.push(11);
    							 cout << "缺少右括号" << endl;
    							 break;
    				}
    				}
    			}
    			else{
    				if (analysis[stack_top][lookahead][0] == 'a'){
    					cout << "接受"<<endl;
    					cout << "结果为:" << val.top() << endl;
    					return;
    				}
    				else{	
    					cout << "无法识别,完蛋了!" << endl;
    					return;
    				}
    			}
    
    			cout << "--------------------------------------" << endl;
    	}
    	
    }


    展开全文
  • 为分析隔离度对制导系统的影响,提出了隔离度引起的寄生耦合问题。首先建立了制导回路数学模型,讨论了寄生耦合的产生机理。...研究结果表明,为保证快响应寻的制导系统的性能最优,必须进行制导系统的匹配性设计。
  • 3、要求在语法分析模块中利用语法制导翻译技术完成具体的中缀表达式到后缀表达式的翻译,其中包括按前述翻译器的规格说明构建对应表达式、项、因子的非终结符expr、term和factor的函数以及检查记号是否匹配的函数;...
  • 以正弦抖动激光光斑作为制导系统的跟踪目标,分析了稳瞄系统不同抖动频率的照射光斑对制导精度的影响....因此在实际设计中,应匹配具体制导系统的时间常数和稳瞄系统的频带,以避免产生较大脱靶量.
  • 语法制导的翻译

    万次阅读 多人点赞 2017-11-30 21:32:37
    语法制导的翻译方案(Syntax-Directed Translation scheme,SDT)是SDD的一种补充,它是在其产生式体中嵌入程序片段的一个上下文无关文法,这些程序片段称为语义动作,它们可以出现在产生式体中的任何地方。...

    继词法分析和文法分析之后,本文将介绍使用上下文无关文法来引导对语言的翻译。

    SDD

    语法制导定义(Syntax-Directed Definition,SDD)是一个上下文无关文法和属性及语义规则的结合。属性和文法符号相关联,语义规则和产生式相关联,文法符号X的属性a表示为X.a。

    非终结符号可以有两种属性:

    • 综合属性:如果语法分析树上的结点N的某个属性a只能通过N的子结点和N本身的属性值来定义,那么属性a是结点N的一个综合属性;
    • 继承属性:如果语法分析树上的结点N的某个属性b只能通过N的父结点、N本身和N的兄弟结点的属性值来定义,那么属性a是结点N的一个继承属性。

    终结符号可以有综合属性,但不能有继承属性,终结符号的属性是由词法分析器提供的词法值。

    综合属性

    如果语法分析树中的结点N的某个属性a只能通过N的子结点或N本身的属性值来定义,那么属性a是结点N的一个综合属性。

    对表达式文法G:

        E → E+T | T
        TT*F | F
        F → (E) | id

    它对应的SDD如下:

    20171122_img1

    其中,属性val是文法符号的数值,属性lexval是由词法分析器返回的数值。为id1*id2+id3构建语法分析树,其中,id1、id2、id3的lexval属性分别为3、4、5:

    20171122_img2

    在这棵语法分析树中,所有结点的属性都被显示了出来,这样的语法分析树也称为注释语法分析树

    继承属性

    如果语法分析树上的结点N的某个属性b只能通过N的父结点、N本身和N的兄弟结点的属性值来定义,那么属性a是结点N的一个继承属性。

    考虑上一小节中的表达式文法的非左递归形式G’:

        E → TE'
        E'→ +TE' | ε
        T → FT'
        T'→ *FT' | ε
        F → (E) | id

    它对应的SDD如下:

    20171122_img3

    其中,属性val是文法符号的数值,属性lexval是由词法分析器返回的数值,属性inh是一个继承属性,属性syn是一个综合属性。为id1*id2+id3构建语法分析树,其中,id1、id2、id3的lexval属性分别为3、4、5:

    20171122_img4

    在这棵语法分析树中,属性inh“向下地传递参数”,属性syn“向上地返回结果”,关于继承属性和综合属性的求值顺序将在下一小节介绍。

    SDD的求值顺序

    和终结符号的综合属性直接由词法分析器给出不同,非终结符号的综合属性和继承属性都或多或少地依赖于其他属性,因此确定一棵注释语法分析树中属性的求值顺序是十分重要的,依赖图可以帮助我们完成这个工作。

    依赖图描述了某个语法分析树中的属性实例之间的信息流,从一个属性实例到另一个属性实例的边表示计算第二个属性实例需要用到第一个属性实例的值。具体地讲,一个依赖图包括:

    • 属性结点:对于语法分析树中的每个结点N,N的每个属性在依赖图中都有一个结点;
    • 综合属性的边:如果和产生式p关联的语义规则通过X.a的值定义了综合属性Y.b的值,那么在依赖图中有一条从X.a到Y.b的边;
    • 继承属性的边:如果和产生式p关联的语义规则通过X.a的值定义了继承属性Y.b的值,那么在依赖图中有一条从X.a到Y.b的边。

    得到依赖图后,如果这个依赖图中没有环,那么这个依赖图至少存在一个拓扑排序。假设依赖图的结点集合为N,边集合为E,计算此依赖图的拓扑排序的步骤为:

    1. 构建一个序列A,A的长度为len(N),将i初始化为0;
    2. 从N中选出一个入度为0的结点n,从N中删除n且从E中删除所有以n为起点的边,将A[i]设为n,同时将i加1;
    3. 如果N不为空,重复步骤2,否则排序结束,得到拓扑序列A[0]、A[1]、…、A[len(N)-1]。

    考虑图1的注释语法分析树,它的依赖图如下,结点前的标号是拓扑排序后的结果:

    20171122_img5

    考虑图2的注释语法分析树,它的依赖图如下,结点前的标号是拓扑排序后的结果:

    20171122_img6

    到这里,我们已经知道了如何借助依赖图确定一棵注释语法分析树中属性的求值顺序。但是,不是所有的注释语法分析树都能通过依赖图找到一个拓扑排序,如果依赖图中存在环,那么这个依赖图没有拓扑排序。如果我们能小心地定义SDD中的语义规则使得其依赖图中没有环,那么我们一定能够确定此SDD中属性的求值顺序,下面介绍的S属性的SDD和L属性的SDD一定能确定属性的求值顺序。

    S属性的SDD

    如果一个SDD的每个属性都是综合属性,那么这个SDD是一个S属性的SDD。

    对于一个S属性的SDD,可以按照语法分析树结点的任何自底向上顺序来计算它的各个属性值。S属性的SDD可以在自底向上的语法分析过程中实现。

    L属性的SDD

    L属性的SDD的思想是在一个产生式体所关联的各个属性之间,依赖图的边总是从左到右,而不能从右到左。也就是说,每个属性必须满足如下条件:

    • 要么是一个综合属性;
    • 要么是一个继承属性,但是它的语义规则有这些限制:假设有产生式A→X1X2…Xn和继承属性Xi.a,Xi.a的计算规则只能使用A的继承属性以及Xj(1<=j<=i)的综合属性或继承属性,并且Xi的全部属性组成的依赖图中不存在环。

    L属性的SDD可以在自顶向下的语法分析过程中实现。

    SDT

    语法制导的翻译方案(Syntax-Directed Translation scheme,SDT)是SDD的一种补充,它是在其产生式体中嵌入程序片段的一个上下文无关文法,这些程序片段称为语义动作,它们可以出现在产生式体中的任何地方。通常情况下,语义动作的两边要加上花括号,如果花括号作为文法符号出现,则要给它们加上引号。

    实现SDT的通用方法

    语义动作可以放在产生式体中的任何位置,当一个语义动作左边的所有符号都被处理完后该动作立即执行。更具体的,对产生式A→X{a}Y,有:

    • 如果语法分析过程是自底向上的,那么当X出现在语法分析栈的栈顶时立即执行动作a;
    • 如果语法分析过程是自顶向下的,那么当试图展开Y(Y是非终结符号)或在输入中检测到Y(Y是终结符号)之前执行动作a。

    通用的SDT实现方法如下:

    1. 忽略语义动作,对输入进行语法分析,并产生一棵语法分析树;
    2. 然后检查每个内部结点N,假设它的产生式是A→α。将α中的各个动作当作N的附加子结点加入,使得N的子结点从左到右和α中的符号及动作完全一致;
    3. 对这棵语法分析树进行前序遍历,并且当访问到一个以某个动作为标号的结点时立即执行此动作。

    对于表1显示的SDD,把它转换成SDT:

    20171122_img7

    注意到,此SDT和相应的SDD相比,只有前两个产生式的语义动作和原来的语义规则不同。由于这两个产生式的产生式头已经是开始符号,因此相应的语义动作需要把实现结果输出。由此SDT构建的嵌入了动作的语法分析树如下:

    20171122_img8

    对上面的语法分析树进行前序遍历,每遇到一个动作就立即执行它,遍历完成后就实现了此SDT。

    在语法分析过程中实现SDT

    可以在语法分析过程中实现的SDT包括后缀SDT和L属性定义的SDT,后缀SDT通常在自底向上的语法分析过程中实现,L属性定义的SDT通常在自顶向下的语法分析过程中实现。注意,不是所有的SDT都能在语法分析过程中实现。

    后缀SDT

    如果一个SDD的基础文法是LR文法并且此SDD是S属性定义的,那么我们可以构造这样一个SDT,其中的每个动作都放在产生式的最后,并且在按照这个产生式将产生式体归约为产生式头的时候执行这个动作。像这样所有动作都在产生式体最右端的SDT也称为后缀翻译方案(后缀SDT)。

    将一个S属性定义的且基础文法为LR文法的SDD转换为一个SDT的规则如下:

    • 将计算一个产生式头的综合属性的动作放置在这个产生式体的最右端。

    注意到,由于表1中的SDD是S属性定义的且其基础文法G是LR文法,因此可以把它转换成后缀SDT,表3中的SDT就是此SDD的一个转换形式。下面我们进一步改进表3中的SDT,使其能够在语法分析过程中实现:

    20171122_img9

    表4中的stack表示LR语法分析栈,top指向栈顶。为了帮助读者理解这个SDT中的语义动作,以产生式F→(E)为例,考虑将(E)归约成F的过程,如图6所示:

    20171122_img10

    图6显示了把(E)归约成F的LR语法分析过程。图6(a)是即将把(E)归约成F的语法分析栈快照,此时有stack[top]=")"stack[top-1]="E"stack[top-2]="("。执行的归约动作是连续3次出栈操作(将”)”、”E”、”(“依次弹出栈顶,如图6(b))和1次入栈操作(将”F”压入栈顶,如图6(c))。注意到,(c)中的top相当于(a)中的top-2,也就是说,F实际上出现在(a)中的stack[top-2]处;另外,由于E.val将被赋值给F.val,并且E出现在(a)中的stack[top-1]处,因此在(a)中有stack[top-2].val=stack[top-1].val;将(a)变成(c)还需要执行2次出栈操作(实际上是3次出栈操作和1次入栈操作),因此还需要把top指针向下移动2位。

    从SDT中消除左递归

    在详细介绍如何在语法分析过程中实现L属性定义的SDT之前,我们先来介绍如何从SDT中消除左递归。在介绍语法分析的时候我们知道了带有左递归的文法不能按照自顶向下的方式进行语法分析,并且我们还知道如何从一个左递归的文法中消除左递归。当文法是SDT的一部分时,我们还需要考虑如何处理其中的语义动作。

    情况1

    最简单的情况是,我们只需要关心一个SDT中动作的执行顺序。在这种情况下,当对文法进行消除左递归的转换时,可以简单地将动作当成终结符号处理。之所以可以这样做,是因为对文法的转换保持了由文法生成的符号串中终结符号的顺序。举个例子,对下面的SDT:

        EE+T { print('+'); }
        E → T

    将动作看作终结符号,消除左递归后得到的SDT为:

        E → TR
        R → +T { print('+'); } R | ε
    情况2

    另一种比较复杂的情况是,一个SDT的动作包含了对属性值的计算。举个例子,对下面的SDT:

        A → A1Y { A.a = g(A1.a, Y.y); }
        A → X { A.a = f(X.x); }

    其中,f和g是两个任意的函数,对基础文法消除左递归得到:

        A → XR
        R → YR | ε

    现在尝试在文法中加入语义动作。我们给文法符号R附加上两个属性,一个属性i是继承属性,它用来保存函数f和g的结果,另一个属性s是综合属性,它会在计算结束后返回最终的计算结果。得到的SDT为:

        A → X { R.i = f(X.x); } R { A.a = R.s; }
        R → Y { R1.i = g(R.i, Y.y); } R1 { R.s = R1.s; }
        R → ε { R.s = R.i; }

    我们用注释语法分析树来展示对SDT消除左递归前后的变化(这里省略了对R.s的计算):

    20171122_img11

    L属性定义的SDT

    如果一个SDD的基础文法能够以自顶向下的方式进行语法分析,并且此SDD是L属性定义的,那么我们可以把这个SDD转换成一个L属性定义的SDT。

    将一个L属性定义的SDD转换为一个SDT的规则如下:

    • 将计算某个非终结符号A的继承属性的动作插入到产生式体中紧靠在A的本次出现之前的位置上。如果A的多个继承属性以无环的方式相互依赖,就需要对这些属性的求值动作进行排序,以便先计算需要的属性;
    • 将计算一个产生式头的综合属性的动作放置在这个产生式体的最右端。

    在语法分析过程中实现L属性定义的SDT的方法包括:

    1. 使用一个递归下降的语法分析器。它为每个非终结符号都建立一个函数,对应于非终结符号A的函数以参数的形式接受A的继承属性,并返回A的综合属性;
    2. 使用一个递归下降的语法分析器,以边扫描边生成的方式生成代码;
    3. 与LL语法分析器结合实现一个SDT。属性的值存放在语法分析栈中,各个规则从栈中的已知位置获取需要的属性值;
    4. 与LR语法分析器结合实现一个SDT。如果基础文法是LL的,我们总是可以按照自底向上的方式来处理语法分析和翻译过程。
    在递归下降语法分析过程中进行翻译

    一个递归下降的语法分析器对每个非终结符号A都有一个函数A,我们可以把这个语法分析器扩展为一个翻译器:

    1. 函数A的参数是非终结符号A的继承属性,返回值是非终结符号A的综合属性;
    2. 在函数A的函数体中进行语法分析并处理属性。

    举个例子,考虑表2中的SDD,非终结符号E对应的函数E如下:

    float E() {
        float Tval = T();
        float EQUOTEinh = Tval;
        float EQUOTEsyn = EQUOTE(EQUOTEinh);
        float Eval = EQUOTEsyn;
        return Eval;
    }

    在函数E中,首先,注意到函数E没有任何参数,这是因为非终结符号E没有任何继承属性;其次,在E的函数体中,调用了函数T和函数EQUOTE,前者对应于非终结符号T(T也没有任何继承属性),后者对应于非终结符号E’(E’有一个继承属性);最后,定义了一系列变量来保存继承属性或综合属性(实际上是为了方便读者理解才定义了如此多的变量),并返回了计算结果。

    另外,非终结符号E’对于的函数EQUOTE如下:

    float EQUOTE(float EQUOTEinh) {
        if (下一个输入符号为'+') {
            读取输入
            return EQUOTE(EQUOTEinh + T());
        } else if (输入已经结束) {
            return EQUOTEinh;
        } else {
            ...
        }
    }
    边扫描边生成代码

    对上面的例子,如果需要在调用函数EQUOTE的过程中打印出表达式,而不是返回最后的结果,那么可以一边扫描一边生成代码。使用这个方法需要满足的条件是:每个非终结符号存在一个综合属性作为主属性,对主属性的求值是将相关产生式体中的非终结符号的主属性值连接起来得到的(连接时也可能包括非主属性),各个非终结符号的主属性值在连接运算中出现的顺序和这些非终结符号在产生式体中出现的顺序相同。

    修改函数EQUOTE,使其打印出表达式:

    float EQUOTE(float EQUOTEinh) {
        if (下一个输入符号为'+') {
            读取输入
            print(EQUOTEinh);
            print('+');
            float Tval = T();
            return EQUOTE(EQUOTEinh + Tval);
        } else if (输入已经结束) {
            return EQUOTEinh;
        } else {
            ...
        }
    }
    L属性的SDD与LL语法分析

    对于一个基础文法是LL文法的L属性的SDD,如果我们已经把它转换成了一个L属性定义的SDT,那么我们可以在LL语法分析过程中完成对它的翻译。

    为了在LL语法分析过程中实现L属性定义的SDT,语法分析栈需要被扩展,扩展后的语法分析栈可以存放三种记录:

    • 代表终结符号和非终结符号的记录,实际上是状态记录;
    • 动作记录。非终结符号A的继承属性放在表示A的栈记录中,对A的继承属性求值的代码放在一个紧靠在A的栈记录之上的动作记录中;
    • 综合记录。非终结符号A的综合属性放在一个紧靠在A的栈记录之下的综合记录中。

    在语法分析过程中,某些属性值可能会被拷贝到动作记录或综合记录中,这是因为一个分析表驱动的LL语法分析器模拟了一个最左推导过程。举个例子,当语法分析器按照一个产生式A→BC对栈顶的非终结符号A展开时,栈顶的A被替换为BC,假设C有一个继承属性C.i依赖于A的某个属性,但是此时已经无法访问到A,因此我们需要把A的属性临时拷贝到C的动作记录中,这样一来,C在计算其属性C.i时就能找到这个依赖属性了。

    下图是用文法G’中的产生式E'→ +TE'对E’进行展开的语法分析过程:

    20171122_img12

    我们对这个语法分析过程进行分析:

    1. 图8(a)中展示了即将展开E'的语法分析栈,此时栈顶是E'的栈记录,紧跟其后的是E'的综合记录,假设E'.inh已经被拷贝给了E1'的动作记录中的EQUOTEval
    2. 图8(b)用产生式体+TE1'替换了E'。一开始,+的栈记录在栈顶,它将和输入进行匹配,在匹配完成后,它被弹出栈顶,T的栈记录变为栈顶;
    3. 由于T的栈记录位于栈顶,因此会用某个产生式对符号T进行展开,当这个展开过程结束后,T的综合记录将位于栈顶,并且该记录中的val属性值已经被赋值了;
    4. 由于E1'的继承属性依赖于T.val,因此在将T的综合记录弹出栈顶之前,还需要把T.val拷贝给E1'的动作记录中的Tval
    5. 此时E1'的动作记录位于栈顶,它使用两个拷贝的属性值计算E1'.inh,计算的结果被放入E1'的栈记录中;
    6. 由于E1'的栈记录位于栈顶,因此会用某个产生式对符号E1'进行展开,当这个展开过程结束后,E1'的综合记录将位于栈顶,并且该记录中的syn属性值已经被赋值了;
    7. E1'的综合记录将E1'.syn赋值给E'.syn,到这里,用产生式体+TE1'展开E'的过程结束。
    L属性的SDD与LR语法分析

    我们可以使用自底向上的方法来完成任何可以用自顶向下方式完成的翻译过程,也就是说,对一个基础文法为LL文法的L属性的SDD,我们可以修改这个文法,使得可以在LR语法分析过程中实现这个新文法上的SDD。具体的方法包括:

    1. 将给定的基础文法为LL文法的L属性的SDD转换成SDT,这样的SDT在每个非终结符号之前放置语义动作计算它的继承属性,并且在产生式最右端放置一个语义动作计算综合属性;
    2. 对每个内嵌的语义动作,向这个文法中引入一个标记非终结符号来替换它。每个这样的位置都有一个不同的标记,并且对于任意一个标记M都有一个产生式M→ε;
    3. 如果标记非终结符号M在某个产生式A→α{a}β中替换了语义动作a,对a进行修改得到a’,并且将a’关联到M→ε上。这个动作a’将动作a需要的A或α中符号的任何属性作为M的继承属性进行拷贝,并且按照a中的方法计算各个属性,计算得到的属性将作为M的综合属性。

    对表2中的SDD,先将其转换成SDT:

    20171122_img13

    以这个SDT中的产生式E'→+TE1'为例,它的LR语法分析过程如下:

    20171122_img14

    图9(a)中首先对产生式E'→+TE1'进行变换,引入了一个标记非终结符号M对嵌入的动作{E1'.inh=E'.inh+T.val}进行替换,其中,E'.inhT.val将作为M的两个继承属性,E1'.inh将作为M的综合属性。

    图9(b)中是LR语法分析栈,我们假设接下来的输入能够匹配产生式体+TME1'并且最终被归约成产生式头E'。在这个语法分析栈中,我们不知道栈顶的记录代表了哪一个文法符号(或者状态),但是我们一定能确定这个记录中的某个字段保存了E’的inh属性。

    图9(c)中显示了即将把产生式体+TME1'归约成产生式头E'之前的语法分析栈。我们对从图9(b)到图9(c)的LR语法分析过程进行详细的分析:

    1. 语法分析栈的初始状态如图9(b)所示,此时栈顶的记录保存了E’的inh属性;
    2. 由于检测到的下一个输入的文法符号是”+”,因此识别出的产生式肯定是E'→+TME1'
    3. 假设接下来的输入被成功归约成T,此时栈顶是代表非终结符号T的记录,该记录中保存了T的val属性。由于我们已经确定了产生式是E'→+TME1',因此我们可以确定下一步是把ε归约成M;
    4. 在把ε归约成M时,栈顶是代表标记非终结符号M的记录,并且会执行一个动作,这个动作把E.inh(位于stack[top-3]的记录中)和T.val(位于stack[top-1]的记录中)分别拷贝给M的i和j属性,同时使用属性i和j计算它的综合属性s,属性s实际上是下一个非终结符号E1’的继承属性;
    5. 假设接下来的输入被成功归约成E1’,此时栈顶是代表非终结符号E1’的记录,计算E1’的syn属性时用到的E1’的inh属性是从代表M的记录中拿到的,这种情况下,代表M的记录相当于图9(b)中栈顶的记录,唯一的区别是这里我们能够知道保存E1’.inh的记录是代表M的记录;
    6. 由于句柄+TME1'已经位于栈顶,因此我们可以把+TME1'归约成E',此时会执行一个动作,这个动作把E1’.syn拷贝到stack[top-3]记录中,并执行3次出栈操作(实际上是4次出栈操作和1次入栈操作)。到这里,从图9(b)到图9(c)的LR语法分析过程结束。

    fightingZh
    欢迎关注微信公众号fightingZh٩(๑>◡<๑)۶

    展开全文
  • 图像匹配之归一化积相关灰度匹配

    千次阅读 2015-09-11 20:28:36
    图像匹配之最简单的归一化积相关灰度匹配,我的代码

            基于灰度的匹配是图像匹配中的一类重要算法,也称相关匹配。它基于空间二维滑动模板实现,并在制导导航方面得到了广泛应用。目前基于灰度的匹配算法有MAD算法、序贯相似性检测法等

            基本原理:



    当模板与原图找到最佳匹配部分时,R值最大,原理类似于:





    当a,b越接近时,R值越大,趋近于1。


    代码如下(我取b通道做图像匹配):

    
    

    #include "stdafx.h"
    #include <cv.h>
    #include <highgui.h>
    using namespace cv;
    
            double dbMax = 0;                                       //最大像素值
    	double dSigmaST, dSigmaS, dSigmaT;                      //中间结果
    	double   R;                                             //相似性测量
    	int   i, j, m, n ;
    	int  nMaxWidth, nMaxHeight;
    	CvScalar  pixelSrc, pixelTem, pixel0, pixel1;
    
    	IplImage* TemplateSrc = cvLoadImage("D:\\20.jpg");        //模板图像
    	IplImage* src = cvLoadImage("D:\\24.jpg");                //原图
    
    	//计算dSigmaT
    	dSigmaT = 0;
    	for (n = 0; n < TemplateSrc->height; n++)
    	{
    		for (m = 0; m < TemplateSrc->width; m++)
    		{
    			pixelTem = cvGet2D(TemplateSrc, n, m);
    			dSigmaT += (double)pixelTem.val[0] * pixelTem.val[0];
    		}
    	}
    
    	//找到图像中最大相似性出现的位置
    	for (j = 0; j < src->height - TemplateSrc->height+1; j++)
    	{
    		for (i = 0; i < src->width - TemplateSrc->width + 1; i++)
    		{
    			dSigmaST = 0;
    			dSigmaS = 0;
    			for (n = 0; n < TemplateSrc->height; n++)
    			{
    				for (m = 0; m < TemplateSrc->width; m++)
    				{
    					pixelSrc = cvGet2D(src, j+n, i+m);
    					pixelTem = cvGet2D(TemplateSrc, n, m);
    					dSigmaS += (double)pixelSrc.val[0] * pixelSrc.val[0];
    					dSigmaST += (double)pixelSrc.val[0] * pixelTem.val[0];
    				}
    			}
    			R = dSigmaST / (sqrt(dSigmaS)*sqrt(dSigmaT));    //计算相似性
    			if (R > dbMax)         //与最大相似性比较
    			{
    				dbMax = R;
    				nMaxHeight = j;
    				nMaxWidth = i;
    			}
    		}
    	}
    
    	//对目标像素进行赋值
    	for (j = nMaxHeight; j <TemplateSrc->height + nMaxHeight; j++)
    	{
    		for (i = nMaxWidth; i < TemplateSrc->width + nMaxWidth; i++)
    		{
    			pixel0 = cvGet2D(src, j , i );
    			pixel1.val[0] = pixel0.val[0] / 2;
    			pixel1.val[1] = pixel0.val[1] / 2;
    			pixel1.val[2] = pixel0.val[2] / 2;
    			cvSet2D(src,j, i, pixel1);
    		}
    	}
    
    
    	cvNamedWindow("White", CV_WINDOW_AUTOSIZE);
    	cvShowImage("White", src);
    	
    
    	while (1)
    	{
    		if (cvWaitKey(100) == 27) break;
    	}
    	cvDestroyWindow("White");
    	cvReleaseImage(&src);
    	exit(0);


    调试效果如图:

    原图:



    模板图:


    效果图:







    展开全文
  • 文章目录概念语法制导翻译的基本思想SDD && SDT语义规则文法属性(S,L)SDD注释分析树副作用抽象语法树( AST )SDD的实现方法SDT子问题语法和语义的区别应用SDD生成抽象语法树AST 概念 语法制导翻译的基本...

    概念

    语法制导翻译的基本思想

    在这里插入图片描述
    在语法分析基础上边分析边翻译

    • 翻译的依据:语义规则或语义子程序
    • 翻译的结果:相应的中间代码
    • 翻译的做法:为每个产生式配置相应的语义子程序,每当使用某 个产生式进行规约或推导时,就调用语义子程序,完成一部分翻 译工作
    • 语法分析完成时,翻译工作也告结束

    SDD && SDT

    • 语法制导定义 Syntax-Directed Definitions(SDD

      • 将文法符号和某些属性相关联 规则与产生式相关联
      • 并通过语义规则来描述如何计算属性的值 EE1+TE.val=E1.val+T.valE →E1+T E.val=E1.val + T.val
    • 语法制导的翻译方案 Syntax-Directed Translation Scheme(SDT

      • 在产生式体中加入语义动作,并在适当的时候执行这些语义动作
      • EE1+T{E.val=E1.val+T.val;}E → E1+T \{E.val=E1.val + T.val;\}

    语义规则

    • 描述一个产生式所对应的翻译工作,如:
      • 改变某些变量的值;
      • 填/查各种符号表;
      • 发现并报告源程序错误;
      • 产 生中间代码
    • 决定于翻译的目的,例如:产生什么样的中间代码

    文法属性(S,L)

    • 综合属性:
      分析树节点N上的非终结符的综合属性只能通过该节点或子节点的属性来定义。

      终结符可以具有综合属性,值由词法分析器提供。

    • 继承属性
      分析树节点N上的非终结符的继承属性只能通过该节点或父节点或兄弟节点的属性来定义。
      在这里插入图片描述
      终结符没有继承属性

    SDD

    • 只包含综合属性的SDD称为S属性的SDD
    • 含有继承属性的SDD

    在对SDD的求值过程中,如果结点N的属性a依赖于结点M1的属性a1, M2的属性a2,…。那么我们必须先计算出Mi的属性,才能计算N的 属性a , 使用依赖图来表示计算顺序

    在这里插入图片描述

    L属性的SDD
    每个属性 要么是综合属性(S属性SDD属于L属性SDD) , 要么是继承属性。 且产生式A → X1X2…Xn中计算Xi.a的规则只能使用:

    • A的继承属性
    • Xi左边的文法符号Xj的继承属性或综合属性
    • Xi自身的继承或综合属性,且这些属性之间的依赖关系不形成环

    注释分析树(注释语法树)

    在这里插入图片描述

    副作用

    • 一个没有副作用的SDD称为属性文法,一个属性文法的规则仅 通过其他属性值和常量值来计算另一个属性值
    • 引入副作用可以带来一些方便,比如语法分析时如果没有副作用,标识符表就必须作为属性传递 –,可以把标识符表作为全局变量,然后通过副作用函数来添加新标识符
    • 受控的副作用 – 不会对属性求值产生约束,即可以按照任何拓扑顺序求值,不会影响 最终结果 – 或者对求值过程添加简单的约束

    抽象语法树( AST )

    语法树是分析树的浓缩表示:算符和关键字是作为内部结点
    语法制导翻译可以基于分析树,也可以基于语法树

    抽象语法树

    • 每个结点代表一个语法结构;对应于一个运算符
    • 结点的每个子结点代表其子结构;对应于运算分量
    • 可以忽略掉一些标点符号等非本质的东西

    抽象语法树的表示方法

    • 每个结点用一个对象表示,对象有多个域
    • Leaf(op, val)创造一个叶子对象,返回一个指向叶子结点对应新记录的指针
    • Node(op, c1, c2, …, ck),其中c1-ck为子结点
      在这里插入图片描述

    SDD的实现方法

    最通用的实现是先分析得到语法树再翻译,一个更方便但是有局限性的做法是边分析边翻译。
    在这里插入图片描述

    SDT

    实现SDT时,实际上并不会真的构造语法分析树,而是在分析过程中 执行语义动作
    我们主要关注用SDT实现以下两类重要的SDD

    1. 基本文法是LR的,且SDD是S属性的 (最简单的情况)
    2. 基本文法是LL的,且SDD是L属性的 (generalized)

    对于第一种,直接在产生式右部添加语义动作即可,这样在规约的时候计算LHS的综合属性。

    产生式内部带有语义动作的SDT

    • 动作左边的所有符号(以及动作)处理完成后,就立刻执行这个动作
      • B → X{a}Y
      • 自底向上分析时,在X出现在栈顶时执行动作a
      • 自顶向下分析时,在试图展开Y或者在输入中检测到Y的时刻执行a

    这个的实际实现方式是:1. 增加一个特殊的终结符M, 增加产生式和语义动作 Mϵ   {a}M\longrightarrow\epsilon\ \ \ \{a\} 也就是说,增加中部的语义动作会引入空产生式,从而导致新的冲突

    子问题

    语法和语义的区别

     在CFG中,语法正确只是指这个句子结构正确,仅仅是一个局部的概念,是没有考虑上下文的。比如a[0] = f(4);这个语句语法是正确的,因为存在一个语法结构可以匹配这个语句。然而这个语句是否真的正确还要看两点:a是否是数组或指针,f的参数是否匹配。而这两点信息只能通过上下文获取,也就是它们的**语义*。*

     不同的符号有不同的语义类型,比如上面的a是变量,语义至少有:值和类型。f是函数语义至少有:函数指针,返回类型,参数。

    应用SDD生成抽象语法树AST

    例:
    在这里插入图片描述
    在这里插入图片描述

    S属性的SDT

    由于S属性的计算顺序与对语法树的后序遍历顺序相同,所以S属性的SDD可以构造出后缀 SDT。有两种实现方案:

    • 在递归的预测分析过程中进行语义翻译
    • 在LR分析过程中进行语义翻译

    在这里插入图片描述

    L属性的SDT

    使用内部含有语义动作的SDT,实现这样的SDT可以采用通用的方法:先构造分析树,再遍历。也可能可以使用翻译与语法分析同步的方式:

    1. 在递归的预测分析过程中进行语义翻译
    2. 在LL分析过程中进行语义翻译
    3. 在LR分析过程中进行语义翻译
    • 首先把SDD转换成内部含有语义动作的SDT
      在这里插入图片描述
      在这里插入图片描述
    • 语义动作的执行时机
      • B → X{a}Y
      • 自底向上分析时,在X出现在栈顶时执行动作a
      • 自顶向下分析时,在试图展开Y或者在输入中检测到Y的时刻执行a

    通用实现方法(不和语法分析同步进行))

    步骤:

    • 忽略语义动作,对输入进行语法分析,产生一个语法分析树
    • 检查每个内部结点N,如果产生式为AαA\longrightarrow α,将α中各个动作当做 N的附加子结点加入,使得N的子结点从左到右和α中符号及动作 完全一致
    • 对分析树进行前序遍历,在访问虚拟结点时执行相应动作
      在这里插入图片描述

    L属性定义的LL分析实现

    PPT137-145

    L属性定义的递归下降实现

    首先看一下递归下降的语法分析
    在这里插入图片描述
    然后对它推广到翻译方案的实现
    在这里插入图片描述
    在这里插入图片描述

    L属性定义的LR分析实现

    PPT158-179

    展开全文
  • 针对景像匹配制导,设计了先粗后精的匹配控制策略,实现了归一化积相 关图像匹配算法的有效加速,并给出了简化的快速算法的基本设计思想。通过大量的匹配仿真实验,系统分析了 算法对灰度畸变、噪声干扰、几何旋转...
  • 自适应控制理论能准确实时调整控制加权系数,实现系统自身性能与外界信息的匹配和沟通,达到最佳性能,并有效应用于智能鱼雷的控制平台中。提出了一种基于自适应控制理论的鱼雷制导控制多通道加权算法,根据自适应多...
  • 能力强、匹配准确的匹配算法,因此,在导航制导中广泛应用。但由于其运算量比较大,对于要求实时匹配 的地形辅助导航系统来说,其运算速度需要进一步提高。在NCC方法的基础上,把卷积用于景象匹配,大 大简化并提高了NCC的...
  • 语法制导翻译,讲了两个大的实例,很有趣。边翻译、边计算。
  • 输入:添加制导的源程序*.c 输出:打印每个函数对应的是否在制导范围内,如果在制导范围内,对应的规则号 输出格式为 函数名:[0,1,2](1 表示有 as-check 制导 rule1,2 表示有制导 rule2, 0 表示没有)每个函数...
  • 光纤线管是光纤制导武器系统的重要组成部分,由于组成材料热膨胀系数之间的差异,精确缠绕样式的光纤线包性能会随温度变化而发生显著变化.为保证光纤线包结构稳定性及性能可靠性,需要对光纤线管各组成部分进行温度性能...
  • 为了实现激光驾束制导信息场性能参数检测,设计了基于虚拟仪器技术的激光驾束制导仪信息场仿真系统,将仿真系统应用于信息场性能参数与空间匹配特性检测系统中,实现对检测系统的校正与自检。信息场模拟器的设计精度...
  • 目录语义分析概述语义分析任务语法制导翻译属性文法综合属性继承属性 语义分析概述 编程语言的语法和语义之间并没有明确界限,语义可完成CFG无法描述的特性 如: 标识符先声明后引用的语法规定,可用简单的抽象语言...
  • 编译原理(十)语法制导翻译

    千次阅读 2020-05-17 18:15:23
    语法制导翻译 SDD 综合属性:从前面语句中获取属性,由底向上的 继承属性:从后面语句中获取属性,由顶向下的 什么属性可能就与代码有关
  • 编译原理-语法制导的翻译

    千次阅读 2018-11-22 17:19:04
    语法制导定义(Syntax-Directed Definition,SDD)是一个上下文无关文法和属性及语义规则的结合。属性和文法符号相关联,语义规则和产生式相关联,文法符号X的属性a表示为X.a。 非终结符号可以有两种属性: 综合...
  • 【无人机 学习笔记 2】无人机导航制导与控制

    万次阅读 多人点赞 2018-08-20 14:18:53
    梳理完控制以及飞行力学的一些基本原理之后,就该正式进入无人机导航、制导与控制的讨论了。导航制导与控制是无人机系统中最复杂的分系统,其功能可以有多种划分方法,本文中,我们就以下面框图所示的划分方法为例,...
  • 完成以下描述赋值语句 SLR(1)文法语法制导生成中间代码四元式的过程。G[E]: S→V=E E →E+T∣E-T∣T T→T*F∣T/F∣F F→(E)∣i V=I 2.[设计说明] 终结符号i 为用户定义的简单变量,即标识符的定义。 3.[设计要求] (1...
  • 作者:Ken Shirriff,排版整理:晓宇微信公众号:芯片之家(ID:chiphome-dy)作者最近一直在研究Titan II核导弹的制导计算机。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,248
精华内容 499
关键字:

匹配制导