Blogger of AceStrong

终于又可以在这里发帖了～

2011-08-29T23:23:00.000+08:00

感谢telex，让我又可以翻墙发帖了～

虽然在单位不能上网，但晚上回家还是有属于自己的时间的～

以后要多利用晚上时间充实自己，也为东仔做个表率吧～

毛坯房验房程序

2010-03-09T20:42:00.001+08:00

毛坯房验房程序

　　一、先看外部：外立面、外墙瓷砖和涂料、单元门、楼道。　　

　　二、再查内部：入户门、门、窗、天棚、墙面、地面、墙砖、地砖、上下水、防水存水、

　　强弱电、暖气、煤气、通风、排烟、排气。

　　三、后测相邻：闭存水试验、水表空转等问题必须和楼上楼下邻居配合。

　　验房常用工具：

　　一、量具：5m盒尺、25～33cm直角尺、50～60cm丁字尺、1m直尺

　　二、电钳工具：带两头和三头插头的插排(即带指示灯的插座)；各种插头：电话、电视、宽带；万用表；摇表；多用螺丝刀(“-”字和“＋”字)；5号电池2节、测电笔；手锤；小锤；大灯、小灯

　　三、辅助工具：镜子、手电、塑料袋多个、纸＋火柴、卫生纸、凳子、纸笔

　　验房专用工具：垂直检测尺；多功能内外直角检测尺；多功能垂直校正器；游标塞尺；对角检测尺；反光镜；伸缩杆等。

　　验房自备工具

　　1)1只塑料洗脸盆--用于验收下水管道

　　2)1只小榔头--用于验收房子墙体与地面是否空鼓

　　3)1只塞尺--用于测裂缝的宽度

　　4)1只5米卷尺--用于测量房子的净高

　　5)1只万用表---用于测试各个强电插座及弱电类是否畅通

　　6)1只计算器---用于计算数据

　　7)1只水笔--用于签字

　　8)1把扫帚--用于打扫室内卫生

　　9)1只小凳子和一些报纸、塑料带，包装绳--用于时间长，可休息一下及预先封闭下水管道。

　　验房过程

　　去物业部门查看资料部分，分别有以下几份资料需要查验：

　　A 房屋的《住宅质量保证书》--可带走

　　B《住宅使用说明书》--可带走

　　C《竣工验收备案表》

　　D 面积实测表

　　E 管线分布竣工图(水、强电、弱电、结构)--可带走

　　自己验房注意问题及简单操作方法：

　　1、厨房烟道：用纸卷点火后灭火冒烟，放在烟道口下方十公分左右，看烟是否上升到烟道口立即拐弯吸走。

　　2、卫生间通风：应在吊顶下留通风口。留在吊顶上面时要用手灯查看是否具备安装性，同时用上法测抽力。烟道、通风口中用手电查看是否存有建筑垃圾。

　　3、管道煤气：用冒烟的纸卷放到报警装置附近，看报警装置是否灵敏动作，报警声光提示同时关闭进气电磁阀。如果不能动作，及时修复；

　　4、空鼓：手锤垫上几层纸(避免留下锤印)敲击墙壁，检查墙面空鼓。专用钢针小锤(10g)测墙砖空鼓。

　　5、验电：

　　A、检查插座：

　　五孔插座上分别插上带有指示灯的插排，灯亮，表示有电，此时拉下总开关箱内的插座开关(应有标示)，指示灯灭，频繁测试几次证明开关、接线良好，插座安全。如果开关拉下，插座指示灯仍亮或仍在闪烁，说明开关质量有问题或接线有误，立即修复，否则误触电时无法及时断电危及生命。插座还应用摇表来测试对地绝缘情况是否良好。

　　B、开关箱内的各分路开关应有明显的标示。如果没有或不明确，立即纠正。

　　C、开关箱内开关应安装牢固，每个都要用力左右晃动检查，如果发现松动，应紧固或更换。否则日后使用中出现接触不良打火现象时，会造成更大危险。

　　D、检查有线电视插座、宽带插座，插进去有无松动或插不进现象。

　　E、检查弱电插座数目：

　　F、检查可视对讲、紧急呼叫按钮是否工作正常。

　　G、检查入户门门铃：带2节5号电池测试门铃。是否不响或响了不停。

　　6、视镜(猫眼)：入户后观察猫眼，是否松动、不清晰、视野不全或因有异物无法看清楚等现象，修复或更换。

　　7、测高度：用盒尺检查房顶，取4-5个点，进行测量，若数值一致，比如房高均为2.5m(或者2.6m)说明房顶没有倾斜。

　　8、测墙壁地面：用长尺(或者带有水平的专用直尺)，靠墙壁地面，检查是否平整，同时观察是否有划痕裂纹，墙面是否有爆点(爆点：生石灰在发成熟石灰时因搅拌不匀没发好，抹在墙上干后就会形成爆点)。

　　9、测乳胶漆质量：墙面天花板是否平整，周围光线暗时带大功率灯泡(200瓦)照射，灯一亮，墙壁天花板是否平整立刻通过光线阴影看出，如果不平，要提出重新补腻子刷漆，如果局部刷漆(修补过)会与墙壁原色产生差异。

　　10、镜子：用镜子放到门顶部和门底部，检查这些平时看不到的地方是否刷过油漆。如果是卫生间的门，顶部和底部的油漆没有刷全，时间一长，因环境潮湿，卫生间的使用率又高，会使门底部过早腐烂损坏。

　　11、楼道窗户是否有纱窗，如果没有，应及时提出。

　　12、检查防盗门，有无划痕，门边是否变形，门与框的密封是否严密，门和锁开关应灵活。

　　13、检查门窗的密封是否良好，可用一长纸条放在密封点上，关门压住纸条用力抽出，多点试验看密封条的压力是否均匀。

　　14、窗户：推拉窗上的纱窗和窗扇，推动灵活，相互无碰撞。窗户外窗框上应有防堵帽，防止异物堵塞影响排水，导致下雨时窗户进水。双层玻璃里外都擦不干净时应提出拆换玻璃清洁，否则以后不易解决。

　　15、检查管道安装、通畅和密封：用手使劲晃动暖气管和上水管，应固定牢固。如果松动，应重新固定。打开水阀看排水是否流畅(否则下水管被建筑垃圾堵塞)，放水同时用卫生纸擦拭上下管道底部有无渗漏。

　　16、厨房和卫生间是瓷砖到顶的，要检查阴角阳角达90度，四角无磕碰(房顶四角和地面四角)，地砖墙砖无变形开裂和空鼓。用小锤划击地砖和墙砖，有空洞声音，说明没有铺设好，这样时间久了可能会出现瓷砖开裂和脱落，应重新铺设。

　　18、闭存水试验、水表空转试验：(重要检验项目)

　　19、卫生间：

　　A:卫生间在楼道内有窗户的应该安装防盗网。

　　B:如若没有窗户，则应有通风孔。通风孔设在吊顶下面。离通风孔最近的插座是防水插座。

　　20、暖气片：

　　A:暖气片上方应有排气孔，使用时应拧动将气体排掉。如果拧不动就需要修理解决，否则气排不出来，暖气片不热。

　　B:还要注意暖气片安装时进水管和回水管的坡度符合要求，否则影响采暖。

　　验收毛坯房的八大验收标准

　　屋内只有门框没有门，墙面地面仅做基础处理而未做表面处理的房叫做“毛坯房”，虽然毛坯房已经过相关部门的工程验收，但购房者在把毛坯房变成展现自我个性的空间之前，需要对毛坯房的验收标准有所了解。按照通常的标准，交付房屋时毛坯房需要对以下方面进行验收：

　　1、全部外饰面，包括阳台、雨罩的外饰面应按设计文件完成装修工程。

　　2、公用部位、公共设施、各种管道(给、排、雨水、暖、热)、电气设备(配电箱、柜、

　　盘、插座、开关、灯具等)等都应按设计文件完成全部装修，并按规定完成各种测试项目。

　　3、各种管道还应进行通水、试压、通球试验和暖气热工调试等验收工作。

　　4、屋面工程项目进行蓄水、淋水试验。

　　5、户门以内各房间采用预制楼板或现浇板顶棚的，应做到不抹灰、用腻子找平，达到板缝密实、无裂缝，接搓平顺无错台，表面平整、色泽基本均匀、线角顺直。户门以内各房间基层地面混凝土应做到表面平整、压实，达到粘结牢固、无裂缝。

　　6、有防水要求的房间地面应严格按照防水层、保护层的建筑要求来规划，在验收时应进行两次蓄水试验，做到无渗漏。

　　7、地漏与泛水坡度符合设计要求，达到不倒泛水，结合处严密平顺，无渗漏。

　　8、各种房间水泥地面基层标高，应考虑预留再装修时的高度尺寸要求

　　验房知识集--户内概貌验收

　　测试编号验收条目检验方法/参照标准结果

　　套内

　　户型对照施工图，三室两厅两卫一厨相符

　　朝向按楼书相符

　　日照是否达到国家规定？

　　尺寸按合同：套内＝ m2公摊＝ m2 实测：套内＝ m2 【套内误差 m2】公摊＝ m2 【套内误差 m2】

　　热、气

　　供热供热是否符合合同约定？

　　燃气报警器是否安装？

　　燃气表是否安装？煤气表字数：

　　通讯

　　电话是否每间房间和客厅都有电话插口？共有个电话插口

　　网络是否具备网络接口？

　　电视是否每间房间和客厅都具备电视接口？

　　对讲系统是否可用？

　　验房知识集水验收

　　是否有水？

　　水质如何？

　　水表是否安装？水表字数：

　　是否有水表空走？

　　是否阀门关闭不严？

　　是否有阀门脱丝，连接件滴水？

　　是否有截止阀生锈影响水质？

　　验房知识集电验收

　　电表字数电表字数：

　　是否通电？

　　电表是否安装？

　　电气线路安装应平整、牢固、顺直

　　过墙应有导管，导管连接必须紧密

　　铝导连接不允许用绞接或绑接

　　按动漏电保护器测试钮现象如何

　　拉闸断电测试

　　插座是否带保险装置

　　开关插座面板是否有划痕

　　是否有接地装置。零地电压应小于1V；如果等于0，那么可能是将零地接在一起了零地压差：

　　电线是否符合国际质量

　　电线的截面面积是否符合要求？一般来说，家里的电线不应低于 2.5 平方，空调线更应达到 4 平方，否则使用空调时，容易过热变软

　　开关是否妥当

　　按动漏电保护器的测试钮

　　管线是否安全可靠

　　插座面板是否有电

　　拉闸断电测试

GPS导航DIY指南

2010-01-30T11:01:00.000+08:00

年底要去老婆老家，准备开车去，一路近800公里，又是第一次开，有一个导航当然是最好不过了～作为导航业内人士，有现成的GPS设备可以用，当然不屑用市面上的GPS导航仪（好吧，我承认没有钱也是一个重要的原因～），DIY自然成了我的首选！导航其实就是能在地图上显示出你当前的位置、方向、速度等信息，所需的硬件就是GPS接收机和显示地图的设备，所需的软件就是接收GPS接收机的数据并解析显示于地图上。下面就来一个个的分析。

先说说硬件吧～

GPS接收机有现成的，无非是精度好点差点，都属于单点定位，精度在5-15米之间，这个问题不大～
显示地图的设备无非是嵌入式系统或者本本。嵌入式系统的优点是小巧方便，缺点是功能比较弱，需要专门定制软件，作为DIY的话不方便利用已有的成果，且屏幕一般都比本本小得多，另外一个放弃的重要原因是我手头上虽然有一个嵌入式系统，还带触摸屏，但是这个东西关系着毕业大计，金贵着呢，可不敢随便拿出来折腾！因此这里我选用本本作为显示地图的载体。它功能强，屏幕大，有丰富的软件资源可供利用，唯一的缺点就是有点大，不方便直接放在前车窗，会挡住视线，估计要放在副驾驶位子上了～
至于GPS接收机与本本的连接当然用经典的串口了（其实我也知道蓝牙更好～），本本没有物理串口不要紧，用USB-串口转接线，还省去了不能带电插拔的麻烦！

再来说说软件。

以前也查过，windows下的免费的导航软件很少，OZI的demo版据说功能限制很多，GooPs试用过，反正是不咋的，需要GE开着，没法联网的时候要事先在缓存里有地图才行，比较麻烦，不实用！再来看Linux下的GPS导航软件，其他的我不知道，反正是一眼就看中gpsDrive[1]了！瞧人家主页上说的，支持Linux、Mac OSX和FreeBSD，就是不支持Windows！我喜欢^_^装了一看，界面还蛮好看的，估计接上GPS就能工作了！就选它了～
选好了gpsDrive，下面就是找地图下载了～在gpsDrive的主页里它主要是从OpenStreetMap项目里下载地图，顺链接过去看了一下，这玩意靠的是大家都来贡献，在中国地图基本上没法用！还是要另想办法啊～在谷歌里搜索gpsdrive，还真找到一个台湾的哥们在eeePC上用过[2]，给出了使用指南，最关键的是给出了一个地图下载的网址[3]！赶紧顺着网址看过去，嘿，还真是专门为qpeGPS和 gpsDrive设计的！里面可以设定要下载的范围、缩放等级、重叠率等，然后记着要点击“Generate wGet”，不然非等死你不可！即使这样，生成一个包含690个小图的下载链接及配套经纬度信息的页面也要让我的Firefox假死几分钟～
有了下载链接和经纬度信息下面怎么办呢？很简单，把下载链接都拷到一个文件里，保存为sh文件，然后执行即可。需要注意的是，网络不好的时候，经常会停在某个wget半天也不动弹，是可忍，孰不可忍！我的经验是肉眼看看不行了就Ctrl+C中断sh的执行，将已经保存下来的图片对应的wget命令注释掉（我用kate里的Ctrl+D来干这事，忒方便），然后再次执行。这样的过程根据网络的好坏不同，可能需要执行N次（在我这里N>10），这也是整个地图下载过程中最ugly的部分（应该也可以编程来自动处理这种情况的，但宽恕我偷懒了～）……下载完的小地图放在~/.gpsdrive/maps/里，还需要将配套的经纬度信息也存到一个文本文件里，以备后用～
这时下载好的小地图尺寸是固定的（1280*1024），满足gpsDrive的要求，相对精度也是没有问题的，但由于万恶的GOV人为增加偏移量，直接使用配套的经纬度信息来显示地图那误差是相当的大，目测大约有600-1000米，当然是没法用了！也许你要问市面上那些GPS导航仪怎么就能定位到路上呢？除了他们一定使用了道路匹配算法外，最主要原因应该还是他们手头上有相应的加密解密算法，这玩意我们自然搞不到，所以只有另想办法～
要不怎么说我人品好呢，就在2009年的下半年，有人刚刚发现了谷歌地图的偏移值可以通过网络查询的方式获得，更为可贵的是，发现者无私的奉献出了全部知识[4-5]，让我由衷的敬佩！按照发现者的指引，我成功的解决了谷歌地图偏移的问题[6]，根据前面下载的与小地图匹配的经纬度信息来查询偏移值，然后进行修正，最后统一放在了~/.gpsdrive/maps/map_koord.txt文件中～
说到这里技术上的难题基本上都解决了，设定GPS接收机送出NMEA中的RMC语句就可以得到时间、经纬度、方向、速度等信息，配合gpsd，就可以正常使用gpsDrive了！不过根据人品守恒定律，我也该碰到点麻烦了～果然，本来准备用的Garmin 25-LVS的天线好像有问题，导致接收机始终无法输出任何东西，没办法，只好用JNS100来代替。设置输出RMC语句后，用串口调试助手可以看到正确的输出了GNRMC语句，但是用gpsd+xgps来观察，状态却始终是Unkown，这是怎么回事呢？将输出语句改为GGA，输出的是GPGGA语句，这就可以定位了！但是由于GGA语句的信息不全，还要另外加VTG语句才完整。再设定添加VTG，输出GNVTG，在xgps中依然看不到速度、方向信息！仔细观察了一下，发现问题可能就出在开头的标识符上，凡是GP***开头的好像gpsd就认，以GN***开头的就不认！那就自己加个小程序[7]，从/dev/ttyUSB0接收GN***的语句，然后改为GP***后再输出到一个伪终端（/dev/pts/*），让gpsd从那个伪终端接收即可～嘿嘿，幸亏前一阵要离线调试监控系统，逼着自己搞通了虚拟串口和伪终端，现在这样的工作就是小case了～中间也出了一点小波折，改完后的GP***语句gpsd还是不认，观察 gpsd的调试信息发现是校验码错误，这才想起来光改了内容，没有生成新的校验码，不错才有鬼了！NMEA的校验码很简单，就是字节的XOR操作，很快就搞定了，这时xgps里已经能够正确的显示所有需要的信息了～
最后连上lab的GPS天线测试了一下，肉眼观察误差在5米之内，perfect！至此，所有的技术问题都解决了，剩下的就是找个盒子把这些零碎装起来，只留三个接口出来，加上我的本本就可以GPS车载导航了～
具体的程序我依然都放在了代码发芽网上，这里就给个链接，因为内容仍会时不时的更新一下，不方便直接放在这里。
[1] GpsDrive - a free car (bike, ship, plane) navigation system：http://www.gpsdrive.de/
[2] EeePC上用GPSDrive玩GPS和Google Map：http://www.terewong.com/mytoys0ab27.htm
[3] Google maps to qpeGPS and gpsDrive：http://gtm.tel.uva.es/ztep/maps/dmap.htm
[4] 中国地图经纬度偏移修正算法完美解决方案：http://blog.csdn.net/dongmeng110/archive/2009/10/31/4750380.aspx
[5] Google地图经纬度到像素索引值的转换公式：http://blog.csdn.net/dongmeng110/archive/2009/12/13/4997634.aspx
[6] 谷歌地图校准程序：http://fayaa.com/code/view/8649/
[7] 串口接收GNRMC转发GPRMC到伪终端：http://fayaa.com/code/view/8643/

ps，后来发现25LVS不是天线的问题，而是串口的线断了！重新焊了一下，又用上了！这下子原来写的“串口接收GNRMC转发GPRMC到伪终端”程序就用不上了，开了GPSD直接就可以收到GPRMC语句，更加的方便了~~定位精度还是很高的，显示在地图上能有5米左右。但是开始纸盒子的安装设计不太好，受力点集中在串口连接头上，因为没有螺丝固定，很容易就掉下来了，另外电源的连接头也不牢靠。干脆换了一个扁扁的硬纸盒子，把各种连接头都放在了盒子里面，只将又粗又结实的USB线和电源线引出来，这下就牢靠多了！当然天线也是要引出来~
多讲一句，有了淘宝就是好啊，本来以为一个磁性天线要200多，在淘宝上一查，20块就可以搞定！买了两根，试了一下，一点问题也没有！现在是已经停产的25LVS+20块钱的磁性天线+自己的本本，嘿嘿，非常便宜，心里没有负担啦！^_^
在校园里跑车试了一下，在一条仅能通过一辆车的路上，GPS也能精确的定位，感觉精度已经差不多1-2米了！真是意外啊！现在一切准备就绪，就等出发啦~~

还是minicom好用

2009-04-27T22:26:00.002+08:00

这几天在重新熟悉Ubuntu下用2410的开发板进行编程。

用下来的感受是windows下可以做的事情Ubuntu下完全可以做到，加上我们是在用嵌入式linux进行开发，所以完全应该在Ubuntu下进行，忘掉Windows吧～

回到主题，说说minicom。前面写过一篇文章，里面说minicom用不惯，用了它的一个前端——cutecom。这几天使用下来，发现cutecom的一个重要缺点——显示时乱码。这个问题其实不是它所独有的，在Windows下的DNW和一般的串口调试助手都会出现这个问题。在Windows下的解决方法是使用自带的超级终端，它不仅不会显示乱码，还可以彩色显示，带tab自动补全，甚至可以利用zmodem协议来传输小文件！

那么Ubuntu下有没有这样的好东西呢？当然有了，那就是minicom！minicom的使用其实很简单，先用"minicom -s"启动设置界面，将串口名，波特率，握手协议等设定好，保存为默认的df1，以后只要用"minicom -m -c on"打开就可以了，不用再进行串口设置。直接使用minicom和超级终端一样自带tab补全，也可以利用zmodem协议传输文件，只要在输入rc后按Alt+S，就会出现选择要传输文件的提示窗口，在其中用空格选择要传输的文件，最后按回车就可以开始传输了。传输过程中有进度提示，完毕后会自动回到minicom的命令行。唯一让我不爽的是对中文支持不好，不过暂时用的都是英文，按理说minicom应该也能支持中文的，好像是-8选项，但我还没倒腾出来，就先不说了，以后再来研究～

在嵌入式开发中使用Qt

2009-04-24T21:55:00.002+08:00

1. 编译PC上的Qt。这里的configure参数不是很重要，用默认的参数即可。这里为了调试方便加入-qvfb参数。
gunzip qt-x11-opensource-src-4.3.2.tar.gz
tar xvf qt-x11-opensource-src-4.3.2.tar
./configure -qvfb
make
make install

2. 交叉编译嵌入式Qtopia-core。这里的configure参数对于最终库文件的大小和支持的功能至关重要，一定要确保加入了足够的功能，同时不需要的功能一个也不要！
gunzip qtopia-core-opensource-src-4.3.2.tar.gz
tar xvf qtopia-core-opensource-src-4.3.2.tar

cd /tmp/qtopia-core-opensource-src-4.3.2
在qtopia-core-opensource-src-4.2.2/src/gui/embedded/qmouselinuxtp_qws.h加入
#define QT_QWS_IPAQ
#define QT_QWS_IPAQ_RAW
以上两个定义是为了支持触摸屏
在下面的configure参数中，-prefix指定了最后install的目录，
./configure -prefix /home/ace/Qtopiacore-4.3.2 -no-largefile -xplatform qws/linux-arm-g++ -no-libtiff -no-gif -no-libmng -no-openssl -no-cups -no-qdbus -embedded arm -little-endian -no-freetype -qt-gfx-linuxfb -no-qt3support -depths 8,16
make
make install

将编译好Qtopiacore-4.3.2下lib库放到根文件系统的Qtopiacore下（注意根文件系统中的目录要和-prefix /home/ace/Qtopiacore-4.3.2一样否则下到arm板上运行程序的时候会报错说找不到字体）。
如果报错说找不到libstc++.so.6文件，可以将usr/local/arm/3.4.1/arm-linux/lib/libstc++.so.6复制到/home/ace/Qtopiacore-4.3.2/lib下（或者软链接）。
为了实现触摸屏的校准将/home/ace/Qtopiacore-4.3.2/examples/qtopiacore/mousecalibration/mousecalibration拷贝到根文件系统中,在文件系统的.bashrc文件中加入环境变量，并且export QWS_MOUSE_PROTO="LinuxTP:/dev/h3600_tsraw"。

3. 制作根文件系统及进行触摸屏校准。
将根文件系统下到arm板子上去,启动板子运行./mousecalibration -qws 进行触摸屏的校准。
校准完后 cat /etc/pointercal，将显示的数据记录下来，然后新建一个空白文档将其命名为pointercal ，然后将记录的数据放到pointercal文档中。
rm -f /etc/pointercal
sudo cp -f 新建的pointercal /etc
sudo chown 500:244 /etc/pointercal
制作根文件系统，烧到arm板子。

4. Done！

基于svm的驾驶决策建模

2009-04-15T10:14:00.004+08:00

在前文的基础上，将该方法进一步推广到整个驾驶过程的决策建模，除了解决了驾驶决策的问题，还能避免其他方法参数校准的难题。

对于整个驾驶过程决策建模，要考虑在不同的驾驶阶段，驾驶者关注的决策变量是不同的。如果对各种不同的驾驶阶段分别进行基于svm的建模，当然可以，但需要另外对不同阶段间的转换进行判断，而各个阶段之间的过渡往往是模糊的，不同阶段转换的会很复杂，工作量甚至可能超过svm建模！为避免这个问题，我们用一个包含所有阶段的决策变量的状态空间来进行建模。以基本的跟驰阶段为例，用四个决策变量就可以进行驾驶决策了，但这时要给出所有决策变量在该时刻的值，如果没有的话就设为某一固定值（一般取为0即可），这样驾驶者在不同驾驶阶段的转换逻辑也包含在了状态空间模型中，不用另外做判断的工作，只需在每一时刻给出所有决策变量的值，大大简化了驾驶决策的建模。

本方法的优点很明显，但是缺点和前文类似，都需要包含各种类型决策变量的数据来进行训练，数据质量的好坏直接影响了模型的有效性和完备性。虚拟驾驶数据采集系统是解决这一问题的最佳方案！

知道如何在blogger里发帖子了

2009-04-15T10:07:00.002+08:00

最近在笔记本上的xp系统里往blogger发帖子老是连接不上，这就直接导致这个月都没在这里写什么东西！当然在本地还是写了一些的，CintaNote确实蛮方便的～

现在是在Ubuntu下，刚才偶尔打开一个blogger上自己以前写的帖子，发现速度还可以，就尝试着进入控制台发个帖子，发现速度还不错！以后就在Ubuntu下发blogger的帖子了～但是在本地写的东西放在CintaNote里，在xp系统下，拷贝到Ubuntu下不是很方便，要想个办法～

Grep学习笔记

2009-03-23T21:02:00.000+08:00

Grep学习笔记

JTSS的log输出配合grep简直就是完美啊！
grep的核心就是正则表达式，看来有必要再看看正则表达式～

[转]利用消息队列实现进程间通信

2009-03-19T20:56:00.000+08:00

UNIX系统程序设计-10-编程语言-电脑网络-搜狐社区: "第十章：利用消息队列实现进程间通信

所谓消息功能，是指由一个进程产生并送出的消息，被放在一个叫做“消息队列”的列中管理，然后由接收方从消息队列中取出消息，这么一种功能。（先入先出）

做一个例子程序看看：
下面的两个程序分为发送方和接收方。发送方将自己的PID和从标准输入输入的一个字符串送至消息队列，接收方把消息队列中所有的PID和字符串读出，并输出至标准输出。

/* msend.c */
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>

int main()
{
int msqid;
key_t msgkey;
struct msgbuf
{
long mtype;
char mdata[256];
};
struct msgbuf msgdata , *p ;

p = &msgdata ;
printf('Enter message : ');
fflush( stdin ); /* 刷新标准输入缓冲区 */

gets( p->mdata ); /* 输入字符串 */
p->mtype = getpid();
msgkey = ftok ( 'mrecv' , 'a' ); /* 计算标识符 */
msqid = msgget( msgkey , IPC_CREAT | 0666 ) ; /* 建立消息队列 */
msgsnd( msqid , p , sizeof(p->mdata) , 0 ); /* 送消息 */
return 0;
}

/* mrecv.c */
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>

int main()
{
int msqid;
key_t msgkey;
struct msgbuf
{
long mtype;
char mdata[256];
};
struct msgbuf msgdata , *p ;
p = &msgdata ;
msgkey = ftok( 'mrecv' , 'a' ); /* 计算标识符 */
msqid = msgget( msgkey , IPC_CREAT | 0666 ) ; /* 取得消息队列的ID */
while(1)
{
msgrcv( msqid , p , sizeof(p->mdata) , 0 , 0 ) ; /* 读消息 */
printf('Message received from %ld\n%s\n' , p->mtype , p->mdata );
}
return 0;
}

执行例：
% msend
Enter message : Hello , world
%msend
Enter message : I am Syuu I

%mrecv
Message received from 321
Hello , world
Message received from 326
I am Syuu I

使用消息功能，可分如下几步
发送方：
1.生成消息队列，取得ID。
2.向消息队列送消息。
接收方：
1.根据标识符，取得ID。
2.从消息队列接收消息。
3.删除消息队列。

例程序相对来说比较简单。我们就不解释了。

消息队列的使用方法以及函数的构造等等基本上和上一章所讲的共享内存的使用方法一样。可参考上一章来理解本章内容。
说说出现的函数：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgget( key_t msgkey , int flag );
取得一个消息队列的ID，如不存在则建立。
返回值：成功时：消息队列的ID
失败时：-1

int msgsnd( int msqid , struct msgbuf *msgp , size_t msgsiz , int msgflag );
向消息队列送消息
返回值：成功时：0
失败时：-1
msqid是消息队列的ID，size_t msgsiz是结构体成员mdata的大小，msgflag与上一章所讲的共享内存的flag起一样的作用，不过，当这个参数为IPC_NOWAIT的时候，如果消息队列已满，则返回错误值。如果不为IPC_NOWAIT，在消息队列已满的情况下，会一直等到消息队列有空地方的时候再发送。
注意这里的这个 struct msgbuf *msgp 。要求的格式如下：
struct msgbuf
{
long mtype;
char mdata[256];
};
long mtype在这里我们用来保存本进程的PID。mdata则是保存要发送的数据。由于mdata的大小不一定（根据实际需要定义），所以这个结构体并没有事先定义好。但是我们定义这个结构体的时候一定要遵循这个规定。你可以改的，只有mdata的大小，和结构体的名称。尽量不要修改结构体成员的名称和类型。实际上，根据mtype，我们还可以有所选择地接受消息。这在下面将会谈到。

int msgrcv( int msqid , struct msgbuf *msgp , size_t msgsiz , long msgtyp , int msgflag );
从消息队列取得一个消息
返回值：成功时：0
失败时：-1
msqid , *msgp , msgsiz不用说了。long msgtyp是结构体msgbuf的mtype成员。msgflag与上述一样。只不过为IPC_NOWAIT的时候，如果消息队列是空的，则等到有消息可读的时候再读。当不为IPC_NOWAIT的时候，如果消息队列是空的，则返回错误值（与字面上理解的有些相反）

同样地，为了控制管理消息队列，一样有一个函数msgctl()如下：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgctl( int msqid , int cmd , struct msqid_ds *buf );
返回值：成功时：0
失败时：-1
cmd所指定的值与共享内存部分相同。

本来还应该有一章关于Semaphore的。其使用方法于共享内存和消息队列差不多，只不过使用场合不同。可是我自己也没太弄明白那个东东是怎么回事，为了避免以讹传讹……就不写了。

看了我这么多贴子，大家辛苦了。《UNIX系统程序设计》这一系列的贴子到此宣告完成。在这些文章的创作过程中得到了SOHU C\C++论坛诸位朋友的大力支持。在此笔者深表谢意。
接下来，如果有时间的话，我会继续写一套《UNIX网络程序设计（C语言版）》。不知大家有兴趣否。
再有一点。本文中所解释的所有的函数，严格地说，应该叫：系统调用( system call )。"

[转]利用共享内存实现进程间通信

2009-03-19T20:47:00.000+08:00

UNIX系统程序设计-9-编程语言-电脑网络-搜狐社区: "第九章：利用共享内存实现进程间通信

在两个进程间共享数据的方法，至今为止我们只说过利用管道。管道只是利用了输入输出重定向的原理，非常简单。而且只能在父子进程间使用。很多场合下这种方法是无法满足我们的要求的。
那么现在，我们又有了一种新的方法——利用共享内存(shared memory)。这可以使我们在任意两个进程间传递数据，而且也是相对简单容易实现的一个方法。
注意：在正常情况下，一个进程的所使用的内存区是不允许其它进程访问的。这里我们要开辟的共享内存是例外。
我们来做一个简单的剪贴板。从标准输入向mcut输入数据，mcut将其放在共享内存中，然后mpaste从共享内存中读出数据并显示。

/* mcut.c */
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>

int main()
{
key_t shmkey;
int shmid , in_tmp ;
char *head , *pos ,
in_data[4096] , *in_ptr ;

shmkey = ftok( 'mcut' , 'a' ); // 计算标识符
// shmid开辟共享内存
shmid = shmget( shmkey , sizeof(in_data) , IPC_CREAT | 0666 ) ;

head = pos = shmat( shmid , 0 , 0 ); // 允许本进程使用这块共享内存

in_ptr = in_data ;
// 开始从标准输入输入数据，暂时存在in_data里。
while( (in_tmp=getchar()) != EOF )
{
*in_ptr = in_tmp ;
in_ptr++ ;
}

*in_ptr = '\0' ;
in_ptr = in_data ;

// 开始写入共享内存
while( *in_ptr != '\0' )
{
*pos = *in_ptr ;
pos++;
in_ptr++;
}
*pos = '\0' ;
shmdt( head ); // 禁止本进程使用这块内存
return 0;
}

/* mpaste.c */
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>

int main()
{
key_t shmkey;
int shmid;
char *head , *pos ,
out_data[4096] , *out_ptr ;

shmkey = ftok( 'mcut' , 'a' ); // 计算标识符
// 开辟共享内存
shmid = shmget( shmkey , sizeof(out_data) , IPC_ALLOC | 0666 );
head = pos = shmat( shmid , 0 , 0 ); // 允许本进程使用这块共享内存
out_ptr = out_data ;

// 从共享内存中取得数据
while( *pos != '\0' )
{
*out_ptr = *pos ;
out_ptr++ ;
pos++ ;
}
*out_ptr = '\0' ;
printf( '%s\n' , out_data );
fflush( stdout );
shmdt( head ); // 禁止本进程使用这块共享内存
return 0;
}

如何？明白多少了？
要使用共享内存，应该有如下步骤：
1.开辟一块共享内存 shmget()
2.允许本进程使用共某块共享内存 shmat()
3.写入/读出
4.禁止本进程使用这块共享内存 shmdt()
5.删除这块共享内存 shmctl()或者命令行下ipcrm

上面的程序中用到了如下函数，我们一一解释一下。

首先是ftok()。它有两个参数，一个是字符串，一个是字符。字符串一般用当前进程的程序名，字符一般用来标记这个标识符所标识的共享内存是这个进程所开辟的第几个共享内存。ftok()会返回一个key_t型的值，也就是计算出来的标识符的值。

其次，操作共享内存,我们用到了下面的函数
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int shmget( key_t shmkey , int shmsiz , int flag );
void *shmat( int shmid , char *shmaddr , int shmflag );
int shmdt( char *shmaddr );

shmget()是用来开辟/指向一块共享内存的函数。参数定义如下：
key_t shmkey 是这块共享内存的标识符。如果是父子关系的进程间通信的话，这个标识符用IPC_PRIVATE来代替。但是刚才我们的两个进程没有任何关系，所以就用ftok()算出来一个标识符使用了。
int shmsiz 是这块内存的大小．
int flag 是这块内存的模式(mode)以及权限标识（关于权限的意思，请参阅本系列第五章）。
模式可取如下值：新建：IPC_CREAT
使用已开辟的内存：IPC_ALLOC
如果标识符以存在，则返回错误值：IPC_EXCL
然后将“模式” 和“权限标识”进行“或”运算，做为第三个参数。
如： IPC_CREAT | IPC_EXCL | 0666
这个函数成功时返回共享内存的ID，失败时返回-1。

shmat()是用来允许本进程访问一块共享内存的函数。
int shmid是那块共享内存的ID。
char *shmaddr是共享内存的起始地址
int shmflag是本进程对该内存的操作模式。如果是SHM_RDONLY的话，就是只读模式。其它的是读写模式
成功时，这个函数返回共享内存的起始地址。失败时返回-1。

shmdt()与shmat()相反，是用来禁止本进程访问一块共享内存的函数。
参数char *shmaddr是那块共享内存的起始地址。
成功时返回0。失败时返回-1。

此外，还有一个用来控制共享内存的shmctl()函数如下：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int shmctl( int shmid , int cmd , struct shmid_ds *buf );
int shmid是共享内存的ID。
int cmd是控制命令，可取值如下：
IPC_STAT 得到共享内存的状态
IPC_SET 改变共享内存的状态
IPC_RMID 删除共享内存
struct shmid_ds *buf是一个结构体指针。IPC_STAT的时候，取得的状态放在这个结构体中。如果要改变共享内存的状态，用这个结构体指定。
返回值：成功：0
失败：-1

刚才我们的mpaste.c程序中还可以加入这样几句。

struct shmid_ds buf;
... ...
shmctl( shmid , IPC_STAT , &buf ); // 取得共享内存的状态
... ...
shmctl( shmid , IPC_RMID , &buf ); // 删除共享内存

注意！！！！！！！！！：在使用共享内存，结束程序退出后。如果你没在程序中用shmctl()删除共享内存的话，一定要在命令行下用ipcrm命令删除这块共享内存。你要是不管的话，它就一直在那儿放着了。
简单解释一下ipcs命令和ipcrm命令。

取得ipc信息：
ipcs [-m|-q|-s]
-m 输出有关共享内存(shared memory)的信息
-q 输出有关信息队列(message queue)的信息
-s 输出有关“遮断器”(semaphore)的信息
%ipcs -m

删除ipc
ipcrm -m|-q|-s shm_id
%ipcrm -m 105"

[转]UNIX进程(Process)及信号(signal)

2009-03-19T20:39:00.000+08:00

UNIX系统程序设计-7-编程语言-电脑网络-搜狐社区: "第七章：UNIX进程(Process)及信号(signal)

在进程执行过程中，如果出现什么事件(event)，系统将会给进程一个信号。进程可以在得到这个信号后做些适当的处理。
还是与以前一样，咱们先来个小程序吧。

/* slot.c */
#include <stdio.h>
#include <signal.h>

int x[3];
long kin;

int kekka();
int main( int argc , char *argv[] )
{
srand( getpid() ); /* 设定随机数的种子数 */
signal( SIGKILL , kekka ); /* 当Ctrl+C按下时，执行kekka函数 */
kin = atoi( argv[1] ); /* 取得赌注数目 */

printf('press Ctrl+C to stop maching !\n');
while(1)
{
x[0]=rand()%10;
x[1]=rand()%10;
x[2]=rand()%10;
printf('%d %d %d\n',x[0],x[1],x[2]);
fflush( stdout );
}
return 0;
}
int kekka()
{
if( x[0]==x[1] && x[1]==x[2] )
printf('Great , you won %d \n' , kin*3000);
else
printf('You lost %d\n',kin);
exit(0); /* 游戏结束。退出程序 */
}

执行方法：
%./slot 100

执行后。画面上会出现一排排的数字。当你按下Ctrl+C的时候，程序得到信号，跳转至kekka()函数入，判断随机数。然后退出程序。
这里有这样一个新函数。是我们在UNIX程序设计中时常用得到的。

#include <signal.h>
int ( *signal( int sig , void (*func()) ))();
返回值：成功时：进程中断地址
错误时：SIG_ERR

这个函数挺不好懂呵。解释解释。它的意思是，当收到SIG这个信号时，跳转至func()这个函数处继续执行。
int sig这个参数其实好办。下面我们会给出一个表。将其所有的参数一并列出。这是在头文件中#define的，代表各种不同的信号。
void ( * func() )
这个参数是一个函数指针。意思是在SIG信号被传给进程后，所要执行的部分。
此外，func()这个参数还可以为如下值：
SIG_DEL 系统的默认动作
SIG_IGN 忽略这个信号。

signal作用只有一次，当一个信号发生，触发signal动作的之后，signal就不起作用了。比方说，在上例中，如果你把所有的exit(0)全去掉（不退出程序），程序会进入无限循环中。你按一次Ctrl+C，signal执行一次，显示出结果。然后继续循环，生成随机数，输出。你再按Ctrl+C，signal就不好使了。
如果需要重复使用signal()函数，可以考虑在signal调用的动作函数中再加一个signal，比方说在上例的程序中再加一个 signal( SIGKILL , kekka );

加了signal这个函数后，整个程序如果没收到信号，则正常执行。否则跳转至signal中指定的func()函数处继续。
当然，我们不可能，也没有必要去为每一个信号指定一个动作。当未指定动作的信号发生的时候，系统会执行默认的动作。比方说我们知道：当Ctrl+C按下的时候，正常默认的动作是结束程序。但是，Ctrl+C按下时，发生的信号是SIGKILL，如果你为SIGKILL这个信号指定了一个动作的话，系统将去执行你指定的这个动作，而不管原来默认的了。
打个比方让大家更容易懂一些：
比方说：你在睡午觉。突然来了一个美女（帅哥）（Ctrl+C）让你陪她/他去逛街购物共进晚餐……（此处删去若干字），你正常的默认的动作是马上起来陪她出去玩（程序中止）。但是你妈说不许去，你妈说你得在家擦窗户，你只好留在家擦窗户（signal()指定的动作）。擦完窗户之后你可以选择陪美女去逛街（默认动作，Ctrl+C的埸合是退出程序，即上例程序中的exit(0)），可以选择继续睡觉（回到原来中断的地方继续执行，上例程序中如果没有exit(0)，便会回到中断处继续执行）。
（大哥。打个比方嘛。干嘛拿臭鸡蛋砸我……）

signal种类非常多，在此不一一列出。

使用这个函数，你可以防止用户按下Ctrl+C结束程序。还可以做很多其它的事——只有你想不到的，没有C做不到的。

注意：根据UNIX系统的不同，signal的定义是不一样的。比方说，有的老式UNIX工作站上SIGINT是按下del键后发生的信号，而有些机型上刚是按下Ctrl+Z发生的。在使用时要注意。"

[转]标准输入输出以及管道操作

2009-03-19T20:12:00.001+08:00

UNIX系统程序设计-6-编程语言-电脑网络-搜狐社区: "第六章：标准输入输出以及管道操作

标准输入输出大概所有的操作系统都差不多吧。从键盘输入。从屏幕输出。除非你用的还是打纸带的老家伙。呵呵。
主要说一下管道操作。注意：此处所说的管道操作不是
% cat -n test.c | more
这是在提示符状态下使用管道，把第一个程序(cat)的输出作为输入传给第二个程序(more)。我们现在要在程序中使用的管道原理与此相同。将某一个程序的输出变为另一个程序的输入。

做一个石头剪子布的程序。其中包括一个父程序和一个子程序。注意是两个程序，不是两个函数。也不是两个进程。不过因为父程序运行的时候要通过exec()函数来执行子程序。所以我们也可以把它看成是两个进程。
父进程取得用户的输入（石头S，剪子C，布P中的某一个，P=0,S=1,C=2）并通过管道传给子进程
子进程取得父进程传来的数字，加上自己的PID后做为种子数，生成一个随机数然后被3除，得出来一个余数是0、1或者2。再通过管道传回给父进程。
父进程根据两个数字（用户输入的，以及子进程传回来的）判定胜负，输出

/* parent. */
#include <sys/types.h>
#include <stdio.h>
int main()
{
int i , j ,
st , fd[2] ;
pid_t pid ;
static int result[3][3]={1,0,2,2,1,0,0,1,2};
char argv1[3] , argv2[3] ,
ch ;

ch=getchar();
switch(ch)
{
case 'P': i=0;break;
case 'S': i=1;break;
case 'C': i=2;break;
default:
fprintf( stderr , 'Enter P , S or C , Please!\n' );
exit(1);
}
if( pipe(fd)!=0 ) //建立管道
{
fprintf( stderr , 'PIPE Error !\n' );
exit(1);
}
sprintf( argv1 , '%d' , fd[0] );
sprintf( argv1 , '%d' , fd[1] );

switch( pid=fork() ) // fork出一个新的进程，执行子程序
{
case 0:
if( execl('child','child',argv1,argv2,(char *)0) == (-1)) exit(1);
//执行了子程序
break;
case -1:
fprintf( stderr , 'fork Error !\n' );
exit(1)
}
write( fd[1], &i , sizeof(i) ); //向管道写数据
wait( &st ); //等待子程序结束
read( fd[0] , &j , sizeof(j) ); //从管道读数据
switch(result[j])
{
case 0:
printf( 'You won\n' );
break;
case 1:
printf( 'Same\n' );
break;
case 2:
printf( 'You lost\n' );
}
close(fd[0]);
close(fd[1]);
return 0;
}

/* child.c */
#include <stdio.h>
int main(int argc , char *argv[])
{
int i,j,
read_fd,
write_fd;
read_fd=atoi( argv[1] ); //设定输入用管道
write_fd=atoi( argv[2] ); //设定输出用管道
read( read_fd , &i , sizeof(i) ); //从管道中取得数据
srand( i+getpid() ); //设定随机数的种子数
j=rand()%3; //生成随机数
write( write_fd , &j , sizeof(j) ); //写向管道
close( read_fd );
close( write_fd );
return 0;
}

编译执行父程序即可。

这种管道是用来在父子进程间传递数据的。如同大家在程序中所见：父进程开辟管道，然后生成子进程执行子程序，并将管道参数作为main()函数的参数传给子程序。通过一个相同的管道实现读写。开辟管道时，我们用到了这个函数：

int pipe( int fd[2] ); 开辟一个管道

参数fd[2]是一个有两个元素的数组。可以看成是两个管道的记述子。fd[0]用来读，fd[1]用来写。
返回值：成功时：0
失败时：-1
读取/写入管道时，我们用到了下面函数

读取管道中的数据
int read( int fd , char *buf , unsigned int nbyte );
向管道中写入数据
int write( int fd , char *buf , unsigned int nbyte );

其中，fd是管道记述子，也就是我们前面说的fd[0]或者fd[1]，buf装数据，nbyte指定读/写数据的数量，单位是字节。成功时返回0，失败时返回-1。

由于准备考研。这篇文章耽误了一些时日。最近还有些事，也许下一篇也得几天后才能再贴。
另外，在此向诸位致歉。我的程序是在学校的UNIX下写的，一般是用软盘带回来，写上一篇贴子程序的时候没有带软盘，只好打印出来回来再敲。在输入的时候有一个错误（现已改正）
int main( int argc , char *argvp]);
应为
int main( int argc , char *argv[]);
下一章准备说说UNIX的进程(Process)和信号(signal)。"

[转]目录及文件操作

2009-03-19T17:13:00.001+08:00

UNIX系统程序设计-5-编程语言-电脑网络-搜狐社区: "第五章：目录及文件操作

上一章我们说了一些UNIX的文件系统的物理构造。下面我们来看看具体怎么对文件进行操作。当然这里所说的文件及目录操作不是fopen()。呵呵。我们要做一些fopen办不到的事。

/* newer.c 比较参数所指定的两个文件
将其中新的文件的文件名输出来 */
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
int main( int argc , char *argvp] )
{
struct stat buf[2] , *p ;
if( argc!=3 )
{
fprintf( stderr , 'Usage : %s file1 file2\n' , argv[0] );
exit(1);
}
p=buf;
if( stat(argv[1],p)!=0 ) //取得第一个文件的信息
{
fprintf( stderr , '%s not found !\n' , argv[1] );
exit(1);
}
p++;
if( stat(argv[2],p)!=0 ) //取得第二个文件的信息
{
fprintf( stderr , '%s not found !\n' , argv[2] );
exit(1);
}
if( buf[0].st_mtime > buf[1].st_mtime ) //比较最终更新时间
printf( '%s\n' , argv[1] );
else
printf( '%s\n' , argv[2] );
return 0;
}

执行结果：
%newer afile bfile
bfile

使用stat()函数，可以得到文件的信息。这些信息是在i node中保存的这个文件信息的一部分。得到的信息将会保存在stat.h中定义的stat型的结构体中。stat()函数解释如下：
#include <sys/types.h>
#include <sys/stat.h>
int stat( char *path , struct stat *buf );
返回值：成功时：0
失败时：-1

我们再来写一个玩玩

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#define MASK 0555 //这个数字的意思等一下解释，他代表“可读”和“可执行”
int main( int argc , char *argv[] )
{
struct stat buf[1];
mode_t mode;
if( argc!=2 )
{
fprintf( stderr , 'Usage : %s file\n' , argv[0] );
exit(1);
}
if( stat(argv[1],buf)!=0 )
{
fprintf( stderr , 'Cannot read i-node\n' );
exit(1);
}
mode = ( buf[0].st_mode & MASK ); //计算文件新的权限标志
if ( chmod(argv[1],mode)!=0 ) //改变文件的权限标志
{
fprintf( stderr , 'Cannot change mode\n' );
exit(1);
}
return 0;
}

现在来解释一下0555这个数字的意思。
众所周知，UNIX是一个多用户多任务的操作系统。每个用户有自己的权限，这个权限限制了用户可以做哪些事，不可以做哪些事。对于文件来说，用户可以分成四类：
root（根用户，超级用户）
这个用户是系统的管理呐，权限最大，可以随意读写任何文件。
owner（文件拥有者）
实际拥有文件的用户。文件属主。
group（组成员）
用户所在的用户组的成员
other
以上三类之外的其它用户

UNIX中，每个文件信息中包括一组9位的权限标志。分别给文件属主，用户组和其他用户指定对该文件的读、写和执行权。请看下面的例子：
%ls -l /bin/ls
-rwxr-xr-x 1 root bin 27281 Aug 15 2002 /bin/ls*
重要是看-rwxr-xr-x，第一个 - 表示这是一个普通文件，这个位置也可以出现些别的字符，比方说目录的话这里会是 d 。而 l 表示一个链接。余下的9位可以分成三段，每段三位。本例中从左至右
rwx 表示文件的属主拥有文件的读，写，执行权
r-x 表示同组的用户拥有文件的读，执行权（注意，“写”权限的位置是一个 - ）
r-x 表示其它的用户拥有文件的读，执行权
文件的访问权限还可以用三位8进制来表示。如上例
rwx r-x r-x 可以换成
111 101 101 （有该权限，则该位为1，否则为0）
换成8进制，二进制的111是八进制的7 ，二进制的101是八进制的5。
现在看看0555是什么意思？就是说，可以读，可以写的意思。
把0555和原来文件的权限标志做与运算，得到的新的权限标志就是把原来的文件权限标志中所有的写权限全取消了。其余权限变。然后在程序中用chmod()把这个新的权限标志赋给文件即可。

chomd()函数用法如下：
#include <sys/types.h>
#include <sys/stat.h>
int chmod( char *path , mode_t mode );
返回值：成功时：0
失败时：-1

关于目录，还有另一个比较有用的函数，即chdir()。用这个函数可以在程序中转换当前目录。
#include <sys/types.h>
#include <sys/stat.h>
int chdir( char *path );
返回值：成功时：0
失败时：-1

以上两章，简单地叙述了一下UNIX的文件系统以及在UNIX C中对文件的操作方法。并列举了常用的一些函数。
下一章，我们将简单地叙述一下UNIX C的输入输出，以及用管道(pipe)实现两个进程互换数据。"

[转]在程序中执行UNIX命令或者其它程序

2009-03-19T17:01:00.001+08:00

搜狐社区-论坛-聊天室-博客-BBS: "第二章：在程序中执行UNIX命令或者其它程序
在UNIX下，像DOS的command.com那样的程序，我们称之为外壳（shell）。外壳就是一个命令解释器，你在外壳的提示符下输入命令（如同DOS的提示符一样），系统便会执行。
DOS的提示符一般是C:>，当然，你想改成什么样就能改成什么样，又当然，像BBS一样贴张图上去是不太现实的。
UNIX的提示符根据外壳的不同是不同的。
为了更好地说明本章想讲解的内容，我们先做一个外壳试试（玩具级别的）。我们给他起名叫SSH（Sohu Shell）吧。想取名叫CSH，可惜CSH在没生我之前就有了。呵呵。

/* 简单的外壳程序 */
#include<stdio.h>
int main()
{
static char prompt[64]='> ';
char command[256];
int st;

fprintf(stderr,'%s',prompt); // 在屏幕上输出提示符
while(gets(command)!=NULL) // 取得命令
{
if(fork()==0) // 生成子进程
{ // 这里是子进程接下来要做的事
if( execl(command,command,(char *)0)==(-1) )
// 上一句是执行命令
exit(1); // 当出错时子进程异常中止
}
else
{ // 父进程
wait(&st); // 等待子进程结束
fprintf(stderr,'%s',prompt);
// 输出提示符，等待命令
}
}
return 0;
}

执行方法：
%./ssh
>/bin/ls
当前目录下文件名一览
>Ctrl+D
%

普通的外壳在执行exit命令后会关闭。也就是说，退出一层外壳。咱们这个程序现在还做不到。愿意的话加上这个功能试试好了。所以要关闭这个外壳就得来点狠的。Ctrl+D，Ctrl+C什么的。再不你就再开一个外壳然后ps -ef再kill。再狠一些……拆硬盘，拨电源

我们这里有了一个新的函数：execl()。其实他是一组函数中的一个。这组函数如下：
int execl( path , arg0 , arg1 , ... , argn , (char *)0 );
int execv( path , argv );
int execle( path , arg0 , arg1 , ... , argn , (char *)0 , envp );
int execve( path , argv , envp );
int execlp( file , arg0 , arg1 , ... , argn , (char *)0 );
int execvp( file , argv );
其中的参数定义如下：
char *path;
char *file;
char *arg0 , *arg1 , ... , *argn;
char *argv[];
char *envp[];
返回值：成功时：所执行的命令将会覆盖现有的进程，所以无返回值
失败时：-1
用过TC的朋友应该知道，TC的Process.h里有一个system()函数。这组函数其实和system()的功能差不多。

比方说：
execl( '/bin/ls' , '/bin/ls' , '-al' , '/home' , (char *)0 );
或者
char *argv[];
strcpy( argv[0] , '/bin/ls' );
strcpy( argv[1] , '-al' );
strcop( argv[2] , '/home' );
execv( '/bin/ls' , argv );
都相当于在命令行下敲入了'/bin/ls -al /home'并且回车。（引号不是命令里的。是我解释时加上去的。别看混了）。
execle()和execve()，函数名最后一个字母都是e。就是说，这两个函数在调用其它程序的同时，还可以把环境变量一起传给被调程序
execlp()和execvp()，函数名最后一个字母都是p，就是说，这两个函数在使用的时候，就算你不指定命令文件所在的路径，它也会根据环境变量PATH去挨个地方找。找着就执行。找不着拉倒。
比方说：
setenv $path = ( /bin $path ) 这句话将环境变量PATH的第一个路径设为/bin。这是在SHELL下执行的。C里没这东西吧。
在程序中这样用这个函数
execlp( 'ls' , 'ls' , '-al' , '/home' , (char *)0 );
与上面的效果一样。当然。如果你PATH变量没设好的话。它就不一定找到哪儿去了。

还有一个函数是wait()，说明如下：
#include <sys/types.h>
pid_t wait(int *stat_loc);
返回值就是一个PID了。忘了PID是什么意思的朋友光顾一下我上一篇贴子。
它的参数有些意思。其实它与你的子进程用什么方式结束有关系。当你的子进程以exit()方式结束的话，stat_loc所指向的地址的前8位将会是exit()的参数的后8位，而stat_loc所指向的地址的后8位是0。比方说：你的子进程是exit(1);那stat_loc所指向的地址的内容应该是0000 0001 0000 0000。

exit():
#include <stdlib.h>
void exit(int status);
就算你在程序中没写exit()函数，编译器也是认为你是在最后加入了这个函数。"

[转]生成一个Process（进程）

2009-03-19T16:58:00.000+08:00

搜狐社区-论坛-聊天室-博客-BBS: "第一章：生成一个Process（进程）
进程是什么？简单地说，进程就是在执行状态下的一个程序（包括CPU状态，所占内存的状态，等等）
A进程生成了B进程，也就是说，A程序在执行的时候，又生成了另一个进程B。这个时候，我们可以把A进程叫做父进程，把B进程叫做子进程。
例程序：

// Usage : ./a.out 20
#include<stdio.h>
int main( int argc , char *argv[])
{
int dep_time;
dep_time = atoi( argv[1] )*60 ; //将参数中给出的20（分钟）转换成整型的秒数
if( fork()==0 ) //生成子进程，然后父进程中止
{
sleep( dep_time );
fprintf( stderr , '!!!!!!!!n');
}
return 0;
}

上面的程序是一个闹钟程序。当你执行之后。程序不会显示什么，而是一下就回到UNIX的提示符下。但是你在命令行中指定了20分钟后你有事，那么在你执行这个程序之后20分钟，他会提醒你到时间了。
本程序只是做示例用，没有检查参数是否正确，等等。
生成一个新的进程，可以使用 fork() 函数。以下说说fork()函数。

头文件： #include <sys/types.h>
形式 pid_t fork();
参数无
返回值成功时：父进程中：子进程的PID (Process ID)
子进程中：0
失败时：父进程中：-1
由于失败，没有生成子进程；

fork()刚执行完的时候，子进程和父进程是完全一模一样的两份进程（当然，PID是不一样的）。他们的各个变量的值都是一样的，而且都认为自己已经执行完fork()了。fork()后，区分父进程和子进程，只要看fork()的返回值就行了。
if( fork()==0 ) printf('这是子进程');
else printf('这是父进程');

同理：
if( fork()==0 )
{
//接下来要子进程做的工作
}
else
{
//接下来要父进程做的工作
}

一般，我们会把fork()返回给父进程的值保存下来（其实就是子进程的PID），等到需要结束子进程的时候，我们关掉他，如下：

pid_t child_pid ;
child_pid=fork();
if( child_pid==0 )
{
// ... ...
}
else
{
// ... ...
}
// ... ...需要结束子进程的时候
kill( child_pid , SIGKILL ) // kill()函数是用来发给另一个进程一个消息的。以后再讲。"

[转]向其它进程传递信号

2009-03-19T16:47:00.001+08:00

精华区-编程语言: "本文所有程序均应在UNIX系操作系统下编译执行。

第八章：向其它进程传递信号

上一章，我们简单地说了一下信号。信号不仅仅可以在本进程内使用，还可以向其它的进程传递。确切地说，一般情况下，一个进程收到的信号绝大部分是从系统的INIT传来的。而INIT也是一个进程。
用过UNIX或者LINUX的朋友大概都知道，UNIX系的操作系统里，有一个kill命令。如果你的一个进程无法中止，可以使用kill命令强行干掉它。
%kill mypro
我们自己也可以做个简单的kill命令。

/* nkill.c */
#include <stdio.h>
#include <sys/types.h>
#include <signal.h>

int main( int argc , char *argv[] )
{
pid_t pid;
if( argc != 2 ) // 检查命令行参数个数
{
fprintf( stderr , Usage : %s PID \n , argv[0] );
exit(1);
}
pid = atol( argv[1] );
if( kill( pid , SIGKILL )!=0 ) // 向pid这个进程传送一个SIGKILL信号
{
fprintf( stderr , kill failed\n );
}
return 0;
}

执行例：
%sleep 300 & (后台睡眠300秒)
[1] 520
%nkill 520
[1] + Killed sleep 300

你用自己写的程序杀死了一个sleep进程。没事。杀了就杀了吧。留着也是垃圾……
说明一下，众所周知，UNIX是非常注意用户的权限的。所以，如果你向你自己生成的进程发送SIGKILL的话，这个进程会中止。如果你是向别的（你没有写权限的）进程发送SIGKILL的话，除非那个进程允许你动它，否则你发了也是白发。打个不恰当的比较下流一些的比方：如果你要求亲一下你自己老婆的话（你有“亲”的权限），你会如愿以偿。但是如果你想亲一下别人的老婆的话（你没有“亲”的权限），除非他及她同意，否则……呵呵。你死定了。
所以，执行上面的程序的时候，你必须保证你有权限关掉那个进程。可不是说你ps -ef然后随便挑一个进程就能关的。要不那黑客也太好当了。

几乎是咱们的老规矩了：先写个程序，然后解释这个程序，说说其中新出现的函数。这回还照旧吧。
大家看到了。这里新出来一个kill()函数。解释如下：

#include <sys/types.h>
#include <signal.h>

int kill( pid_t pid , int sig );
返回值：成功时：0
失败时：-1
这个函数是向进程ID（PID）为pid的进程传送一个sig信号。
这个函数有什么用呢？用处可大了。
在上一章中，我们用到了SIGKILL信号。这一节我们用的还是这个信号。实际上，信号(signal)有许多。而且根据UNIX系统的不同，这些信号也不太一样。

我们简单列举一些信号例子。其用途请恕小生才疏，解释不清。有兴趣的朋友可以自己查阅一下资料。
SIGHUP , SIGINT , SIGQUIT , SIGILL , SIGTRAP , SIGABRT , SIGEMT , SEGFPE（注意，这里是SEG）,SIGKILL , SIGBUS , SIGSEGV , SIGSYS , SIGPIPE , SIGALRM , SIGTERM , SIGUSR1 , SIGUSR2 , SIGCLD , SIGPWR , SIGWINCH , SIGSTOP , SIGTSTP , SIGCONT , SIGTTIN , SIGTTOU
使用kill()函数，可以将这些信号中的一个或者多个送至另一个进程。刚才的程序中，我们就是将一个SIGKILL信号送至sleep那个进程，该进程收到信号，以为是用户按下了Ctrl+C，就中止了。

知道了这些，我们再来做一个比较有意思的程序。我们做一个cat程序（类似于DOS下的type，查看文本文件的内容）。不过这个cat程序与UNIX的cat不太一样，我们把由参数指定的文件的内容输出到屏幕上。如果你没指定文件，那么这个程序会等你五秒，在这五秒钟里，你可以从标准输入输入一个文件。然后显示。万一这五秒钟里你也没输入什么文件名。程序会把当前目录下的所有文件名打印出来（ls），以督促你输入一个文件名。

/* show.c */
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>

jmp_buf env;

int func();
int main( int argc , char *argv[] )
{
char filename[256];
signal( SIGALRM , func ); // 如果收到一个SIGALRM信号，则转至func处执行
if( argc==1 )
{
fprintf( stderr , & );
alarm(5); // 5秒钟后向自己发送一个SIGALRM信号
setjpm(env); // 设置记号
scanf( %s , filename );
execl( /usr/bin/more , more , filename , (char *)0 );
}
else
{
execl( /usr/bin/more , more , argv[1] , (char *)0 );
}
return 0;
}
int func()
{
int st;
fprintf( stderr , Which file do you want to read ?\n\n );
if( fork()==0 )
{
execl( /bin/ls , ls , -FCa , (char *)0 );
}
wait(&st);
longjmp( env , 0 ); // 跳转至先前的setjmp()处
}

这个程序看明白了吗？可能有些不太好懂。我们从头跑一遍试试。
首先是装入头文件等等。没关系了。然后signal( SIGALRM , func )，即，当收到一个SIGALRM信号的时候，中断现在所做的工作。转而执行func()函数。
不过可惜得很，现在暂时还没人给咱们发送SIGALRM信号，我们继续往下看。下面是判断命令行参数了。如果只有这个程序的可执行文件一个参数的话（也就是说，没有指明要显示哪个文件的内容），那就打印出一个&号来。然后设置alarm(5)，也就是说，在5秒后给自己发一个SIGALRM信号。下一句setjpm(env)是设置一个记号，以后当执行至longjmp()函数的时候，就会跳转到这里来。然后等待你输入文件名。
如果在这五秒种里，你输入了一个文件名的话，那么就向下执行——通过execl()函数调用系统的more命令，显示该文件的内容。然后退出。这只需要要很少的一段时间。绝对用不上一秒（看你当前目录下有多少文件了。没人会在一个目录下装上1G吧？）。最后结束程序。alarm()在5秒后发出的信号乐意咋地咋地去吧。咱不用管了。
问题是：如果在这五秒钟里，你没有输入文件名的话，事情就变得非常微妙了。这种情况下，程序将停留在
scanf( %s , filename );
这一行。等待你输入文件名。然后五秒种的期限到了。alarm()函数向这个进程发了一个SIGALRM信号。signal()函数检测到这个信号，转向func()函数处执行。
func()函数先是输出了一个提示信息 Which file do you want to read ? 。然后fork()出一个子进程。这个子进程通过execl()函数调用/bin/ls命令，显示出当前目录下的所有文件。execl()函数生成的进程覆盖掉了子进程。显示完所有文件名后退出。父进程等待子进程结束（wait()）后，执行longjmp()函数，返回到刚才的setjmp那行程序结尾处。继续执行下一步，也就是再执行一次 scanf( %s , filename )。当然，上一次的scanf()已经中止了。剩下的就简单地一路到底。明白了？
为什么要fork()出一个子进程，而不用原来的进程呢？是因为execl()函数会覆盖掉当前进程。如果直接使用execl()的话，咱们这个宝贝进程就被execl()覆盖，调用完 /bin/ls 后直接结束退出了。还怎么跳来跳去的呀。呵呵。

好。又多了三个函数：

unsigned alarm( unsigned sec );
在sec指定的秒数之后，向本进程发送一个SIGALRM信号。
返回值是以前的alarm()函数执行后所剩余的时间。

还记不记得第一章中，咱们做过的闹钟程序了？那个时候是让进程休眠一段时间，然后再报时。现在我们有了另一个法宝——alarm()。这回也别让进程浪费大好时光睡大觉去了。让它做点别的什么事吧。写写试试？

#include <setjmp.h>
int setjmp( jmp_buf env ); // 设置跳转记号env
void longjmp( jmp_buf env , int val ); // 跳转至记号env处。

jmp_buf env就是跳转记号了。那么longjmp第二个参数 int val 是干什么用的呢？当你用longjmp()函数跳转至setjmp()处的时候，setjmp()函数应该会返回一个值吧？这个值就是int val，也就是longjmp()第二个参数。
setjmp()的返回值，在第一次使用的时候是0。在由longjmp()跳转过来的时候，返回值是longjmp()的第二个参数。
但是有一个特例：像刚才程序中所写的，longjmp( env , 0 )，longjmp()第二个参数是 0 的时候，setjmp()的返回值是 1 。

有很多界面比较友好的程序中，当等待用户输入数据的时候，如果用户过了一段时间还没有输入的话，程序会输入一些提示信息，或者是可供选择的选项来供用户参考。在Windows编程中，例如VC，VB等等，大概可以用定时器 timer 或者其它的什么办法来解决（我粗通VB。VC一点都不会）。在UNIX下，上面那样便是一种解决方法。当然。编程习惯不同，解决方法也不尽相同。

信号(signal)这个东西，在UNIX编程中占很重要的地位。笔者一直想用通俗的语言来解释，可是限于笔者的语文水平，所以做到的仅此而已。总的来说，signal可以看成是一种软中断。当一个signal被发送到程序的时候，会引发程序的默认过程（比方说SIGKILL的场合是强制结束）或者程序的作者自定义的过程（用signal()函数指定）。
另外。longjmp()和setjmp()两个函数由于使用了跳转（类似于goto语句，但是longjmp()能实现函数外跳转，就是说能跳到另一个函数里去。goto办不到吧），这不符合结构化程序设计的要求，所以如果不是万不得以，不推荐使用。"

[转]Rise Vs Raise

2009-03-19T09:31:00.002+08:00

Rise Vs Raise: "rise和raise都有'上升,升起,上涨,举起'等意思
但是rise多用于不及物动词(rise后面不加宾语),raise是及物动词(raise后面要加宾语).
还有个简单的方法,一般事物自身可以升高,上升的,常用rise,例如太阳东升,河水上涨.而raise一般是人为地让事物升高,例如举起胳膊,提高薪水等.
The sun rose at seven o'clock.
太阳七点钟升起。
The river is rising after the rain.
雨后河水涨了。
The plane was then able to rise and it cleared the mountains by 400 feet.
'这时飞机能上升了,并在距山头400英尺的高度飞越了山头。'
The steps of the palace rise in easy flights.
宫殿台阶上升的坡度不大。
Prices have risen steadily during the past decade.
过去十年间物价一直在上涨。
(物价上涨是不能人为控制的哦~)
He raised his arms above his head.
他把手臂举过头顶。
I will not raise a hand against you.
我不会做任何不利于你的事。
to raise salaries
提高工资
to raise the rent
提高租金"

DOP和差分GPS

2009-03-17T20:40:00.000+08:00

今天在做E650V串口输出数据的解析与提取，对PDOP的概念不甚清楚，向镇海请教了一下，他也只记得大概，给了我一本书“卫星导航原理与应用”。除了PDOP等概念外，趁机对差分GPS的类型等知识也重新梳理一遍。

先来看看DOP（Dilution of Precision）精度衰减因子的概念。
DOP包括GDOP（Geometric DOP）几何精度衰减因子，PDOP（Position DOP）位置精度衰减因子，HDOP（Horizontal DOP）水平精度衰减因子，VDOP（Vertical DOP）垂直精度衰减因子和TDOP（Time DOP）时间精度衰减因子。各个因子的表达式如下：
GDOP=(Tx**2+Ty**2+Tz**2+Tt**2)**0.5/T;
PDOP=(Tx**2+Ty**2+Tz**2)**0.5/T;
HDOP=(Tx**2+Ty**2)**0.5/T;
VDOP=Tz/T;
TDOP=Tt/T;
其中Tx,Ty,Tz,Tt分别是x,y,z,t的方差。从表达式可以看出，影响GDOP的因素包括x,y,z,t，PDOP包含x,y,z，HDOP包含x，y，VDOP仅包含z，TDOP仅包含t。

再来看看差分GPS的类型。
根据差分GPS基准站发送的信息内容的不同分为位置差分，伪距差分，相位平滑伪距差分和载波相位差分四种。其工作原理相同，都是由基准站发送改正数，由游动站接收并对其测量结果进行改正。所不同的是发送的改正数的具体内容，最后得到的差分定位精度也不同。

位置差分：发送的修正量是解算坐标与参考站已知坐标的误差。优点是计算方法简单，适用于一切GPS接收机，包括最简单的接收机。缺点是必须严格保持参考站与用户观测同一组卫星。适用于用户与基准站间距离在1000km以内的情况。

伪距差分：发送的修正量是参考站与可见卫星的距离与含有误差的测量值的差值。优点是1）修正量是直接在WGS84坐标下计算的，无须坐标变换，因而可保证精度；2）这种方法能提供伪距修正量及其变化率，可以精确地考虑吧时间延迟的影响；3）它能提供所有卫星的修正量，用户可选用任意4颗卫星定位。随着用户到基准站距离的增加，卫星时钟误差被完全消除，对流层误差、接收机噪声不受距离变化的影响，星历误差、电离层误差和UERE（用户等效距离误差）随距离增加而变大。

广域增强：WAAS不是广播距各卫星的距离修正值，而是广播卫星星历的误差矢量和速率误差矢量，因此克服了局域增强（LAAS）只在小范围内起作用的缺点。

相位平滑的差分伪距是直接差分伪距观测量与推算量的加权平均。

载波相位差分：RTK（Real Time Kinematic）是建立在实时处理两个测点的载波相位基础上的。发送的修正量是基准站的载波观测量及站坐标信息。用户接收GPS卫星的载波相位与来自参考站的载波相位，组成相位差分观测值进行实时处理，能实时给出厘米数量级的定位结果。

在python中解析带符号24位数

2009-03-17T18:45:00.002+08:00

如何在python中将S24（带符号24位数）从二进制数解析出来？这个问题困扰了我一个上午，终于在吃午饭前解决了～

来讲讲思路。首先是用struct.unpack将整个B1(PVT)数据块分为一个个的word，其他的U8、U16、U32、S32等2的整数次幂都好办，就是碰到S24时有点麻烦，没有直接对应的数据类型，要用间接的方法来解析数值。我采用的方法是用三个Byte来存储S24的从低到高的三个字节，然后分别左移高两位字节（一个左移8位，一个左移16位），再拼成一个完整的无符号整数（用或运算），用struct.pack包装成的字节流（就是一个字符串），然后判断是正数还是负数，如果是负数要将最高一个字节改为0xff。再用struc.unpack来解包，注意此时是作为带符号整数来解包的！这样就得到了S24的值。

说了这么多，看一下代码就清楚了～

def parseS24(self,c0,c1,c2):
s = struct.pack('<I',c0|c1<<8|c2<<16)
if c2>0x7f:
ss = list(s)
ss[3] = '\xff'
s = "".join(ss)
result = struct.unpack('<i',s)[0]
return result

def w10(self):
c0 = self.data[11]
c1 = self.data[12]
c2 = self.data[13]
result = self.parseS24(c0,c1,c2)
return result

完整的代码在下面～

Python语言: 解析二进制的B1（PVT）数据块

Python语言: 从串口读入数据并解析其中的导航信息

编程的首要原则(s)是什么？ - 刘未鹏|C++的罗浮宫 - CSDNBlog

2009-03-11T15:21:00.000+08:00

编程的首要原则(s)是什么？ - 刘未鹏|C++的罗浮宫 - CSDNBlog

坏习惯不是你的敌人_武志红的BLOG_新浪博客

2009-03-08T20:42:00.000+08:00

坏习惯不是你的敌人_武志红的BLOG_新浪博客

查找zotero中给定item所在的collection

2009-03-07T15:02:00.003+08:00

阿军抱怨zotero这个功能缺失好久了～～今天兴起，想用SQL语句解决这个问题。

一番挣扎之后，写出来了：“select collectionName from collections where collectionID = (select collectionItems.collectionID from collectionItems where itemID = (select itemData.itemID from itemData where valueID = (select valueID from itemDataValues where value = "?")))”。其中?处填上item的全称，在SQLite Spy或SQLite Manager中执行该语句即可（当然在任何支持sqlite3的软件中执行皆可）。

但这样只能查找到item直接所在的collection，而collection有可能还有上一层的collection，写出这样的SQL语句已经超出了我的能力范围，只有借助于python了～。

Python语言: 在zotero中查找给定item的collection层次

#! /usr/bin/env python
#coding=utf-8
03
import sqlite3 as sqlite
05
def findCollectionNames(itemName):
   conn = sqlite.connect('zotero.sqlite')
   c = conn.cursor()
   param = (itemName,)
   # 查找collectionName和parentCollectionID
   c.execute("select collectionName, parentCollectionID from collections where collectionID = \
              (select collectionID from collectionItems where itemID = \
              (select itemID from itemData where valueID = \
              (select valueID from itemDataValues where value = ?)))", param)
   collectionNames = []
   for row in c:
#        print row[0].encode('gbk')
       collectionNames.append(row[0])
       parentCollectionID = row[1]
       while parentCollectionID:
           cur = conn.cursor()
           param = (parentCollectionID,)
           cur.execute("select collectionName, parentCollectionID from collections where collectionID = ?", param)
           res = cur.fetchall()[0]
#            print res[0].encode('gbk')
           collectionNames.append(res[0])
           parentCollectionID = res[1]
28
   # We can also close the cursor if we are done with it
   c.close()
31
   # 显示出来
   collectionNames.reverse()
   for name in collectionNames:
       print ("%s - " % name.encode('gbk')),
   print ("\"%s\"" % itemName)
37
if __name__ == '__main__':
   findCollectionNames(u"Panda3D - Forums")

在matlab中调用libsvm的时候数据归一化与反归一化的m代码 - 浮世记 - 博客大巴

2009-03-04T11:00:00.000+08:00

在matlab中调用libsvm的时候数据归一化与反归一化的m代码 - 浮世记 - 博客大巴

为什么读博士以及有什么意义(转载) | contrast的对比人生

2009-03-03T11:48:00.000+08:00

为什么读博士以及有什么意义(转载) | contrast的对比人生

所有程序员都应该至少读上两遍的十篇论文 - 刘江@图灵 - CSDNBlog

2009-03-02T11:30:00.000+08:00

所有程序员都应该至少读上两遍的十篇论文 - 刘江@图灵 - CSDNBlog

可以下载国外学位论文的网址_star的博客_雅虎博客_雅虎空间

2009-03-02T11:20:00.000+08:00

可以下载国外学位论文的网址_star的博客_雅虎博客_雅虎空间

回顾一下车辆跟驰两大流派之争

2009-03-02T10:53:00.001+08:00

由Brackstone于1999年发表的一篇文章"Car-following: a historical review"，引起了车辆跟驰研究的流派之争。

Brackstone的文章总结了所有基于pysical的车辆跟驰模型，但有意无意的忽略了基于psycological的工作。这引起了心理学研究者的不满，Hancock，Boer，Ranney等人纷纷发文表示抗议，从不同的角度提出了质疑。最后，还是Brackstone在"What is the answer and come to that, what are the questions?"一文中做出了回应，肯定了心理学研究在驾驶行为研究中的贡献，同时指出了感知模型的一个重要难题：模型校准。在文章的最后他亮出了自己的观点：哪种模型更“真”，其实并不重要，只要它能用来完成手头的任务，那就是合适的答案。能最好的完成手头任务的工具，就是最合适的答案。

可以说Brackstone是物理学派（工程学派）的捍卫者，对于心理学模型无法校准的弱点，想来是心中很不屑的（对于当时工程学派中缺乏模型校准的趋势也是很不屑的）。这也确实是心理学派的一个软肋，虽然感知模型对于驾驶行为中的不确定性做了很好的解释，但苦于难以校准，始终无法应用到仿真等领域中。相反的，如果能提供一个和实测数据符合的模型，即使它没有考虑驾驶者实际的驾驶决策过程，对于仿真也是合适的工具。

无模型车辆跟驰建模

2009-03-01T21:43:00.004+08:00

说是无模型，其实还是有模型的，但相对于“传统”的车辆跟驰模型来说，没有用事先假设的模型来构建一个框架，然后用数据来校准模型的参数。采用的是从实测数据出发，先对数据进行聚簇分类，然后拟合分类中的数据，并训练SVM模型。

对数据进行聚簇分类，采用的是层次聚类的思想，从底层开始向上构建，用簇内聚合度和簇间分离度来评价聚类质量。对高维，大数据量的数据集也有较好的效率。对非凸数据簇也能很好的识别。嘿嘿，当然不是我自己想出来的，是参考陈黎飞的文章。

上面的层次聚类方法属于离线计算方法，不适合在仿真运行中使用，因此需要一个能够对分类很好识别的方法。SVM方法就是这样一个满足需求的好方法，能从分类数据中找出若干“支持向量”，使得结构风险最小。

用SVM在线识别出新的数据点属于哪个分类后，还要根据该分类中训练数据给出的规律求出新的数据点对应的加速度值。这个规律如何得到呢？当然是要用数据拟合的方法，由分类中的训练数据拟合出一个函数。如何拟合呢？还是SVM！SVM除了可以用来分类外，还能用于回归，也就是拟合啦～原理和分类时的类似，找出若干“支持向量”，用来勾画出拟合的函数。

在用libsvm进行SVM的编程时，发现文档中说SVM的参数选择对于分类和拟合的效果（精度）有很大的影响。默认的搜索参数的方法是所谓的“网格”（grid）方法，也就是在参数的取值空间内隔一段取一个值，构成一张网，在取值空间内这么一过滤，就能筛出好的参数值了！说白了，这就是暴力搜索，网格越密，越能搜出好的参数值，但是所消耗的时间也就越长！SVM用于分类要搜索c和g两个参数值，用于拟合要搜索c，g和p三个参数值，因为不知道可能的参数值取值范围多大合适，我就把取值范围放宽了一点，网格取密了一点，结果拟合的参数算了好几天也没算出个结果出来！！

最后决定采用PSO（粒子群优化）算法来搜索参数值。PSO算法比较简单，收敛速度快，但容易收敛于局部最优，因此有各种的改良版本。看了国内两位作者的极值扰动的改良版本，受到了启发，又做了一些改进，就用它了！

实测数据用的还是那次跑车的数据，看看效果如何。必须要指出的是，无模型车辆跟驰建模对于数据的要求很高，要求能尽量覆盖所有的情况，没有覆盖到的情况当然无法得出对应的分类，也就无法在仿真中遇到相应情况时提供合理的反应。这也就自然的引出了下面的工作：虚拟测试及数据采集系统的研究。

wps的zotero插件

2009-02-27T10:32:00.003+08:00

前几天突然想到为wps写一个zotero的插件，因为WPS2009用得挺不错的，但Zotero对它没有支持，这也成了我难以彻底放弃其他类似编辑器的最重要的理由。

开始想用C#来写ActiveX Dll插件，发现不行，转而用VB6来写，按部就班，可以在WPS中显示Hello World了～接下去的工作一想就头大！

又上网搜了一下，发现wps号称和word的vba开发差不多，使用差不多的接口。于是想到能不能从Zotero为word写的插件中找找灵感呢？找到zotero.dot文件，打开后，用VBA编辑器打开一看，嘿嘿，代码全在里面待着呢～

函数命名还是挺规范的，一看就明白～做了一个按钮，用来触发功能函数，发现有问题，而且问题很多～甚至在和firefox的50001端口通讯上都有问题！真是郁闷了……

最近也没什么时间搞这个了，等着以后有空了再来整这个东东～目前只能把wps作为众多编辑器的之一了，希望它能越做越好～～

这两天忙了点啥

2009-02-23T16:01:00.002+08:00

除了正事外，还看了以下东西：

SPADE，一个python实现的多智能体开发环境，使用XMPP/Jabber，还专门为JADE开发了一个XMPP的MTP插件，但在Windows下不好用，试了几个小时也没搞定，就没兴趣再整了……
Kalman滤波器，看了原理，很简单，关键是人家写的好，还找到了一个用python实现的代码，里面给出了我看的那篇文章的链接，看来还蛮火的～：）
Wireshark，一个开源的功能强悍的网络包抓取和分析工具，试用了一下，蛮好用的，这里还有一个中文的教程，以前我咋就不知道有这样的好东西呢！
在云端上找到一个timeEdition软件，可以记录在电脑上干了些什么，并且可以将结果导出放到Google calendar上，真是太和我的心意了～阿军听我介绍后马上又找出一个叫rescue time的时间记录软件，功能好像也蛮强大的～

支持CNKI的Zotero的translator

2009-02-19T22:55:00.003+08:00

显示出来有乱码，还是点击下方的rawfile下载原始版本比较靠谱～

完成支持豆瓣的Zotero的translator

2009-02-19T22:15:00.003+08:00

最近发现豆瓣很好用，想把要看的书在zotero中保存下来，手动的太麻烦了，就动手做了一个translator～

JavaScript语言: 支持豆瓣的zotero的translator

{
"translatorID":"fc353b26-8911-4c34-9196-f6f567c93901",
"translatorType":4,
"label":"Douban",
"creator":"Ace Strong<acestrong@gmail.com>",
"target":"^https?://www.douban.com/subject",
"minVersion":"1.0.0",
"maxVersion":"",
"priority":100,
"inRepository":true,
"lastUpdated":"2009-2-19 20:45:00"
}

function detectWeb(doc, url) {
var articleRe = /subject_search/;
var s = articleRe.exec(url);

if(s) {
return "multiple";
} else {
return "book";
}

return false;
}

function scrape(doc) {
//var namespace = doc.documentElement.namespaceURI;
//var nsResolver = namespace ? function(prefix) {
// if (prefix == "x") return namespace; else return null;
//} : null;
var nsResolver = null;

var itemType = "book";

var newItem = new Zotero.Item(itemType);
Zotero.debug(itemType);

// 附件，网页快照
newItem.attachments.push({document:doc, title:"web snapshot"});
//Zotero.debug(doc);
Zotero.debug("Title:");
// 标题，/html/body/div/h1
var titleTag = doc.evaluate('//html/body/div/h1', doc, nsResolver, XPathResult.ANY_TYPE, null).iterateNext();

//Zotero.debug("stage2:");
var title = Zotero.Utilities.trimInternal(titleTag.textContent);
Zotero.debug(title);
newItem.title = title;

// 其他信息，//*[@id="info"]
var info = doc.evaluate('//*[@id="info"]', doc, nsResolver, XPathResult.ANY_TYPE, null).iterateNext();
//Zotero.debug(info);
// 找出作者信息（包括译者）
var dataRows = info.getElementsByTagName("span");
//Zotero.debug(dataRows.length);
var dataRow;
var i = 0;
while(dataRow = dataRows[i]) {
i = i + 1;
var spanTags = dataRow.getElementsByTagName("span");
//Zotero.debug(spanTags.length);
if (spanTags.length>0){
// 作者或译者
var authorType = Zotero.Utilities.trimInternal(spanTags[0].textContent);
var name = Zotero.Utilities.trimInternal(dataRow.getElementsByTagName("a")[0].textContent);
//Zotero.debug(authorType);
//Zotero.debug(name);
if(authorType == "作者"){
newItem.creators.push(Zotero.Utilities.cleanAuthor(name, "author", true));
}else if(authorType == "译者"){
newItem.creators.push(Zotero.Utilities.cleanAuthor(name, "translator", true));
}
}
}

// 提取ISBN,页数，定价，出版社，装帧，出版年信息
var obmo = info.getElementsByTagName("div")[0];
var content = obmo.textContent;
//Zotero.debug(content);

dataRows = obmo.getElementsByTagName("span");
Zotero.debug(dataRows.length);
i = 0;
while(dataRow = dataRows[i]) {
i = i + 1;
var infoType = dataRow.textContent;
//Zotero.debug(infoType);
// 去除无用的信息
content = content.replace(infoType,"");
//Zotero.debug(content);
}
// 去除前后空格
content = content.replace(/(^\s*)|(\s*$)/g, "");
// 将中间的空格转换为","
content = content.replace(/\s+/g, ',');
// 分离信息
var infoContents = content.split(",");
//Zotero.debug("detail info:");
//for (x in infoContents){
// Zotero.debug(infoContents[x]);
//}

// ISBN
newItem.ISBN = infoContents[0];
// 页数
newItem.pages = infoContents[1];
// 出版社
newItem.publisher = infoContents[3];
// 出版年
newItem.date = infoContents[5];
newItem.complete();
}

function doWeb(doc, url) {
var namespace = doc.documentElement.namespaceURI;
var nsResolver = null;

if(detectWeb(doc, url) == "multiple") {
Zotero.debug("Enter multiple~");
// search page
var items = new Array();

// //*[@id="in_tablem"]
var tablemTag = doc.evaluate('//*[@id="in_tablem"]', doc, nsResolver, XPathResult.ANY_TYPE, null).iterateNext();
var tableTags = tablemTag.getElementsByTagName("table");
Zotero.debug(tableTags.length);
var tableTag;
Zotero.debug("begin to fetch multiple title and link");
var i = 0;
while(tableTag = tableTags[i]) {
i = i + 1;
var tds = tableTag.getElementsByTagName("td");
var title ="";
var link = "";
var as = tds[1].getElementsByTagName("a");
link = as[0].href;
title = as[0].textContent;

Zotero.debug(title);
Zotero.debug(link);
if(link) {
items[link] = Zotero.Utilities.cleanString(title);
}
}
// 让用户选择要保存哪些文献
items = Zotero.selectItems(items);
if(!items) return true;
Zotero.debug("go on processing.");

var urls = new Array();
for(var url in items) {
urls.push(url);
}
} else {
var urls = [url];
}
Zotero.debug(urls);
// 下面对每条url进行解析
Zotero.Utilities.processDocuments(urls, scrape, function() { Zotero.done(); });
Zotero.wait();
}

用mingw编译boost，在Code::Block中使用

2009-02-18T23:28:00.004+08:00

下载boost，目前最新的是1.38.0，解压后可以选择下载预编译的bjam.exe，也可以从源码编译bjam。我选择从源码编译，命令很简单：

build.bat mingw

然后将bjam.exe拷贝到根目录下（任何目录都可以啦），加入系统PATH中。回到boost的根目录，输入命令：

bjam --toolset=gcc "--prefix=D:\Boost" install
然后就是等待了～

wiki上有详细的介绍：http://wiki.codeblocks.org/index.php?title=BoostWindowsQuickRef

注册表的文件关联及应用_最爱№绿茶

2009-02-16T14:20:00.000+08:00

注册表的文件关联及应用_最爱№绿茶

从小白开始写make-1-3.3 伯乐谷中华英才网

2009-02-13T22:10:00.000+08:00

从小白开始写make-1-3.3 伯乐谷中华英才网

Free Mind » 训练数据对分类器性能的影响

2009-02-12T23:20:00.000+08:00

Free Mind » 训练数据对分类器性能的影响

相信我，你并不孤单！

2009-02-12T23:10:00.002+08:00

首先来说说今天晚上完成的批量测试几种PSO算法的结果：

> "D:\Python25\pythonw.exe" -u "F:\projects\svr\pso.py"
training with function: Sphere
training with pso: bPSO
average value = 33895.368806, best value = 16366.455677
training with pso: sPSO
average value = 713.990013, best value = 5.145062
training with pso: tPSO
average value = 31565.762681, best value = 12586.708452
training with pso: stPSO
average value = 620.577996, best value = 5.207246
training with pso: istPSO
average value = 0.015338, best value = 0.004548
best pso is istPSO
training with function: Griewank
training with pso: bPSO
average value = 9.637782, best value = 4.977231
training with pso: sPSO
average value = 0.735644, best value = 0.191848
training with pso: tPSO
average value = 8.538446, best value = 4.857032
training with pso: stPSO
average value = 0.557846, best value = 0.187582
training with pso: istPSO
average value = 0.045185, best value = 0.000121
best pso is istPSO
training with function: Rosenbrock
training with pso: bPSO
average value = 9618082261.674509, best value = 2725173927.465609
training with pso: sPSO
average value = 179243235.044173, best value = 631.653198
training with pso: tPSO
average value = 8046176465.674629, best value = 1196837169.500892
training with pso: stPSO
average value = 2338.451929, best value = 612.315377
training with pso: istPSO
average value = 367129077.608837, best value = 29.142729
best pso is istPSO
training with function: Rastrigin
training with pso: bPSO
average value = 34903.229750, best value = 20759.712907
training with pso: sPSO
average value = 378.882609, best value = 186.164672
training with pso: tPSO
average value = 29756.547518, best value = 13739.131209
training with pso: stPSO
average value = 785.898331, best value = 205.353543
training with pso: istPSO
average value = 91.394043, best value = 1.290095
best pso is istPSO

显然，istPSO效果最好，但我还是不太满意，准备做进一步的优化！

再来说说今天看到的一个帖子，前面已经给了一个链接，从TopLanguage里看到的，点击进去看了，发现是个豆瓣的帖子，楼主开篇的话让我觉得“并不孤单”！笑来的话再次应验了：相信我，你并不孤单！

明天还要考试，今晚不能太迟睡了，再看会这个帖子，看看楼主是如何攻克拖延症的～晚上的批量测试程序就是在看到这个帖子后才开始做的，看到有这么多人和我有一样的痛苦，不觉中痛苦就减轻了很多，嘿嘿：）

攻克拖延症--经历记录与心得分享

2009-02-12T21:16:00.000+08:00

攻克拖延症--经历记录与心得分享

Geo Globle | 小乙BLOG

2009-02-12T18:49:00.000+08:00

Geo Globle | 小乙BLOG

改进PSO

2009-02-09T20:28:00.002+08:00

重复文章中的实验，发现结果并没有说的那么好～

倒是改进后的PSO，效果倒是相当不错，至少比改进前要好了不少！准备再进一步改进一下，看看能不能再提高一些～

[转]Python：time.clock() vs. time.time()

2009-02-04T16:49:00.000+08:00

Python：time.clock() vs. time.time()

Posted by Ross Wan on 九月 19, 2008

有时候，我们需要知道程序或者当中的一段代码的执行速度，于是就会加入一段计时的代码，如下：

start = time.clock()
    ... do something
elapsed = (time.clock() - start)

又或者

start = time.time()
    ... do something
elapsed = (time.time() - start)

那究竟 time.clock() 跟 time.time()，谁比较精确呢？带着疑问，查了 Python 的 time 模块文档，当中 clock() 方法有这样的解释：

clock()

On
Unix, return the current processor time as a floating point number
expressed in seconds. The precision, and in fact the very definition of
the meaning of “processor time”, depends on that of the C function of
the same name, but in any case, this is the function to use for
benchmarking Python or timing algorithms.

On Windows, this
function returns wall-clock seconds elapsed since the first call to
this function, as a floating point number, based on the Win32 function
QueryPerformanceCounter(). The resolution is typically better than one
microsecond.

可见，time.clock() 返回的是处理器时间，而因为 Unix 中 jiffy 的缘故，所以精度不会太高。

总结

究竟是使用 time.clock() 精度高，还是使用 time.time() 精度更高，要视乎所在的平台来决定。总概来讲，在 Unix 系统中，建议使用 time.time()，在 Windows 系统中，建议使用 time.clock()。

这个结论也可以在 Python 的 timtit 模块中（用于简单测量程序代码执行时间的内建模块）得到论证：

if sys.platform == "win32":
    # On Windows, the best timer is time.clock()
    default_timer = time.clock
else:
    # On most other platforms the best timer is time.time()
    default_timer = time.time

使用 timeit 代替 time，这样就可以实现跨平台的精度性：

start = timeit.default_timer()
    ... do something
elapsed = (timeit.default_timer() - start)

参考资料：

从赵本山巩俐谈“明星换国籍”……--流氓兔 - 乐活中国

2009-02-02T16:14:00.000+08:00

从赵本山巩俐谈“明星换国籍”……--流氓兔 - 乐活中国

多维粒子群（PSO）算法

2009-02-02T13:25:00.002+08:00

这两天就捣鼓这个了。

先从这个网站找到一个简单并且有点不靠谱的一维PSO的python实现。特点是简单，容易看懂，并且用pygame将优化过程保存成图片，方便以后查看。改为多维的实现，能运行后发现调用libsvm进行交叉校验每次都会打印出信息，大大减慢了算法的速度！于是昨晚就调试怎么去掉这个了～
今天早上起来想到那个保存成图片的功能不错，多维算法可以指定其中一维来实现，大不了多搞几个这样的类给PSO，分别保存每一维的优化过程就是了！实现后发现有问题，蓝色的最优点居然会跑到fitness函数外面！幸亏这个保存图片的功能，不然还真发现不了这个bug呢！经过调试发现是因为复制列表时仅复制了引用，这样在种群继续进化时就直接导致最优点的值也变了！找到问题就好办了，用deepcopy复制列表就OK啦～

多维PSO的代码如下：

Python语言: 粒子群（PSO）算法

# Copyright (C) 2004, Maxime Biais <maxime@biais.org>
# Copyright (C) 2009, Ace Strong <acestrong@gmail.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: pso.py,v 2.0 2009/02/02 10:00:45 ace Exp $

from random import uniform
from copy import deepcopy

class PSO:
def __init__(self, pop_size, particle_size, particle_scope, C1, C2, w, max_w, min_w, max_iter, func, extra_args=None):
'''
pop_size: size of population
particle_size: dimension of each particle
particle_scope: value range of each particle's dimension
C1: cognitive factor following personal best
C2: social facotr following global best
w: const inertial factor
min_w: min range of inertial factor
max_w: max range of inertial factor
max_iter: max iteration of algrithm
func: fitness evaluation function
'''
# fitness function
self.func = func
# used for fitness function
self.extra_args = extra_args

self.pop = []
# converging factor
self.r = 0.729
self.particle_size = particle_size
# parse range of each dimension
self.min_range = particle_scope[::2]
self.max_range = particle_scope[1::2]
# 0: position, 1: velocity, 2: fitness
for i in xrange(pop_size):
self.pop.append(self.initParticle())
self.evaluate()
# global best
self.gbest = deepcopy(self.pop[0])
# personal best, each partical has one
self.pbest = deepcopy(self.pop)
# weight following personal best, cognitive factor
self.C1 = C1
# weight following global best, social facotr
self.C2 = C2
# weight following current speed, inertial factor
self.w = w
# used by un-const method
self.max_w = max_w
self.min_w = min_w
# max iteration number
self.max_iter = max_iter
# current iteration number
self.curr_iter = 0

def initParticle(self):
particle = []
# position, in particle_size dimension
position = []
for j in xrange(self.particle_size):
position.append(uniform(self.min_range[j], self.max_range[j]))
particle.append(position)
# velocity, in particle_size dimension
velocity = []
for j in xrange(self.particle_size):
velocity.append(uniform(-1, 1))
particle.append(velocity)
# fitness
particle.append(0)
return particle

def update_velocity(self):
# linear descending w
w = self.max_w - self.curr_iter*((self.max_w - self.min_w)/self.max_iter)
# # fixed w
# w = self.w
# # nonlinear descending w, concave function
# w = (self.max_w - self.min_w)*(self.curr_iter/self.max_iter)**2 \
# + (self.min_w - self.max_w)*(2*self.curr_iter/self.max_iter) \
# + self.max_w
# # nonlinear descending w, concave function
# w = self.min_w*(self.max_w/self.min_w)**(1/(1+10*self.curr_iter/self.max_iter))
i = 0
for p in self.pop:
for j in xrange(self.particle_size):
p[1][j] = w * p[1][j] + uniform(0, self.C1) * (self.pbest[i][0][j] \
- p[0][j]) + uniform(0, self.C2) * (self.gbest[0][j] - p[0][j])
i += 1

def evaluate(self):
for p in self.pop:
p[2] = self.func(p[0], self.extra_args)

def move(self):
i = 0
for p in self.pop:
for j in xrange(self.particle_size):
p[0][j] += self.r * p[1][j]
if p[0][j] > self.max_range[j] or p[0][j] < self.min_range[j]:
self.pop[i] = self.initParticle()
break
# if self.func(self.gbest[0],self.extra_args)!=self.gbest[2]:
# print "error in move!"
i += 1

def run(self, update_func=None):
for i in xrange(self.max_iter):
print "current iter = %d" % self.curr_iter
if update_func:
update_func()
self.update_velocity()
self.move()
self.evaluate()
# current best of personal bests
cpbest = deepcopy(self.pbest[0])
for k in xrange(len(self.pop)):
if self.pop[k][2] < self.pbest[k][2]:
self.pbest[k] = deepcopy(self.pop[k])
if self.pbest[k][2] < cpbest[2]:
cpbest = self.pbest[k]

if cpbest[2] < self.gbest[2]:
# print "changing gbest from %s" % self.gbest
self.gbest = cpbest
# print "to %s" % self.gbest
# if self.func(self.gbest[0],self.extra_args)!=self.gbest[2]:
# print "error in run!"
# print self.gbest
self.curr_iter += 1

def __str__(self):
ret = ""
for i in self.pop:
ret += str(i) + "\n"
return ret

import pygame
import time

class PygamePrinter:
'''draw the given dimension's evolution
'''
def __init__(self, pso, w=400, h=300, dimension=0, extra_args=None):
self.calls = 0
self.w = w
self.h = h
self._init_pygame()
self.pso = pso
self.dimension = dimension
self.extra_args = extra_args

def _init_pygame(self):
self.screen = pygame.display.set_mode((self.w, self.h), 0, 8)
self.backcolor = (0, 0, 0)
self.funccolor = (255, 255, 255)
self.partcolor = (255, 0, 0)
self.elitecolor = (0, 0, 255)

def draw_point(self, color, x, y, size=3):
pygame.draw.rect(self.screen, color, (x - size, y - size, \
size*2, size*2))

def p2p(self, x, y):
return (x + 1) * 200, y * 300

def draw_func(self):
for i in range(self.w):
x = i / (self.w / float((self.pso.max_range[self.dimension] \
- self.pso.min_range[self.dimension]))) \
+ self.pso.min_range[self.dimension]
y = self.pso.func((x, self.dimension), self.extra_args)
rh = y * (self.h / 2.) + (self.h / 2.)
self.draw_point(self.funccolor, i, rh, 1)

def _draw_xy(self, color, x, y):
self.draw_point(color, (x + self.pso.max_range[self.dimension]) * self.w \
/ float((self.pso.max_range[self.dimension] - self.pso.min_range[self.dimension])), \
(y + 1)*self.h/2)

def draw_pop(self):
for i in self.pso.pop:
self._draw_xy(self.partcolor, i[0][self.dimension], i[2])
i = self.pso.gbest
self._draw_xy(self.elitecolor, i[0][self.dimension], i[2])

def __call__(self):
#time.sleep(0.5)
self.screen.fill(self.backcolor)
self.screen.lock()
self.draw_func()
self.draw_pop()
self.screen.unlock()
pygame.display.flip()
if self.calls % 2 == 0:
# print "call=%d" % self.calls
pygame.image.save(self.screen, "pso-%d.bmp" % self.calls)
self.calls += 1

import math
def testFunc(arg, extra_args):
x = arg[0]
return math.cos(x) * math.exp(math.sin(x)) * math.sin(x) / 1.5

def test():
import math
# func = lambda x:math.cos(x*math.sin(x*0.3)-x) / 1.5
# func = lambda x:math.cos(x) * math.exp(math.sin(x)) * math.sin(x) / 1.5
p = PSO(15, 1, (-4.5, 4.5), C1=2, C2=2, w=0.5, max_w=0.95, min_w=0.4, max_iter=20, func=testFunc)
printer = PygamePrinter(p)
p.run(update_func=printer)
# p.run()
print p
print p.gbest

if __name__ == "__main__":
test()

去掉libsvm中的输出信息

2009-02-02T01:50:00.004+08:00

终于成功编译libsvm的源文件了！

因为默认的输出信息大大减慢了程序运行的速度，原来想在python中将stdout重定向来解决这个问题，后来发现不管用。于是就打算从libsvm的源码入手来解决。找到定义info函数的地方，将"if 1"改为 "if 0"就可以了。但下面编译出svmc.pyd文件费了老劲了！折腾了一个多小时，总算是搞定了！

用如下命令编译出svmc.pyd：

D:\GreenSoftware\libsvm-2.88\python>g++ svm.cpp svmc_wrap.c -shared -o svmc.pyd -ID:\Python25\include -ID:\MinGW\include -ID:\MinGW\include\c++\3.4.5 -ID:\MinGW\include\c++\3.4.5\backward -LD:\Python25\libs -lpython25

用如下命令install：

D:\GreenSoftware\libsvm-2.88\python>python setup.py build --compiler=mingw32 install

就可以了！

使用libsvm进行SVR

2009-01-30T16:17:00.003+08:00

昨天最大的收获就是明了了原来SVM中的SVC对我没用，因为它需要将数据分好类，对我有用的是SVR，用它来做回归，也就是拟合，效果据说不错～
今天就正式开始动手了，先简单的写了一个数据转换的类（以后要把所有的数据格式转换都放到这个类里面去，用不同的函数来调用），将模糊推理里用的数据转为libsvm指定的格式。然后在easy.py里在Cross validation和后面的Training里添加上了"-s 3"，用教程里说的"python easy.py c-z-1.svm"来处理数据，结果是：“Best c=32768.0, g=0.5 CV rate=8.0785”！看起来好像不太妙，虽然还不是很清楚这里的CV rate是什么意思，但前面的c居然等于32768这么大的数，肯定是出问题了～
上网继续搜libsvm的使用，发现还有个gridregression.py的程序，好像是专门针对SVR进行grid搜索的。下载一看，就是在grid.py的基础上修改的，好像就是添加了一个-p，从而是搜索c,g,p三维空间，这下子搜索量就更大了！看来搞一个启发式的搜索最佳参数的算法还是很有必要的啊～
改了gridregression.py中的路径（后来发现其实不用改，因为用easy.py调用时会传入路径），在easy.py中也修改了相应的调用命令，得出的c，g，p都正常许多，CV rate值变成了一点多，看来是越小越好啊～
修改后的gridregression.py和easy.py都发到发芽网上去了。以后还要写个启发式搜索c,g,p的算法，不然运算量太大了，算一次得老半天，这可不行啊！

Stifled Laughter: How the Communist Party Killed Chinese Humor

2009-01-29T21:17:00.000+08:00

Stifled Laughter: How the Communist Party Killed Chinese Humor

对于树来说它就是一只猛兽！

2009-01-29T21:01:00.000+08:00

学会如何在python中从源码编译安装第三方的模块

2009-01-25T01:22:00.004+08:00

以前安装第三方模块时也从源码安装过，不过那些源码都是python的源码，不牵扯到c语言的编译。凡是牵扯到c语言编译的，如libsvm，都会说我没有安装vs2003，所以无法编译安装。每次遇到这种情况，我就只好去下一个Windows下的exe安装文件来装，这经常不是最新的版本！
今天决定搞定这个问题。去网上搜了一下，发现其实只要用这个命令“python setup.py build --compiler=mingw32 install”就可以了～
用libsvm试了一下，开始遇到问题，编译发生错误。仔细看看，原来是缺少c语言的源文件。从上一级目录拷贝源文件到python目录下，再次执行就可以了。

BTW，删除这种方式安装的第三方模块该如何进行呢？答案超简单，到python的安装目录下找到copy到其中的第三方模块的文件和文件夹（如果有的话），直接删除就可以了。

活着的人要更好的活下去_韩寒_新浪博客

2009-01-23T14:01:00.000+08:00

活着的人要更好的活下去_韩寒_新浪博客

本月任务

2009-01-22T20:31:00.002+08:00

快到春节了，这段时间最容易浪费了～

尽早计划一下，充分利用好这段时间～

几项任务：

cops用于TS建模；
svm用于TS建模；
虚拟数据采集；
仿真平台完成；
显示模块完成；

其中任务1和2是承接前面的工作，用新的算法解决遗留问题。任务3-5需要大量的编程工作，3维显示要用到Panda3D，头部活动感应要用到Wii，还有仿真平台内agent的决策，都需要做大量的工作。

先从Wiki入手，学习svm，利用一切可以上网的时间，来代替在网上的闲逛。然后用libsvm+python来进行TS建模。cops方法有matlab的程序，看看能不能快速的应用到TS建模中。这两项任务在春节前完成。编程活动放在春节后进行。

python中socket编程

2009-01-17T11:56:00.002+08:00

这里（Socket Programming HOWTO）是讲python中的socket编程，很好，很强大。通过这个网页我学会了select，知道了如何非阻塞的用UDP接收数据。这样一来就可以用定时器代替线程了，简单了很多。
以前看过几次select，但一直不明白怎么用。今天总算是明白是干嘛的了～～

经纬度与UTM坐标的转换

2009-01-15T14:50:00.004+08:00

昨天花了一个晚上的时间搞定了经纬度到UTM坐标的转换，UTM到经纬度的转换还没来得及弄，不过有了前者，后者就有底了～
按理说来，这个LL2UTM的转换以前就有中文的网页介绍过，具体网址我记不清了，应该很容易搜到，还有用C语言实现的函数代码，用的是UGSC的方法。我用它来转换经纬度到UTM，画出的地图和实际的很像，就想当然的认为已经搞定了。
昨天因为需要进行逆向转换，也就是UTM2LL，所有在网上搜索，G到了这个网页，作者是Steven Dutch，最后更新是08年4月1号，愚人节哦～里面讲得挺清楚的，有LL2UTM，也有UTM2LL。
LL2UTM有两种方法，一种是美国军方给出的，一种是美国地质测量部给出的，分别简称为Army和USGS。至于UTM2LL，Army的方法牵扯到查表插值，所以只给出了USGS的方法。最让人开心的是Steven还给出了包含转换实现的Excel文件下载！这个东西作用大大的，后面会说到。
我开始没有多想，直接拿我前面转换好的UTM的X、Y坐标填入Excel文件中，转换出来的值却是和原始的经纬度值大不一样！如果UTM2LL的转换没有错的话，那么就是我的LL2UTM出错了！拿原始经纬度值填入Excel文件中转换成UTM坐标，和我转换出来的果然不一样！还差了不少！
仔细看了看Excel文件中转换的中间值，发现我的中央经纬度值就出错了！原先我写的LL2UTM函数需要把中央经纬度值作为输入参数，我手动算118度的中央经纬度居然算出了120，实际上应该是117，改了以后再转换一遍，就差不多了。但看着尚存的误差，我还是有点不甘心。我原先写的函数实际上用的是USGS方法，Steven建议的是用Army的方法，于是我就又用python实现一遍。这次就曲折大了！
按照Steven给出的公式写完函数后，填入原始经纬度值调用，发现出来的UTM值查了好多！仔细检查了好几遍，没错啊！还好Excel文件中有中间过程值显示，就把中间结果都打印出来比较，发现是最后算K*时出的错。看了Excel中的计算公式，发现问题所在了：和网页中的公式不一样！按照Excel中的计算公式改了再试，可以了～～

从经纬度转换为UTM坐标（USGS方法）

def LL2UTM_USGS(a, f, lat, lon, lonOrigin, FN):
'''
** Input：(a, f, lat, lon, lonOrigin, FN)
** a 椭球体长半轴
** f 椭球体扁率 f=(a-b)/a 其中b代表椭球体的短半轴
** lat 经过UTM投影之前的纬度
** lon 经过UTM投影之前的经度
** lonOrigin 中央经度线
** FN 纬度起始点，北半球为0，南半球为10000000.0m
---------------------------------------------
** Output:(UTMNorthing, UTMEasting)
** UTMNorthing 经过UTM投影后的纬度方向的坐标
** UTMEasting 经过UTM投影后的经度方向的坐标
---------------------------------------------
** 功能描述：UTM投影
** 作者： Ace Strong
** 单位： CCA NUAA
** 创建日期：2008年7月19日
** 版本：1.0
** 本程序实现的公式请参考
** "Coordinate Conversions and Transformations including Formulas" p35.
** & http://www.uwgb.edu/dutchs/UsefulData/UTMFormulas.htm
'''

# e表示WGS84第一偏心率,eSquare表示e的平方
eSquare = 2*f - f*f
k0 = 0.9996

# 确保longtitude位于-180.00----179.9之间
lonTemp = (lon+180)-int((lon+180)/360)*360-180
latRad = math.radians(lat)
lonRad = math.radians(lonTemp)
lonOriginRad = math.radians(lonOrigin)
e2Square = (eSquare)/(1-eSquare)

V = a/math.sqrt(1-eSquare*math.sin(latRad)**2)
T = math.tan(latRad)**2
C = e2Square*math.cos(latRad)**2
A = math.cos(latRad)*(lonRad-lonOriginRad)
M = a*((1-eSquare/4-3*eSquare**2/64-5*eSquare**3/256)*latRad
-(3*eSquare/8+3*eSquare**2/32+45*eSquare**3/1024)*math.sin(2*latRad)
+(15*eSquare**2/256+45*eSquare**3/1024)*math.sin(4*latRad)
-(35*eSquare**3/3072)*math.sin(6*latRad))

# x
UTMEasting = k0*V*(A+(1-T+C)*A**3/6
+ (5-18*T+T**2+72*C-58*e2Square)*A**5/120)+ 500000.0
# y
UTMNorthing = k0*(M+V*math.tan(latRad)*(A**2/2+(5-T+9*C+4*C**2)*A**4/24
+(61-58*T+T**2+600*C-330*e2Square)*A**6/720))
# 南半球纬度起点为10000000.0m
UTMNorthing += FN
return (UTMEasting, UTMNorthing)

从经纬度转换到UTM（Army方法）

def LL2UTM_Army(a, b, lat_ll, lon_ll, FN):
'''
** Input：(a, b, lat, lon, FN)
** a 椭球体长半轴
** b 椭球体短半轴
** lat_ll 经过UTM投影之前的纬度(角度为单位)
** lon_ll 经过UTM投影之前的经度(角度为单位)
** FN 纬度起始点，北半球为0，南半球为10000000.0m
---------------------------------------------
** Output:(UTMEasting, UTMNorthing)
** UTMNorthing 经过UTM投影后的纬度方向的坐标
** UTMEasting 经过UTM投影后的经度方向的坐标
---------------------------------------------
** 功能描述：UTM投影
** 作者： Ace Strong
** 单位： CCA NUAA
** 创建日期：2009年1月14日
** 版本：1.0
** 本程序实现的公式请参考
** http://www.uwgb.edu/dutchs/UsefulData/UTMFormulas.htm
'''

lat = math.radians(lat_ll)
lon = math.radians(lon_ll)
lon0_ll = 6*(int(lon_ll/6)+31)-183
k0 = 0.9996
e = math.sqrt(1-b**2/a**2)
e2 = e**2/(1-e**2)
n = (a-b)/(a+b)
rho = a*(1-e**2)/((1-(e*math.sin(lat))**2)**(3.0/2))
nu = a/((1-(e*math.sin(lat))**2)**(1.0/2))
p = (lon_ll-lon0_ll)*3600/10000
sin1 = math.pi/(180*60*60)

A = a*(1 - n + (5.0/4)*(n**2 - n**3) + (81.0/64)*(n**4 - n**5))
B = (3*a*n/2)*(1 - n + (7.0/8)*(n**2 - n**3) + (55.0/64)*(n**4 - n**5))
C = (15*a*n**2/16)*(1 - n + (3.0/4)*(n**2 - n**3))
D = (35*a*n**3/48)*(1 - n + (11.0/16)*(n**2 - n**3))
E = (315*a*n**4/51)*(1 - n)
S = A*lat - B*math.sin(2*lat) + C*math.sin(4*lat) - D*math.sin(6*lat) + E*math.sin(8*lat)

# y
K1 = S*k0
K2 = nu*math.sin(lat)*math.cos(lat)*sin1**2*k0*(100000000)/2
K3 = (sin1**4*nu*math.sin(lat)*math.cos(lat)**3/24)*(5 - math.tan(lat)**2 + 9*e2*math.cos(lat)**2 + 4*e2**2*math.cos(lat)**4)*k0*(10000000000000000)
UTMNorthing = K1 + K2*p**2 + K3*p**4
# 南半球纬度起点为10000000.0m
UTMNorthing += FN
# x
K4 = k0*sin1*nu*math.cos(lat)*10000
K5 = (sin1*math.cos(lat))**3*(nu/6)*(1 - math.tan(lat)**2 + e2*math.cos(lat)**2)*k0*1000000000000
UTMEasting = K4*p + K5*p**3 + 500000
return (UTMEasting, UTMNorthing)

开始尝试svm

2009-01-12T13:29:00.004+08:00

前几天在网上看到Google Developer Day上关于机器学习的一个演讲，演讲者之一是台湾的林智仁教授，讲了svm的原理和发展情况。可惜视频上没有演讲时的ppt的内容，他的演讲又是中英混杂的，时不时蹦一个英文单词出来，对于没有相关背景的我来说，有不少都不懂是什么意思。演讲中提到了林教授是svm研究中的先锋人物（当然不是林教授自己说的，是另一个Google的工程师说的），还提到了libsvm工具包。于是顺藤摸瓜找到了libsvm，原来就是林教授开发的！对python语言的支持非常好，是内置在包里的。而且好像用的人也很多，网上相关的资料很多，看了一下，上手很容易。
恰好知道师兄也用过svm，就发个飞信问他用的是不是这个，结果说是ls-svm。上网又搜了一下，这是最小二乘支持向量机：

近年，Suykens J.A.K提出一种新型支持向量机方法—最小二乘支持向量机（Least Squares Support Vector Machines，简称LS-SVM）用于解决模式分类和函数估计问题等.最小二乘支持向量机方法是采用最小二乘线性系统作为损失函数，代替传统的支持向量机采用的二次规划方法。

LS-SVM方法简化了计算的复杂性。另外，由于LS-SVM采用了最小二乘法，因此运算速度明显快于支持向量机的其它版本。

问了一下，另一个师妹也是用的这个。不过ls-svm好像只支持c和matlab，对于其他语言不支持。当然支持c就可以包装成python可用的模块，但毕竟麻烦一点，还有人说：

但是该方法也是以推广性的损失为代价的
要根据使用的范围确定选用什么样的方法

这让我回过神来，这些都是工具，要对svm的原理有了清楚的认识才能合理、正确、有效的使用这些工具。正好师兄的大论文里有关于SVM的详细介绍，看完这个再来选择吧～

piaip's Using (lib)SVM Tutorial

2009-01-10T21:37:00.000+08:00

piaip's Using (lib)SVM Tutorial

piaip's Using (lib)SVM Tutorial piaip 的 (lib)SVM 簡易入門

piaip at csie dot ntu dot edu dot tw,
Hung-Te Lin
Fri Apr 18 15:04:53 CST 2003
$Id: svm_tutorial.html,v 1.13 2007/10/02 05:51:55 piaip Exp piaip $ 原作：林弘德，轉載請保留原出處

Why this tutorial is here

我一直覺得 SVM 是個很有趣的東西，不過也一直沒辦法 (mostly 衝堂) 去聽林智仁老師的 Data mining 跟 SVM 的課；後來看了一些網路上的文件跟聽 kcwu 講了一下 libsvm 的用法後，就想整理一下，算是對於並不需要知道完整 SVM 理論的人提供使用 libsvm 的入門。原始 libsvm 的 README 跟 FAQ 也是很好的文件，不過你可能要先對 svm 跟流程有點了解才看得懂 (我在看時有這樣的感覺)；這篇入門就是為了從零開始的人而寫的。 I've been considering SVM as an interesting and useful tool but couldn't attend the "Data mining and SVM" course by prof. cjline about it (mostly due to scheduling conflicts). After reading some materials on the internet and discussing libsvm with some of my classmates and friends , I wanted to provide some notes here as a tutorial for those who do not need to know the complete theory behind SVM theory to use libsvm . The original README and FAQ files that comes with libsvm are good documents too. But you may need to have some basic knowledge of SVM and its workflow (that's how I felt when I was reading them). This tutorial is specificly for those starting from zero.

後來還有一些人提供意見，所以在此要感謝： I must thank these guys who provided feedback and helped me make this tutorial:

kcwu, biboshen, puffer, somi

不過請記得底下可能有些說法不一定對，但是對於只是想用 SVM 的人來說我覺得這樣說明會比較易懂。 Remember that some aspect below may not be correct. But for those who just wish to "USE" SVM, I think the explanation below is easier to understand.

這篇入門原則上是給會寫基本程式的人看的，也是給我自己一個備忘, 不用太多數學底子，也不用對 SVM 有任何先備知識。 This tutorial is basically for people who already know how to program. It's also a memo to myself. Neither too much mathmatics nor prior SVM knowledge is required.

還看不懂的話有三個情形, 一是我講的不夠清楚, 二是你的常識不足, 三是你是小白 ^^; If you still can't understand this tutorial, there are three possibilities: 1. I didn't explain clearly enough, 2. You lack sufficient common knowledge, 3. You don't use your brain properly ^^;

我自己是以完全不懂的角度開始的，這篇入門也有不少一樣不懂 SVM 的人看過、而且看完多半都有一定程度的理解，所以假設情況一不會發生，那如果不懂一定是後兩個情況 :P 也所以, 有問題別問我。 Since I begin writing this myself with no understanding of the subject, ans this document has been read by many people who also didn't understand SVM but gained a certain level of understanding after reading it, possibility 1 can be ruled out. Thus if you can't understand it you must belong to the latter two categories, :P thus even if you have any questions after reading this, don't ask me.

SVM: What is it and what can it do for me?

SVM, Support Vector Machine , 簡而言之它是個起源跟類神經網路有點像的東西，不過現今最常拿來就是做分類 (classification)。也就是說，如果我有一堆已經分好類的東西 （可是分類的依據是未知的！） ，那當收到新的東西時， SVM 可以預測 (predict) 新的資料要分到哪一堆去。 SVM, Support Vector Machine , is something that has similar roots with neural networks. But recently it has been widely used in Classification. That means, if I have some sets of things classified (But you know nothing about HOW I CLASSIFIED THEM, or say you don't know the rules used for classification), when a new data comes, SVM can PREDICT which set it should belong to.

聽起來是很神奇的事（如果你覺得不神奇，請重想一想這句話代表什麼： 分類的依據是未知的！，還是不神奇的話就請你寫個程式解解看這個問題），也很像要 AI 之類的高等技巧... 不過 SVM 基於 統計學習理論 可以在合理的時間內漂亮的解決這個問題。 It sounds marvelous and would seem to require advanced techniques like AI searching or some time-consuming complex computation. But SVM used some Statistical Learning Theory to solve this problem in reasonable time.

以圖形化的例子來說明(by SVMToy), 像假定我在空間中標了一堆用顏色分類的點, 點的顏色就是他的類別, 位置就是他的資料, 那 SVM 就可以找出區隔這些點的方程式, 依此就可以分出一區區的區域; 拿到新的點(資料) 時, 只要對照該位置在哪一區就可以(predict) 找出他應該是哪一顏色(類別)了: Now we explain with a graphical example(by SVMToy), I marked lots of points with different colors on a plane, the color of each point is its "class" and the location is its data. SVM can then find equations to split these points and with these equations we can get colored regions. When a new point(data) comes, we can find (predict) what color (class) a point should be just by using the point's location (data)

原始資料分佈 Original Data	SVM找出來的區域 SVM Regions

當然 SVM 不是真的只有畫圖分區那麼簡單, 不過看上面的例子應該可以了解 SVM 大概在作什麼. Of course SVM is not really just about painting and marking regions, but with the example above you should should be able to get some idea about what SVM is doing.

要對 SVM 再多懂一點點，可以參考 cjlin 在 data mining 課的 slides: pdf or ps 。
底下我試著在不用看那個 slide 的情況解釋及使用 libsvm。 To get yourself more familiar with SVM, you may refer to the slides cjlin used in his Data Mining course : pdf or ps .
I'm going to try to explain and use libSVM without those slides.

所以, 我們可以把 SVM 當個黑盒子, 資料丟進去讓他處理然後我們再來用就好了. Thus we can consider SVM as a black box. Just push data into SVM and use the output.

How do I get SVM?

林智仁(cjlin)老師的 libsvm 當然是最完美的工具. Chih-Jen Lin's libsvm is of course the best tool you can ever find.

Download libsvm

下載處: Download Location:

libsvm.zip or libsvm.tar.gz

.zip 跟 .tar.gz 基本上是一樣的, 只是看你的 OS; 習慣上 Windows 用 .zip 比較方便 (因為有 WinZIP, 不過我都用 WinRAR), UNIX 則是用 .tar.gz Contents in the .zip and .tar.gz are the same. People using Windows usually like to use .zip files because they have WinZIP, which I always replace with WinRAR. UNIX users mostly prefer .tar.gz

Build libsvm

解開來後, 假定是 UNIX 系統, 直接打 make 就可以了; 編不出來的話請詳讀說明和運用常識. 因為這是 tutorial, 所以我不花時間細談, 而且會編不出來的情形真是少之又少, 通常一定是你的系統有問題或你太笨了. 其他的子目錄可以不管, 只要 svm-train, svm-scale, svm-predict 三個執行檔有編出來就可以了. After you extracted the archives, just type make if you are using UNIX. You may ignore some of the subdirectories. We only need these executable files: svm-train, svm-scale, and svm-predict

Windows 的用戶要自己重編當然也是可以, 不過已經有編好的 binary 在裡面了: 請檢查 windows 子目錄, 應該會有 svmtrain.exe, svmscale.exe, svmpredict.exe, svmtoy.exe . Windows users may rebuild from source if you want, but there're already some prebuilt binaries in the archive: just check your "windows" subdirectory and you should find svmtrain.exe, svmscale.exe, svmpredict.exe, and svmtoy.exe .

Using SVM

libsvm 有很多種用法, 這篇 tutorial 只打算講簡單的部分. libsvm has lots of functions. This tutorial will only explain the easier parts (mostly classification with default model).

The programs

解釋一下幾個主要執行檔的作用: (UNIX/Windows 下檔名稍有不同, 請用常識理解我在講哪個) I'm going to describe how to use the most important executables here. The filenames are a little bit different under Unix and Windows, apply common sense to see which I'm referring to.

svmtrain: Train (訓練) data. 跑 SVM 被戲稱為 "開火車" 也是由於這個程式名而來. train 會接受特定格式的輸入, 產生一個 "Model" 檔. 這個 model 你可以想像成 SVM 的內部資料, 因為 predict 要 model 才能 predict, 不能直接吃原始資料. 想想也很合理, 假定 train 本身是很耗時的動作, 而 train 好可以以某種形式存起內部資料, 那下次要 predict 時直接把那些內部資料 load 進來就快多了. Use your data for training. Running SVM is often referred to as 'driving trains' by its non-native English speaking authors because of this program. svmtrain accepts some specifically format which will be explained below and then generate a 'Model' file. You may think of a 'Model' as a storage format for the internal data of SVM. This should appear very reasonable after some thought, since training with data is a time-consuming process, so we 'train' first and store the result enabling the 'predict' operation to go much faster.
svmpredict: 依照已經 train 好的 model, 再加上給定的輸入 (新值), 輸出 predict (預測) 新值所對應的類別 (class). Output the predicted class of the new input data according to a pre-trained model.
svmscale: Rescale data. 因為原始資料可能範圍過大或過小, svmscale 可以先將資料重新 scale (縮放) 到適當範圍. Rescale data. The original data maybe too huge or small in range, thus we can rescale them to the proper range so that training and predicting will be faster.

File Format

檔案格式要先交代一下. 你可以參考 libsvm 裡面附的 "heart_scale": This is the input file format of SVM. You may also refer to the file "heart_scale" which is bundled in official libsvm source archive.

[label] [index1]:[value1] [index2]:[value2] ... [label] [index1]:[value1] [index2]:[value2] ... . .

一行一筆資料，如 One record per line, as:

+1 1:0.708 2:1 3:1 4:-0.320 5:-0.105 6:-1

label: 或說是 class, 就是你要分類的種類，通常是一些整數。 Sometimes referred to as 'class', the class (or set) of your classification. Usually we put integers here.
index: 是有順序的索引，通常是放連續的整數。 Ordered indexes. usually continuous integers.
value: 就是用來 train 的資料，通常是一堆實數。 The data for training. Usually lots of real (floating point) numbers.

每一行都是如上的結構, 意思就是: 我有一排資料, 分別是 value1, value2, .... valueN, (而且它們的順序已由 indexN 分別指定)，這排資料的分類結果就是 label。 Each line has the structure described above. It means, I have an array(vector) of data(numbers): value1, value2, .... valueN (and the order of the values are specified by the respective index), and the class (or the result) of this array is label.

或許你會不太懂，為什麼會是 value1,value2,.... 這樣一排呢？這牽涉到 SVM 的原理。你可以這樣想（我沒說這是正確的），它的名字就叫 Support "Vector" Machine，所以輸入的 training data 是 "Vector"(向量), 也就是一排的 x1, x2, x3, ... 這些值就是 valueN，而 x[n] 的 n 就是由 indexN 指定。這些東西又稱為 "attribute"。

真實的情況是，大部份時候我們給定的資料可能有很多 "特徵(feature)" 或說 "屬性(attribute)"，所以輸入會是一組的。舉例來說，以前面畫點分區的例子來說，我們不是每個點都有 X 跟 Y 的座標嗎？所以它就有兩種 attribute。假定我有兩個點： (0,3) 跟 (5,8) 分別在 label(class) 1 跟 2 ，那就會寫成 1 1:0 2:3 2 1:5 2:8 同理，空間中的三維座標就等於有三組 attribute。 Maybe it's confusing to you: why value, value2, ...? The reason is usually the input data to the problem you were trying to solve involves lots of 'features', or say 'attributes', so the input will be a set (or say vector/array). Take the Marking points and find region example described above, we assumed each point has coordinates X and Y so it has two attributes (X and Y). To describe two points (0,3) and (5,8) as having labels(classes) 1 and 2, we will write them as: 1 1:0 2:3 2 1:5 2:8 And 3-dimensional points will have 3 attributes.

這種檔案格式最大的好處就是可以使用 sparse matrix，或說有些 data 的 attribute 可以不存在。 This kind of fileformat has the advantage that we can specify a sparse matrix, ie. some attribute of a record can be omitted.

To Run libsvm

來解釋一下 libsvm 的程式怎麼用。你可以先拿 libsvm 附的 heart_scale 來做輸入，底下也以它為例： Now I'll show you how to use libsvm. You may use the heart_scale file in the libsvm source archive as input, as I'll do in this example:

看到這裡你應該也了解，使用 SVM 的流程大概就是： You should have a sense that using libsvm is basically:

準備資料並做成指定格式 (有必要時需 svmscale) Prepare data in specified format and svmscale it if necessary.
用 svmtrain 來 train 成 model Train the data to create a model with svmtrain.
對新的輸入，使用 svmpredict 來 predict 新資料的 class Predict new input data with svmpredict and get the result.

svmtrain

svmtrain 的語法大致就是:

The syntax of svmtrain is basically:

svmtrain [options] training_set_file [model_file]

training_set_file 就是之前的格式，而 model_file 如果不給就會叫 [training_set_file].model。 options 可以先不要給。

The format of training_set_files is described above. If the model_file is not specified, it'll be [training_set_file].model by default. Options can be ignored at first.

下列程式執行結果會產生 heart_scale.model 檔：(螢幕輸出不是很重要，沒有錯誤就好了) The following command will generate the heart_scale.model file. The screen output may be ignored if there were no errors.

./svm-train heart_scale optimization finished, #iter = 219 nu = 0.431030 obj = -100.877286, rho = 0.424632 nSV = 132, nBSV = 107 Total nSV = 132

svmpredict

svmpredict 的語法是 : The syntax to svm-predict is:

svmpredict test_file model_file output_file

test_file 就是我們要 predict 的資料。它的格式跟 svmtrain 的輸入，也就是 training_set_file 是一樣的！ predict 完會順便拿 predict 出來的值跟 test_file 裡面寫的值去做比對，這代表： test_file 寫的 label 是真正的分類結果，拿來跟我們 predict 的結果比對就可以知道 predict 有沒有猜對了。 test_file is the data the we are going to 'predict'. Its format is almost exactly the same as the training_set_file, which we fed as input to svmtrain. After predicting svm-predict will compare the predicted label with the label written in test_file. That means, test_file has the real (or correct) result of classification, and after comparing with our predicted result we can know whether the prediction is correct or not.

也所以，我們可以拿原 training set 當做 test_file再丟給 svmpredict 去 predict (因為格式一樣)，看看正確率有多高，方便後面調參數。 So we can use the original training_set_file as test_file and feed it to svmpredict for prediction (nothing different in file format) and see how high the accuracy is so we can optimize the arguments.

其它參數就很好理解了： model_file 就是 svmtrain 出來的檔案， output_file 是存輸出結果的檔案。 Other arguments should be easy to figure out now: model_file is the model trained by svmtrain, and output_file is where we store the output result.

輸出的格式很簡單，每行一個 label，對應到你的 test_file 裡面的各行。 Format of output is simple. Each line contains a label corresponding to your test_file.

下列程式執行結果會產生 heart_scale.out： The following commands will generate heart_scale.out:

./svm-predict heart_scale heart_scale.model heart_scale.out Accuracy = 86.6667% (234/270) (classification) Mean squared error = 0.533333 (regression) Squared correlation coefficient = 0.532639(regression)

As you can see，我們把原輸入丟回去 predict，第一行的 Accuracy 就是預測的正確率了。如果輸入沒有 label 的話，那就是真的 predict 了。 As you can see, after we 'predict'ed the original input, we got 'Accuracy=86.6667%" on first line as accuracy of prediction. If we don't put labels in input, the result is real prediction.

看到這裡，基本上你應該已經可以利用 svm 來作事了：你只要寫程式輸出正確格式的資料，交給 svm 去 train，後來再 predict 並讀入結果即可。 Now you can use SVM to do whatever you want! Just write a program to output its data in the correct format, feed the data to SVM for training, then predct and read the output.

Advanced Topics

後面可以說是一些稍微進階的部份，我可能不會講的很清楚，因為我的重點是想表達一些觀念和解釋一些你看相關文件時很容易碰到的名詞。 These are a little advanced and I may not explain very clearly. Because I just want to help you get familiar with some of the terminology and ideas that you'll encounter when you read other (lib)SVM documents.

Scaling

svm-scale 目前不太好用，不過它有其必要性。因為適當的scale有助於參數的選擇(後述)還有解svm的速度。
svmscale 會對每個 attribute 做scale。範圍用 -l, -u 指定，通常是[0,1]或是[-1,1]。輸出在 stdout。
另外要注意的(常常會忘記)是 testing data 和 training data要一起scale。
而 svm-scale 最難用的地方就是沒辦法指定 testing data/training data(不同檔案) 然後一起scale。

svm-scale is not easy to use right now, but it is important. Scaling aids the choosing of arguments (described below) and the speed of solving SVM.
svmscale rescales all atrributes with the specified (by -l, -u) range, usually [0,1] or [-1,1].
Please keep in mind that testing data and training data MUST BE SCALED WITH THE SAME RANGE. Don't forget to scale your testing data before you predict.
We can't specify the testing and training data file together and scale them in one command, that's why svm-scale is not so easy to use right now.

Arguments

前面提到，在 train 的時候可以下一些參數。(直接執行 svm-train 不指定輸入檔與參數會列出所有參數及語法說明) 這些參數對應到原始 SVM 公式的一些參數，所以會影響 predict 的正確與否。
舉例來說，改個 c=10:
./svm-train -c 10 heart_scale
再來 predict ，正確率馬上變成 92.2% (249/270)。

We know that we can use some arguments when we were training data (Running svm-train without any input file or arguments will cause it to print its list syntax help and complete arguments). These arguments corresponds to some arguments in original SVM equations so they will affect the accuracy of prediction.
Let's use c=10 as an example:
./svm-train -c 10 heart_scale
If you predict again now, the accuracy will be 92.2% (249/270).

Cross Validation

一般而言， SVM 使用的方式(在決定參數時)常是這樣：

先有已分好類的一堆資料
亂數拆成好幾組 training set
用某組參數去 train 並 predict 別組看正確率
正確率不夠的話，換參數再重複 train/predict

Mostly people use SVM while following this workflow:

Prepare lots of pre-classified (correct) data
Split them into several training sets randomly.
Train with some arguments and predict other sets of data to calculate the accuracy.
Change the arguments and repeat until we get good accuracy.

等找到一組不錯的參數後，就拿這組參數來建 model 並用來做最後對未知資料的 predict。這整個過程叫 cross validation ，也就是交叉比對。 When we got some nice arguments, we will then use them to train the model and use the model for final prediction (on unknown test data). This whole process is called cross validation .

在我們找參數的過程中，可以利用 svmtrain 的內建 cross validation 功能來幫忙：
-v n: n-fold cross validation
n 就是要拆成幾組，像 n=3 就會拆成三組，然後先拿 1跟2來 train model 並 predict 3 以得到正確率；再來拿 2跟 3 train 並 predict 1，最後 1,3 train 並 predict 2。其它以此類推。 In the process of experimenting with the arguments, we can use the built-in support for validation of svmtrain:
-v n: n-fold cross validation
n is how many sets to split your input data. Specifing n=3 will split data into 3 sets; train the model with data set 1 and 2 first then predict data set 3 to get the accuracy, then train with data set 2 and 3 and predict data set 1, finally train 1,3 and predict 2, ... ad infinitum.

如果沒有交叉比對的話，很容易找到只在特定輸入時好的參數。像前面我們 c=10 得到 92.2%，不過拿 -v 5 來看看： ./svm-train -v 5 -c 10 heart_scale ... Cross Validation Accuracy = 80.3704% 平均之後才只有 80.37%，比一開始的 86 還差。 If we don't use cross validation, sometimes we may be fooled by some arguments only good for some special input. Like the example we used above, c=10 has 92.2%. If we do so with -v 5: ./svm-train -v 5 -c 10 heart_scale ... Cross Validation Accuracy = 80.3704% After the prediction results is averaged with cross validation we have only 80.37% accuracy, even worse than with the original argument (86%).

What arguments rules?

通常而言，比較重要的參數是 gamma (-g) 跟 cost (-c) 。而 cross validation (-v) 的參數常用 5。 Generally speaking, you will only modify two important arguments when you are using training with data: gamma (-g) and cost (-c) . And cross validation (-v) is usually set to 5.

cost 預設值是 1, gamma 預設值是 1/k ，k 等於輸入資料筆數。那我們怎麼知道要用多少來當參數呢？

用試的
是的，別懷疑，就是 Try 參數找比較好的值。

cost is 1 by default, and gamma has default value = 1/k , k = number of input records. Then how do we know what value to choose as arguments?

T R Y
Yes. Just by trial and error.

Try 參數的過程常用 exponential 指數成長的方式來增加與減少參數的數值，也就是 2^n (2 的 n 次方)。 When experimenting with arguments, the value usually increases and decreases in exponential order. i.e., 2^n.

因為有兩組參數，所以等於要 try n*n=n^2 次。這個過程是不連續的成長，所以可以想成我們在一個 X-Y 平面上指定的範圍內找一群格子點 (grid，如果你不太明白，想成方格紙或我們把平面上所有整數交點都打個點，就是那樣)，每個格子點的 X 跟 Y 經過換算 (如 2^x, 2^y) 就拿去當 cost 跟 gamma 的值來 cross validation。 Because we have two important arguments, we have to try n*n=n^2 times. The whole process is discontinous and can be thought of as finding the grid points on a specified region (range) of the X-Y plane (Think of marking all integer interception points on a paper). Convert each grid point's X and Y coordinate to exponential values (like 2^x, 2^y) then we can use them as value of cost and gamme for cross validation.

所以現在你應該懂得 libsvm 的 python 子目錄下面有個 grid.py 是做啥的了：它把上面的過程自動化，在你給定的範圍內呼叫 svm-train 去 try 所有的參數值。 python 是一種語言，在這裡我不做介紹，因為我會了 :P (just a joke，真正原因是 -- 這是 libsvm 的 tutorial)。 grid.py 還會把結果 plot 出來，方便你尋找參數。 libsvm 有很多跟 python 結合的部份，由此可見 python 是強大方便的工具。很多神奇的功能，像自動登入多台機器去平行跑 grid等等都是 python 幫忙的。不過 SVM 本身可以完全不需要 python，只是會比較方便。 So look for 'grid.py' in the 'python' subdirectory inside the libsvm archive. You should know what it does now: automatically execute the procedure above, try all argument values by calling svm-train within the region specified by you. Python is a programming language which I'm not going to explain here. grid.py will also plot the result graphically to help you look for good arguments. There're also many parts of libsvm powered by python, like logging into several hosts and running grids at the same time parallel. Keep in mind that libsvm can be used without python entirely. Python just only helped us to do thinks quickly.

跑 grid (基本上用 grid.py 跑當然是最方便，不過如果你不懂 python 而且覺得很難搞，那你要自己產生參數來跑也是可以的) 通常好的範圍是 [c,g]=[2^-10,2^10]*[2^-10,2^10] 另外其實 grid 用 [-8,8] 也很夠了。 Running for grids (it's more convenient to just use grid.py but it's also ok if you don't) you may choose the range as [c,g]=[2^-10,2^10]*[2^-10,2^10] Usually [-8,8] is enough for grids.

Regression

另一個值得一提的是 regression。

簡單來說，前面都是拿 SVM 來做分類 (classification), 所以 label 的值都是 discrete data、或說已知的固定值。而 regression 則是求 continuous 的值、或說未知的值。你也可以說，一般是 binary classification, 而 regression是可以預測一個實數。

比如說我知道股市指數受到某些因素影響, 然後我想預測股市.. 股市的指數就是我們的 label, 那些因素量化以後變成 attributes。以後蒐集那些 attributes 給 SVM 它就會預測出指數(可能是沒出現過的數字)，這就要用 regression。那樂透開獎的號碼呢？因為都是固定已知的數字，很明顯我們應該用一般 SVM 的 classification 來 predict。 (註：這是真實的例子 -- llwang 就寫過這樣的東西)

所以說 label 也要 scale, 用 svm-scale -y lower upper

但是比較糟糕的情況是 grid.py 不支援 regression ，而且cross validation 對 regression 也常常不是很有效。

總而言之，regression 是非常有趣的東西，不過也是比較進階的用法。在這裡我們不細談了，有興趣的人請再參考 SVM 與 libsvm 的其它文件。

The other important issue is "Regression".

To explain briefly, we only used SVM to do classification in this tutorial. The type of label we used are always discrete data (ie. a known fixed value). "Regression" in this context means to predict labels with continuous values (or unknown values). You can think of classification as predictions with only binary outcomes, and regression as predictions that output real (floating point) numbers.

Thus to predict lottery numbers (since they are always fixed numbers) you should use classification, and to predict the stock market you need regression.

The labels must also be scaled when you use regression, by svm-scale -y lower upper

However grid.py does not support regression, and cross validation sometimes does not work well with regression.

Regression is interesting but also advanced. Please refer to other documents for details.

Epilogue

到此我已經簡單的說明了 libsvm 的使用方式，更完整的用法請參考 libsvm 的說明跟 cjlin 的網站、 SVM 的相關文件，或是去上 cjlin 的課。 Here we have already briefly explained the libsvm software. For complete usage guides please refer to documents inside the libsvm archive, cjlin's website, SVM-related documents, or go take cjlin's course if you are a student at National Taiwan University :)

對於 SVM 的新手來說， libsvmtools 有很多好東西。像 SVM for dummies 就是很方便觀察 libsvm 流程的東西。 Take a glance at libsvmtools especially "SVM for dummies" there. Those are good tools for SVM newbies that helps in observing libsvm workflow.

Copyright

All HTML/text typed within VIM on Solaris.
Style sheet from W3C Core StyleSheets.

Original URL: http://www.csie.ntu.edu.tw/~r91034/svm/svm_tutorial.html

好看簿不好看了

2009-01-08T15:21:00.000+08:00

最近感觉好看簿越来越不稳定了！打开速度变慢了，有时还打不开来，还是把东西放在这里比较安稳，图片可以放在Picasa里，视频放在Youtube里，好看簿就放些故事吧～
自己随时的一些感想可以用Twitter来写，也挺好用的～

地图解析

2009-01-08T13:57:00.002+08:00

决定了用Python+PyQt+PyOpenGL+PyGame来快速实现虚拟终端。
整理了一下思路，大致分为以下几个步骤：
1.用PyQt构建GUI界面
2.用PyQt显示二维地图
3.用PyQt动态显示车辆
4.模拟DTU发送接收数据
5.用PyGame操纵虚拟车辆
6.用PyOpenGL显示三维地图和车辆
前四步是一定要完成的，后面两步最好也要能完成！

其中1已经有现成的例子可以用了，2需要先对地图进行解析。原来以为是要从xml文件中进行，后来发现我已经将地图数据放入sqlite数据库中了，且保存了Lat-Lon和UTM两张表，所以地图解析就是读取数据库的工作了～
2和3都用Qt的Graphics view框架来实现，这也很简单。
4是工作量比较大的一步，需要再看看TCP连接方面的书，还有DTU的数据格式。
5需要构建一个能够实时计算速度和位置的vehicle类，接收键盘输入。
6完全是OpenGL方面的工作了，不是很熟悉，边看边学吧～

又来了新的任务

2009-01-04T15:55:00.002+08:00

老板刚才过来通知我写个介绍项目的PPT，从项目的意义开始写起，包括现在的进度，未来的应用展望，写完了去忽悠投资去～
说来就脸红，还是第一次写类似的东西。这几天要好好折腾折腾了！写现在的进度，项目做了哪些东西都没问题，就是写背景，意义这些不太擅长，不过也该锻炼锻炼了，就当为以后大论文做准备吧！这些个东西以后可以直接放进去用的啊～

开始二维显示模块的编码

2008-12-26T11:32:00.002+08:00

昨天开始简单的二维显示模块的编码。
用python写PyQt的代码就是爽啊！同样是对XML文件的解析，同样是用dom方式，感觉用python的ElementTree就是比用Java来的方便～一个小巧的Ulipad就可以完成Eclipse里功能，limodou真是干实事的人啊～～
二维显示分为四个部分：地图解析，地图显示，组播监听，动态显示。目前完成了前两个部分，组播监听以前用python做过，把代码集成到模块中即可，动态显示也就是简单的更新车辆item的位置和信号item的颜色（如果需要的话），今天应该就可以完成了。
然后就是JTSS中的ResultReporter将收集到的系统中的agent的信息发送到组播端口，将显示模块与JTSS主模块连接起来，这样调试起来就方便多了～
没几天这个月就结束了，调试JTSS要在这个礼拜内完成，下面还有用COPS对数据分类训练TS模型的任务要尽快完成呢！

完全在Linux下进行ARM开发

2008-12-17T14:25:00.002+08:00

在linux下开发ARM早就是业界公认的了，编写代码，编译代码，早就不是难题了，当然下载到ARM板上也不是难题，但如我等菜鸟一直都不太明了如何操作，单单把下载操作放在Windows环境下用DNW或者其他串口工具来完成。
由于实验室的台式机装的是双系统，而不是虚拟机，在两个系统间切换就尤为不便，于是下定决心要在Linux环境下实现下载操作！
看看DNW的功能，主要有两个：串口交互界面和USB传输文件。在我的Ubuntu系统中，通常知道的串口交互使用命令行工具minicom，但是命令行工具用起来毕竟不是那么方便，于是又找到一款使用minicom作为后端的图形界面程序——cutecom。使用起来非常方便，所有的功能都用按钮放在界面上，不用找来找去。至于USB传输文件的程序，在Ubuntu中文论坛里找到了usb2ram这个小程序，不知道是谁写的，正好针对s3c2410，小胡甚至怀疑是优龙公司出的～：）这个小程序带源代码、makefile文件和二进制文件。其中二进制文件执行有问题，自己在Makefile文件中定义一下CC=gcc，重新make一下，生成新的可执行文件即可。用"sudo ./usb2ram 30200000 filename"执行，注意别漏了sudo哦，不然会出现权限问题。30200000是下载到RAM中的地址，filename可以是内核文件，或者根文件系统，记得下载后不要立即执行（选择n），要再写入到NAND flash中才算完成。会提示你是内核还是根文件系统的，别看错就行～

每天都有新的bug

2008-12-12T17:02:00.001+08:00

今天发现两个bug！一处是在MatchUpdate中，没有使用与fillContent匹配的extractContent函数；另一处是增加了IP处理注册请求结束后的回复信息，使得CA可以继续进行流程！

当爸爸真不容易啊！

2008-12-03T15:45:00.003+08:00

昨天我家孩子终于出生了！多等了一个礼拜，才肯从娘胎里出来～出来的时候可活泼了，哭声响亮，两只黑黝黝的大眼睛睁得溜圆，头发不太多，五官端正，比他爹强，以后八成是个帅哥～～
5点11出生，7点多进了病房，白天我回家补觉，没睡踏实，晚饭后又杀了过了，小家伙在睡觉，喊他也不醒，好不容易醒了，却是因为拉了一泡屎～这家伙能吃能拉，一晚上拉了5次，两次量不多，三次超大量，作为一个连尿不湿也不会换的初级爸爸，忙得我几乎没有活下去的勇气了～～
老婆的伤口很疼，没法帮我，最后发现小家伙喝奶太频繁了，干脆放在床上和妈妈一起睡，效果还真不错，让我们睡了一个小时的好觉～之后开始三番两次的哭，看看尿不湿，没有拉屎，给他喂奶，吃得那叫个欢啊！老婆非说是遗传的我，没办法，承认吧～～
天亮了，在第N次吃完奶后，小家伙终于沉沉的睡去了，我也该回家补觉去了～可怜我家老婆，晚上和我一样没睡好，还要忍受伤口的疼痛，白天还要受小家伙的折磨，当爸爸真不容易，当妈妈更不容易啊！

笑来真是一个好老师

2008-11-30T10:42:00.002+08:00

一直在看李笑来的博客，感觉他写的东西都是大实话，把自己的一些学习、做事的经历贴出来与大家分享，尤其是与广大的学生分享，对于那些孩子们的成长是大有裨益的！他所强调的耐心，和遇到困难时的态度，都值得反复去体会，学习～
以后让我家孩子也经常上去看看～：）

修改ontology

2008-11-30T09:18:00.002+08:00

发现用protege生成的代码是符合规范的，但fillContent后得到的内容却是不符合规范的！其中Concept和Predicate是正常的，AgentAction却是错误的！也没时间仔细研究错误在哪里，干脆先把AgentAction都变成Predicate，能跑起来再说，以后再来调试这个bug～

昨天写了一个摘要，开始想从已有的一个改改，发现不行，思路很混乱。和lp聊了一下，把自己做的工作一说，用大陆上次教的方法一分析，找到了思路，用最简单明了的话把思路表达出来，搞定！可惜后来又发现还有字数要求，并且要求用中文表述一遍。用中文写了一遍出来，发现还是中文表达的更顺畅，毕竟是母语呀～再依据中文把英文的修改了一下，搞定！

问题解决了

2008-11-28T09:47:00.003+08:00

找到问题了，不怪行为古怪，要怪就怪我给并行行为的其中一个子行为实现为了OntShotBehaviour，结果运行一次就结束了，而并行行为又设置成了WHEN_ANY，所以整个agent的行为都结束了，但在RMA中看agent却还在，把我迷惑了～改成SimpleBehaviour，添加done函数就解决了～

古怪的行为

2008-11-27T23:44:00.002+08:00

今天去医院检查，一切正常，但下个月还不出来的话就要住院观察了～

下午就开始调试程序，很奇怪，用AgentAction就是不行，非要把Register定义为其他的，如Concept，然后用现成的Action才可以！仔细观察了一下message的content，发现果然是有个地方不对劲，难道是JADE的bug？找了半天也没发现自己错在哪里了！不管了，先用这种方法吧，以后再说～

成功建立起分布在各个host上的container及静态agent之后，TSM也接收到了所有时间相关agent的注册消息，成功注册后开始仿真，向每个事件相关agent发送step消息。消息发出了，可那些agent却没能做出反应，似乎是没有收到。在sniffer中查看确实是发送过去了，在接收step消息处加断点，没有触发！现在怀疑是setup处设置行为时出了问题，还没看出来哪里有问题。串行行为好像没有问题，在onEnd处打印信息，在控制台也看到了，说明它是正常的。并行行为应该两个行为都能接收到message的，至少我原来是这么想的，但现在看来，似乎只有一个可以接收到！这就麻烦了！

今天不行就要等到明早来看了。真是古怪的行为啊！

换一种布置agent的方式

2008-11-26T06:58:00.002+08:00

昨晚搞了许久都没有解决创建SourceGenerator的问题，十分怀疑是由于arguments的内容太大，用message传递出的问题。苦于用命令行方式启动的jvm无法看到调试信息，一切都只是猜测。但时间不等人啊！

于是决定换一种布置agent的方法来试试。在每一个host中都有完整的map和deployment文件，首先启动MySimulation，用Simulator启动主container和TSM，TSM不再负责创建其他的agent，但是仍有一个initital行为，等待所有的静态agent启动完毕，才开始推进仿真。在其他每个host中，单独启动一个外部程序，这个外部程序根据输入的值确定自己负责启动的子container，然后启动一个agent，由它负责具体静态agent的创建。该agent采用昨天看到的那种简单方式来创建新的agent，避免向AMS发送消息这种方式。

在调试期间，可以用eclipse的debug来启动所有的程序，这样可以解决调试不方便的问题。

今天26号了，下午有事要出门，要开始写摘要了，月底要截止了～

创建新的agent

2008-11-25T21:03:00.002+08:00

原来是从外部创建agent，后来要在multi-host上配置，就改用了向AMS发送请求的方式，但这种方式要在消息内传递底层的数据，效率确实不高。今晚在网上搜到一个blog，博主也是从06年开始使用JADE，看了几篇文章，发现其中一篇讲到从一个agent创建另一个agent，用的是类似外部创建的方式，但由于是在agent内执行，效率很高，代码很简洁，很受启发，决定在SourceGenerator里使用这种方式。这种方式的限制是只能在本地container中创建 agent，不过由于SourceGenerator是TSM用向AMS发送请求的方式创建的，是分布在各个host中的，因此正好解决了这个问题。

进度有点慢了

2008-11-21T00:03:00.002+08:00

前两天生了点病——咽炎，差不多快好的时候头又开始疼了，这两天就没有怎么干正事。现在问题来了，进度有点拖慢了！

今天看了笑来的博客，最新的一篇博文又是讲“提高效率的最有效方法——克服拖拉”，里面提到了拖拉“最重要的原因应该在于大多数人喜欢先做甚至只做自己喜欢的……很多人实际上根本不知道自己所谓的“喜欢做某件事情”实际上更可能只不过是因为那件事情相对简单、容易获得奖励而已”。很有道理，至少对于我是正确的。

如果早上起床先做了今天计划中我认为最难的部分，那么这一天就会过得很愉快，工作就会进行的更加顺利一些。所以下面几天每天早上起床吃完饭后要立马开始工作，这样才能完成计划～

终于完成一件事

2008-11-16T00:44:00.005+08:00

这些天一直在忙这篇小论文，今天总算赶在截止日期前投了出去，本以为来不及了，后来发现12点后还可以，仔细想想明白了，人家是国际会议，时间上当然是以GMT为准，中国是GMT+8，提前了8个小时了～～：）

虽说这件事完了，但后续的事情还没有完，还要继续把仿真平台完善，并做出模拟数据采集系统，这些都要尽快完成。待程序完善后还要写篇中文的投投，也向国内的朋友推荐一下～

该睡觉了，老婆还在等着呢～：）

测试一下Google Doc的博客发布功能

2008-11-08T15:52:00.001+08:00

测试一下Google Doc的博客发布功能

试一下各种效果

粗体

斜体

下划线

链接

第一
第二
第三

时间只有细分才能充分利用

2008-11-07T09:07:00.002+08:00

昨日深感浪费时间之危害，回想笑来的文章，决定动手规划一下自己今天的时间安排。

与以往的规划不同的是，这次结合今天要干的事情——写英文句子，将规划细化到每一个句子要花费多少时间，这也许是我唯一可以估计的偏差不太大的东西了。同时顺手将自己避免不了的发散项目——看邮件、看blog、写blog等等明确的列出来，给每一项分配时间，把24小时安排的满满的，当然睡觉也安排进去了～

安排下来，有一种时间就在手中的感觉～下面就看执行力了！这次要严格按照计划来做，同时，先做最困难的事情！

发散的紧

2008-11-06T00:50:00.003+08:00

今天起床的时候想着要把引言写完，结果到了晚上，目标变成了要把引言的思路理清楚！

看了李笑来的一篇博文，大致的意思是大多数人想到了要干什么（what），为什么要去干（why），唯独在如何去干（how）上没有想清楚。将how细分再细分，直到自己确信确实已经知道要如何安排时间为止，这时会发现要比开始想象的要复杂困难的多！

晚上花了点时间看Google Earth与GPS互联的东西，有个叫GooPs的免费软件很好，可以将GPS信息实时显示在Google Earth上，可惜现在主页出了点问题，无法访问了（不免怀点恶意的想是不是因为抢了Google的生意～），还好在上帝之眼论坛可以下到中英文版。
程序很小，900多K，试用了一下Demo，果然比较好用，选项也很丰富，界面简单实用。仔细观察了一下，发现其原理就是在本地建立了一个服务器，然后从GE中打开一个指向该服务器地址的KML文件，向服务器动态发送GET请求，返回包含新内容的kml格式文件，文件中包含最新的位置坐标，就达到了动态显示的效果～
各种选项其实就是KML文件中的各个tag的内容，尝试用Python来实现服务器，看了BaseHTTPServer和SimpleHTTPServer的源代码，心里有底了～不过现在是没时间搞这个了，以后买车了需要导航时再自己DIY一个出来用吧～

一点多了了，想起老罗说过的夜里两点出来散散步，头脑比较清醒，现在才深有同感～赶紧整点正事睡觉吧！

Blogger of AceStrong

终于又可以在这里发帖了～

最近的动态

毛坯房验房程序

GPS导航DIY指南

还是minicom好用

在嵌入式开发中使用Qt

基于svm的驾驶决策建模

知道如何在blogger里发帖子了

Grep学习笔记

[转]利用消息队列实现进程间通信

[转]利用共享内存实现进程间通信

[转]UNIX进程(Process)及信号(signal)

[转]标准输入输出以及管道操作

[转]目录及文件操作

[转]在程序中执行UNIX命令或者其它程序

[转]生成一个Process（进程）

[转]向其它进程传递信号

[转]Rise Vs Raise

DOP和差分GPS

在python中解析带符号24位数

编程的首要原则(s)是什么？ - 刘未鹏|C++的罗浮宫 - CSDNBlog

坏习惯不是你的敌人_武志红的BLOG_新浪博客

查找zotero中给定item所在的collection

在matlab中调用libsvm的时候数据归一化与反归一化的m代码 - 浮世记 - 博客大巴

为什么读博士以及有什么意义(转载) | contrast的对比人生

所有程序员都应该至少读上两遍的十篇论文 - 刘江@图灵 - CSDNBlog

可以下载国外学位论文的网址_star的博客_雅虎博客_雅虎空间

回顾一下车辆跟驰两大流派之争

无模型车辆跟驰建模

wps的zotero插件

这两天忙了点啥

支持CNKI的Zotero的translator

完成支持豆瓣的Zotero的translator

用mingw编译boost，在Code::Block中使用

注册表的文件关联及应用_最爱№绿茶

从小白开始写make-1-3.3 伯乐谷 中华英才网

Free Mind » 训练数据对分类器性能的影响

相信我，你并不孤单！

攻克拖延症--经历记录与心得分享

Geo Globle | 小乙BLOG

改进PSO

[转]Python：time.clock() vs. time.time()

Python：time.clock() vs. time.time()

总结

参考资料：

从赵本山巩俐谈“明星换国籍”……--流氓兔 - 乐活中国

多维粒子群（PSO）算法

去掉libsvm中的输出信息

使用libsvm进行SVR

Stifled Laughter: How the Communist Party Killed Chinese Humor

对于树来说它就是一只猛兽！

学会如何在python中从源码编译安装第三方的模块

活着的人要更好的活下去_韩寒_新浪博客

本月任务

python中socket编程

经纬度与UTM坐标的转换

开始尝试svm

piaip's Using (lib)SVM Tutorial

piaip's Using (lib)SVM Tutorial piaip 的 (lib)SVM 簡易入門

Why this tutorial is here

SVM: What is it and what can it do for me?

How do I get SVM?

Download libsvm

Build libsvm

Using SVM

The programs

File Format

To Run libsvm

svmtrain

svmpredict

Advanced Topics

Scaling

Arguments

Cross Validation

What arguments rules?

Regression

Epilogue

Copyright

All rights reserved by Hung-Te Lin (林弘德, piaip), ， Website: piaip at ntu csie ，2003.

从小白开始写make-1-3.3 伯乐谷中华英才网

All rights reserved by Hung-Te Lin (林弘德, piaip), ，
Website: piaip at ntu csie ，2003.