hxpwork http://hxpwork.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 Drools4：Manners示例分析 hxpwork 作者: hxpwork  链接：http://hxpwork.javaeye.com/blog/112597  发表时间: 2007年08月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

  1. /*  
  2.     manners示例是一个安排座位的例子，它的要求如下：  
  3.     1、客人应当按照男女性别相邻而坐，围成一圈  
  4.     2、假设客人会有2-3个个人爱好（爱好的可选范围是3种），为了让大家能够更好的交流，  
  5.        要安排每个人都和相邻座位的两个人有共同的爱好，并且与左右两边的共同爱好不要相同  
  6.     3、客人的人数在本例中为64人，男女各一半  
  7.       
  8.     解题思路：  
  9.     1) 按照规则引擎的特性，首先应当将所有可能的数据准备好，从本例来看，客人是主要的数据对象，  
  10.        姓名/性别/兴趣 是三个主要属性，姓名和性别是固定的，可能有多个选择的就是兴趣爱好，  
  11.        那么首先应当将客人的兴趣分别与姓名/性别组合后放入WorkingMemory  
  12.     2) 再考虑一下，本例中规定了每个客人都会有三种爱好里的两种，也就是说任意两个人都必然有相同爱好  
  13.        只要注意不要性别相同以及两边爱好一致就可以；那么只要先安排一个人坐下（这个人应当三种爱好都有），  
  14.        然后找一个性别不同，有一种相同爱好的客人A坐在左边；接下去找一个坐在A旁边的客人B，同样与A性别  
  15.        不同，并且和前一位的共同爱好也不同。这样一直排下去，直到最后一个座位。这里解释一下为什么一开始  
  16.        第一个人要三种爱好齐备，因为这种算法有一个漏洞是没有考虑第一个客人和最后一个客人是相邻而坐的，  
  17.        如果第一个客人和最后一个客人只有一个共同兴趣而这个兴趣又正好是第一和第二个客人的共同兴趣，那么  
  18.        这种算法会得到不正确的结果，但只要第一个坐下来的人三种爱好都有，那么必然和两边的人都有不同爱好，  
  19.        这也弥补了算法的不同。  
  20.        注：从本例中准备的数据和算法来看并没有考虑到这个问题，虽然按照原始数据可以得到正确的结果，但是  
  21.        进行针对性的调整后就会发现结果会有问题  
  22.     3) 因为座位是一个一个找出来的，因此要有合适的流程控制方法。    
  23.       
  24. */  
  25.   
  26.   
  27. package org.drools.benchmark.manners   
  28.   
  29. # 从客人中找出一位放入第一个座位   
  30. # 根据Drools引擎的特性，应当是最后一个加入的Guest   
  31. # 利用Context.state属性控制该规则只执行一次   
  32. rule assignFirstSeat   
  33.     when   
  34.         # Context用于流程控制   
  35.         context : Context( state == Context.START_UP )   
  36.         #   
  37.         #   原例中使用的是  Guest() ， 获得最后插入的Fact，但是这样会引起之前提到的Bug   
  38.         #   因此在下面进行了改进，保证找出三个兴趣都有的客人   
  39.         #   
  40.         guest : Guest( $name:name , $hobby : hobby )   
  41.         Guest ( name == $name , hobby != $hobby , $hobby1 : hobby )   
  42.         Guest ( name == $name , hobby != $hobby , hobby != $hobby1 )   
  43.            
  44.         count : Count()   
  45.     then   
  46.         String guestName = guest.getName();   
  47.            
  48.         # Seating用于记录每个座位上的客人，是寻找下一个座位的客人的依据   
  49.         Seating seating =  new Seating( count.getValue(), 1, true, 1, guestName, 1, guestName);   
  50.         insert( seating );   
  51.            
  52.         # Path用来避免已经入座的客人再次被选中   
  53.         Path path = new Path( count.getValue(), 1, guestName );   
  54.         insert( path );   
  55.            
  56.         # 用于计数，并作为Seating的ID   
  57.         count.setValue(  count.getValue() + 1 );           
  58.         update( count );   
  59.   
  60.         System.out.println( "assign first seat :  " + seating + " : " + path );   
  61.   
  62.         # 进入找下一个座位环节   
  63.         context.setState( Context.ASSIGN_SEATS );           
  64.         update( context );   
  65. end   
  66.   
  67. # 寻找相邻的同伴   
  68. rule findSeating   
  69.    when    
  70.        context : Context( state == Context.ASSIGN_SEATS )   
  71.        # 获得最近安排好座位的客人   
  72.        $s:Seating( seatingId:id, seatingPid:pid, pathDone == true, seatingRightSeat:rightSeat, seatingRightGuestName:rightGuestName )   
  73.        # 找到一位有共同兴趣但性别不同的相邻客人   
  74.        Guest( name == seatingRightGuestName, rightGuestSex:sex, rightGuestHobby:hobby )   
  75.        Guest( leftGuestName:name , sex != rightGuestSex, hobby == rightGuestHobby )   
  76.   
  77.        count : Count()   
  78.        # 排除已经入座的客人   
  79.        #   
  80.        # 原例中使用了Path.id作为一个约束条件，而事实上要排除已经入座的客人只要判断guestName就可以了   
  81.        # 因此原例中的makePath规则如果注释掉，然后将下面的语句改为   
  82.        # not ( Path( guestName == leftGuestName) )   
  83.        # 执行后也可以得到完全相同的结果   
  84.        # Manners是作为规则引擎的测试基准发布的，因此这里完全按照标准实现，所以这里虽然
  85.        # 可以进行改进，但是可能因为为了测试规则引擎，因此保留这种算法
  86.        #
  87.        not ( Path( id == seatingId, guestName == leftGuestName) )   
  88.           
  89.        # 排除入座客人已经和使用过的兴趣，保证两边相邻的客人共同兴趣不一样   
  90.        not ( Chosen( id == seatingId, guestName == leftGuestName, hobby == rightGuestHobby) )   
  91.    then   
  92.        int rightSeat = seatingRightSeat;   
  93.        int seatId = seatingId;   
  94.        int countValue = count.getValue();   
  95.           
  96.        # 安排一个新的座位   
  97.        Seating seating = new Seating( countValue, seatId, false, rightSeat, seatingRightGuestName, rightSeat + 1, leftGuestName );   
  98.        insert( seating );        
  99.        # 记录已经入座的客人                       
  100.        Path path = new Path( countValue, rightSeat + 1, leftGuestName  );   
  101.        insert( path );   
  102.        # 记录已经使用的兴趣爱好   
  103.        Chosen chosen = new Chosen( seatId, leftGuestName, rightGuestHobby );   
  104.        insert( chosen  );   
  105.   
  106.        System.err.println( "find seating : " + seating + " : " + path + " : " + chosen);   
  107.        count.setValue(  countValue + 1 );   
  108.        update( count );          
  109.   
  110.        context.setState( Context.MAKE_PATH );   
  111.        update( context );   
  112.           
  113.        retract ( $s );   
  114. end   
  115.   
  116. /*  
  117.   这个规则的执行将为之前所有入座的客人建立一个路径  
  118.   如果使用一个打印语句，部分打印内容如下：  
  119.   makePath :[Path id=1, seat=1, guest=63]  
  120.   makePath :[Path id=2, seat=1, guest=63]  
  121.   makePath :[Path id=2, seat=2, guest=52]  
  122.   makePath :[Path id=3, seat=2, guest=52]  
  123.   makePath :[Path id=3, seat=1, guest=63]  
  124.   makePath :[Path id=3, seat=3, guest=64]  
  125.   makePath :[Path id=4, seat=3, guest=64]  
  126.   makePath :[Path id=4, seat=1, guest=63]  
  127.   makePath :[Path id=4, seat=2, guest=52]  
  128.   makePath :[Path id=4, seat=4, guest=50]  
  129.   makePath :[Path id=5, seat=4, guest=50]  
  130.   makePath :[Path id=5, seat=2, guest=52]  
  131.   makePath :[Path id=5, seat=1, guest=63]  
  132.   makePath :[Path id=5, seat=3, guest=64]  
  133.   makePath :[Path id=5, seat=5, guest=62]  
  134.   ......  
  135.   也就是每个id的数值就对应有多少个Path，而事实上这种数据模型对本例来说并不是太需要  
  136.   在之前的findSeating规则中有说明。  
  137. */  
  138. rule makePath   
  139.     when    
  140.         Context( state == Context.MAKE_PATH )   
  141.         Seating( seatingId:id, seatingPid:pid, pathDone == false )   
  142.         $path : Path( id == seatingPid, pathGuestName:guestName, pathSeat:seat )   
  143.         not Path( id == seatingId, guestName == pathGuestName )   
  144.     then   
  145.         System.out.println ( "makePath :" + $path  );   
  146.         insert( new Path( seatingId, pathSeat, pathGuestName ) );   
  147. end    
  148.   
  149. # 结束座位的路径设置   
  150. rule pathDone   
  151.     when   
  152.         context : Context( state == Context.MAKE_PATH )    
  153.         seating : Seating( pathDone == false )    
  154.     then   
  155.         seating.setPathDone( true );    
  156.         update( seating );   
  157.            
  158.         context.setState( Context.CHECK_DONE );    
  159.         update( context );   
  160. end   
  161.   
  162. # 检查是否安排的客人座位已经到达指定人数，结束规则运算   
  163. rule areWeDone   
  164.     when   
  165.         context : Context( state == Context.CHECK_DONE )    
  166.         LastSeat( lastSeat: seat )   
  167.         Seating( rightSeat == lastSeat )    
  168.     then   
  169.         context.setState(Context.PRINT_RESULTS );    
  170.         update( context );   
  171. end   
  172.   
  173. # 如果之前的areWeDone规则没有允许，则继续座位查找   
  174. rule continue  
  175.     when   
  176.         context : Context( state == Context.CHECK_DONE )    
  177.     then   
  178.         context.setState( Context.ASSIGN_SEATS );    
  179.         update( context );   
  180. end   
  181.   
  182. # 打印完成提示   
  183. rule allDone   
  184.     when   
  185.         context : Context( state == Context.PRINT_RESULTS )    
  186.     then   
  187.         System.out.println( "All Done" );   
  188. end   
  189.   
  190. //query getResults   
  191. //  context : Context( state == Context.PRINT_RESULTS )    
  192. //end    
  193.    

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 15 Aug 2007 16:32:19 +0800 http://hxpwork.javaeye.com/blog/112597 http://hxpwork.javaeye.com/blog/112597 drools4: Conway示例分析 hxpwork 作者: hxpwork  链接：http://hxpwork.javaeye.com/blog/110968  发表时间: 2007年08月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

  1. /*  
  2.     Conway: 元细胞自动机模型，俗称生命游戏  
  3.     它有些类似于一张围棋棋盘，但是可以更大。每个棋盘上的格子（元细胞）只能是生/死两种状态之一。  
  4.     游戏遵循下面的规则  
  5.     1）格子的状态只能是生/死两种状态之一  
  6.     2）格子以其上下左右及斜角方向的8个格子为邻居  
  7.     3）一个格子的生死由其在该时刻本身的生死状态和周围八个邻居的状态 (确切讲是状态的和)决定:  
  8.         a、在当前时刻，如果一个格子状态为"生"，且八个相邻格子中有两个或三个的状态为"生"，  
  9.            则在下--时刻该格子继续保持为"生"，否则"死"去；  
  10.         b、在当前时刻。如果一个格子状态为"死"。且八个相邻格子中正好有三个为"生"。  
  11.            则该格子在下一时刻 "复活"。否则保持为"死"。  
  12.  
  13.     元细胞自动机模型已在多方面得到应用。它的演化规则近似地描述了生物群体的生存繁殖规律:  
  14.     在生命密度过小(相邻元胞数<2) 时，由于孤单、缺乏配种繁殖机会、缺乏互助也会出现生命危机，元胞状态值由1变为0;  
  15.     在生命密度过大 (相邻元胞数>3)时，由于环境恶化、资源短缺以及相互竞争而出现生存危机，元胞状态值由1变为0;  
  16.     只有处于个体适中(相邻元胞数为2或3)位置的生物才能生存(保持元胞的状态值为1)和繁衍后代(元胞状态值由0变为1)。  
  17.     正由于它能够模拟生命活动中的生存、灭绝、竞争等等复杂现象，因而得名"生命游戏"。  
  18.     J·H·Conway还证明，这个元胞自动机具有通用图灵机的计算能力(谢惠民，1994;李才伟，1997)，  
  19.     与图灵机等价，也就是说给定适当的初始条件，生命游戏模型能够模拟任何一种计算机。  
  20.  
  21.       
  22.     本示例设计到界面显示，用到的类比较多，这里简单说明一下每个类的用途，不再详细列举代码  
  23.     AbstractRunConway.java              建立GUI界面  
  24.     ConwayGUI.java                      在这里定义好了界面，以及按钮相关事件  
  25.     CellGridCanvas.java                 绘制界面  
  26.     ConwayRuleFlowGroupRun.java         继承AbstractRunConway，使用规则流模式启动程序  
  27.     ConwayAgendaGroupRun.java           继承AbstractRunConway，使用Agenda组模式启动程序，之前版本不推荐  
  28.     ConwayApplicationProperties.java    用于从conway.properties中读取预定义的属性  
  29.     ConwayRuleDelegate.java             作为Agenda和规则流两种模式的统一接口  
  30.     *RuleFlowDelegate.java              规则流模式行为响应代理，界面按钮的动作由该类转发给规则引擎，引起WorkingMemory中的变化  
  31.                                         使用规则流控制规则执行时，针对应用的不同操作共使用了4组规则流如下：  
  32.                                         初始化init - 规则流"register neighbor"  
  33.                                         产生下一步的变化nextGeneration - 规则流"generation"，连续变化通过重复调用该步骤进行  
  34.                                         清除killAll - 规则流"kill all"  
  35.                                         模式设置setPattern - 规则流"calculate"  
  36.     AgendaGroupDelegate.java            Agenda模式行为响应代理，作用同上  
  37.     Cell.java                           代表一个格子，有行列属性和状态属性  
  38.     CellGrid.java                       控制表格的抽象接口  
  39.     *CellGridImpl.java                  表格接口的实现，用于向规则引擎中插入数据，以及调用响应代理  
  40.                                         数据的插入分为两种情况  
  41.                                         1、初始化棋盘  
  42.                                             将代表棋盘的CellGrid实例插入  
  43.                                             将棋盘上的每一个格子产生一个Cell对象插入  
  44.                                         2、设置初始模式  
  45.                                             根据提供的模式数组长宽向棋盘中间对齐，对于True的数组数据  
  46.                                             修改对应格子的Cell状态为Live  
  47.     CellState.java                      格子状态（生/死）  
  48.     Phase.java                          在规则中用于控制格子处理的阶段，间接影响格子的状态  
  49.     Neighbor.java                       用于保存两个格子之间的邻居关系  
  50.       
  51.     ConwayPattern.java                  模型初始化数据读取接口  
  52.     Border.java                         一种模型初始格式，实现ConwayPattern接口  
  53.     Hi.java                             同上  
  54.     Pentadecathalon.java                同上  
  55.     Pulsar.java                         同上  
  56.     SimpleGlider.java                   同上    
  57.       
  58.     思路：  
  59.         从元细胞自动机模型的规则中我们可以发现几个关键要点，  
  60.         1、一个格子的状态由相邻格子的状态决定；因此在规则处理中我们要能够方便的确定每个格子的相邻格子情况  
  61.         2、格子的状态变化是一次性完成计算的，格子状态的改变不会对本次变化产生影响；因此在规则处理时要注意  
  62.           解决fact变化激活新的规则的问题  
  63.       
  64.         作者将所有规则按照规则流分组的方式分为下面几个组  
  65.         "register north east"   -   建立格子间的邻居关系（再次提醒，规则引擎推理基于数据，应当将所有需要的数据事先准备好  
  66.                                     数据模型的好坏直接影响规则的效率和质量）  
  67.                                       
  68.         "evaluate"              -   根据格子邻居的情况判定格子下一步的状态，并预设一个值；这里之所以没有直接改变格子  
  69.                                     状态就是因为上面提到的一次性计算问题，如果直接改变状态会影响对其它邻居格子的判断  
  70.                                     Phase：只对Phase==EVALUATE的格子执行  
  71.                                       
  72.         "calculate"             -   遍历每一个格子，根据该格子的生存/死亡状态更新邻居格子的‘邻居’生存个数  
  73.                                     这里留意的是，按照正常的编程思路，应当是找到格子后获得所有邻居状态，然后计算有多少  
  74.                                     个邻居格子是生存状态的，然后更新本格子中的LiveNeighbors计数；但是要采用这样的  
  75.                                     思路，必然涉及到对集合的处理以及一些循环语句，这样增加了规则的复杂度以及引入了过程  
  76.                                     代码，这都是在规则中应当避免的问题；而换一个角度思考我们就会得到更为简单的规则。  
  77.                                     Phase：规则完成后将格子的Phase设为EVALUATE  
  78.                                     注：使用规则引擎不只是掌握一门新技术，而是要求在编程思维上的改变。  
  79.                                       
  80.         "reset calculate"       -   取消"calculate"组激活的规则，因为每次格子重新设置pattern时，盘面上还有生存的格子  
  81.                                     这时如果使用kill all规则来将格子设为死亡，如果之前的calcuate规则还起作用，那么就会  
  82.                                     引起calcuate规则执行，建立新的生存格子，反过来又会引起kill all规则执行，造成无限循环  
  83.           
  84.         "kill"                  -   将Phase为KILL的格子状态设为死亡  
  85.           
  86.         "birth"                 -   将Phase为BIRTH的格子状态设为生存  
  87.           
  88.         "kill all"              -   将所有格子的状态设为死亡，是用在初始化棋盘时  
  89. */  
  90.   
  91. package org.drools.examples   
  92.     
  93. import org.drools.examples.conway.Cell;   
  94. import org.drools.examples.conway.CellGrid;   
  95. import org.drools.examples.conway.Neighbor;   
  96. import org.drools.examples.conway.Phase;   
  97. import org.drools.examples.conway.CellState;   
  98.   
  99. import org.drools.WorkingMemory;   
  100. import org.drools.common.InternalWorkingMemoryActions;   
  101. import org.drools.RuleBase;   
  102.   
  103. /*  
  104.     下面的四条规则都属于ruleflow-group："register neighbor"  
  105.     它们的作用是建立格子之间彼此的邻居关系。  
  106.     我们知道每个格子会有8个相邻的格子，而规则建立关系时都是成对建立的，  
  107.     因此只用四条规则即可完成所有邻居关系建立  
  108. */  
  109. # 建立格子与其右上角格子的邻居关系   
  110. rule "register north east"  
  111.     ruleflow-group "register neighbor"  
  112. when   
  113.     # 获得棋盘列数   
  114.     CellGrid( $numberOfColumns : numberOfColumns )   
  115.     # 获得棋盘内的每个格子，最右边除外，因为最右边没有右上角   
  116.     $cell: Cell( $row : row > 0, $col : col < ( $numberOfColumns - 1 ) )       
  117.     # 获得上面格子的东北角格子         
  118.     $northEast : Cell( row  == ($row - 1), col == ( $col + 1 ) )       
  119. then                       
  120.     # 为这两个格子建立邻居关系   
  121.     insert( new Neighbor( $cell, $northEast ) );   
  122.     insert( new Neighbor( $northEast, $cell ) );           
  123. end   
  124.   
  125. # 建立格子与其正上方格子的邻居关系   
  126. rule "register north"  
  127.     ruleflow-group "register neighbor"     
  128. when   
  129.     $cell: Cell( $row : row > 0, $col : col )      
  130.     $north : Cell( row  == ($row - 1), col == $col )       
  131. then           
  132.     insert( new Neighbor( $cell, $north ) );   
  133.     insert( new Neighbor( $north, $cell ) );           
  134. end   
  135.   
  136. # 建立格子与其左上角格子的邻居关系   
  137. rule "register north west"  
  138.     ruleflow-group "register neighbor"  
  139. when   
  140.     $cell: Cell( $row : row > 0, $col : col > 0 )              
  141.     $northWest : Cell( row  == ($row - 1), col == ( $col - 1 ) )                           
  142. then           
  143.     insert( new Neighbor( $cell, $northWest ) );   
  144.     insert( new Neighbor( $northWest, $cell ) );           
  145. end   
  146.   
  147. # 建立格子与其左边格子的邻居关系   
  148. rule "register west"  
  149.     ruleflow-group "register neighbor"  
  150. when   
  151.     $cell: Cell( $row : row >= 0, $col : col > 0 )             
  152.     $west : Cell( row  == $row, col == ( $col - 1 ) )                          
  153. then           
  154.     insert( new Neighbor( $cell, $west ) );   
  155.     insert( new Neighbor( $west, $cell ) );            
  156. end   
  157.   
  158. /*  
  159.     下面的三条规则都属于ruleflow-group："evaluate"  
  160.     它们是用在进行下一步的变化评估中的，这3个规则中并没有直接改变Cell.CellState,  
  161.     因为CellState是用来进行评估用的，随意改变会造成无限的循环调用，因此规则使用了Phase字段来控制格子状态变化  
  162.     在评估中只是改变Phase，最后根据Phase的状态完成所有格子CellState的设置，并将Phase设回EVALUATE状态  
  163. */  
  164.   
  165. # 将格子的邻居中少于两个是生存状态的格子的状态设为死   
  166. rule "Kill The Lonely"  
  167.     ruleflow-group "evaluate"  
  168.     no-loop   
  169. when   
  170. #   A live cell has fewer than 2 live neighbors   
  171.     theCell: Cell(liveNeighbors < 2, cellState == CellState.LIVE, phase == Phase.EVALUATE)   
  172. then   
  173.     theCell.setPhase(Phase.KILL);   
  174.     update( theCell );   
  175. end   
  176.   
  177. # 将格子的邻居中超过3个状态是生存的格子状态设为死   
  178. rule "Kill The Overcrowded"  
  179.     ruleflow-group "evaluate"  
  180.     no-loop   
  181. when   
  182. #   A live cell has more than 3 live neighbors   
  183.     theCell: Cell(liveNeighbors > 3, cellState == CellState.LIVE, phase == Phase.EVALUATE)   
  184. then   
  185.     theCell.setPhase(Phase.KILL);   
  186.     update( theCell );   
  187. end   
  188.   
  189. # 将格子的邻居中正好有3个是生存状态的死亡格子变为生   
  190. rule "Give Birth"  
  191.     ruleflow-group "evaluate"  
  192.     no-loop   
  193. when   
  194. #   A dead cell has 3 live neighbors   
  195.     theCell: Cell(liveNeighbors == 3, cellState == CellState.DEAD, phase == Phase.EVALUATE)   
  196. then   
  197.     theCell.setPhase(Phase.BIRTH);   
  198.     update( theCell );   
  199. end   
  200.   
  201. # 取消ruleflow-group为"calculate"的所有激活规则   
  202. # clearRuleFlowGroup    -   Clears the RuleFlow group, cancelling all its Activations   
  203. # 因为在"generation"后，"calculate"组的规则还留在引擎中，如果不事先取消，就会引起无限循环   
  204. rule "reset calculate"  
  205.     ruleflow-group "reset calculate"  
  206. when   
  207. then   
  208.     WorkingMemory wm = drools.getWorkingMemory();   
  209.     wm.clearRuleFlowGroup( "calculate" );   
  210. end   
  211.   
  212. # 将所有格子的Phase为Kill的格子状态设置为死，并将处理阶段Phase设置为DONE   
  213. rule "kill"  
  214.     ruleflow-group "kill"  
  215.     no-loop   
  216. when   
  217.     theCell: Cell(phase == Phase.KILL)   
  218. then   
  219.     theCell.setCellState(CellState.DEAD);   
  220.     theCell.setPhase(Phase.DONE);      
  221.     update( theCell );   
  222. end    
  223.   
  224. # 将所有格子的Phase为Birth的格子状态设置为生，并将处理阶段Phase设置为完成   
  225. rule "birth"  
  226.     ruleflow-group "birth"  
  227.     no-loop   
  228. when   
  229.     theCell: Cell(phase == Phase.BIRTH)   
  230. then   
  231.     theCell.setCellState(CellState.LIVE);   
  232.     theCell.setPhase(Phase.DONE);   
  233.     update( theCell );     
  234. end    
  235.   
  236. # 根据格子的生存状态改变邻居格子中LiveNeighbors属性的计数   
  237. rule "Calculate Live"  
  238.     ruleflow-group "calculate"  
  239.     lock-on-active  # 本规则更新的数据在规则流处理完成前不激活新的规则   
  240. when   
  241.     # 获得状态为生存的格子   
  242.     theCell: Cell(cellState == CellState.LIVE)   
  243.     # 找到该格子的每一个邻居   
  244.     Neighbor(cell == theCell, $neighbor : neighbor)    
  245. then   
  246.     # 为这个格子的每一个邻居的LiveNeighbors属性加1  
  247.     $neighbor.setLiveNeighbors( $neighbor.getLiveNeighbors() + 1 );   
  248.     # 将邻居格子的处理阶段Phase设置为EVALUATE   
  249.     $neighbor.setPhase( Phase.EVALUATE );      
  250.     update( $neighbor );   
  251.     System.out.println( "--live--" );   
  252.     System.out.println( "theCell: row"+theCell.getRow()+"col"+theCell.getCol());   
  253.     System.out.println ( "Neighbor: row:"+$neighbor.getRow()+"col"+$neighbor.getCol()+";LiveNeighbors:"+ $neighbor.getLiveNeighbors()) ;   
  254. end    
  255.   
  256. # 类似上一规则，只是进行递减操作   
  257. # 对于这个规则，不太熟悉规则引擎的程序员可能会有所迷惑，所有的格子初始化状态都是DEAD   
  258. # 那这样的话很多格子的LiveNeighbors就会变成负数了，有这样的想法是因为忽略了规则引擎不是从数据里找到规则合适的地方   
  259. # 而是在数据插入或发生变化时找到规则，一开始初始化所有格子为DEAD时确实激活了"Calculate Dead"的很多实例，但是在   
  260. # setPattern时首先执行了"reset calculate"，这取消了之前的所有"Calculate Dead"的激活实例   
  261. # 然后运行"kill all"规则，如果是第一次，该规则不改变任何数据也不会激发新的规则   
  262. # 然后是根据数据设置格子的生存状态，此时上面的"Calculate Live"规则被激活   
  263. # 在后面的规则运算中每次执行"evalaute"规则组都要运行"reset calculate"也是这个原因   
  264. # 然后在运行了"birth"和"kill"规则后才执行"Calculate Live"和"Calculate Dead"规则   
  265. rule "Calculate Dead"  
  266.     ruleflow-group "calculate"  
  267.     lock-on-active # 本规则更新的数据在规则流处理完成前不激活新的规则   
  268. when   
  269.     theCell: Cell(cellState == CellState.DEAD)   
  270.     Neighbor(cell == theCell, $neighbor : neighbor )   
  271. then   
  272.     $neighbor.setLiveNeighbors( $neighbor.getLiveNeighbors() - 1 );   
  273.     $neighbor.setPhase( Phase.EVALUATE );   
  274.     update( $neighbor );       
  275.     System.out.println( "--dead--" );   
  276.     System.out.println( "theCell: row"+theCell.getRow()+"col"+theCell.getCol());   
  277.     System.out.println ( "Neighbor: row:"+$neighbor.getRow()+"col"+$neighbor.getCol()+";LiveNeighbors:"+ $neighbor.getLiveNeighbors()) ;   
  278. end    
  279.   
  280. # 将所有生存状态的格子设为死亡   
  281. rule "Kill All"  
  282.     ruleflow-group "kill all"      
  283.     no-loop   
  284. when   
  285.     theCell: Cell(cellState == CellState.LIVE)   
  286. then   
  287.     theCell.setCellState(CellState.DEAD);   
  288.     update( theCell );   
  289. end  

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 10 Aug 2007 18:24:51 +0800 http://hxpwork.javaeye.com/blog/110968 http://hxpwork.javaeye.com/blog/110968 Drools4：对Sudoku示例的分析 hxpwork 作者: hxpwork  链接：http://hxpwork.javaeye.com/blog/109129  发表时间: 2007年08月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

  1. /*  
  2.     Sodu：数独游戏，一个9x9的方格棋盘中，按照每三行三列再细分为9个小棋盘,如下  
  3.             |a|a|a|b|b|b|c|c|c|  
  4.             |a|a|a|b|b|b|c|c|c|  
  5.             |a|a|a|b|b|b|c|c|c|  
  6.             |d|d|d|e|e|e|f|f|f|  
  7.             |d|d|d|e|e|e|f|f|f|  
  8.             |d|d|d|e|e|e|f|f|f|  
  9.             |g|g|g|h|h|h|i|i|i|  
  10.             |g|g|g|h|h|h|i|i|i|  
  11.             |g|g|g|h|h|h|i|i|i|  
  12.           其中a,b...i分别代表大棋盘中的9个小棋盘，规则是：  
  13.           1、使用1-9，九个数字填入字母a-i所在位置  
  14.           2、大棋盘上的每一行，每一列都不能有重复数字  
  15.           3、小棋盘上也不能有重复的数字  
  16.           数独游戏实际上是一个推理游戏，与数字计算无关；首先会随机产生一些数字在棋盘上，然后游戏者完成剩下的填空  
  17.       
  18.     数独游戏通常会在棋盘上事先准备好一些数字，然后由游戏者完成剩下的格子。  
  19.       
  20.     如何使用规则引擎完成这一任务呢？  
  21.       
  22.     --首先我们要对Drools这种正向推理性的引擎有一个认识前提，就是它是基于数据进行规则推导的，  
  23.     也就是说如果需要规则引擎帮你找到结果，那首先必须将所有可能的结果都准备好。  
  24.     这一方法在Golfer球员排序时也使用过，当时是将所有球员组合情况都放到引擎中，由引擎自己找出答案。  
  25.       
  26.     那么现在我们第一步要做的就是在所有未确定数据的空格子位置上准备所有可能的结果，也就是在那里放上从1-9的数字，最后由引擎自己挑选。  
  27.     现在我们在每个空格子里面都准备好了数据，那么下面就是要将格子中无关的数据去掉，如果剩下一个，那显然就是答案了。  
  28.     要如何去掉格子中无效的数据呢？那显然就是要遵循行、列、区域中都不能有重复数字的规则了。  
  29.     设想一下，获得某一行上有数据的格子，那么空格子中与这些格子的数据显然就不能重复，这样就可以排除掉无用的数据。  
  30.     依次类推，在列与区域中也进行这样的检查，那么最终会有空格子的可选数据会只剩一个，此时就将该可选数据转换为正式数据，  
  31.     同时又会引发新的筛选，进一步减少可选值。  
  32.       
  33.     但是这样的规则够了吗？从实际效果上看显然是不够的，因为在很多情况下，这样的规则并不能确定所有格子的值，还需要继续的挖掘潜在的规则。  
  34.     从游戏的原则中我们又可以推导从下面的规则：  
  35.     如果在一个区域/行/列内，某一个空格子上的可选值在这个区域/行/列里是唯一的，并且不会违反行列区域已有数字冲突的原则，那么该可选值就是格子真正的数字。  
  36.     采用了这个规则后，大部分的格子可以完成推导，有时甚至可以完成全部格子推导，但是仍然存在不可以得到结果的情况。  
  37.     或许对于数学非常精通的程序员，可以通过数学定理推导规则是否可以满足所有情况，但是作为大多数人，多测试是唯一的办法。  
  38.       
  39.     这也提醒我们，使用规则引擎解决复杂推理问题时，一定要多想多测试，并尽可能找到显式规则以及所有的潜在规则，  
  40.     宁多勿缺，只要规则正确，最多就是走走弯路，好过没有完成任务！  
  41.       
  42.     最后我们再找到一组潜在的规则  
  43.     如果在区域中有两个格子都只剩两个可选值，并且这两个可选值一样的情况下，显然这两个格子只能是这两个可选值中的一个；  
  44.     这时删除区域中其它空格子中相同的可选值。  
  45. */  

Fact 插入

  1. StatefulSession session = null;   
  2. try {   
  3.     Collection fields = new ArrayList();   
  4.     // 对于数独阵列中的每一个格子有4个属性：数字，行，列，区域   
  5.     // 下面就是根据这四个属性建立Fact数据，顺便将每一行数据打印出来   
  6.     for ( int i = 0; i < field.length; i++ ) {   
  7.         String row = "{";   
  8.         for ( int j = 0; j < field[i].length; j++ ) {   
  9.             row += field[i][j] + ",";   
  10.             fields.add( new Field( "" + field[i][j],   
  11.                                    j + 1,   
  12.                                    i + 1,   
  13.                                    getZone( i,   
  14.                                             j ) ) );   
  15.         }   
  16.         row += "}";   
  17.         System.out.println( row );   
  18.     }   
  19.     // 启动规则引擎   
  20.     RuleBase ruleBase = readRule();   
  21.     session = ruleBase.newStatefulSession();   
  22.   
  23.     // 将每一个Field实例插入WorkingMemory，同时保存FachHandle   
  24.     Iterator iter = fields.iterator();   
  25.   
  26.     Collection handles = new ArrayList();   
  27.     while ( iter.hasNext() ) {   
  28.         handles.add( session.insert( iter.next() ) );   
  29.     }   
  30.     session.fireAllRules();   
  31.   
  32.     System.out.println( "Size: " + iteratorToList( session.iterateObjects() ).size() );   
  33.   
  34.     // 完成计算以后将数据写回阵列   
  35.     iter = session.iterateObjects();   
  36.     //Copy the values of the fields into the matrix   
  37.     while ( iter.hasNext() ) {   
  38.         Object next = iter.next();   
  39.         if ( next instanceof Field ) {   
  40.             field[((Field) next).getRow() - 1][((Field) next).getColumn() - 1] = Integer.parseInt( ((Field) next).getValue() );   
  41.         }   
  42.     }   
  43.   
  44.     // 打印结果   
  45.     for ( int i = 0; i < field.length; i++ ) {   
  46.         String row = "{";   
  47.         for ( int j = 0; j < field[i].length; j++ ) {   
  48.             row += field[i][j] + ",";   
  49.         }   
  50.         row += "}";   
  51.         System.out.println( row );   
  52.     }   
  53.   
  54. } catch ( Throwable t ) {   
  55.     t.printStackTrace();   
  56. } finally {   
  57.     if ( session != null ) {   
  58.         session.dispose();   
  59.     }   
  60. }   

规则

  1. # 首先将所有数字为0的格子删除，并对这个格子插入从1-9的所有可能情况   
  2. rule "Rule 1: If a field has the value 0, it is empty: remove it and insert the PossibleValues"  
  3.     salience 100  
  4.     when   
  5.         $field : Field( value == 0, $row : row, $column : column, $zone : zone )   
  6.     then   
  7.         insert( new PossibleValue("1", $field ) );   
  8.         insert( new PossibleValue("2", $field ) );   
  9.         insert( new PossibleValue("3", $field ) );   
  10.         insert( new PossibleValue("4", $field ) );   
  11.         insert( new PossibleValue("5", $field ) );   
  12.         insert( new PossibleValue("6", $field ) );   
  13.         insert( new PossibleValue("7", $field ) );   
  14.         insert( new PossibleValue("8", $field ) );   
  15.         insert( new PossibleValue("9", $field ) );   
  16.         // 插入完毕后删除Field，因为该Field中的数据不是我们所需要的，   
  17.         // 我们需要的只是它的位置信息，而这些是不变的，已经在PossibleValue初始化时保留。   
  18.         retract( $field );   
  19.            
  20.         #System.out.println("Rule 1 fired.");   
  21. end     
  22.   
  23. # 这个规则是当某一个格子上的PossibleValue只剩下一个时，那么这个PossibleValue的值就是要寻找的值   
  24. rule "Rule 2: If there is one PossibleValue left at a certain position, it should be the Fields value"  
  25.     salience 5  
  26.     when   
  27.         $pv : PossibleValue ( $row : row, $zone : zone, $column : column, $value : value )   
  28.         not ( PossibleValue ( row == $row, zone == $zone, column == $column, value != $value ) )   
  29.     then   
  30.         insert( new Field( $value, $column, $row, $zone ) );   
  31.         System.out.println ( "Field be found in row="+$row+";col="+$column+"value="+$value );   
  32.         retract( $pv );   
  33.            
  34.         #System.out.println("Rule 2 fired.");   
  35. end     
  36.   
  37. # 获得行中已确定的数字，将该行上空格子中的相同备选数字删除   
  38. rule "Rule 3: If there is a field with a value in a row, remove all PossibleValues with this value in this row"  
  39.     salience 15  
  40.     when           
  41.         $field2 : Field( $row : row, $value : value != 0 )   
  42.         $possible : PossibleValue( row == $row, value == $value )   
  43.     then   
  44.         retract( $possible );   
  45.         #System.out.println("Rule 3 fired.");   
  46. end   
  47.   
  48. # 获得列中已确定的数字，将该列上空格子中的相同备选数字删除   
  49. rule "Rule 4: If there is a field with a value in a column, remove all PossibleValues with this value in this column"  
  50.     salience 15  
  51.     when           
  52.         $field1 : Field( $column : column, $value : value != 0 )   
  53.         $possible : PossibleValue( column == $column, value == $value )   
  54.     then   
  55.         retract( $possible );   
  56.         #System.out.println("Rule 4 fired.");   
  57. end   
  58.   
  59. # 获得区域中已确定的数字，将该区域上空格子中的相同备选数字删除   
  60. rule "Rule 5: If there is a field with a value in a zone, remove all PossibleValues with this value in this zone"  
  61.     salience 15  
  62.     when           
  63.         $field1 : Field( $zone : zone, $value : value != 0 )   
  64.         $possible : PossibleValue( zone == $zone, value == $value )   
  65.     then   
  66.         retract( $possible );   
  67.         #System.out.println("Rule 5 fired.");   
  68. end   
  69.   
  70. # 一旦产生新的格子数字，则删除在这个格子上的所有可选值   
  71. # Rule 2,3,4,5 不会引起该规则的调用，因为这几个规则是将其它可选值删除后剩余的值设为格子数字。   
  72. # 该规则是由Rule 7，8，9激发的   
  73. rule "Rule 6: For fields with a value remove all PossibleValues"  
  74.     salience 250  
  75.     when   
  76.         Field( value != 0, $col : column, $row : row, $zone : zone )   
  77.         $pv : PossibleValue( column == $col, row == $row, zone == $zone )   
  78.     then   
  79.         retract( $pv );   
  80.         #System.out.println("Rule 6 fired.");   
  81. end   
  82.   
  83. # 如果在一个小区域内，某一个空格子上的可选值在这个区域里是唯一的   
  84. # 并且不会违反行列区域数字冲突的原则，那么该可选值就是格子真正的数字   
  85. rule "Rule 7: If there is only one PossibleValue left in a zone, it must have the value of the field"  
  86.     salience 4  
  87.     when           
  88.         $pv : PossibleValue( $zone : zone, $value : value, $col : column, $row : row)   
  89.         not (PossibleValue( zone == $zone, value == $value ))   
  90.         not (Field( value == $value, zone == $zone) )   
  91.         not (Field( value == $value, row == $row) )   
  92.         not (Field( value == $value, column == $col) )   
  93.     then   
  94.         insert( new Field( $value, $col, $row, $zone ) );   
  95.         retract( $pv );   
  96.         #System.out.println("Rule 7 fired.");   
  97. end   
  98.   
  99. # 如果在一列上，某一个空格子上的可选值在这个列上是唯一的   
  100. # 并且不会违反行列区域数字冲突的原则，那么该可选值就是格子真正的数字   
  101. rule "Rule 8: If there is only one PossibleValue left in a column, it must have the value of the field"  
  102.     salience 4  
  103.     when           
  104.         $pv1 : PossibleValue( $zone : zone, $value : value, $col : column, $row : row)   
  105.         not (PossibleValue( column == $col, value == $value ))   
  106.         not (Field( value == $value, zone == $zone) )   
  107.         not (Field( value == $value, row == $row) )   
  108.         not (Field( value == $value, column == $col) )   
  109.     then   
  110.         insert( new Field( $value, $col, $row, $zone ) );   
  111.         retract( $pv1 );   
  112.         #System.out.println("Rule 8 fired.");   
  113. end   
  114.   
  115. # 如果在一行上，某一个空格子上的可选值在这个行上是唯一的   
  116. # 并且不会违反行列区域数字冲突的原则，那么该可选值就是格子真正的数字   
  117. rule "Rule 9: If there is only one PossibleValue left in a row, it must have the value of the field"  
  118.     salience 4  
  119.     when           
  120.         $pv : PossibleValue( $zone : zone, $value : value, $col : column, $row : row)   
  121.         not (PossibleValue( row == $row, value == $value ))   
  122.         not (Field( value == $value, zone == $zone) )   
  123.         not (Field( value == $value, row == $row) )   
  124.         not (Field( value == $value, column == $col) )   
  125.     then   
  126.         insert( new Field( $value, $col, $row, $zone ) );   
  127.         retract( $pv );   
  128.         #System.out.println("Rule 9 fired.");   
  129. end   
  130.   
  131. # 如果在一个区域中的两个空格子只剩两个可选值，则删除该区域中与这两个可选值相同的其它可选值   
  132. rule "Rule 10: If there are two fields with only two possible values, remove the PossibleValues for the same Value in the rest of the zone"  
  133.     salience 1  
  134.     when   
  135.         # 找到一个可选值A   
  136.         PossibleValue( $zone : zone, $val1 : value, $row1 : row, $col1 : column )   
  137.         # 要求在相同区域中，不同列上具有与A数字相同的可选值C   
  138.         PossibleValue( zone == $zone, value == $val1, $row2 : row, $col2 : column != $col1)   
  139.         # 要求与A在同一个格子里有其它可选值B   
  140.         PossibleValue( zone == $zone, row == $row1, column == $col1, $val2 : value )   
  141.         # 要求在C的格子里有与B的数字相同的可选值   
  142.         PossibleValue( zone == $zone, row == $row2, column == $col2, value == $val2 )   
  143.         # 要求在A格子中不存在除A与B的数字以外的可选值，也就是说A格子中的可选值不超过两个   
  144.         not ( PossibleValue( zone == $zone, row == $row1, column == $col1, value != $val1, value != $val2 ) )   
  145.         # 要求在C格子中不存在除A与B的数字以外的可选值，也就是说C格子中的可选值不超过两个   
  146.         # 这两个not条件组合起来要表达的就是区域中有A，C两个格子中的可选值一样，并且只有两个   
  147.         not ( PossibleValue( zone == $zone, row == $row2, column == $col2, value != $val1, value != $val2 ) )   
  148.         # 获得区域中与A数字相同的其它可选值   
  149.         $pv : PossibleValue( zone == $zone, value == $val1)   
  150.     then   
  151.         retract( $pv );   
  152.         #System.out.println("Rule 10 fired.");   
  153. end   
  154.   
  155. # 如果在一个区域中的两个空格子只剩两个可选值，则删除该区域中与这两个可选值相同的其它可选值   
  156. # 本规则与上一规则基本一样区别是寻找C格子时使用不同行而不是不同列   
  157. rule "Rule 11: If there are two fields with only two possible values, remove the PossibleValues for the same Value in the rest of the zone"  
  158.     salience 1  
  159.     when