亚洲国产成人精品91久久久 ,色综合久久综合中文综合网,色综合久久88色综合天天

Android游戏计时

Bill Hsu — Sun, 30 Jan 2011 15:16:00 GMT

Read this post in english:http://androgeek.info/?p=299

以前代码�l�验很多都是��Z��windows的，所以对android下面的计时函��C��是太了解�?br>
在写Friut3D�Ӟ��我用的代码是用gettimeofday()来计时的。但是效果不好，游戏里有个场景跑��h��十分卡，acepig兄和我都觉得�q�个问题很诡异。开始觉得这是模型的问题�Q�现在看来是计时函数不精��惹得祸�?br>
看看当时写的获取�pȝ��旉��的代码：

static long getTime(void)

{
gettimeofday(&now, NULL);
return (long)(now.tv_sec*1000 + now.tv_usec/1000);
}

今天在一个google讨论�l�里得知gettimeofday()记得的tick是不准确的。而这个游戏逻辑依赖于time delta来计��各个物体运动，计时不精��，渲染自然会卡��ѝ�?br>
于是用纳�U��的准��度的clock_gettime()重写了getTime()函数�Q?br>

static long _getTime(void)

{
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return now.tv_sec*1000000 + now.tv_nsec/1000;

}

改了计时函数后，游戏各个场景都流畅了�?br>

Bill Hsu 2011-01-30 23:16 发表评论

Android NDK 开发OpenGL ES 2.0一些注意点

Bill Hsu — Tue, 10 Aug 2010 03:37:00 GMT

Android是个好系�l�哇�Q�特别是Android NDK r3出来以后�Q�可以用OpenGL ES 2.0了�?br>自己也试了试用NDK�~�一个OpenGL ES 2.0的程序，可是�Q�编译的时候出��C��一大堆错�?br>
如图�Q�满屏幕都是 undefined reference to 那些OpenGL ES函数�?br>看来是库文�g没有链接�q�来�?br>
�q�是NDK例子里的Android.mk的写法：

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := libgl2jni
LOCAL_CFLAGS    := -Werror
LOCAL_SRC_FILES := gl_code.cpp
LOCAL_LDLIBS    := -llog -lGLESv2

include $(BUILD_SHARED_LIBRARY)

问题��出在用�U�色标出的那行�?br>
把那句修改�ؓ�Q?br>

LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog
LOCAL_LDLIBS+=-L$(SYSROOT)/usr/lib -lGLESv2

��可以正常编译了�?br>
�q�有一些注意点是：
�~�译�E�序前要clean�Q�否则编译会出错�Q?br>每次更新了自��q��.so文�g后，在eclipse的那个java��目里要记着refresh一下�?br>

Bill Hsu 2010-08-10 11:37 发表评论

靠得住的休眠函数XSleep

Bill Hsu — Fri, 30 Jul 2010 02:55:00 GMT

直接用timeGetTime()�q�个函数的误差是有目��q��的，�?5ms左右�Q�于是，如果游戏的消息��@环用了timeGetTime()�Q�那�?D游戏画面会因��Z��帧之间时间误差大而有些抖动�?br>今天在csdn上看��C��一��文章：http://blog.csdn.net/lanzhengpeng2/archive/2008/05/06/2401554.aspx
讲的也正好是�q�个问题�Q�记录一下�?br>
在��用timeGetTime()的代码块的前后加�?span class="Apple-style-span" style="border-collapse: separate; color: #000000; font-family: Simsun; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; line-height: normal; orphans: 2; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; font-size: medium;">timeBeginPeriod(1)�?/span>timeEndPeriod(1)�Q�就可以提高timeGetTime()的精度�?br>
同时�Q�可以利用timeSetEvent写了一个靠得住的休眠函数[代码来自上述文章]�Q?br>

static void XSleep(DWORD dwDelay,HANDLE hEvent)
{
  MMRESULT hTimer = timeSetEvent(dwDelay,1,(LPTIMECALLBACK)hEvent,0,TIME_ONESHOT | TIME_CALLBACK_EVENT_SET);
  MsgWaitForMultipleObjectsEx(1,&hEvent,INFINITE,QS_ALLINPUT,0); //当有Windows消息�Ӟ��q�能�l�箋处理Windows消息。故选择了这个函数�?/span>
  timeKillEvent(hTimer);
}

消息循环[代码来自上述文章]�Q?br>

MSG msg;
DWORD dwLastTime;
HANDLE hSleepEvent = CreateEvent(NULL,FALSE,FALSE,NULL);

timeBeginPeriod(1);

dwLastTime = timeGetTime();
while(isActive())
{
  //需要一直处理Windows消息到无消息处理为止
  for(;PeekMessage(&msg,NULL,0,0,PM_REMOVE);)
  {
   if(msg.message == WM_QUIT)
   {
    CloseHandle(hSleepEvent);
    timeEndPeriod(1);
    return ;
   }
   if(!TranslateAccelerator(msg.hwnd,hAccelTable,&msg))
   {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
   }
  }

  DWORD FrameDelay = max(1,1000/max(1,GetMaxFPS()));
  DWORD dwTime = timeGetTime();
  if(dwLastTime + FrameDelay > dwTime)
  {
   XSleep(dwLastTime + FrameDelay - dwTime,hSleepEvent);
  }
  else
  {
   update();
   dwLastTime += ((dwTime - dwLastTime) / FrameDelay) * FrameDelay; //当实际��C��重低于预期��数时�Q�这�D�代码可以完成蟩帧功能；当实际��数大于等于预期��数时�Q�这�D�代码仍然可以��帧之间的旉��间隔固定。之前谢Boss没有处理好的主要��是�q�个�?/span>
  }
}

CloseHandle(hSleepEvent);
timeEndPeriod(1);

�q�样�Q�时间误差就会在1ms之内了，游戏也就不会抖动了�?br>

Bill Hsu 2010-07-30 10:55 发表评论

Bill Hsu — Sat, 27 Mar 2010 10:37:00 GMT

感觉fstream有些地方设计的不太合理，不知道是bug�q�是那些牛X们故意这��L��?br />
首先�Q�fstream竟然在中文�\径这�U�东西上不支持，�|�上也可以看到许多实现方法，但有的方法其实�ƈ不是太好�?br />我觉得这样做最��单：

setlocale(LC_ALL,"");//讄��成当前语�a�环境
ofstream out(filename);//打开文�g
setlocale(LC_CTYPE, 0);

�q�有�Q�fstream的getline也有问题�Q�对于那些\n \r �I�� 什么的都没考虑�Q�用��h��会出错�?br />在网上看��C��个函数可以完��解册��个问题：

bool readline(ifstream& infile, string& textline)
{

while(getline(infile, textline, '\n'))
{
  int prev_pos = 0; //最开始有效字�W�位�|?
  int post_pos = 0; //最后有效字�W�位�|?br />  //下面的��@环语句能够用textline.find_first_not_of(filter,pos)来处�?��Z��效率考虑本处使用�q�样的算�?/span>
  while(textline[prev_pos] == ' ' || textline[prev_pos] == '\t' || textline[prev_pos] == '\r')//�q��o开始空�?/span>
   prev_pos++;
  if(textline[prev_pos] == '\0')
   continue;//假如是空白行则再��M��行进行处�?
  else
  {
       post_pos=textline.length()-1;
       while(textline[post_pos] == ' ' || textline[post_pos] == '\t' || textline[post_pos] == '\r')//�q��o最后的�I�白
             {
                  post_pos--;
             }
       textline=textline.substr(prev_pos,post_pos+1-prev_pos);
   return true;//成功��d��一有效�?/span>
  }

}
return false;//��d��文��的末��?/span>
}

我根据上面这个函�?重蝲了一个char* 版的�Q?br />

bool readline(ifstream& infile, char* textline)
{
while(infile.getline(textline,32))
{
  int prev_pos = 0; //最开始有效字�W�位�|?/span>
  int post_pos = 0; //最后有效字�W�位�|?
  string str=textline;
  //下面的��@环语句能够用textline.find_first_not_of(filter,pos)来处�?��Z��效率考虑本处使用�q�样的算�?/span>
  while(str[prev_pos] == ' ' || str[prev_pos] == '\t' || str[prev_pos] == '\r')//�q��o开始空�?/span>
   prev_pos++;
  if(str[prev_pos] == '\0')
   continue;//假如是空白行则再��M��行进行处�?/span>
  else
  {
         post_pos=str.length()-1;
         while(str[post_pos] == ' ' || str[post_pos] == '\t' || str[post_pos] == '\r')//�q��o最后的�I�白
         {
               post_pos--;
         }
         string str2=str.substr(prev_pos,post_pos+1-prev_pos);
         strcpy(textline,str2.c_str());

   return true;//成功��d��一有效�?/span>
  }
}
return false;//��d��文��的末��?/span>
}

Bill Hsu 2010-03-27 18:37 发表评论

GPU水面模拟

Bill Hsu — Tue, 23 Mar 2010 12:59:00 GMT

先上个自己实现的水面模拟图：

效果比较��单，只是模拟了下水面的反��效果。折��与Fresnel�p�L��没有考虑�?br />
水面模拟大致需要分�q�么几步�Q?br />1.剪裁掉水面以下的��点[gpu里的clipplane要注意�{换到Clip Space]�Q?br />��摄像机攑ֈ�同原摄像机关于水面对�U�的位置�Q�比如原来摄像机�?x,y,z)�Q?br />此时��p��把摄像机攑֜�(x,-y,z)�Q�up向量也要讄��成向下的�?br />再把场景渲染到Render Target的纹理上(我用的纹理大��是256*256)�Q�不知道��Z��么Render Target的纹理大��不能超�q�窗口大��，��过的话渲染会出错，知道的大大告诉我一下哈�?br />
于是�Q�就得到了这样一个纹理：

2.��上面得到的�U�理与水面的��点对应.
把Vertex Shader中乘�q�变换矩阵后的坐标传到Pixel Shader,
在PS中计��?br />

        float2 clipspace = input.Coord.xy / input.Coord.w;
        clipspace.x=((clipspace.x * 0.5f) + 0.5f);
        clipspace.y = ((clipspace.y * -0.5f) + 0.5f);
        clipspace.x=1-clipspace.x;

既可以让水面��点与纹理对应，然后再想办法把纹理坐标扰乱来模拟水面波动�?br />
3.再渲染一�ơ场景就可以了�?br />
大家也可以参考下Azure的水面渲染源代码�Q?a temp_href=" http://www.azure.com.cn/article.asp?id=186" href="%20http://www.azure.com.cn/article.asp?id=186">
http://www.azure.com.cn/article.asp?id=186

Bill Hsu 2010-03-23 20:59 发表评论

Bill Hsu — Wed, 20 Jan 2010 14:00:00 GMT

剪裁�q�面 (Clip Plane) 在图形学领域有着重要的作用，比如水面模拟中，渲染折射�U�理�Ӟ��我们��必��d��水面以上的顶炚w��过剪裁�q�面剪裁掉�?/span>

在过�ȝ��固定渲染��道时代�Q�剪裁��^面的实现较�ؓ��单，比如�?/span> DirectX 9 中，可以先设定剪裁��^面在世界坐标�p�M��的方�E?/span> (ax+by+cz+d=0) �Q�再调用 SetClipPlane(DWORD Index,CONST float * pPlane) �q�个 API 函数��可以了�?/span>

附上例子�E�序�Q?/span>

vPosition=D3DXVECTOR3(0,0,0); // �q�面上一个点
vNormal=D3DXVECTOR3(0,1,0); // 法向�?span>
D3DXPlaneFromPointNormal( &clipplane, &vPosition, &vNormal ); // 生成剪裁�q�面

m_pDevice()->SetClipPlane( 0, ( float *)clipplane);

然而，在现在的可编�E�管�?/span> (programmable pipeline) 下，讄��的剪裁��^面会被在剪裁坐标�p�M��处理�Q�而不是在世界坐标�p�M��?/span>

解决�q�个问题的方法有�Q?br />
1�Q��?�l�要剪裁的顶点做标记�Q�在Pixel Shader中把它剪裁掉�?br />
2�Q��?使用�q�斜�q�面裁剪�Q�Oblique Near-Plane Clipping�Q�，即修�Ҏ��q��阵，��要剪裁的顶�Ҏ��在视截体之外�Q�从而避免了该顶点的�l�制�?br />
3�Q��?修改�q�面方程�Q��之从世界坐标�p��{换到剪裁坐标�p�R�?span>

上述�Ҏ��中，�W�一�U�和�W�二�U�效率�ƈ不高�Q�在Pixel Shader中剪裁没有减��Q何不必要的顶点处理，而计��近斜��^面裁剪矩阵较为繁琐。所以，�Ҏ��三是最佳选择�?/span>

要将一个��^面从世界坐标�p��{换到剪裁坐标�p�，必须求出�q�个变换矩阵�?/span>

讑��^面方�E?/span>ax+by+cz+d=0�Q�用一�?/span>4�l�向量来n表示(a,b,c,d)�Q�设�q�面上有个点p:(x,y,z,1)。根据��^面方�E�的定义�Q�有�Q?/span>

n^Tp = ax + by + cz + d = 0

讄��?/span>R可以让点P从世界坐标系转换到剪裁坐标系�Q�矩�?/span>Q可以让��^�?/span>n实现同样的变换。那么，有：

p'= Rp

n'= Qn

其中p'�?/span>n'分别是�{换后的点与��^面�?/span>

n'^Tp'= 0

(Qn)^T (Rp) = 0
n^TQ^TRp = 0

如果�Q?/span>Q^TR = I

那么�Q?/span>

n^TQ^TRp = n^TIp = n^Tp = 0

于是�Q?/span>

Q^T = R^-1
Q = (R^-1)^T

�?/span>DirectX 3D中，��一个点从世界坐标系转换到剪裁坐标系�Q�所用的矩阵��察矩阵与投媄矩阵的乘�U�，卻I��

D3DXMATRIX TranMatrix = matView*matProj;

(TranMatrix为所求的变换矩阵�Q?span>matView�?span>matProj分别�?/span>观察矩阵与投��q��?/span>)

附上�?/span>D3D中变换的完整代码�Q?/span>

D3DXPLANE tempPlane = clipplane;
D3DXPlaneNormalize(&tempPlane, &tempPlane);

D3DXMATRIX TranMatrix = matView*matProj;
D3DXMatrixInverse(&TranMatrix, NULL, &TranMatrix);
D3DXMatrixTranspose(&TranMatrix, &TranMatrix);
D3DXPlaneTransform(&tempPlane, &tempPlane, &TranMatrix);

参考资料：

1.Back Face Culling Notes ,Jordan Smith (University of California, Berkeley)

http://www.cs.berkeley.edu/~ug/slide/pipeline/assignments/backfacecull.shtml

2.GameDev Forum

http://www.gamedev.net/community/forums/topic.asp?topic_id=402381

3.Oblique Near-Plane Clipping with Orthographic Camera ,Aras

http://aras-p.info/texts/obliqueortho.html

Bill Hsu 2010-01-20 22:00 发表评论

Bill Hsu — Fri, 11 Dec 2009 14:23:00 GMT

摘要: 感觉�U�性代��C��业里一直少不了矩阵求逆，

写个带输出算逆矩�늚�步骤的矩阉|��逆程序，希望�l�即��或正在学线代的同学一�Ҏ��ѝ�?nbsp; 阅读全文

Bill Hsu 2009-12-11 22:23 发表评论

发日志纪念~~�W�一�ơ写导出插�g

Bill Hsu — Wed, 25 Nov 2009 11:25:00 GMT

今天�l�于把模型导出插件最基本的功�?-导出�|�格�l�写好了�?/p>

c++和max sdk一��L��的感觉很怪，�pȝ��崩溃了N�ơ，不过�Q��ȝ��能导出网��g��~

有图有真相，截图�U�念

(注意�Q�模型是从value的csol中弄出来�?

在d3d中渲染导出的模型�B

我的模型导出插�g�B

导出数据��h��Q?/p>

[�q�是一个带贴图的立方体的导出数据]

8//　　8个顶�?br /> -6.70302 -21.2068 -5.46039
17.1883 -6.46757 0.162097
-22.4049 2.22378 -0.162097
1.48644 16.963 5.46039
-8.48039 -28.3257 20.7542
15.411 -13.5865 26.3767
-24.1823 -4.89514 26.0525
-0.290929 9.84411 31.675

12//　　12个纹理坐�?br /> 0 1 0
1 1 0
0 0 0
1 0 0
0 1 0
1 1 0
0 0 0
1 0 0
0 1 0
1 1 0
0 0 0
1 0 0

12//　　12个面引烦
0 9 2 11 3 10
3 10 1 8 0 9
4 8 5 9 7 11
7 11 6 10 4 8
0 4 1 5 5 7
5 7 4 6 0 4
1 0 3 1 7 3
7 3 5 2 1 0
3 4 2 5 6 7
6 7 7 6 3 4
2 0 0 1 4 3
4 3 6 2 2 0

Bill Hsu 2009-11-25 19:25 发表评论

Bill Hsu — Sat, 17 Oct 2009 05:10:00 GMT

低手交流�Q�高手勿�?br />
当初觉得DX中设备丢失很讨厌�Q�差点就投奔OpenGL了�?br /> 不过现在发现其实也没那么�ȝ��啦，写点东西�Q�给不清�?/font> 讑֤�丢失怎么处理的同学参考下�?br />
在创建时使用D3DPOOL_MANAGED标志的资源可以不需要重新蝲入，但D3DPOOL_DEFAULT加蝲的资源就需要先释放�Q�后重徏�?br />
通常需要这样处理的有ID3DXFont和ID3DXSprite�Q��?X模型什么的��׃��需要�?br />在发现设备丢失时�Q�我们要调用 OnLostDevice(void)函数让D3DPOOL_DEFAULT加蝲的资源释放掉�?br />好在ID3DXFont和ID3DXSprite有设备丢失处理函敎ͼ�直接调用��好�?div style="border: 1px solid rgb(204, 204, 204); padding: 4px 5px 4px 4px; background-color: rgb(238, 238, 238); font-size: 13px; width: 98%;">void OnLostDevice(void)
{
m_sprite->OnLostDevice();
m_font->OnLostDevice();
}

可是�Q�怎么知道讑֤�丢失了呢�Q?br />如果讑֤�丢失�Q�Present()函数��׃��“出问题”，�q�回值是D3DERR_DEVICELOST�?br />

m_pIDirect3DDevice->EndScene();

HRESULT hr;
hr = m_pIDirect3DDevice->Present(NULL, NULL, NULL, NULL);
if(hr == D3DERR_DEVICELOST)
{
    if(m_pIDirect3DDevice->TestCooperativeLevel() == D3DERR_DEVICENOTRESET)
    {
        OnLostDevice();
        OnResetDevice();
    }
}

TestCooperativeLevel()== D3DERR_DEVICENOTRESET�Ӟ��可以恢复设备了�?br />于是�Q�我们调�?/span>OnLostDevice()让D3DPOOL_DEFAULT加蝲的资源释放掉�Q�之后，调用OnResetDevice()来恢复设备就可以了�?br />
怎么恢复讑֤�呢？

void OnResetDevice(void)
{
    if(FAILED(m_pIDirect3DDevice->Reset(&d3dpp)))
    {
        return;
    }

    m_sprite->OnResetDevice();
    m_font->OnResetDevice();

    InitDevice();
}

先让D3D讑֤�reset�Q�然后调�?/span>ID3DXFont和ID3DXSprite的恢复函敎ͼ�最后，需要把D3D讑֤�中的状态啊�Q�矩阵变换啊�q�些重新讄��下就完成了，也就是调�?/span>InitDevice()�?br />

void InitDevice()
{
m_pIDirect3DDevice->SetRenderState( D3DRS_ZENABLE, TRUE );

m_pIDirect3DDevice->SetRenderState( D3DRS_AMBIENT, 0xffffffff );

m_pIDirect3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
m_pIDirect3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
m_pIDirect3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);

D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, 1.0f, 1.0f, 1000.0f );
m_pIDirect3DDevice->SetTransform( D3DTS_PROJECTION, &matProj );

vEyeVec=D3DXVECTOR3(0.0f,0.0f,-1.0f);
vLookatVec=D3DXVECTOR3(0.0f,0.0f,0.0f);
vUpVec=D3DXVECTOR3(0.0f,1.0f,0.0f);
D3DXMatrixLookAtLH( &matView, &vEyeVec, &vLookatVec, &vUpVec );
m_pIDirect3DDevice->SetTransform( D3DTS_VIEW, &matView );

}

啊，�q�样讑֤�丢失��处理好�?br />
//
tag:DirectX 3D d3d lost device TestCooperativeLevel OnLostDevice 恢复讑֤� 讑֤�丢失 DeviceLost

Bill Hsu 2009-10-17 13:10 发表评论

自己写的Rap3d 引擎开源发布啦

Bill Hsu — Sat, 25 Jul 2009 07:00:00 GMT

Rap3d是自己写的一个轻量��3D引擎�Q�自��p��得比较好用�?br />我在sourceforge上申请了开源项目，在那里可以下载到Rap3d SDK.
http://rap3d.sf.net/

Rap3d SDK 中有引擎的��用说明和几个例子�Q�上手很快的�?br />

What Rap3d can do?

1.Display 3d models

2.Bill Board,Sprite,Animation..

3.Music playing

4.Draw text on screen

http://rap3d.sf.net/

Bill Hsu 2009-07-25 15:00 发表评论

Rap3d更新

Bill Hsu — Tue, 23 Jun 2009 02:12:00 GMT

增加�?TextureManager�?
BillBoard动画播放,方便渲染爆炸效果

Bill Hsu 2009-06-23 10:12 发表评论

游戏中CPU使用率的控制

Bill Hsu — Fri, 12 Jun 2009 04:00:00 GMT

通常情况下，如果不处理下�Q�再��的游戏也会让CPU使用�?00%.
应该用Sleep(1)把多余的片段�q�给CPU,
像这��P��

while(true)
{
DWORD start_time = GetTickCount();
if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
if (msg.message == WM_QUIT) break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
update(float(GetTickCount() - start_time));
while((GetTickCount() - start_time) < 30) Sleep(1);
}

update(float timeDelta)是游戏逻辑与画面更新的函数�?br />效果图：

Bill Hsu 2009-06-12 12:00 发表评论

3D引擎计划

Bill Hsu — Wed, 10 Jun 2009 13:15:00 GMT

暑假了，打算写一�?D游戏引擎�?br /> 其实也就是把一些类��装一下，让开发更��l�，以开源和实用为第一准则�?br />

Bill Hsu 2009-06-10 21:15 发表评论

用GDI实现3D

Bill Hsu — Sat, 27 Dec 2008 09:18:00 GMT

在CSDN上看��C��一个很强大的程序：用GDI实现3D,可以变换视角的查�?x文�g�?br />
不过��x��看，好像实现��h��也�ƈ不难。。�?br />和所有基��?D�E�序一��P��先把视椎变换为单位立方体�Q?br />
变换矩阵为：

当然�Q�DirectX和OpenGL里都有现成的函数�Q?br />

//OpenGL
void gluPerspective(GLdouble fovy,
    GLdouble aspect,
    GLdouble zNear,
    GLdouble zFar);

//DirectX
D3DXMatrixPerspectiveFovLH( D3DXMATRIX *pOut,
    FLOAT fovY,
    FLOAT Aspect,
    FLOAT zn,
    FLOAT zf
);

单位立方体中的点正交投媄得到�?x,y,z)*视口变换矩阵得到 (x',y',z')�?br />(x',y')对应屏幕点，z'为其深度�Q�用于点的竞争�?br />把每个三角面匚w��U�理用GDI基本函数��d��来就可以了�?br />

CSDN的那个程�?br />

Bill Hsu 2008-12-27 17:18 发表评论

A* (A-star A�?寻�\��法

Bill Hsu — Sat, 01 Nov 2008 10:19:00 GMT

A*在游戏寻路算法里使用很广�Q�可是感觉很多介�l�它的文章故意让人看不懂�?br />仔细看了看gamedev.net的一片文�?A* Pathfinding for Beginners http://www.gamedev.net/reference/articles/article2003.asp )�Q�对A*更了解了一点，写点东西记录一下�?br />A*是一�U�启发式的算法，所谓的"启发�?�Q�就是对每一个搜索的位置�q�行评估�Q�也��是把找的位�|�离目标的距��d��成找点的一个依据，然后猜测�q�个�Ҏ��否最�?"启发�?��是猜测)�?br />

��Z��扑ֈ�最佳的那个�?br />可以规定�Q?br />G = 从�v点，沿着产生的�\径，�U�d��到网��g��指定�Ҏ��的距��R�?br />H = 从网��g��那个�Ҏ��U�d��到终点B的预估移动距��R�?br />
F = G + H
F最��的点可以认为是该选的炏V�?br />

引用一下原文的��译�Q?br />我们令水�q�x��者垂直移动的耗费�?0�Q�对角线方向耗费�?4。我们取�q�些值是因�ؓ沿对角线的距��L��沿水�q�x��垂直�U�d��耗费的的根号2�Q�别怕）�Q�或者约1.414倍。�ؓ了简化，我们�?0�?4�q�似。比例基本正��，同时我们避免了求根运��和��数�?br />

既然我们在计��沿特定路径通往某个�Ҏ��的G��|��求值的�Ҏ��是取它父节点的G��|��然后依照它相对父节点是对角线方向或者直角方�?非对角线)�Q�分别增�?4�?0。例子中�q�个�Ҏ��的需求会变得更多�Q�因为我们从��L��Ҏ��以外获取了不止一个方根{�?br />
H值可以用不同的方法估��。我们这里��用的�Ҏ��被称为曼哈顿�Ҏ��Q�它计算从当前格到目的格之间水��^和垂直的�Ҏ��的数量��d��Q�忽略对角线方向。然后把�l�果乘以10。这被成为曼哈顿�Ҏ��是因为它看�v来像计算城市中从一个地方到另外一个地方的街区敎ͼ�在那里你不能沿对角线方向�I�过街区。很重要的一点，我们忽略了一切障��物。这是对剩余距离的一个估��，而非实际��|��q�也是这一�Ҏ��被称为启发式的原因。想知道更多�Q�你可以在这里找到方�E�和额外的注解�?br />

�W�一步搜索的�l�果可以在下面的图表中看到。F,G和H的评分被写在每个�Ҏ��里。正如在紧挨起始格右侧的�Ҏ��所表示的，F被打印在左上角，G在左下角�Q�H则在右下角�?/span>

引用一下原文的��译�Q?/span>

我们做如下操作开始搜索：
1�Q�从点A开始，�q�且把它作�ؓ待处理点存入一个“开启列表”。开启列表就像一张购物清单。尽��现在列表里只有一个元素，但以后就会多��h��。你的�\径可能会通过它包含的�Ҏ��Q�也可能不会。基本上�Q�这是一个待��查方格的列表�?br /> 2�Q�寻找�v点周围所有可到达或者可通过的方��|��跌��有墙�Q�水�Q�或其他无法通过地�Ş的方根{��也把他们加入开启列表。�ؓ所有这些方��g��存点A作�ؓ“父�Ҏ��”。当我们��x��q��\径的时候，父方格的资料是十分重要的。后面会解释它的具体用途�?br /> 3�Q�从开启列表中删除点A�Q�把它加入到一个“关闭列表”，列表中保存所有不需要再�ơ检查的�Ҏ��?br />
��Z��l�箋搜烦�Q�我们简单的从开启列表中选择F值最低的�Ҏ��。然后，寚w��中的方格做如下处理�Q?br />
4�Q�把它从开启列表中删除�Q�然后添加到关闭列表中�?br /> 5�Q�检查所有相��L��子。蟩�q�那些已�l�在关闭列表中的或者不可通过�?有墙�Q�水的地形，或者其他无法通过的地�?�Q�把他们��d��q�开启列表，如果他们�q�不在里面的话。把选中的方��g��为新的方格的父节炏V�?br /> 6�Q�如果某个相��L��已经在开启列表里了，��查现在的�q�条路径是否更好。换句话��_��查如果我们用新的路径到达它的话，G值是否会更低一些。如果不是，那就什么都不做�?br /> 另一斚w��Q�如果新的G值更低，那就把相��L��格的父节�Ҏ��为目前选中的方��|��在上面的图表中，把箭头的方向改�ؓ指向�q�个�Ҏ��Q�。最后，重新计算F和G的倹{��如果这看�v来不够清晎ͼ�你可以看下面的图�C��?/span>

�q�样��可以找到最佌��\径了�?br />

Bill Hsu 2008-11-01 18:19 发表评论

游戏框架

Bill Hsu — Sat, 18 Oct 2008 09:46:00 GMT

如果不用框架�Q�开始开发的速度可能有优势，但一旦代码过多，一切就乱大了。。�?br />可以把图形渲染，逻辑处理�Q�网�l�联机等都做成差不多的模块，然后加到框架�Q�这样好��理一炏V�?br />

class CFramework
{
public:
CFramework();
~CFramework();
void init();
void update();
void Shutdown();
void add(Module *module);//加入模块
};

Module 是一个纯虚函数类

class Module
{
public:
virtual void init();
virtual void update(float dt);
};

囑�Ş渲染�Q�逻辑处理�Q�网�l�联机模块就可以�q�行了�?img src ="http://www.shnenglu.com/billhsu/aggbug/64311.html" width = "1" height = "1" />

Bill Hsu 2008-10-18 17:46 发表评论

Bill Hsu — Fri, 10 Oct 2008 09:36:00 GMT

在gameres上看见一个问题帖�Q?br />

什么时候该用 Object object;

什么时候该用 Object *object;
object=new Object();

感觉看�v来没什么区别，其实不一��P��前一个是栈对象，后一个是堆对象�?br />
引用一下别人对栈对象、堆对象的解释：

　　栈对象的优势是在适当的时候自动生成，又在适当的时候自动销毁，不需要程序员操心�Q�而且栈对象的创徏速度一般较堆对象快�Q�因为分配堆对象�Ӟ��会调用�?/span>operator new操作�Q?/span>operator new会采用某�U�内存空间搜索算法，而该搜烦�q�程可能是很�Ҏ��间的�Q��生栈对象则没有这么麻烦，它仅仅需要移动栈��指针就可以了。但是要注意的是�Q�通常栈空间容量比较小�Q�一般是1MB�?MB�Q�所以体�U�比较大的对象不适合在栈中分配。特别要注意递归函数中最好不要��用栈对象�Q�因为随着递归调用深度的增加，所需的栈�I�间也会�U�性增加，当所需栈空间不够时�Q�便会导致栈溢出�Q�这样就会��生运行时错误�?br />
　　堆对象，其��生时��d��销毁时刻都要程序员�_��定义�Q�也��是��_��E�序员对堆对象的生命��h��完全的控制权。我们常帔R��要这��L��对象�Q�比如，我们需要创��Z��个对象，能够被多个函数所讉K��Q�但是又不想使其成�ؓ全局的，那么�q�个时候创��Z��个堆对象无疑是良好的选择�Q�然后在各个函数之间传递这个堆对象的指针，便可以实现对该对象的�׃�n。另外，相比于栈�I�间�Q�堆的容量要大得多。实际上�Q�当物理内存不够�Ӟ��如果�q�时�q�需要生成新的堆对象�Q�通常不会产生�q�行旉��误，而是�pȝ��会��用虚拟内存来扩展实际的物理内存�?/span>

所�?br />当你知道你要使用的类型拥有准��数量时使用 Object object;
当你不知道你要创建的�c�d��有多��个时��?Object *object;
object=new Object();

Bill Hsu 2008-10-10 17:36 发表评论

Bill Hsu — Tue, 30 Sep 2008 11:34:00 GMT

四元数常常可以在3D的书上看到�?br />但我的那�?D囑�Ş学书上，在没讲四元数是干什么的之前�Q�就列了几张�U�的公式�Q?br />大概因�ؓ自己�q�在上高中，不知道的太多�Q�看了半天没看懂。。�?br />�l�于�Q�在gameres上看��C��某强人翻译的一个�?元数宝典 ”（原文是日本�h写的。。。）�Q�感觉很好，分��n下�?br />

★旋转篇�Q?br />　我将说明使用了四元数�Q�si yuan shu, quaternion�Q�的旋�{的操作步�?br />�Q?/span>�Q?/span>�Q�四元数的虚部，实部和写�?br />所谓四元数�Q�就是把4个实数组合�v来的东西�?br />4个元素中�Q�一个是实部�Q�其�?个是虚部�?br />比如�Q�叫做Q的四元数�Q�实部t而虚部是x,y,z构成�Q�则像下面这样写�?br />Q = (t; x, y, z)
又，使用向量 V=(x,y,z)�Q?br />Q = (t; V)
也可以这么写�?br />
正规地用虚数单位i,j,k的写法的话，
Q = t + xi + yj + zk
也这样写�Q�不�q�，我不大��?br />
�Q?/span>�Q?/span>�Q�四元数之间的乘�?br />虚数单位之间的乘法�?br />ii = -1, ij = -ji = k (其他的组合也是��@环地以下同文)
有这么一�U�规则。（我总觉得，�q�就像是向量�U�（外积�Q�，对吧�Q��?br />用这个规则一点点地计��很�ȝ��Q�所以请用像下面�q�样的公式计��?br />
A = (a; U)
B = (b; V)
AB = (ab - U·V; aV + bU + U×V)
不过�Q�“U·V”是内积�Q�「U×V」是外积的意思�?br />注意�Q�一般AB<>BA所以乘法的左右要注意！

�Q?/span>3�Q?�ơ元的坐标的四元数表�C?br />如要��某坐标(x,y,z)用四元数表示�Q?br />P = (0; x, y, z)
则要�q�么写�?br />
另外�Q�即使实部是零以外的��|��下文的结果也一栗��用零的话省事所以我推荐�?br />
�Q?/span>�Q?/span>�Q�旋转的四元数表�C?br />以原点�ؓ旋�{中心�Q�旋转的轴是(��, β, ��)
�Q�但 ��^2 + β^2 + ��^2 = 1�Q�，
�Q�右手系的坐标定义的话，望向向量(��, β, ��)的前�q�方向反旉��圎ͼ�
转θ角的旋转，用四元数表示��是�Q?br />Q = (cos(θ/2); �� sin(θ/2), β sin(θ/2), �� sin(θ/2))
R = (cos(θ/2); -�� sin(θ/2), -β sin(θ/2), -�� sin(θ/2))
(另外R 叫 Q 的共轭四元数。）

那么�Q�如要实行旋转，
则�?font color="#ff6600">R P Q = (0; �{�案)

请像�q�样三明��d��地计��。这个值的虚部��是旋�{之后的点的坐标倹{�?br /> �Q�另外，实部应该为零。请验算看看�Q��?/span>

例子代码

/// Quaternion.cpp
/// (C) Toru Nakata, toru-nakata@aist.go.jp
/// 2004 Dec 29

#include <math.h>
#include <iostream.h>

/// Define Data type
typedef struct
{
              double t; // real-component
              double x; // x-component
              double y; // y-component
              double z; // z-component
} quaternion;


//// Bill 注：Kakezan 在日语里�?“乘法”的意�?/b>
quaternion Kakezan(quaternion left, quaternion right)
{
              quaternion ans;
              double d1, d2, d3, d4;

              d1 =  left.t * right.t;
              d2 = -left.x * right.x;
              d3 = -left.y * right.y;
              d4 = -left.z * right.z;
              ans.t = d1+ d2+ d3+ d4;

              d1 =  left.t * right.x;
              d2 =  right.t * left.x;
              d3 =  left.y * right.z;
              d4 = -left.z * right.y;
              ans.x =  d1+ d2+ d3+ d4;

              d1 =  left.t * right.y;
              d2 =  right.t * left.y;
              d3 =  left.z * right.x;
              d4 = -left.x * right.z;
              ans.y =  d1+ d2+ d3+ d4;

              d1 =  left.t * right.z;
              d2 =  right.t * left.z;
              d3 =  left.x * right.y;
              d4 = -left.y * right.x;
              ans.z =  d1+ d2+ d3+ d4;

              return ans;
}

//// Make Rotational quaternion
quaternion MakeRotationalQuaternion(double radian, double AxisX, double AxisY, double AxisZ)
{
              quaternion ans;
              double norm;
              double ccc, sss;

              ans.t = ans.x = ans.y = ans.z = 0.0;

              norm = AxisX *  AxisX +  AxisY *  AxisY +  AxisZ *  AxisZ;
              if(norm <= 0.0) return ans;

              norm = 1.0 / sqrt(norm);
              AxisX *= norm;
              AxisY *= norm;
              AxisZ *= norm;

              ccc = cos(0.5 * radian);
              sss = sin(0.5 * radian);

              ans.t = ccc;
              ans.x = sss * AxisX;
              ans.y = sss * AxisY;
              ans.z = sss * AxisZ;

              return ans;
}

//// Put XYZ into  quaternion
quaternion PutXYZToQuaternion(double PosX, double PosY, double PosZ)
{
              quaternion ans;

              ans.t = 0.0;
              ans.x = PosX;
              ans.y = PosY;
              ans.z = PosZ;

              return ans;
}

///// main
int main()
{
              double px, py, pz;
              double ax, ay, az, th;
              quaternion ppp, qqq, rrr;

              cout << "Point Position (x, y, z) " << endl;
              cout << "  x = ";
              cin >> px;
              cout << "  y = ";
              cin >> py;
              cout << "  z = ";
              cin >> pz;
              ppp = PutXYZToQuaternion(px, py, pz);

              while(1) {
                            cout << "\nRotation Degree ? (Enter 0 to Quit) " << endl;
                            cout << "  angle = ";
                            cin >> th;
                            if(th == 0.0) break;

                            cout << "Rotation Axis Direction ? (x, y, z) " << endl;
                            cout << "  x = ";
                            cin >> ax;
                            cout << "  y = ";
                            cin >> ay;
                            cout << "  z = ";
                            cin >> az;


                            th *= 3.1415926535897932384626433832795 / 180.0; /// Degree -> radian;

                            qqq = MakeRotationalQuaternion(th, ax, ay, az);
                            rrr = MakeRotationalQuaternion(-th, ax, ay, az);

                            ppp = Kakezan(rrr, ppp);
                            ppp = Kakezan(ppp, qqq);

                            cout << "\nAnser X = " << ppp.x
                                          <<  "\n      Y = " << ppp.y
                                          <<  "\n      Z = " << ppp.z << endl;

              }

              return 0;
}

http://staff.aist.go.jp/toru-nakata/quaternion.html
http://bbs.gameres.com/showthread.asp?threadid=73511

Bill Hsu 2008-09-30 19:34 发表评论

��经元网�l�的��入门

Bill Hsu — Sat, 30 Aug 2008 12:08:00 GMT
一直不太懂��经元网�l�，看了�q�篇文章(来自IBM developerWorks 中国)后终于感觉有�Ҏ��白了�Q�特意拿出来大家一��L��?br>

2001 �q?nbsp;6 �?nbsp;01 �?br>
��经�|�络也许是计��机计算的将来，一个了解它的好�Ҏ��是用一个它可以解决的难题来说明。假讄��?nbsp;500 个字�W�的代码�D�，您知道它们是 C、C++、Java 或�?nbsp;Python。现在构造一个程序，来识别编写这�D�代码的语言。一�U�解��x��案是构造一个能够学习识别这些语�a�的神�l�网�l�。这��文章讨��Z��经�|�络的基本功能以及构造神�l�网�l�的�Ҏ��Q�这样就可以在编码时应用它们了�?/span>

Bill注：解释一下，�q�文章是�? ( _ . = ; " , ' * / { } : - 0 + 1 [ ] �q?0个特�D�符号出现频�?人工��经元的判断来识�?span style="color: #000000;">代码�D?/span>�?nbsp;C、C++、Java 或�?nbsp;Python

�Ҏ��一个简化的�l�计�Q��h脑由百亿条神�l�组�?�? 每条��经�q�_��q�结到其它几千条��经。通过�q�种�q�结方式�Q�神�l�可以收发不同数量的能量。神�l�的一个非帔R��要的功能是它们对能量的接受�ƈ不是立即作出响应�Q��? 是将它们累加��h��Q�当�q�个累加的��d��辑ֈ�某个临界阈值时�Q�它们将它们自己的那部分能量发送给其它的神�l�。大脑通过调节�q�些�q�结的数目和强度�q�行学习。尽��? �q�是个生物行为的��化描�q�。但同样可以充分有力地被看作是神�l�网�l�的模型�?/p>
阈值逻辑单元�Q�Threshold Logic Unit�Q�TLU�Q?/span>

理解��经�|�络的第一步是从对抽象生物��经开始，�q�把重点攑֜� 阈值逻辑单元�Q�TLU�Q?/em>�q�一特征上。一�? TLU 是一个对象，它可以输入一�l�加权系数的量，对它们进行求和，如果�q�个和达到或者超�q�了某个阈��|��输出一个量�? 让我们用�W�号标注�q�些功能�Q�首先，有输入��g��及它们的权系敎ͼ�X ₁, X ₂, ..., X _n�?W ₁, W _2, ..., W _n。接着是求和计��出�?X _i*W _i �Q��生了�Ȁ发层 a�Q�换一�U�方法表�C�：

a = (X1 * W1)+(X2 * W2)+...+(Xi * Wi)+...+ (Xn * Wn)

阈值称�?theta。最后，输出�l�果 y。当 a >=theta �?y=1�Q�反�? y=0。请注意输出可以是连�l�的�Q�因为它也可以由一�?squash 函数 s�Q�或 sigma�Q�判定，该函数的自变量是 a�Q�函数值在 0 �?1 之间�Q�y=s(a)�?/p>
�?1. 阈值逻辑单元�Q�带�?sigma 函数�Q�顶部）�?cutoff 函数�Q�底部）

TLU 会分�c�，假设一�?TLU 有两个输入��|��它们的权�p�L��{�于 1�Q�theta 值等�?1.5。当�q�个 TLU 输入 <0,0>�?lt;0,1>�?lt;1,0> �?<1,1> �Ӟ��它的输出分别�?0�?�?�?。TLU ��这些输入分��Z��l�：0 �l�和 1 �l�。就像懂得逻辑�q�接�Q�布��运��? AND�Q�的��可以�c�M��地将逻辑�q�接的句子分�c�那��P��TLU 也懂得一炚w��辑�q�接之类的东�ѝ�?/p>
TLU 能够用几何学上的解释来阐明这�U�现象。它的四�U�可能输入对应于�W�卡��图的四个点。从�{�式 X ₁*W ₁+ X ₂*W ₂ = theta�Q�换句话��_��也即 TLU 转换其分�c�行为的点开始，它的炚w��分布在曲�U?X ₂ = -X ₁ + 1.5 上。这个方�E�的曲线��?4 个可能的输入分成了两个对应于 TLU 分类的区域。这�?TLU 原理中更为普通的实例。在 TLU 有�Q意数目的 N 个输入的情况下，一�l�可能的输入对应�?N �l�空间中的一个点集。如果这些点可以被超�q�面 �? 换句话说�Q�对应于上面�C�Z��中的�U�的 N �l�的几何外�Ş切割�Q�那么就有一�l�权�p�L��和一个阈值来定义其分�c�d��好与�q�个切割相匹配的 TLU�?

Bill注：所谓的N�l�空间就是N个输入节�?br>

TLU 的学习原�?/span>

既然 TLU 懂得分类�Q�它们就知道素材。神�l�网�l�也可假定�ؓ可以学习。它们的学习机制是模仿大脑调节神�l�连�l�的原理。TLU 通过改变它的权系数和阈值来学习。实际上�Q�从数学的观点看�Q�权�p�L��阈值的特征有点武断。让我们回想一下当 SUM(Xi * Wi) >= theta �?TLU 在��界点时输出的�?1 而不�? 0�Q�这相当于说临界�Ҏ��出现�?SUM(X _i* W _i)+ (-1 * theta) >= 0 的时候。所以，我们可以�?-1 看成一个常量输入，它的权系�?theta 在学习（或者用技术术语，�U�Cؓ 培训�Q�的�q�程中进行调整。这��P��? SUM(X _i* W _i)+ (-1 * theta) >= 0 �Ӟ��y=1�Q�反�?y=0�?

在培训过�E�中�Q�神�l�网�l�输入：

一�p�d��需要分�cȝ��术语�C�Z��

它们的正��分�c�L��者目�?/li>

�q�样的输入可以看成一个向量：1, X ₂, ..., X _n, theta, t>�Q�这�?t 是一个目标或者正��分�c�R��神�l�网�l�用�q�些来调整权�p�L��Q�其目的使培训中的目标与其分�cȝ��匚w��。更��切地说�Q�这是有指导的培训，与之相反的是无指导的培训。前者是��Z��带目标的�C�Z��Q�而后者却只是建立在统计分析的基础上。权�p�L��的调整有一个学习规则，一个理惛_��的学习算法如下所�C�：

清单 1. 理想化的学习��法

fully_trained = FALSE
DO UNTIL (fully_trained):
fully_trained = TRUE
FOR EACH training_vector = ::
# Weights compared to theta
a = (X1 * W1)+(X2 * W2)+...+(Xn * Wn) - theta
y = sigma(a)
IF y != target:
fully_trained = FALSE
FOR EACH Wi:
MODIFY_WEIGHT(Wi) # According to the training rule
IF (fully_trained):
BREAK

您或许想知道�Q?#8220;哪些培训规则�Q?#8221;有很多，不过有一条似乎合理的规则是基于这样一�U�思想�Q�即权系数和阈值的调整应该由分�? (t - y) ��定。这个规则通过引入 alpha (0 < alpha < 1) 完成。我们把 alpha �U�Cؓ 学习�?/em>。W _i 中的更改值等�? (alpha * (t - y)* Xi)。当 alpha ��向�?0 �Ӟ��经�|�络的权�p�L��的调整变得保守一点；�?alpha ��向�?1 �Ӟ��权系数的调整变得�Ȁ�q�。一个��用这个规则的��经�|�络�U�Cؓ 感知�?/em>�Q��ƈ且这个规则被�U�Cؓ 感知器学习规�?/em>。Rosenblatt �?1962 �q�下的结论是�Q�如�?N �l�空间的炚w��被超�q�面切割�Q�那么感知器的培训算法的应用��会最�l�导致权�p�L��的分配，从而定义了一�? TLU�Q�它的超�q�面会进行需要的分割。当�Ӟ��Z��记�v Keynes�Q�最�l�我们都切断了与外界的联�p�，专心思考。但是在计算旉��之外�Q�我们仍�Ȓ��危险�Q�因为我们需要自��q��经�|�络对可能输入的�I�间�q�行不止一�ơ的切割�?

文章开始的��N��举例说明了这个，假设�l�您 N 个字�W�的代码�D�，您知道是 C、C++、Java 或�? Python。难的是构造一个程序来标识�~�写�q�段代码的语�a�。用 TLU 来实现需要对可能的输入空间进行不止一�ơ的分割。它需要把�I�间分成四个区域。每�U�语�a�一个区域。把��经�|�络培训成能实现两个切割��可完成�q�种工作。第一个切割将 C/C++ �?Java/Python 分开来，另一个将 C/Java �?C++/Python 分开。一个能够完成这些切割的�|�络同样可以识别源代码样本中的语�a�。但是这需要网�l�有不同�l�构�Q�在描述�q�个不同之处之前�Q�先来简单地看一下实跉|��面的考虑�?/p>
�?2. 初步的（不完整的�Q�感知器学习模型

考虑到排除取�?N 个字�W�代码所需的计��时��_��l�计�?ASCII 码的 32 �?127 的范围内可视 ASCII 码字�W�出现的频率�Q��ƈ在这个统计以及关于代码语�a�的目标信息的基础上培训神�l�网�l�。我们的�Ҏ��是将字符�l�计限制�? C、C++、Java �?Python 代码字符库中最常用�?20 个非字母数字字符。由于关注��Q点运��的执行�Q�我们打��用一�U�规格化因素��这 20 字符�l�计分开来，�q�以此培训我们的�|�络。显�Ӟ��一个结构上的不同是我们的网�l�有 20 个输入节点，但这是很正常的，因�ؓ我们的描�q�已�l�暗�C�Z��q�种可能性。一个更有意思的区别是出��C��一对中间节点，N1 �?N2�Q�以及输��Ҏ��量从两个变成了四个（O1 �?O4�Q��?/p>
我们��培�?N1�Q�这样当它一看到 C �?C++�Q�设�|?y1=1�Q�看�?Java �? Python�Q�它��设�|?y1=0。同理培�?N2�Q�当它一看到 C �?Java�Q�设�|? y2=1�Q�看�?C++ �?Python�Q�设�|?y2=0。此外，N1 �?N2 ��输�?1 �?0 �l?Oi。现在如�?N1 看到 C �?C++�Q�而且 N2 看到 C 或�? Java�Q�那么难题中的代码是 C。而如�?N1 看到 C �?C++�Q�N2 看到 C++ �? Python�Q�那么代码就�?C++。这个模式很显而易见。所以假�?Oi 已被培训�q�根据下面表格的情况输出 1 �?0�?/p>
映射到输出（作�ؓ布尔函数�Q�的中间节点

N1 N2 O1 (C) O2 (C++) O3 (Java) O4 (Python)

0 0 0 0 0 1

0 1 0 0 1 0

1 0 0 1 0 0

1 1 1 0 0 0

如果�q�样可行的话�Q�我们的�|�络��可以从代码�C�Z��中识别出语言了。这个想法很好。但是在实践上却有些难以�|�信。不�q�这�U�解��x��案预�C�Z�� C/C++ �?Java/Python 输入被一个超�q�面切割了，同样 C/Java �? C++/Python 输入被另一个切剌Ӏ�这是一个网�l�培训的解决�Ҏ��Q�迂回地解决了这个输入空间的设想�?/p>
Bill注：看�v来很强大

关于 delta 规则

另一�U�培训的规则叫做 delta 规则。感知器培训规则是基于这样一�U�思�\ �?权系数的调整是由目标和输出的差分方程表达式决定。�? delta 规则是基于梯度降落这样一�U�思�\。这个复杂的数学概念可以举个��单的例子来表�C�。从�l�定的几�Ҏ��看，向南的那条�\径比向东那条更陡些。向东就像从悬崖上掉下来�Q�但是向南就是沿着一个略微倾斜的斜坡下来，向西像登一座陡峭的山，而北边则��C��q�_��Q�只要慢慢的闲逛就可以了。所以您要寻扄��是到辑��^地的所有�\�? 中将陡峭的��d��减少到最��的路径。在权系数的调整中，��经�|�络��会扑ֈ�一�U�将误差减少到最��的权系数的分配方式�?

��我们的�|�络限制为没有隐藏节点，但是可能会有不止一个的输出节点�Q�设 p 是一�l�培训中的一个元素，t(p,n) 是相应的输出节点 n 的目标。但是，�?y(p,n) �׃��上提到的 squash 函数 s 军_��Q�这�? a(p,n) 是与 p 相关�?n 的激�z�d��敎ͼ�或者用 (p,n) = s( a(p,n) ) 表示��Z�� p 相关的节�?n �?squash �q�的�Ȁ�z�d��数。�ؓ�|�络讑֮�权系敎ͼ�每个 Wi�Q�，也�ؓ每个 p �?n 建立 t(p,n) �?y(p,n) 的差分，�q�就意味着为每�?p 讑֮�了网�l�全部的误差。因此对于每�l�权�p�L��来说有一个��^均误差。但�? delta 规则取决于求�q�_��值方法的�_��度以及误差。我们先不讨论细节问题，只是说一些与某些 p �?n 相关的误差：?* square( t(p,n) - y(p,n) )。现在，对于每个 Wi�Q��^均误差定义如下：

清单 2. 查找�q�_��误差

sum = 0
FOR p = 1 TO M: # M is number of training vectors
FOR n = 1 TO N: # N is number of output nodes
sum = sum + (1/2 * (t(p,n)-y(p,n))^2)
average = 1/M * sum

delta 规则��是依据�q�个误差的定义来定义的。因��差是依据那些培训向量来说明的�Q�delta 规则是一�U�获取一个特�D�的权系数集以及一个特�D�的向量的算法。而改变权�p�L��会使神�l�网�l�的误差最��化。我们不需要讨论支持这个算法的微积分学�Q�只要认��Z�Q�? Wi 发生的变化都是如下所�C�就够了�Q?/p>

alpha * s'(a(p,n)) * (t(p,n) - y(p,n)) * X(p,i,n).

X(p,i,n) 是输入到节点 n �?p 中的�W?i 个元素，alpha 是已知的学习率。最�?s'( a(p,n) ) 是与 p 相关的第 n 个节�Ҏ��zȝ�� squashing 函数的变化（�z��Q�率�Q�这��是 delta 规则�Q��ƈ�?Widrow �? Stearns 向我们展�C�Z��? alpha 非常��的时候，权系数向量接�q�某个将误差最��化的向量。用于权�p�L��调节的基�? delta 规则的算法就是如此�?

梯度降落�Q�直到误差小到适当的程度�ؓ止）

step 1: for each training vector, p, find a(p)
step 2: for each i, change Wi by:
alpha * s'(a(p,n)) * (t(p,n)-y(p,n)) * X(p,i,n)

�q�里有一些与感知器算法相区别的重要不同点。显�Ӟ��在权�p�L��调整的公式下有着完全不同的分析。delta 规则��法��L��在权�p�L��上调��_��而且�q�是建立在相对输出的�Ȁ�z�L��式上。最后，�q�不一定适用于存在隐藏节点的�|�络�?/p>
反向传播�q�一��法把支�?delta 规则的分析扩展到了带有隐藏节点的��经�|�络。�ؓ了理解这个问题，设想 Bob �l?Alice 讲了一个故事，然后 Alice 又讲�l�了 Ted�Q�Ted ��查了�q�个事实真相�Q�发现这个故事是错误的。现�?Ted 需要找出哪些错误是 Bob 造成的而哪些又归咎�? Alice。当输出节点从隐藏节点获得输入，�|�络发现出现了误差，权系数的调整需要一个算法来扑և�整个误差是由多少不同的节炚w��成的，�|�络需要问�Q?#8220;是谁让我误入歧途？到怎样的程度？如何弥补�Q?#8221;�q�时�Q�网�l�该怎么做呢�Q?

�?3�Q?#8220;代码识别”反向传播的神�l�网�l?

反向传播��法同样来源于梯度降落原理，在权�p�L��调整分析中的唯一不同是涉及到 t(p,n) �?y(p,n) 的差分。通常来说 W _i的改变在于：

alpha * s'(a(p,n)) * d(n) * X(p,i,n)

其中 d(n) 是隐藏节�?n 的函敎ͼ�让我们来看（1�Q�n 对�Q何给出的输出节点有多大媄响；�Q?�Q�输��Ҏ��w�对�|�络整体的误差有多少影响。一斚w��Q�n 影响一个输��点越多，n 造成�|�络整体的误差也��多。另一斚w��Q�如果输��点媄响网�l�整体的误差��少�Q�n 对输��点的影响也相应减��。这�?d(j) 是对�|�络的整体误差的基��|��W(n,j) �?n �?j 造成的媄响，d(j) * W(n,j) 是这两种影响的��d��。但�?n 几乎��L��影响多个输出节点�Q�也�怼�影响每一个输出结点，�q�样�Q�d(n) 可以表示为：

SUM(d(j)*W(n,j))

�q�里 j 是一个从 n 获得输入的输��点，联系��h��Q�我们就得到了一个培训规则，�W?1 部分�Q�在隐藏节点 n 和输��?j 之间权系数改变，如下所�C�：

alpha * s'(a(p,n))*(t(p,n) - y(p,n)) * X(p,n,j)

�W?2 部分�Q�在输入节点 i 和输��?n 之间权系数改变，如下所�C�：

alpha * s'(a(p,n)) * sum(d(j) * W(n,j)) * X(p,i,n)

�q�里每个�?n 接收输入的输��?j 都不同。关于反向传播算法的基本情况大致如此�?/p>
��?Wi 初始化�ؓ��的随机倹{�?/p>
使误差小到适当的程度要遵��@的步�?/span>

�W?1 步：输入培训向量�?
�W?2 步：隐藏节点计算它们的输�?
�W?3 步：输出节点在第 2 步的基础上计��它们的输出�?
�W?4 步：计算�W?3 步所得的�l�果和期望��g��间的差�?
�W?5 步：把第 4 步的�l�果填入培训规则的第 1 部分�?
�W?6 步：对于每个隐藏节点 n�Q�计��?d(n)�?
�W?7 步：把第 6 步的�l�果填入培训规则的第 2 部分�?

通常把第 1 步到�W?3 步称�? 正向传播�Q�把�W?4 步到�W?7 步称�? 反向传播。反向传播的名字由此而来�?

在掌握了反向传播��法后，可以来看我们的识别源代码��h��语言的难题。�ؓ了解册��个问题，我们提供�? Neil Schemenauer �?Python 模型 bpnn。用它的模型解决问题真是难以�|�信的简单，在我们的�c? NN2 里定制了一个类 NN �Q�不�q�我们的改变只是调整了表达方式和整个�q�程的输出，�q�没有涉及到��法。基本的代码如下所�C�：

清单 3�Q�用 bpnn.py 建立一个神�l�网�l?/strong>

# Create the network (number of input, hidden, and training nodes)
net = NN2(INPUTS, HIDDEN, OUTPUTS)
# create the training and testing data
trainpat = []
testpat = []
for n in xrange(TRAINSIZE+TESTSIZE):

#... add vectors to each set
# train it with some patterns
net.train(trainpat, iterations=ITERATIONS, N=LEARNRATE, M=MOMENTUM)
# test it
net.test(testpat)
# report trained weights
net.weights()

当然我们需要输入数据，实用�E�序 code2data.py 提供了这个功能。它的界面很直观�Q�只要将一堆扩展名各不相同的文件放��C��个子目录 ./code 中，然后�q�行�q�个实用�E�序�Q��ƈ列�D那些扩展名作为命令选项。例如：

python code2data.py py c java

您得到的是一�?STDOUT 上的向量�Q�可以把�q�些向量输入到另一个进�E�或者重定向��C��个文�Ӟ��它的输出如下所�C�：

清单 4�Q�Code2Data 的输出向�?/strong>

0.15 0.01 0.01 0.04 0.07 0.00 0.00 0.03 0.01 0.00 0.00 0.00 0.05 0.00 > 1 0 0
0.14 0.00 0.00 0.05 0.13 0.00 0.00 0.00 0.02 0.00 0.00 0.00 0.13 0.00 > 1 0 0
[...]

让我们回忆一下输入值都是不同特�D�字�W�出现的规格化数目，目标��|��在大于号以后�Q�是 YES/NO�Q�它代表包含�q�些字符的源代码文�g的类型，不过对于什么是什么来��_��q�没有非常明昄��东西。数字可以是输入或期望的 ��L��?/em>�Q�这才是最重要的�?

下一步是�q�行实际�?code_recognizer.py �E�序。这需要（�? STDIN 中）像上面一��L��向量集。这个程序有一个包�Q�它能够�Ҏ��实际文�g推断出需要多��输入节点（计算在内的和期望的）�Q�选择隐藏节点的数目是一个诀�H�。对于源代码的识别，6 �?8 个隐藏节点似乎工作得很好。如果打��试验网�l�从而发现对于这些不同的选项它是如何做的�Q�您可以覆盖命��o行中的所有参敎ͼ�但每一�ơ运行还是会耗费一些时间。值得注意的是�Q? code_recognizer.py ��它的（大的�Q�测试结果文件发送到 STDOUT�Q�而将一些友好的消息攑֜� STDERR 里。这样在大部分时间里�Q��ؓ了安全保��，您将会把 STDOUT 定向��C��个文�Ӟ��q�监视针对进�E�和�l�果概要�?STDERR�?/p>
清单 5�Q�运�? code_recognizer.py

> code2data.py py c java | code_recognizer.py > test_results.txt
Total bytes of py-source: 457729
Total bytes of c-source: 245197
Total bytes of java-source: 709858
Input set: ) ( _ . = ; " , ' * / { } : - 0 + 1 [ ]
HIDDEN = 8
LEARNRATE = 0.5
ITERATIONS = 1000
TRAINSIZE = 500
OUTPUTS = 3
MOMENTUM = 0.1
ERROR_CUTOFF = 0.01
TESTSIZE = 500
INPUTS = 20
error -> 95.519... 23.696... 19.727... 14.012... 11.058... 9.652...
8.858... 8.236... 7.637... 7.065... 6.398... 5.413... 4.508...
3.860... 3.523... 3.258... 3.026... 2.818... 2.631... 2.463...
2.313... 2.180... 2.065... 1.965... 1.877... 1.798... 1.725...
[...]
0.113... 0.110... 0.108... 0.106... 0.104... 0.102... 0.100...
0.098... 0.096... 0.094... 0.093... 0.091... 0.089... 0.088...
0.086... 0.085... 0.084...
Success rate against test data: 92.60%

不断减少误差是个很好的兆��_��q�至��在一�D�长旉��里所获得的一�U�进步，且最后的�l�果必然是深入�h心的。就我们的观点而言�Q�网�l�完成了一��值得��敬的工作，来识别代�? �?我们��会乐意們֐��Q�对于您的数字向量它是如何做的�?

参考资�?

您可以参阅本文在 developerWorks 全球站点上的英文原文.

我们�? 代码识别�E�序是基�? Neil Schemenauer 的反向传播模块�?

关于有指导培训和无指导培训的差异�Q�以及神�l�网�l�的一般介�l�，请参阅由 D. Michie、D.J. Spiegelhalter 以及 C.C. Taylor �~�辑�? Machine Learning, Neural and Statistical Classification�Q�具体内容请参阅 �W? 6 �?/a>�?

关于 Rosenblatt 的感知器�l�果�Q�请参阅他的 Principles of Neurodynamics, 1962, New York: Spartan Books�?

关于一�?delta 规则的详�l�信息，请参�?Kevin Gurney 的著�? An Introduction to Neural Networks 1997, London: Routledge。也可以参阅 Neural Nets早期的在�U�版本�?

关于 delta 规则的证明，请参�?B. Widrow �?S.D. Stearns �? Adaptive Signal Processing, 1985, New Jersey: Prentice-Hall�?

关于包含囑�Ş界面的感知器的执行，请参�?Omri Weisman �?Ziv Pollack 撰写�? The Perceptron �?

什么是没有 FAQ 的科目？请参阅在��M��时候都适用�? Neural Net FAQ�?

关于�q�泛的链接集合，请参�? The Backpropagator's Review�?

请参�? Neural Networks at your Fingertips�Q�它讨论了一�l?C �E�序包，�q�些包说明了 Adaline �|�络、反向传播、Hopfield 模型以及其它�Q�有一�? The Back-propagation Network 特别有趣�Q�它是一�?C �E�序包，说明了一个分析日斑数据的�|�络�?

�? Neural Networking Software�Q�您��会扑ֈ�有友好的囑�Ş界面的同时支�?DOS �?Linux 的神�l�网�l�代码�?

NEURObjects 提供了开发神�l�网�l�的 C++ 的库文�g�Q�它的优点在于面向对象�?

Stuttgart Neural Network Simulator�Q�SNNS�Q�，正如名字所�C�，是用�?GUI �?C �E�序�~�写的，它的手册内容极�ؓ丰富�Q�同时支持友好的 Linux �q�_��?

Bill Hsu 2008-08-30 20:08 发表评论

Bill Hsu — Mon, 28 Jul 2008 04:36:00 GMT
题记�Q?br> Python是荷��C�h写的�Q�Ruby是日本�h写的�Q�Lua是巴西�h写的�Q�我�q�个中国人只能在�q�里脸红�?br> ——CSDN�ȝ�� 孟岩
不打��自讨没��地写个要超�q�Python,Ruby,Lua的脚本引擎，以锻��D��力�ؓ丅R�?br> 估计完成以后和Lua有点像，宗旨是：以比Lua更短��Q�以比Python更长��?/span> :-)
┏━┓　　　┏━━┓　　　┏┓　　　　　
┃┃┣━┳━┫━━╋━┳┳╋╋━┳━━┓
┃　┫━┃┃┣━━┃┣┫┏┫┃┃┣┓┏┛
┗┻┠Z��┫┏┠Z��━┻━┻┛┗┫┏┛┗┛　
┗┛　　　　　　　　┗┛　　　　
引擎��叫RapScript好了(Ruby,Lua,Python 加一�?

Bill Hsu 2008-07-28 12:36 发表评论

N1	N2	O1 (C)	O2 (C++)	O3 (Java)	O4 (Python)
0	0	0	0	0	1
0	1	0	0	1	0
1	0	0	1	0	0
1	1	1	0	0	0