- 博客(1)
- 资源 (2)
- 收藏
- 关注
原创 人工智能发展历史与趋势
人工智能发展历史与趋势 [摘 要] 人工智能是研究使计算机来模拟人的某些思维过程和智能行为(如学习、推理、思考、规划等)的学科,主要包括计算机实现智能的原理、制造类似于人脑智能的计算机,使计算机能实现更高层次的应用。人工智能将涉及到计算机科学、心理学、哲学和语言学等学科。可以说几乎是自然科学和社会科学的所有学科,其范围已远远超出了计算机科学的范畴,人工智能与思维科学的关系是实践和理论的
2009-06-16 20:31:00
9973
1
基于c++数字逻辑电子仿真器
定义数据结构如下:
typedef struct tagMyNode
{
Mytype type; //元件类型
MySubtype Subtype; //元件子类型
tagMyNode* input1; //输入端1
tagMyNode* input2; //输入端1
tagMyNode* output1; //输出端1
UINT input1value; //输入端input1的值
UINT input2value; //输入端input2的值
UINT output1value; //输出端output1的值
int inputs; //当前已经有几个输入端有值
int number; //对于输入结点的序号
CPoint Orgpoint; //记录元件左上角位置
int width; //记录元件宽度
int height; //记录元件高度
}MyNode;
元件类型:元件类型Mytype type中Mytype是一个枚举类型定义如下:
enum Mytype
{
Node, //结点
Gate, //门
};
分为两种类型:Node结点和Gate门。
元件子类型:元件子类型MySubtype Subtype中MySubtype也是一个枚举类
型,定义如下:
enum MySubtype
{
Input, //输入端
Output, //输出端
ANDGate, //与门
ORGate, //或门
NOTGate, //非门
NORGate, //或非门
NANDGate, //与非门
XORGate, //异或门
};
指针连接: tagMyNode* input1;
tagMyNode* input2;
tagMyNode* output1
是指向此结点的指针。由于元件之间是要相互连接的,于是设置这几个指针用于元件之间的连接。其中特殊情况有:
非门:由于非门只有一个输入端,所以非门不用tagMyNode* input2;
输入结点:输入结点只有一个链接端(这里称之为触点),采用tagMyNode* output1
输出结点:同输入结点,只有一个触点,采用tagMyNode* input1;
保存触点值:由于要进行仿真计算,所以还需保存各个触点的值:
UINT input1value;
UINT input2value;
UINT output1value;
同指针连接,有3种特殊情况:
非门:不用UINT input2value;
输入结点:采用UINT output1value;
输出结点:采用UINT input1value;
进位标志:int inputs;
在进行仿真计算时,要用进位标志辅助计算。如与门只有在两个输入端都有值时,即inputs==2时,才能进位。
输入结点序号:int number;
每个输入结点都有不同的序号,从1开始递增。
元件位置和大小:
CPoint Orgpoint;
int width;
int height;
Orgpoint用于记录元件在视图中左上角的坐标
width用于记录元件宽度
height用于记录元件高度
电路图编辑模块
电路图编辑模块又分为两个子模块:鼠标放置元件模块,鼠标连接元件模块
首先在工具栏中可以选择这两种状态,如图4
图4
在按钮上单击可以切换状态。
定义一个枚举类型MyStatus来记录当前状态:
enum MyStatus
{
NONE, //鼠标连接元件状态
ANDGATE,
ORGATE,
NOTGATE,
NORGATE,
NANDGATE,
XORGATE,
NODEINPUT,
NODEOUTPUT
};
MyStatus Status;
其中:NONE为鼠标连接状态,其他为鼠标放置状态。
鼠标放置元件模块
其算法如图5:
图5
DrawObject函数:
首先根据Status的状态,即六个门,两个端结点。共8种来调用DrawObject函数
引入准备好的八张位图(六个门,两个端)
CBitmap MyBitMap;
MyBitMap.LoadBitmap (nID);
将引入的位图拷贝入窗体窗户区
BITMAP bmpInfo;
MyBitMap.GetBitmap (&bmpInfo);
pOldBitmap=dc.SelectObject (&MyBitMap);
ClientDC.BitBlt (point.x ,point.y,bmpInfo.bmWidth ,bmpInfo.bmHeight,&dc,0,0,SRCAND);
dc.SelectObject (pOldBitmap);
用全局变量bmWidth和bmHeight来保存元件的宽度和高度
bmWidth=bmpInfo.bmWidth ;
bmHeight=bmpInfo.bmHeight ;
CreateMyObject函数
函数声明为:CreateMyObject(Mytype type, MySubtype Subtype, CPoint point)
初始化元件
MyNode* pNode=new MyNode;
pNode->type =type;
pNode->Subtype =Subtype;
pNode->input1 =0;
pNode->input2 =0;
pNode->output1 =0;
pNode->output2 =0;
pNode->Orgpoint =point;
pNode->width =bmWidth;
pNode->height =bmHeight;
pNode->input1value =0;
pNode->input2value =0;
pNode->output1value =0;
pNode->inputs =0;
如果创建的元件为输入结点,则要创建并画输入结点前的序号,这里
采用一个全局数组CArray<CPoint,CPoint> numpoint来记录结点前序号。
if(Subtype==Input)
{
//当创建Input时加入点到numpoint数组中
numpoint.Add (CPoint(point.x-15,point.y));
pNode->number =numpoint.GetSize ();
//创建时重绘序号
redrawnum();
}
而redrawnum()函数就是将所有输入结点前的序号重绘。
最后将元件加入到全局链表CList<MyNode*,MyNode*> MyList中。
MyList.AddTail (pNode);
鼠标连接元件模块
鼠标连接元件模块分为三个过程模块:鼠标移动模块,鼠标按下模块,鼠标抬起模块。
鼠标移动模块
其算法如图6
图6
代码如下:
void CMyView::OnMouseMove(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
//此时必然是非画图状态,所以status==NONE;
if(Status==NONE)
{
//当前点在某个物件上吗? 并且 //当前点在该物件触点上吗?
if(IsPointInObject(point) && IsPointInPut(point))
{
//全局变量pNodeNow是在IsPointInObject()这个函数里面记录的
//circlepoint和put是在IsInInput1() IsInInput2() IsInOutput1()
//这三个函数中记录的
//判断此时触点时否己连接非常重要
if(IsPutLinked())
{
//如果此时触点己连接,则退出
return;
}
//此时鼠标移进触点
//当前是连接态吗?
if(IsLink)
{
//连接态画图
LinkStatusDraw(point);
}
//开启画圆圈态
IsDrawCircle=TRUE;
//画圆圈
DrawMyCircle();
}
else//此时鼠标移出触点
{
//如果此时已画圆圈,则要擦除圆圈
if(IsDrawCircle==TRUE)
{
EraserMyCircle();
//关闭画圆圈状态
IsDrawCircle=FALSE;
//重绘连接线
moveoutredrawline();
//重绘圆圈所在的那个物件,因为擦除圆圈的时候可能擦除了部分物件
//-------------------
redrawMyObject(pNodeNow);
//如果此时是连接状态,连接态画图
}
if(IsLink)
{
//连接态画图
LinkStatusDraw(point);
}
}
}
CView::OnMouseMove(nFlags, point);
}
两个关键状态:可连接态IsDrawCircle和正在连接态IsLink
可连接态IsDrawCircle 当且仅当鼠标移动到某个元件上的某个尚未连接的触点上,才开启可连接态IsDrawCircle。之所以取名IsDrawCircle是因为此时会在鼠标停留的尚未连接的触点上画一个黑色小圆圈。
当鼠标移动离开触点,可连接态IsDrawCircle关闭。
正在连接态IsLink 当鼠标按下(见图5)并且此时可连接态IsDrawCircle开启(为TRUE)时正在连接态IsLink开启。
判断当前点是否在某个元件函数:IsPointInObject()
其算法如图7
图7
判断当前点是否在该元件触点上函数:IsPointInPut()
其算法如图8
图8
与门与其它5个门有所不同,与门只有一个输入端,所以要分开来判断
对于输入结点,则判断当前点是否在第一个输出端触点。
对于输出结点,则判断当前点是否在第一个输入端触点。
输入结点和输出结点的这样判断,一眼看上去似乎反了,但实际上有利于整个程序的编写。可以简单地这样分类:总共只有两种端,一种输入,一种输出。
这样,我们就可以将判断触点分为三个函数:
IsInInput1()
IsInInput2()
IsInOutput1()
拿IsInInput1()来分析:
centerpoint=GetCirclePoint(Input_1);
if(IsInArea(point))
{
//说明此时就在触点Input_1,用全局变量put记录下来
put=Input_1;
//如果当前点在,则要保存触点中心点
circlepoint=centerpoint;
return TRUE;
}
else
{
//如果移出触点,肯定不要再保存中心点
return FALSE;
}
首先,调用函数GetCirclePoint()来取得当前触点的中心点。然后调用IsInArea(point)函数来判断当前点point是否在以当前触点中心点为中心的矩形区域内。如果是,则用一个全局枚举变量put来记录来前触点是两个输入端和一个输出端中哪一个。
我们看这个枚举类型:
enum Myput
{
Input_1,
Input_2,
Output_1
};
接下来用一个全局变量circlepoint来记录当前触点中心点。再返回真。
如果当前点不在以当前触点中心点为中心的矩形区域内,则返回假。这时千万不能记录当前触点中心点。这点不注意会出大错。
判断当前触点是否已连接函数:IsPutLinked()
BOOL CMyView::IsPutLinked()
{
switch(put)
{
case Input_1:
if(pNodeNow->input1 !=0)
return TRUE;
break;
case Input_2:
if(pNodeNow->input2 !=0)
return TRUE;
break;
case Output_1:
if(pNodeNow->output1 !=0)
return TRUE;
}
return FALSE;
}
这里根据全局变量put的类型和全局变量pNodeNow所指向的元件,
就可以判断当前元件的当前触点是否已连接。如果连接相应指针不为0。返回真,否则返回假。
连接态画图函数:LinkStatusDraw()
void CMyView::LinkStatusDraw(CPoint point)
{
CClientDC clientDC(this);
CPen whitepen(PS_SOLID,1,RGB(255,255,255));
CPen* pOldPen;
pOldPen=clientDC.SelectObject (&whitepen);
clientDC.MoveTo (startpoint);
clientDC.LineTo (lastpoint);
clientDC.SelectObject (pOldPen);
CPen redpen(PS_DOT ,1,RGB(255,0,0));
pOldPen=clientDC.SelectObject (&redpen);
clientDC.MoveTo (startpoint);
clientDC.LineTo (point);
clientDC.SelectObject (pOldPen);
lastpoint=point;
//重绘所有输入结点前的序号
redrawnum();
//重绘连接线
LinkLineRedraw(startpoint,point);
//重绘物件
lineRedraw(startpoint,point);
}
这里,startpoint是鼠标按下开始连接时起始元件触点中心点坐
标,lastpoint是上一次鼠标移动所停留的点。为了实在连接时鼠标移动
的动画效果,我们要先擦除上一次移动画的线(用白笔),然后再从startpoint到当前点point画线。移动时由于不信的擦除重画,可能将先前已画的元件,输入结点前的序号,和已经连接好的线擦除。于是我们需要重绘。
重绘所有输入结点前的序号
redrawnum();
void CMyView::redrawnum()
{
CClientDC dc(this);
char buffer[20];
CPoint point;
//重绘所有Input前的序号
for(int i=0;i<numpoint.GetSize ();i++)
{
//将数字转换成字符,存于buffer中
_itoa(i+1,buffer,10);
point=numpoint.GetAt (i);
dc.TextOut (point.x ,point.y ,buffer);
}
}
由于每创建一个输入结点,就要相应地记录一个序号。这个序号的位置点记录在numpoint这个数组中。数组声明如下:
CArray<CPoint,CPoint> numpoint;
而数组的下标加1就为序号。
所以每次重绘为了方便,将所有序号都重绘。
重绘连接线
void CMyView::LinkLineRedraw(CPoint startpoint, CPoint point)
{
//将起点startpoint到终点point扩充成一个矩形drawrect
CRect drawrect(startpoint,point);
//rect用于产生连接线最大矩形
CRect rect;
//rectInter用于计算两个矩形的相交区域
CRect rectInter;
//point1和point2用于产生连接线最大矩形
CPoint point1;
CPoint point2;
drawrect.NormalizeRect ();
drawrect.InflateRect (1,1);
//遍历MyPointList链表
POSITION pos=MyPointList.GetHeadPosition ();
while(pos!=0)
{
//pPointArray用于指向点数组对象首址
CArray<CPoint,CPoint>* pPointArray=MyPointList.GetNext (pos);
point1=pPointArray->GetAt (0);
switch(pPointArray->GetSize ())
{
//分两种情况 :2个点和4,5个点的情况
case 2:
//2个点时
point2=pPointArray->GetAt (1);
break;
default:
//4,5个点时
point2=pPointArray->GetAt (3);
}
//用point1和point2设置矩形rect
rect.left =point1.x ;
rect.top =point1.y;
rect.right =point2.x;
rect.bottom =point2.y;
rect.NormalizeRect ();
rect.InflateRect (1,1);
//如果两个矩形相交,则要重绘
if(rectInter.IntersectRect (&drawrect,&rect))
{
DrawLinkLine(pPointArray);
}
}
}
主要的算法思想是:将起点startpoint到当前点point扩充成一个矩形drawrect,然后遍历连接线链表,将每根连接线扩充成一个矩形rect,再判断这两个矩形是否相交,若相交,则需要重绘这根连接线。
连接线链表声明如下:
CList<CArray<CPoint,CPoint>*,CArray<CPoint,CPoint>*>
MyPointList;
链表中每个结点是一个数组对象的地址,而这个数组中每个元素是一个点。这样一个数组就表示了一根连接线,而一个链表可以遍历所以连接线。
画提示连接的小圆圈函数:DrawMyCircle()
void CMyView::DrawMyCircle()
{
//此时全局变量circlepoint记录了要画圆圈的
//而pNodeNow指向了当前的物件
//将物件坐标中的circlepoint转换成VIEW中的坐标
int x,y;
x=pNodeNow->Orgpoint .x +circlepoint.x;
y=pNodeNow->Orgpoint .y +circlepoint.y;
CClientDC dc(this);
//创建一个黑色的画刷
CBrush brush(RGB(0,0,0));
//创建指针pOldBrush用于保存原来的画刷
CBrush* pOldBrush;
//将黑色的画刷选进设备装置DC,并用pOldBrush保存原来的画刷
pOldBrush=dc.SelectObject (&brush);
//画一个圆圈,圆心是(x,y)
//半径是4
dc.Ellipse (x-4,y-4,x+4,y+4);
//将原来的画刷选回
dc.SelectObject (pOldBrush);
}
由于全局变量circlepoint保存的是元件内部的相对坐标,需要将它
转换成视图中的坐标
x=pNodeNow->Orgpoint .x +circlepoint.x;
y=pNodeNow->Orgpoint .y +circlepoint.y;
以上两句完成坐标的转换。
然后以(x,y)为圆心,4为半径,画一个黑色小圆圈
dc.Ellipse (x-4,y-4,x+4,y+4)
擦除小圆圈函数:EraserMyCircle()
void CMyView::EraserMyCircle()
{
int x,y;
x=pNodeNow->Orgpoint .x +circlepoint.x;
y=pNodeNow->Orgpoint .y +circlepoint.y;
CClientDC dc(this);
CPen whitepen(PS_SOLID,1,RGB(255,255,255));
CPen* pOldPen;
pOldPen=dc.SelectObject (&whitepen);
dc.Ellipse (x-4,y-4,x+4,y+4);
dc.SelectObject (pOldPen);
}
与画小圆圈不同的是,擦除时要选择白色的笔和白色的画刷(默认)
CPen whitepen(PS_SOLID,1,RGB(255,255,255));
CPen* pOldPen;
pOldPen=dc.SelectObject (&whitepen);
以上3句选择白色的笔。
鼠标移开触点重绘连接线函数:moveoutredrawline()
为什么需要这个函数,原因是在鼠标称出触点后,此时要擦除刚才画
的小圆圈,而如果此时已经生成了连接线,则会擦除掉连接线的一小部分。于是需要这个函数。
void CMyView::moveoutredrawline()
{
int x,y;
x=pNodeNow->Orgpoint .x +circlepoint.x;
y=pNodeNow->Orgpoint .y +circlepoint.y;
CPoint point1;
CPoint point2;
point1.x=x-4;
point1.y=y-4;
point2.x=x+4;
point2.y=y+4;
LinkLineRedraw(point1,point2);
}
此时pNodeNow指向刚擦除小圆圈的元件,而circlepoint则记录着
触点中心。于是只要将以ciclepoint为中心的半径为4的矩形的左上角点和右下角点为参数调用LinkLineRedraw即可。
重绘元件函数redrawMyObject()
void CMyView::redrawMyObject(MyNode* pNode)
{
switch(pNode->Subtype )
{
case ANDGate:
DrawObject(pNode->Orgpoint ,IDB_ANDGATE);
break;
case ORGate:
DrawObject(pNode->Orgpoint,IDB_ORGATE);
break;
case NOTGate:
DrawObject(pNode->Orgpoint,IDB_NOTGATE);
break;
case NORGate:
DrawObject(pNode->Orgpoint,IDB_NORGATE);
break;
case NANDGate:
DrawObject(pNode->Orgpoint,IDB_NANDGATE);
break;
case XORGate:
DrawObject(pNode->Orgpoint,IDB_XORGATE);
break;
case Input:
DrawObject(pNode->Orgpoint,IDB_NODEINPUT);
break;
case Output:
DrawObject(pNode->Orgpoint,IDB_NODEOUTPUT);
break;
}
}
该函数参数为指向元件的指针,用于重绘所指向的元件。
鼠标按下模块
如图5
图5
前面已经分析了放置元件状态,现在看连接元件状态中的判断:
“当前点是否在某个元件未连接的触点上”其实就是判断“可连接态”IsDrawCircle是否为真。代码如下:
if(IsDrawCircle)//当前点在某个元件未连接的触点上
{
//全局变量IsLink表示开始连接状态
IsLink=TRUE;
//全局变量pNodeStart记录当前物件
pNodeStart=pNodeNow;
//全局变量startpoint记录当前触点中心坐标(注,此时要进行坐标转换
startpoint.x=pNodeNow->Orgpoint .x +circlepoint.x;
startpoint.y=pNodeNow->Orgpoint .y +circlepoint.y;
//全局变量startput记录当前触点类别:Input_1,Input_2,Output_1;
startput=put;
//lastpoint用于鼠标移动时擦除线效果
lastpoint=startpoint;
}
进行连接初始化:首先开启开始连接状态
IsLink=TRUE;
然后用全局变量pNodeStart指向当前元件
pNodeStart=pNodeNow
全局变量startpoint记录当前触点中心坐标(这时要进行坐标的转换)
startpoint.x=pNodeNow->Orgpoint .x +circlepoint.x;
startpoint.y=pNodeNow->Orgpoint .y +circlepoint.y;
全局变量startput记录当前触点类别
startput=put;
最后lastpoint用于鼠标移动时擦除线效果
lastpoint=startpoint;
鼠标抬起模块
其算法如图9
图9
代码如下:
void CMyView::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
if(IsLink)
{
//首先擦除从startpoint到point
CClientDC clientDC(this);
CClientDC* pDC=&clientDC;
CPen whitepen(PS_SOLID,1,RGB(255,255,255));
CPen* pOldPen;
pOldPen=clientDC.SelectObject (&whitepen);
clientDC.MoveTo (startpoint);
clientDC.LineTo (point);
clientDC.SelectObject (pOldPen);
//重绘所有输入结点前的序号
redrawnum();
//重绘连接线
LinkLineRedraw(startpoint,point);
//重绘物件
lineRedraw(startpoint,point);
if(IsDrawCircle)
{
//用全局变量pNodeCurrent记录终点连接的物体
pNodeCurrent=pNodeNow;
//用全局变量currentput记录终点连接的触点
currentput=put;
//用全局变量currentpoint记录终点触点的中心坐标
currentpoint.x=pNodeNow->Orgpoint .x +circlepoint.x;
currentpoint.y=pNodeNow->Orgpoint .y +circlepoint.y;
//IsTwoObjectsCanLink()函数判断两个物件是否能连接
if(IsTwoObjectsCanLink())
{
//先擦除圆圈
//EraserMyCircle();没有必要,只要鼠标移开时重绘连接线就可
//开始两个物件的画图连接
LineLink();
//开始真正连接:指针连接
RealLink();
}
}
//关闭连接状态:
IsLink=FALSE;
}
CView::OnLButtonUp(nFlags, point);
}
判断两个元件是否可以连接
BOOL CMyView::IsTwoObjectsCanLink()
{
//判断两个物件是否能连接
//这两个物件分别由pNodeStart和pNodeCurrent指向
//两个触点分别由startput和currentput标识
//若所指同一物件
if(pNodeStart==pNodeCurrent)
{
MessageBox("连接错误!自身物件不能相互连接");
return FALSE;
}
//输出直接结输出
if(startput==Output_1 && currentput==Output_1)
{
MessageBox("连接错误!输出端不能相互连接");
return FALSE;
}
//输入直接连接输入
if( (startput==Input_1 || startput==Input_2)
&& (currentput==Input_1||currentput==Input_2) )
{
MessageBox("连接错误!输入端不能相互连接");
return FALSE;
}
//循环连接
if( (startput==Output_1)
&&(currentput==Input_1||currentput==Input_2) )
{
if(pNodeCurrent->output1 ==pNodeStart)
{
MessageBox("连接错误!不能循环连接");
return FALSE;
}
}
if( (startput==Input_1||startput==Input_2)
&&(currentput==Output_1) )
{
if(pNodeStart->output1 ==pNodeCurrent)
{
MessageBox("连接错误!不能循环连接");
return FALSE;
}
}
//如果以上情况都不发生,表示可以连接
return TRUE;
}
用图来表示上述几种错误:
同一元件不能连接
图10
输出端不能连接输出端
图11
输入端不能连接输入端
图12
两个元件不能循环连接
图13
两个元件的画图连接:LineLink()
该函数调用了recordLine()
代码如下:
void CMyView::recordLine ()
{
//记录两个物件之间的连接线经过的关键点
//先动态生成一个数组CArray<CPoint,CPoint>之对象
//记录下连接线的关键点,然后将这个数组对象之地址加入到
//CList<CArray<CPoint,CPoint>*,CArray<CPoint,CPoint>*> MyPointList中
int x0,y0,x1,y1,delta_x,delta_y;
//(x0,y0)用于记录输出端起始点坐标
//(x1,y1)用于记录输入端终点坐标
//delta_x,delta_y用于记录x和y的偏移量
//一定是从输出端向输入端画线
if(startput==Output_1)
{
x0=startpoint.x;
y0=startpoint.y;
x1=currentpoint.x;
y1=currentpoint.y;
}
else
{
x1=startpoint.x;
y1=startpoint.y;
x0=currentpoint.x;
y0=currentpoint.y;
}
delta_x=5;
//动态生成数组对象
CArray<CPoint,CPoint>* pPointArray=new CArray<CPoint,CPoint>;
//根据点的位置分为三种情况:2个点,4个点,5个点
if(x0<x1)
{
if(y0==y1)
{
//两个点情况
pPointArray->Add (CPoint(x0,y0));
pPointArray->Add (CPoint(x1,y1));
}
else
{
//4个点情况
pPointArray->Add (CPoint(x0,y0));
pPointArray->Add (CPoint(x0+delta_x,y0));
pPointArray->Add (CPoint(x0+delta_x,y1));
pPointArray->Add (CPoint(x1,y1));
}
}
else if(x0==x1)
{
//两个点情况
pPointArray->Add (CPoint(x0,y0));
pPointArray->Add (CPoint(x1,y1));
}
else //x0>x1
{
//5个点情况
if(y0<y1)
{
delta_y=20;
}
else
{
delta_y=-20;
}
pPointArray->Add (CPoint(x0,y0));
pPointArray->Add (CPoint(x0,y0+delta_y));
pPointArray->Add (CPoint(x1-delta_x,y0+delta_y));
pPointArray->Add (CPoint(x1-delta_x,y1));
pPointArray->Add (CPoint(x1,y1));
}
//加入当前数组对象地址到MyPointList
MyPointList.AddTail (pPointArray);
//用数组中的点画线
DrawLinkLine(pPointArray);
}
首先保证从输出端向输入端画线,这样可以统一画线操作。
然后动态生成数组:
CArray<CPoint,CPoint>* pPointArray=new CArray<CPoint,CPoint>;
用指针pPointArray指向该数组,用于存储连接线的关键点。
连接线根据位置总共有三种线型,如下图所示:
(1)两个关键点的连接线:
图14
(2)4个关键点的连接线
图15
(3)5个关键点的连接线
图16
两个元件的指针连接:RealLink();
其代码如下:
void CMyView::RealLink()
{
//一定是输入连接输出 或 输出连接输入
if(startput==Input_1||startput==Input_2)
{
//输入连接输出
if(startput==Input_1)
{
pNodeStart->input1 =pNodeCurrent;
}
else
{
pNodeStart->input2 =pNodeCurrent;
}
pNodeCurrent->output1 =pNodeStart;
}
else//startput==Output_1
{
//输出连接输入
pNodeStart->output1 =pNodeCurrent;
if(currentput==Input_1)
{
pNodeCurrent->input1 =pNodeStart;
}
else
{
pNodeCurrent->input2 =pNodeStart;
}
}
}
指针连接只有两种情况:输入连接输出和输出连接输入。可以用下图来表示
输入端连接输出端
图17
输出端连接输入端
图18
元件库模块
代码如下:
UINT CMyView::gatefunction(MyNode *pNode)
{
UINT result;
switch(pNode->Subtype )
{
case ANDGate:
result=pNode->input1value & pNode->input2value ;
break;
case ORGate:
result=pNode->input1value | pNode->input2value ;
break;
case NOTGate:
result=pNode->input1value ;
result=1-result;
break;
case NORGate:
result=pNode->input1value | pNode->input2value ;
result=1-result;
break;
case NANDGate:
result=pNode->input1value & pNode->input2value ;
result=1-result;
break;
case XORGate:
result=pNode->input1value ^ pNode->input2value ;
}
return result;
}
这里pNode是指向当前元件的指针,根据当前元件的类型,及当前元件的输入端的值input1value和input2value(注:非门只有一个输入端)来返回元件的输出端的值。
各个门真值表如下表所示:
(1)与门
输入端1 输入端2 输出端
0 0 0
0 1 0
1 0 0
1 1 0
表1
(2)或门
输入端1 输入端2 输出端
0 0 0
0 1 1
1 0 1
1 1 1
表2
(3)非门
输入端 输出端
0 1
1 0
表3
(4)与非门
输入端1 输入端2 输出端
0 0 1
0 1 1
1 0 1
1 1 0
表4
(5)或非门
输入端1 输入端2 输出端
0 0 0
0 1 1
1 0 1
1 1 1
表5
(6)异或门
输入端1 输入端2 输出端
0 0 0
0 1 1
1 0 1
1 1 0
表6
计算结果(仿真)模块
仿真模块在整个仿真器中占有最重要的作用。
当在视图窗体上放置元件,连接元件后。接下工具栏开始按钮 开始计算结果,进行仿真。
其主要算法如图19
图19
代码如下:
void CMyView::OnBegin()
{
//开始计算,输出真值表
// TODO: Add your command handler code here
//判断是否能够连接
if(CalculateResult()==-1)
{
MessageBox("连接线路失败!请检查线路");
}
else
{
//可以连接
//调用函数计算
beginCalculate();
//生成对话框对象
CMyDialog MyDialog;
MyDialog.DoModal ();
}
}
其中判断线路是否正确调用了CalculateResult(),这是仿真中最重要的函数。它的返回值是最终输出结点的值。如果返回-1,说明线路有误。其具体的算法如图20:
CalculateResult()
图20
代码如下:
int CMyView::CalculateResult()
{
//用于从输入端开始计算输出端结果
//遍历所有输入结点
MyNode* pNode;
MyNode* pNodeNext;
POSITION pos=MyList.GetHeadPosition ();
while(pos!=0)
{
pNode=MyList.GetNext (pos);
//判断当前结点是否是输入结点
if(pNode->Subtype ==Input)
{
for(;;)
{
//判断当前的输入结点的输出端指向的结点是否为空
//如果为空,表示连接失败
if(pNode->output1 ==0)
{
//连接失败,返回-1
return -1;
}
//否则不为空
//输出到它指向结点的输入端
//此时要判断输入到哪个输入端:input1 OR input2;
pNodeNext=pNode->output1 ;
if(pNodeNext->input1 ==pNode)
{
//如果是输入到input1
pNodeNext->input1value =pNode->output1value ;
//输入的值++,如果到了2,就可以计算进位了
pNodeNext->inputs ++;
}
else
{
//如果是输入到input2
pNodeNext->input2value =pNode->output1value ;
pNodeNext->inputs ++;
}
//指针跳向下一个结点
pNode=pNodeNext;
//判断此时是否是输出结点,如果是返回输出结点的值input1value;
if(pNode->Subtype ==Output)
{
return pNode->input1value ;
}
//判断是否可以进位,对于非门,只要有一个输入值即可inputs==1
//对于其他门,要两个输入值inputs==2
if(pNode->Subtype==NOTGate)
{
//非门
if(pNode->inputs==1)
{
//可以进位
pNode->output1value =gatefunction(pNode);
}
else
{
//不能进位
break;//跳出for(;;)
}
}
else
{
//其他门
if(pNode->inputs ==2)
{
pNode->output1value =gatefunction(pNode);
}
else
{
//不能进位
break;//跳出for(;;)
}
}
//请空输入值个数inputs,以便下次计算
pNode->inputs =0;
}//for(;;)
}//判断当前结点是否是输入结点
}//while(pos!=0)
//遍历完后若没有返回,说明连接失败
return -1;
}
其算法主要思想是:遍历每一个输入结点,将输入结点的值送入到它所连接的元件的输入端,若此时该元件可以进位,则调用该元件进位函数gatefunction()计算该元件的输出端的值,再将该输出端的值送入它的下一个连接元件,再判断下一个元件能否进位,如此循环,直到输出结点。若此时不可以进位,则遍历下一个输入结点。
可以用下图来说明:
图21
假设此时输入结点遍历的顺序是1->2->3 (顺序不唯一)。假设此时1,2,3号输入结点取值0,1,0。首先将1号输入结点的值送入它所连接的或门的第一个输入端,即input1value=0。此时或门进位标志inputs= =1。于是不能进位。遍历下一个输入结点2,将2号1号输入结点的值送入它所连接的与门的第一个输入端,同样此时与门进位标志也为inputs= =1,不能进位。最后遍历到输入结点3,将值送入到与门的输入端2。由于此时有两个输入了,即与门进位标志inputs= =2,调用与门函数计算与门输出端output1value.然后将此值送入或门,同样或门进位标志inputs= =2,调用或门函数计算或门输出端值,最后送入输出结点,结束。
计算真值表:beginCalculate()
代码如下:
void CMyView::beginCalculate()
{
//计算输入结点的个数,输出真值表
n=numpoint.GetSize ();
//计算要进行循环的次数
int i;
x=1;
for(i=1;i<=n;i++)
{
x=x*2;
}
//动态生成x个字符串保存真值表
//用一个字符串格式化数据
CString str;
//用一个数组I[1]~I[n]记录每个输入结点值
UINT* I=new UINT[n+1];
//用数组J[1]~J[n]辅助计算
UINT* J=new UINT[n+1];
//初始化J[1]~J[n]
J[1]=1;
for(i=2;i<=n;i++)
{
J[i]=J[i-1]*2;
}
//进行x次循环,计算真值表
for(i=0;i<x;i++)
{
//增加数组元素:加入一个字符串
strs.Add (CString());
for(int k=1;k<=n;k++)
{
I[k]=i & J[k];
//向右移位
I[k]=I[k]>>(k-1);
//将输入端1~n的值加入字符串
str.Format ("%d ",I[k]);
//
//连接起来
strs[i]=strs[i]+str;
}
//给输入结点1~n初始化值
POSITION pos=MyList.GetHeadPosition ();
MyNode* pNode;
while(pos!=0)
{
pNode=MyList.GetNext (pos);
//如果结点是输入结点
if(pNode->Subtype ==Input)
{
//结点中的pNode->number 记录了结点序号
//给结点初始化值
pNode->output1value =I[pNode->number ];
}
}
//调用函数计算,将计算结果保存
int result=CalculateResult();
//生成字符串以便输出
str.Format ("%10d",result);
strs[i]+=str;
}
}
代码分析:
(1) 首先得到输入结点的个数:n=numpoint.GetSize ();
这里numpoint是记录输入结点前序号位置点的数组,而有多少个这样的点,就有多少个输入结点。
(2)然后计算真值表的行数,因为有n个输入结点,真值表就有2^n行。
x=1;
for(i=1;i<=n;i++)
{
x=x*2;
}
这里我们用x来保存真值表的行数。
(3)产生所有的输入结点值的组合。
如果有3个输入结点,它的所有组合如下表
输入3 输入2 输入1 i
0 0 0 0
0 0 1 1
0 1 0 2
0 1 1 3
1 0 0 4
1 0 1 5
1 1 0 6
1 1 1 7
我们可以从表的第四列看出可以用数字i从0到x-1来分解出这些组合。
例如:当i为2时,它在内存中最后3位为:010。
此时 输入3=010 & 100=000,再右移2位即可得到0。
于是我们可以得到:输入1 & 001 再右移0位
输入2 & 010 再右移1位
输入1 & 100 再右移2位
我们用一个数组J[1]~J[n]来记录相与的数字。为1,2,4,......,2^(n-1)
初始化J[1]~J[n]
J[1]=1;
for(i=2;i<=n;i++)
{
J[i]=J[i-1]*2;
}
用I[1]~I[n]记录输入1~输入n
产生一行输入值:
strs.Add (CString());
for(int k=1;k<=n;k++)
{
I[k]=i & J[k];
//向右移位
I[k]=I[k]>>(k-1);
//将输入端1~n的值加入字符串
str.Format ("%d ",I[k]);
//
//连接起来
strs[i]=strs[i]+str;
}
给输入结点1~n初始化值
POSITION pos=MyList.GetHeadPosition ();
MyNode* pNode;
while(pos!=0)
{
pNode=MyList.GetNext (pos);
//如果结点是输入结点
if(pNode->Subtype ==Input)
{
//结点中的pNode->number 记录了结点序号
//给结点初始化值
pNode->output1value =I[pNode->number ];
}
}
调用函数计算,将计算结果保存
int result=CalculateResult();
最后生成字符串以便输出
str.Format ("%10d",result);
strs[i]+=str;
完成以上操作后,生成一个对话框,然后将字符串数组strs[]加入到列表框内。最终输出整个真值表。
参考文献:
1 Electronics Workbench 5.0 1992-1996 Interactive Image Technologies Ltd
2 MSDN Libary July 2000 Microsoft
2008-11-16
用递归的方法画分形图
用递归的方法画分形图
用递归的方法画分形图
分形几何是数学领域里新兴的课题,如果将图形的每个元素按某种规则进行变形,得到新的图形,以此类推,进行若干次变形后得到的图形就是分形图形。Couch曲线是最典型的分形图形:
将一条线段按照图1进行变换,得到图1,再将图1中的每条线段按图1的折线变换得到图2,以此类推,进行6次变换就得到图6,如果进行无限次变换,就得到的是Couch曲线,Couch曲线的维数不是整数维,更多详情请见分形方面的书籍。
用分形图形能画图许多漂亮的图案而被广泛地应用,下面将几个简单的分形图形的代码与图形大家分享。
//Couch曲线的画法
void Couch(CDC *pDC,int x1,int y1,int x2,int y2,int n)
{
//pDC是画图的设备上下文的指针
//x1,y1,x2,y2是起始的两点
//其中参数n是递归的层数
int x3,y3,x4,y4,x5,y5;
//以下是根据空间几何计算出来的坐标
x3=x1+(x2-x1)/3;
y3=y1+(y2-y1)/3;
x4=x1+(x2-x1)*2/3;
y4=y1+(y2-y1)*2/3;
x5=x3+(x4-x3)/2+int(sqrt(3)*(y4-y3)/2);
y5=y3-int(sqrt(3)*(x4-x3)/2)+(y4-y3)/2;
//递归最后一层,递归的出口
if(n==1)
{
pDC->MoveTo(x1,y1);
pDC->LineTo(x3,y3);
pDC->LineTo(x5,y5);
pDC->LineTo(x4,y4);
pDC->LineTo(x2,y2);
}
else
{
//递归画图
Couch(pDC,x1,y1,x3,y3,n-1);
Couch(pDC,x3,y3,x5,y5,n-1);
Couch(pDC,x5,y5,x4,y4,n-1);
Couch(pDC,x4,y4,x2,y2,n-1);
}
}
//斯宾斯基篓垫的画法
void Floor(CDC *pDC,int x1, int y1,int x2,int y2,int x3,int y3,int n)
{
//pDC是画图的设备上下文的指针
//x1,y1,x2,y2,x3,y3是起始的三角形的三点坐标
//其中参数n是递归的层数
int x11,x22,x33,y11,y22,y33;
//以下是根据空间几何计算出来的坐标
x11=(x2+x3)/2;
y11=(y2+y3)/2;
x22=(x1+x3)/2;
y22=(y1+y3)/2;
x33=(x1+x2)/2;
y33=(y1+y2)/2;
pDC->MoveTo(x11,y11);
pDC->LineTo(x22,y22);
pDC->MoveTo(x11,y11);
pDC->LineTo(x33,y33);
pDC->MoveTo(x22,y22);
pDC->LineTo(x33,y33);
//递归最后一层,递归的出口
if(n==1)
{
pDC->MoveTo(x11,y11);
pDC->LineTo(x22,y22);
pDC->LineTo(x33,y33);
pDC->LineTo(x11,y11);
}
else
{
//递归画图
Floor(pDC,x1,y1,x33,y33,x22,y22,n-1);
Floor(pDC,x33,y33,x2,y2,x11,y11,n-1);
Floor(pDC,x22,y22,x11,y11,x3,y3,n-1);
}
}
//分形矩形的画法
void Rect(CDC *pDC,int x1,int y1,int x2,int y2,int n)
{
//pDC是画图的设备上下文的指针
//x1,y1,x2,y2是起始矩形坐标
//其中参数n是递归的层数
int x3,y3,x4,y4,x5,y5,x6,y6;
//以下是根据空间几何计算出来的坐标
x3=x1+(x2-x1)/3;
y3=y1+(y2-y1)/3;
x4=x1+(x2-x1)*2/3;
y4=y1+(y2-y1)*2/3;
x5=x3+(y4-y3);
y5=y3-(x4-x3);
x6=x4-(y3-y4);
y6=y4+(x3-x4);
pDC->MoveTo(x1,y1);
pDC->LineTo(x3,y3);
pDC->MoveTo(x4,y4);
pDC->LineTo(x2,y2);
//递归最后一层,递归的出口
if(n==1)
{
pDC->MoveTo(x1,y1);
pDC->LineTo(x3,y3);
pDC->LineTo(x5,y5);
pDC->LineTo(x6,y6);
pDC->LineTo(x4,y4);
}
else
{
//递归画图
Rect(pDC,x3,y3,x5,y5,n-1);
Rect(pDC,x5,y5,x6,y6,n-1);
Rect(pDC,x6,y6,x4,y4,n-1);
}
}
//分形树的画法,其中参数n是递归的层数
void Tree(CDC *pDC,int x1,int y1,int x2,int y2,int n)
{
//pDC是画图的设备上下文的指针
//x1,y1,x2,y2是起始矩形坐标
//其中参数n是递归的层数
int x3,y3,x4,y4,x5,y5;
//以下是根据空间几何计算出来的坐标
x3=x1+(x2-x1)/3;
y3=y1+(y2-y1)/3;
x4=x3+int((x1-x3)*cos(5*pi/6))-int((y1-y3)*sin(5*pi/6));
y4=y3+int((x1-x3)*sin(5*pi/6))+int((y1-y3)*cos(5*pi/6));
x5=x3+int((x1-x3)*cos(5*pi/6))+int((y1-y3)*sin(5*pi/6));
y5=y3-int((x1-x3)*sin(5*pi/6))+int((y1-y3)*cos(5*pi/6));
pDC->MoveTo(x1,y1);
pDC->LineTo(x2,y2);
//递归最后一层,递归的出口
if(n==1)
{
pDC->MoveTo(x3,y3);
pDC->LineTo(x4,y4);
pDC->MoveTo(x3,y3);
pDC->LineTo(x5,y5);
}
else
{
//递归画图
Tree(pDC,x3,y3,x2,y2,n-1);
Tree(pDC,x3,y3,x4,y4,n-1);
Tree(pDC,x3,y3,x5,y5,n-1);
}
}
上述的代码及图形附有Visual C++源代码,并在Windows XP和Visual C++6.0下调试成功。更多的分形图形及图形坐标空间几何的计算方法请与作者联系。
最新评论 [发表评论] [文章投稿]
查看所有评论 推荐给好友 打印
改成sqrt(3.0)就好了,vs的问题,参数多类型重载没自己识别出来 ( maxint 发表于 2008-9-4 21:27:00)
skinfeature界面产品特点介绍
SkinFeature完全支持各种常用控件及窗口 。对话框,单文档界面,多文档界面的全部支持。
完全支持PNG、TGA、bmp 图像格式。
支持皮肤(.rss)文件加密。保护美工图像不被别人非法使用,进一步保护自身知识产权。
支持从msstyle wba 等主题文件中自动转化为rss皮肤文件。
SkinFeature完全支持 VC,Delphi,C#,VB.Net,Visual Basic,C++ Bulider, PowerBuilder, Win32 SDK
Supported WTL, ATL, 第三方厂商SDK, OUTLOOK 等等界面换肤。
支持各Windows平台 Windows 9X/NT/2000/2003/XP/Vista
完全支持ANSI UNICODE 文字编码格式。
完全支持动态换肤(*.rss),支持不规则窗体,支持美工设计自定义界面生成方案。
完全多线程,自定义窗口类换肤支持。
内含15种专业皮肤(.rss)文件。
内含SkinDesigner 皮肤文件开发工具。
http://www.skinfeature.com
( skinfeature 发表于 2008-6-18 17:30:00)
change sqrt(3) to sqrt(3.0) ( Eric_wang 发表于 2007-10-30 9:59:00)
x5=x3+(x4-x3)/2+int(sqrt(3)*(y4-y3)/2);
y5=y3-int(sqrt(3)*(x4-x3)/2)+(y4-y3)/2;
运行是错误的啊?
错误 1 error C2668: 'sqrt' : ambiguous call to overloaded function d:\wordplay\c++\范例\fractral递归方法画分图形\stdafx.cpp 19
错误 2 fatal error C1903: unable to recover from previous error(s); stopping compilation d:\wordplay\c++\范例\fractral递归方法画分图形\stdafx.cpp 19
2008-11-16
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人