Visual Prolog 7ç»ä¸å¦ - PDC Download site

Visual Prolog 7 边练边学 

Contents 

Visual Prolog 7 边练边学 ................................................................................................................. 1 

第一章简介 ................................................................................................................................. 5 

第 1.1 节创建一个新的 GUI 程序 ......................................................................................... 5 

第 1.2 节编译和运行你的程序 .............................................................................................. 6 

第 1.3 节玩一把 : 把程序的显示标题改成我的名字 .......................................................... 8 

第 1.4 节小结和说明 .............................................................................................................. 9 

第 1.5 节逻辑小知识 : 希腊人发明了逻辑 ........................................................................ 10 

第二章 Forms ............................................................................................................................ 10 

第 2.1 节创建一个新的 Form .............................................................................................. 10 

第 2.2 节让任务菜单的项目工作起来 ................................................................................ 12 

第 2.3 节用 Code Expert 添加程序 .................................................................................... 13 

第 2.4 节小结和说明 .......................................................................................................... 15 

第 2.5 节逻辑小知识 : 亚里士多德的符号逻辑 ................................................................ 15 

第三章鼠标事件 ....................................................................................................................... 16 

第 3.1 节增加鼠标按下事件侦听器 .................................................................................... 16 

第 3.2 节 onPaint 绘图 .......................................................................................................... 18 

第 3.3 节小结和说明 ............................................................................................................ 20 

第 3.4 节逻辑小知识 : 布尔代数 ........................................................................................ 21 

第 3.5 节论证的形式 ............................................................................................................ 21 

第四章基本图例 ....................................................................................................................... 22 

第 4.1 节任务菜单 ................................................................................................................ 22 

第 4.2 节目录树 .................................................................................................................... 23 

第 4.3 节创建一个工程项目 ................................................................................................ 25 

第 4.4 节创建一个新的 class ............................................................................................... 27 

第 4.5 节设置控件属性 ........................................................................................................ 28 

第 4.6 节小结和说明 .......................................................................................................... 29 

第 4.7 节逻辑小知识 : 谓词运算 ........................................................................................ 29 

第五章 Horn 语句 ..................................................................................................................... 30 

第 5.1 节函数 ........................................................................................................................ 30 

第 5.2 节谓词 ........................................................................................................................ 30 

第 5.3 节求解 ........................................................................................................................ 30 

第 5.4 节答案不惟一 ............................................................................................................ 34 

第 5.5 节逻辑符号 ................................................................................................................ 36 

第 5.6 节 Horn 句子 .............................................................................................................. 36 

第 5.7 节声明 ........................................................................................................................ 37 

第 5.8 节绘图谓词 ................................................................................................................ 38 

第 5.8 节 GDI 实体 ................................................................................................................ 39

第 5.9 节小结和说明 .......................................................................................................... 40 

第 5.10 节逻辑小知识 :Horn 句子的意义 ......................................................................... 40 

第六章控制台应用 ................................................................................................................... 41 

第 6.1 节截断 ........................................................................................................................ 41 

第 6.2 节表 ............................................................................................................................ 43 

第 6.3 节表相关的几个话题 ................................................................................................ 48 

第 6.4 节字符串操作 ............................................................................................................ 52 

第 6.5 节逻辑小知识 : 谓词的语法 .................................................................................... 61 

第七章文本编辑器 ................................................................................................................... 61 

第 7.1 节建立文本编辑器程序 ............................................................................................ 61 

第 7.2 节文件保存 ................................................................................................................ 63 

第 7.3 节文件调入 ................................................................................................................ 64 

第 7.4 节编辑器的改进 ........................................................................................................ 66 

第八章绘图 ............................................................................................................................... 67 

第 8.1 节 onPainting 相关的话题 ......................................................................................... 67 

第 8.2 节 Custom Control 的应用 ......................................................................................... 72 

第九章数据类型 ....................................................................................................................... 75 

第 9.1 节原始数据类型 ........................................................................................................ 75 

第 9.2 节集合 ........................................................................................................................ 76 

第 9.3 节数字的集合 ............................................................................................................ 76 

第 9.4 节实数 ........................................................................................................................ 78 

第 9.5 节格式 ........................................................................................................................ 78 

第 9.6 节域 ............................................................................................................................ 79 

第十章如何用 Prolog 解决问题 .............................................................................................. 84 

第 10.1 节搜索一个表的所有元素 ...................................................................................... 84 

第 10.2 节寻求两个表的交集表 .......................................................................................... 86 

第 10.3 节两个表的合并 ...................................................................................................... 87 

第 10.4 节表的倒序排列 ..................................................................................................... 88 

第 10.5 节表的分割 ............................................................................................................. 90 

第 10.6 节表的快速排序 ..................................................................................................... 91 

第 10.7 节一年有多少天 ?.................................................................................................. 92 

第 10.8 节地图填色问题 ...................................................................................................... 93 

第 10.9 节翻子游戏 .............................................................................................................. 97 

第 10.10 节 NIM 游戏 ........................................................................................................... 98 

第十一章事实 ......................................................................................................................... 106 

第 11.1 节数据库记录的生成和保存 ................................................................................ 106 

第 11.2 节数据库记录文件的读取 .................................................................................... 108 

第 11.3 节 file 模块 : 读写字符串 readString/writeString .................................................... 109 

第 11.4 节常数 .................................................................................................................... 111 

第十二章 class 和 object ......................................................................................................... 112 

第 12.1 节存取社会保障号 ................................................................................................ 112 

第 12.2 节 Object 的事实 .................................................................................................... 114 

第十三章乌龟爬和语言处理 ................................................................................................. 115 

第 13.1 节乌龟爬行 ............................................................................................................ 115

第 13.2 节乌龟的状态描述 ................................................................................................ 118 

第 13.3 节画出其他的规则图形 ........................................................................................ 119 

第 13.4 节保证每次画出的是一样的图形 ........................................................................ 121 

第 13.5 节递归 .................................................................................................................... 123 

第 13.6 节利用递归方法画复杂曲线 ................................................................................ 124 

第 13.7 节语言处理 ............................................................................................................ 127 

第十四章 L- 系统 ..................................................................................................................... 131 

第 14.1 节画一棵树 ............................................................................................................ 131 

第 14.2 节如何才能画一棵树 ............................................................................................ 133 

第 14.3 节画出不同的树 .................................................................................................... 136 

第十五章游戏 ......................................................................................................................... 137 

第 15.1 节游戏描述 ............................................................................................................ 137 

第 15.2 节游戏设计前的分析 ............................................................................................ 137 

第 15.3 节游戏编程 ............................................................................................................ 137 

第 15.4 节游戏的说明 ........................................................................................................ 144 

第 15.5 节游戏的改进 ........................................................................................................ 146 

第 15.6 节实体事实 Object Facts ....................................................................................... 149 

第十六章几个有趣的部件 ..................................................................................................... 150 

第 16.1 节 TabControl 的应用 ............................................................................................. 150 

第 16.2 节 ListControl 的应用 ............................................................................................ 155 

第 16.3 节 treeView Control、listView Control .................................................................. 169 

第十七章动画 ......................................................................................................................... 177 

第 17.1 节绘图 .................................................................................................................. 178 

第 17.2 节定时器的使用 .................................................................................................... 179 

第 17.3 节动画是怎么实现的 ?........................................................................................ 181 

第 17.4 节改进动画程序 .................................................................................................... 182 

第十八章相关资料介绍、索引 ............................................................................................. 183 

第 18.1 节 Prolog 书籍 ........................................................................................................ 183 

第 18.2 节本书的例子程序的获得 .................................................................................... 185 

第 18.3 节中国的知识基系统研究 .................................................................................... 185 

附录 - 要点索引 ..................................................................................................................... 185 

自序 ....................................................................................................................................... 185 

第一章简介 ......................................................................................................................... 185 

第二章 Forms ...................................................................................................................... 186 

第三章鼠标事件 ................................................................................................................. 186 

第四章基本图例 ................................................................................................................. 186 

第五章 Horn 语句 ............................................................................................................... 187 

第六章控制台应用 ............................................................................................................. 188 

第七章文本编辑器 ............................................................................................................. 189 

第八章绘图 ......................................................................................................................... 189 

第九章数据类型 ................................................................................................................. 189 

第十章如何用 Prolog 解决问题 ........................................................................................ 190 

第十一章事实 ..................................................................................................................... 190 

第十二章 class 和 object ..................................................................................................... 191

第十三章乌龟爬和语言处理 ............................................................................................. 191 

第十四章 L- 系统 ................................................................................................................. 192 

第十五章游戏 ..................................................................................................................... 192 

第十六章几个有趣的部件 ................................................................................................. 192 

第十七章动画 ..................................................................................................................... 193 

第十八章相关资料介绍、索引 ......................................................................................... 193

正文 -------------------------------------- 

自序 

本书是为 Visual Prolog 7 以上版本的编程爱好者而写。我们不谈大而空的理论 , 所以您不用 

担心晦涩难懂 ; 我们也不设立好高骛远的目标 , 所以您也不用担心看不懂。所以它完全是是 

适用于自学的 : 一个人静静地摸索。让纷扰的世界去它的吧 , 把心沉浸在一个循序渐进的创 

建、享受的过程中吧。 

所以本书还适合那些不喜欢纷扰、喜欢独立思考的人们。 

您可以在 www.visual-prolog.com 网站上下载一个免费 Visual Prolog 7 的版本 , 然后一切都 

可以进行下去了。 

我们拿一个个例子 , 来引导您走入 Visual Prolog 殿堂 , 来消除您对一个陌生语言 Visual Prolog 

的隔膜和恐惧。 

我坚信 , 逻辑语言适合中国人掌握 , 因为我们有庞大的人群 , 因为我们有五千年的文化 , 因 

为我们有庞大的应用市场。未来是知识的时代 , 知识处理会是很重要的事 , 我们不能袖手旁 

观 ! 

我知道大学的计算机教育还把 Visual Prolog 5 作为实习的平台 , 然而它虽然好 , 但是已经不 

符合现代化的编程理念了 , 但是 Visual Prolog 7 不同 , 它的理念是新的 , 是符合潮流的 ,class 

和 objects, 在这里一样通行 ; 而开放的结构让它有很强的包容性。你不会浪费时间。 

每个中国的青年和知识壮年 , 都该学习学习 Visual Prolog 7。需要更多信息 , 也可以访问 

www.visual-prolog.cn , 我们会在这里不是更新信息 , 给 Visual Prolog 爱好者一个聚会的交 

流的平台。 

2009-1-4 于北京 

第一章简介 

首先我们要下载安装 Visual Prolog 7.1 免费个人版软件 , 可以正常启动 , 本书内容建立在这 

个软件基础上。 

第 1.1 节创建一个新的 GUI 程序 

我们开始创建一个新的程序 , 如图 1.1.1 所示 , 我们点击菜单项 Project|New,

图 1.1.1 这是起点 

然后 , 根据提示 , 我们创建自己的 GUI 程序 myFirst: 

图 1.1.2 简单填一个名字就可以开始写你自己的程序了 

然后 ,IDE 编程环境进入到 : 

图 1.1.3 创建了第一个程序 

这样就完成了 “myFisrt” 程序的创建 , 基本的框架已经有程序设计环境为你自动生成了。 

第 1.2 节编译和运行你的程序 

在编程环境下 , 点击菜单项 Build||build, 就可以编译你的程序 , 如果要执行程序 , 则点击 

Build|Excute。编译时状态行显示编译进程信息 :

图 1.2.1 编译时状态行显示编译进程 , 要耐心等一等 

如果要执行的程序还没有编译过 , 则 , 点击 Excute 菜单项 , 如图 1.2.1 所示 , 则可以完成从 

编译到执行的全部过程。 

图 1.2.2 执行程序的菜单操作 , 也可以用工具栏的 “E” 来替代 , 经常用到 

我们可以看到 , 我们刚刚建立的程序 , 运行了起来 , 如图 1.2.3 所示。 

图 1.2.3 我的第一个 GUI 程序 myFirst, 也很不错吧 ? 但是花不了 5 分钟啊 ! 

可以看到 , 第一个程序虽然是空的 , 但是 , 却样样齐全 : 有主窗口、信息窗口、菜单系统、 

工具栏和状态行等等基本的元素。

第 1.3 节玩一把 : 把程序的显示标题改成我的名字 

为了增加乐趣 , 我们可以考虑修改 myFirst 为我们自己的名字。比如如果我叫 “ 汀郁桂霞 ”, 

我们让它显示这个 , 如何 ? 首先我们关闭运行的程序 , 然后返回编程环境 , 看到项目文件树 

如图 1.3.1 所示 , 发生了变化 : 

图 1.3.1 编译后的文件树 

多出了一些文件。我们点击 TaskWindow 目录 , 找到 TaskWindow.win, 并点击鼠标右键 , 看 

到弹出菜单 , 如图 1.3.2 所示。 

图 1.3.2 找到主窗口进行编辑 

我们选择 Edit 项目 , 进行编辑 , 首先看到 :

图 1.3.3 修改标题名字成为我的名字 

我们把 Title 项目目前的 myFirst 修改为 “ 汀郁桂霞 ”, 然后再执行一下程序 , 可以看到 , 程 

序显示的标题已经发生了改变 , 如图 1.3.4 所示。你可以尝试改成你自己的名字 , 增加乐趣。 

学习 Visual Prolog 是一个充满乐趣的事情 , 不要忘记了啊。 

图 1.3.4 真的修改成我的名字了 , 很神奇吧 ?! 

第 1.4 节小结和说明 

这里我们建立了第一个程序 , 在目录 myFirst 里。目前这里包含的文件和目录如图 1.4.1 所 

示。 

图 1.4.1 第一个程序的文件和目录列表

我们以后将在这个基础上 , 进行功能添加。这是创建一个程序的开端。 

第 1.5 节逻辑小知识 : 希腊人发明了逻辑 

古希腊人相信这样的信条 : 

Our constitution does not copy the laws of neighboring states; we are rather a model to 

others than imitators ourselves. Its administration favors the many instead of the few; this 

is why it is called a democracy. If we look to the laws, they afford equal justice to all in their 

private differences; if no social standing, advancement in public life falls to reputation for 

capacity, class considerations not being allowed to interfere with merit; nor again does 

poverty bar the way: If a man is able to serve the state, he is not hindered by the obscurity 

of his condition from proposing laws, and political actions. 

在这样一个社会里 , 一个人要想有所作为 , 想有所创新 , 必须首先说服大家。一个人的思想 

一旦为大多数人接受 , 就可以成为法律或者大家普遍遵从的规则。大家行事只能按照惯例、 

英雄们的做法来做。 

聪明的古希腊哲人们为了说服别人 , 发明了逻辑方法、诡辩术、聚众心理学、说谎的艺术等 

等技巧 , 来试图说服大众 , 证明自己的正确。 

而 Visual Prolog 遵从的逻辑学方法 , 正式这样一个古老的方法的一种应用 : 用现存的正确命 

题 , 经过不断的匹配和验证 , 证明一个新命题的正确。 

第二章 Forms 

上一章 , 我们学习了建立一个空的程序项目。这一章 , 我们学习怎么在这个基础上 , 为项目 

增加一个 Form。Form 是窗口界面的基本元素 , 它也是一个窗口 , 相当于一个控制面板。在 

这个面板上 , 我们可以增加一些控件 : 比如静态文本、文本输入框、编辑框、按钮、滑块、 

列表框等等 , 从而实现对用户事件的反应。我们甚至可以在这个面板上绘图。 

第 2.1 节创建一个新的 Form 

启动编程环境 , 打开已有的 Project 名字 “myFirst”。在 myFirst 项目基础上 , 点击菜单项 

File|New in new Package, 如图 2.1.1 所示。

图 2.1.1 击菜单项 File|New in new Package, 创建一个新的 Form 

我们可以看到 , 出现 “Create Project Item” 对话框 , 我们在 Name 处填写 “query”, 在左边 

侧面一列 , 选择 Form 项目 , 如图 2.1.2 所示。 

图 2.1.2 Create Project Item 对话框 Name 处填写 query, 选择 Form 

然后点击下面的 Create 按钮 , 于是 , 一个新的 Form 就创建了 , 在文件树列表里 , 可以看到 

多了一些东西 , 如图 2.1.3 所示。 

图 2.1.3 文件树列表多了一些东西 

并且自动进入 Form 编辑状态如图 2.1.4 所示。 

图 2.1.4 自动进入 Form 编辑状态 

图 2.1.5 所示是控件工具箱。这些控件都是可以放到 Form 这个控制面板上的零部件。我们 

选择需要的 , 首先点击相应的图标 , 然后当鼠标移动到 Form 上方 , 一个阴影一样的图标就 

在光标处 , 你可以用鼠标确定放在什么位置 , 放多大 , 这样就完成了一个控件的放置或者安 

放。复杂的应用界面 , 就是这些一个一个标准的按钮组合起来完成的。

图 2.1.5 控件工具箱 

图 2.1.6 所示是控件版面编辑安置工具箱。这个工具箱是帮助我们把控件在 Form 上安放、 

编排地更合理 , 更有条不紊。它包含了左对齐、竖中心对齐、右对齐、显示网格线、上对齐、 

下对齐、横中心对齐、等大小、等间距、等高、等宽等等工具。我们可以选中相应的控件 , 

然后使用这些功能 , 安排控件布局。 

图 2.1.6 控件版面编辑安置工具箱。 

需要说明的是 ,Form 的控件编辑是随时可以进行的。现在我们只要创建这个缺省的 query 

Form 就行了 , 更多的工作留在以后进行。我们可以点击 query 的右上角关闭按钮 , 根据提 

示保存 Form。 

第 2.2 节让任务菜单的项目工作起来 

我们已经创建了一个 From, 它的名字就是 query, 如何在程序启动后 , 我们点击菜单 File|new, 

就可以把这个界面调出来呢 ? 

首先 , 如图 2.2.1 所示 , 我们在这里找到程序菜单项目所在文件。

图 2.2.1 程序菜单项目所在文件是 TaskWindow.mnu 

然后我们按鼠标右键激活菜单 , 选择 Edit 来编辑菜单 , 如图 2.2.2 所示 , 我们选择 File|New 

项目 , 把上部的 Disable 选择框的勾通过鼠标点击去掉 , 然后关闭这个对话框 , 根据提示保 

存修改。 

图 2.2.2 选择 File|New 项目 , 鼠标点击去掉 Disable 选择框的勾 

第 2.3 节 

用 Code Expert 添加程序 

然后我们选择 TaskWindow.win 文件 , 点击鼠标右键 , 选择 Code Expert 菜单项 , 如图 2.3.1 

所示。这样我们就可进入代码专家界面如图 2.3.2 所示。

图 2.3.1 TaskWindow.win 文件上鼠标右键选择 Code Expert 菜单项 

我们在代码专家对话框里选择 File|New 菜单项目 , 可以采取鼠标双击或者选中项目后点击 

右下角的 add 按钮 , 进入代码编写界面 , 程序自动生成的代码如图 2.3.3 所示。 

图 2.3.2 双击或者点击 add 按钮 

我们在自动生成的代码后写出相应的代码。 

图 2.3.3 程序自动生成了一些代码 

我们把自动生成的代码如下 :

clauses 

onFileNew(_Source, _MenuTag). 

修改为代码如下所示 : 

clauses 

onFileNew(W, _MenuTag) :- X= query::new(W), X:show(). 

然后 , 重新编译运行一下程序 , 注意 , 当程序提示是否加入 query 包 , 要选择 add all。最后 

发现 , 当我们点击 File|New 菜单项后 , 程序显示了 query 对话框 , 如图 2.3.4 所示。 

图 2.3.4 点击 File|New 菜单项程序显示 query 对话框 

第 2.4 节 

小结和说明 

本章我们主要学习了怎么创建一个 Form, 怎么把任务菜单项目变得可用 , 怎么利用代码专 

家 Code Expert 功能来顺利的编写代码 , 最后实现了用菜单激活一个对话框的基本操作。这 

是很重要的一步 , 也是编写程序的最基本操作。希望大家认真融会贯通。 

第 2.5 节逻辑小知识 : 亚里士多德的符号逻辑 

亚里士多德认为 , 一个命题由主体和谓词两部分 , 外加修饰词构成。表示程度的修饰词有 : 

“ 每一个 / 都 ”(every)、“ 没有 / 绝不 ”(no)、“ 一些 / 某种程度上 ”(some)、“ 并非都 ”(not every), 

几种。后来葡萄牙和西班牙的逻辑学家在这个基础上发明了符号逻辑表示方法 , 来简化表述 

命题 : 

限定符号含义书写方法举例 

a Universal affirmative 完全肯定 PaQ Every P is Q 

e Universal negative 完全否定 PeQ No P is Q 

i Particular affirmative 部分肯定 PiQ Some P is Q 

o Particular negative 部分否定 PoQ Some P is not Q 

命题由此被分为不同真的、矛盾的、不同假的。下面是他们的解释 : 

a. 两个命题 P 和 Q 是矛盾的 , 当且仅当 

i. P 和 Q 不能同时是正确的 , 并

ii P 或 Q 有一个是正确的。 

类型 a 和类型 o 是矛盾的 , 同样类型 e 和类型 i 也是矛盾的。 

b. 两个命题 P 和 Q 是相反的 , 当且仅当 

i. P 和 Q 不能同时是真的 , 并 

ii. P 和 Q 可以都是假的。 

类型 a 和类型 e 是不同真的。 

c. P 和 Q 是不完全相反的 , 当且仅当 

i. P 和 Q 不能同时是假的 , 并 

ii. P 和 Q 都可以是真的。 

类型 i 和类型 o 是不同假的。 

三段论是三个命题构成的证明过程 : 两个前提和一个结论 , 并且出现恰好三个论述 , 而且每 

个论述被精确地运用两次。 

设 P 代表结论的预言 ( 主论述 ),S 是结论的主体 ( 次论述 ),M 代表前提中的共同部分 , 但 

M 并不出现在结论里 , 它是中间论述。包含 P 的前提称为大前提 , 包含 S 的前提称为小前 

提。 

第三章鼠标事件 

上一章 , 我们实现了点击 File|New 菜单项 , 弹出一个对话框 query, 下面我们增加在这个对 

话框内 , 对鼠标按下事件的反应。 

第 3.1 节增加鼠标按下事件侦听器 

如图 3.1.1 所示 , 我们在目录树里找到 query.frm 文件 , 鼠标双击它 , 我们就可以进入这个对 

话框 Form 的编辑状态。

图 3.1.1 找到 query.frm 文件 , 鼠标双击进入 Form 编辑状态 

在 Form 编辑状态下 , 我们可以看到一个关于 query 的特性设置和事件设置对话框如图 3.1.2 

所示 , 我们点击下部按钮 Events, 进入下一页 , 并选择 MouseDownLisener 侦听器的反应谓 

词为 onMouseDown。 

图 3.1.2 设置鼠标按下事件侦听器 

然后鼠标双击这个选项 , 则进入代码编辑界面。我们把原代码 : 

predicates 

onMouseDown : drawWindow::mouseDownListener.

clauses 

onMouseDown(_Source, _Point, _ShiftControlAlt, _Button). 

改写成为 : 

predicates 

onMouseDown : drawWindow::mouseDownListener. 

clauses 

onMouseDown(S, Point, _ShiftControlAlt, _Button) :- 

W= S:getVPIWindow(), Point= pnt(X, Y), 

vpi::drawText(W, X, Y, "Hello, World!"). 

然后重新编译、执行一下程序 , 看到 , 每当我们在 query 对话框上点下鼠标 , 就会写出一段 

文字 “Hello, World!”, 如图 3.1.3 所示 , 这就表明我们实现了对鼠标事件的反应程序。 

图 3.1.3 每当我们在框上点下鼠标 , 就会写出一段文字 “Hello, World!” 

第 3.2 节 onPaint 绘图 

当然 , 像上节所述的鼠标点击绘图 ( 文字 ) 事件 , 也可以用另外一种方式来实现 : 即利用重 

画功能 onPaint 来实现。具体操作步骤是 , 如图 3.2.1 所示 , 点击文件 query.pro, 则右边框 

内会出现该文件所包含的谓词名称列表 , 找到 onMouseDown/4 并双击 , 则转到代码的相应 

处。

图 3.2.1 找到鼠标按下事件处理谓词的代码所在处 

进入代码编辑器后 , 我们把上节编写的代码前后夹在 “/*”、“*/” 之间 , 使之变成说明文字 , 

然后添加我们编写的新的鼠标按下事件处理代码 , 最后代码部分变成如下所示 : 

/* 

predicates 


clauses 

onMouseDown(S, Point, _ShiftControlAlt, _Button) :- 

W= S:getVPIWindow(), Point= pnt(X, Y), 

vpi::drawText(W, X, Y, "Hello, World!"). 

*/ 

class facts 

mousePoint:pnt := pnt(-1, -1). 

predicates 


clauses 

onMouseDown(_S, Point, _ShiftControlAlt, _Button) :- 

mousePoint := Point, 

Point= pnt(X, Y), 

R= rct(X-8, Y-8, X+60, Y+8), 

invalidate(R). 

注意到这里我们用到数据库记录 mousePoint 来保存鼠标点击时的坐标数值 , 它的类型是 pnt, 

即坐标结构 ; 并把初始值设为 pnt(-1,-1)。这里还用到 invalidate(R), 这是一个强迫启动重画

R 所指的矩形区域的谓词。R= rct(X-8, Y-8, X+60, Y+8) 表示重画的矩形的左上角和右下角。 

注意 X 代表水平方向 , 左到右 , 数值增加 ;Y 代表垂直方向 , 上到下 , 数值增加。它触发 

重画事件 , 所以我们需要增加重画事件处理程序。如图 3.2.2 所示 , 增加 paintResponder 为 

onPaint。 

图 3.2.2 增加 paintResponder 为 onPaint 

编写代码如下 : 

predicates 

onPaint : drawWindow::paintResponder. 

clauses 

onPaint(_Source, _Rectangle, GDIObject) :- 

if pnt(X, Y)= mousePoint, X>0 

then 

mousePoint := pnt(-1, -1), 

GDIObject:drawText(pnt(X, Y), "Hello, World!", -1) 

else succeed() end if. 

同样实现了这样的功能。 

第 3.3 节小结和说明 

这一章我们学习了如何处理一个事件 , 鼠标事件侦听器。实际上 , 鼠标事件可以区分出鼠标 

是否在移动、按下左键还是右键、单击还是双击、按下还是弹起、是否按了中间键或者滑轮 ? 

这样来做出不同的反应。在事件列表里 , 我们可以看到分成四类如图 3.3.1 所示。 

图 3.3.1 鼠标事件分四类 

就按下事件来讲 , 鼠标按下侦听器的参数定义如下 : 

drawWindow::mouseDownListener

mouseDownListener = ( 

drawWindow Source, 

vpiDomains::pnt Point, 

vpiDomains::keyModifier ShiftControlAlt, 

integer Button) . 

它可以返回所在绘图窗口、所在位置、是否按了 Shift、Control、Alt 等及其联合的修饰键、 

以及是那个键发生的事件。这样便于控制。这些细节要查阅具体的定义。 

第 3.4 节逻辑小知识 : 布尔代数 

1, 符号 “「” 表示逻辑上 “ 非 ”。「p 表示 : 当 p 为真 , 则「p 为假 ; 当 p 为假 , 则「p 为 

真。当为 p 公式 , 则「p 也是公式。 

2, 符号 “∨” 表示逻辑上 “ 或 ”。p∨q 表示 ,p 或者 q。它的含义是 :p 或者 q 任何一个为 

真 ,p∨q 就为真 ;p、q 都为假 ,p∨q 才为假。 

3, 符号 “∧” 表示逻辑上 “ 与 ”。 p∧q 表示 ,p 与 q。它的含义是 :p、q 任何一个为假 ,p 

∧q 为假 ;p、q 都为真 ,p∧q 才为真。 

4,p→q 表示逻辑上的 “ 推定 ”。由 p 可以推定 q。它的含义是 :p 为真 , 则 q 为真。 

5,p≡q 表示逻辑上的 “ 相当 ”。 p 相当于 q。它的含义是 :p 为真 , 则 q 为真 ; 同样 ,q 为 

真 , 则 p 为真。 

通常我们用数字 “1” 表示 “ 真 ”, 而数字 “0” 表示 “ 假 ”。这样我们可以用真值表来说明这 

几个逻辑公式的含义如下 : 

p q 「p p∧q p∨q p→q 「p∨q 

0 0 1 0 0 1 1 

0 1 1 0 1 1 1 

1 0 0 0 1 0 0 

1 1 0 1 1 1 1 

从这里我们可以看出 , 很容易证明 ,p→q 与「p∨q 是完全相当的 , 即 : 

(p→q)≡(「p∨q) 

第 3.5 节论证的形式 

我们把一个论证写作 : 

p∨q 

「p 

├q 

这一段论证说 : 因为 p∨q 是真 , 而且 p 为假 , 则可以插入事实 q 为真。符号 “├” 是插入

的意思。 

在 Prolog 里 , 我们的证明方法是这样的 : 

q←p 

p 

├q 

这就是说 ,p 推定 q,p 为真 , 则插入 q 为真。这就是 Prolog 的证明过程。 

第四章基本图例 

这一章 , 我们通过建立一个工程 factorial 来解释说明一下 , 整个 VIP 编程环境 IDE 的关键 

部件和基本图例 , 在以后的章节里 , 就不再重复了。 

第 4.1 节任务菜单 

如图 1.1.1 所示 , 我们点击主菜单 Project|New 菜单项 , 就可以新建一个软件工程 (Project) 

了。主菜单 , 就是 IDE 的一个主要组成部分 , 如图 4.1.1 所示 , 有很多项目。 

图 4.1.1 IDE 的主菜单有 14 个项目 

“A|B” 的描述 , 是我们对菜单项目点击顺序的一种描述 , 表示先点击菜单项 A 然后点击下 

一层的 B。我们新建项目 factorial 要填写的项目如下 : 

General 

Project Name: factorial 

UI Strategy: Object-oriented GUI(pfc/gui) 

Target Type: Exe 

Base Directory: C:\vispro 

注意 , 我们需要在 Prolog Setting 对话框下 , 对这几个项目做相应的填写或者修改 , 如图 4.1.2 

所示。在这里 , 我们故意把存取我们这个程序文件的目录设置在 C 盘的 vispro 之下 , 其实 

我们可以根据自己需要进行设置。然后点击 OK, 就可以创建我们自己的工程 factorial 图形 

界面程序了 , 如图 4.1.3 所示。

图 4.1.2 填写并更改所存目录 

图 4.1.3 创建 factorial 工程 

第 4.2 节目录树 

我们看到 , 新建的工程的目录树如图 4.2.1 所示。

图 4.2.1 文件目录树 

这些目录双击可以打开 , 看到其中有些什么文件 ; 而其中的文件 , 双击 , 就可以进入相应的 

编辑状态。在文件项目上点击鼠标右键 , 则一般会弹出相应的弹出菜单。如果和上图一样的 

操作 , 我们的描述就是 : 

用 Code Expert 为 TaskWindow/TaskWindow.win 添加代码 

这个指令描述 , 包含以下步骤 : 

(1) 双击鼠标打开目录 TaskWindow 

(2) 找到文件 TaskWindow.win 

(3) 在这个文件上按鼠标右键 , 弹出菜单 

(4) 在弹出菜单上 , 选择 Code Expert 菜单项 

第 4.2.1 代码专家 

代码专家也有一个树形的对话框 , 让你来选择 , 具体增加的编码内容。就之前对 

TaskWindow.win 代码编写来讲 , 当我们启用了代码专家 Code Expert 项目后 , 进入一个对话 

框 , 如图 4.2.2 所示 , 为了对菜单项目 File|New 进行编码 , 我们展开树形结构 , 找到 New 项 

目 , 双击它就可以进行代码编写。

图 4.2.2 Code Expert 通过树形结构来选择具体编码的项目 

在前面我们谈到的 Form 中 ,Code Expert 的实现只需要选择 Events 的项目 , 进行双击 , 就 

可以实现其功能。所以 Code Expert 在不同的地方 , 有不同的启动方法 , 方便我们进行代码 

设计。在 factorial 里 , 我们依然要设计一个 Form, 名字也叫 query, 这样 , 我们用 File|New 

来启动这个对话框。这样增加代码如下 : 

predicates 

onFileNew : window::menuItemListener. 

clauses 

onFileNew(W, _MenuTag) :- S= query::new(W), S:show(). 

而整个操作可以描述为一个简写的动作 : 

TaskWindow.win/CodeExpert/Menu/TaskMenu/id_file/id_file_new, 

而这代表着以下几个动作 : 

(1) 树形目录操作 : 找到 TaskWindow.win 然后右键启动 Code Expert 

(2) 代码专家操作 : 进入树形结构点击 Menu, 然后 TaskMenu, 然后 id_file, 然后 id_file_new 

项目 , 双击进行代码编写。 

第 4.3 节创建一个工程项目 

我们可以创建新的工程项目 : 比如新的代码包 (Package)、新的模块 (class)、新的对话框表 

(Form) 等等。我们这里要在新的包里创建一个名字叫 query 的 Form, 首先进行如下在操 

作 : 

File/New in New Package 

我们创建一个程序包 , 显示的是一个独立的目录 , 名字叫做 “FormContainer”, 结果得到如

图 4.3.1 所示。 

图 4.3.1 新的程序包 FormContainer 

然后进行如下操作 : 

File/New in Existing Package 

选择 FormContainer 程序包 , 创建 Form 名字为 query, 如图 4.3.2 所示。 

图 4.3.2 选择 Form 所在的程序包 , 可以看到可以用下拉列表选择 

这样就进入 Form 的编辑过程。我们希望设计 query 如图 4.3.3 所示。 

图 4.3.3 对话框设计

我们设计一个编辑控件 , 用来接收用户输入 , 而 factorial 按钮 , 用来发出计算输入数字的阶 

乘的指令。 

第 4.4 节创建一个新的 class 

我们要新增加一个模块 (class), 名字 fn, 来实现按钮 factorial 按下的计算功能。如图 : 

图 4.4.1 在 formContainer 里增加 class fn 

在文件 fn.cl 里编写如下代码实际上只有 “calculate:(string) procedure.” 是新增加的 : 

class fn : fn 

open core 

predicates 

classInfo : core::classInfo. 

calculate:(string) procedure. 

end class fn 

在 fn.pro 里编写如下代码 : 

implement fn 

open core 

clauses 

classInfo("forms/fn", "1.0"). 

class predicates 

fact:(integer, integer) procedure (i,o). 

clauses 

fact(0, 1) :- !.

fact(N, N*F) :- 

fact(N-1, F). 

calculate(X) :- 

N= toterm(X), 

fact(N, F), 

stdio::write(F, "\n"). 

end implement fn 

第 4.5 节设置控件属性 

我们设置控件属性 ,edit_ctrl 开始显示空的 ,factorial 按下事件反应调用 fn 的 calculate 来计 

算结果。 

图 4.5.1 编辑控件开始显示空的 , 等待输入 

在编写 factorial 按钮事件代码之前必须 build 一下程序 , 让我们增加的东西进入程序的工程 

管理库里。不然 , 我们在 factorial 按钮里看不到事件列表。我们如图 4.5.2 选择事件的 Code 

Expert 功能 , 进入代码编写状态。 

图 4.5.2 选择按钮事件的反应器 

编写如下代码 , 就把按钮和模块 fn 的功能连接在一起。编写代码之前 : 

predicates 

onFactorialClick : button::clickResponder. 

clauses

onFactorialClick(_Source) = button::defaultAction. 

编写代码之后 : 

predicates 

onFactorialClick : button::clickResponder. 

clauses 

onFactorialClick(_S) = button::defaultAction() :- 

fn::calculate(edit_ctl:getText()). 

运行整个程序。看到 , 当我们输入 4, 按 factorial 按钮 , 在 Message 里显示 24。这就是 4! 

=4×3×2×1 的结果 , 如图 4.5.3 所示。 

图 4.5.3 输入 4, 输出结果 24, 算出了阶乘得数 

第 4.6 节 


本章我们介绍了一些基本的编程、程序设计的叙述约定 , 及 IDE 的一些基本元素 , 这 

样可以使我们以后的叙述更加简练 , 而不需要太多的图片来描述。我们介绍了程序包、模块 

的增加方法 , 实现了一个完整的应用 factorial 的计算。介绍了 Code Expert 怎样帮助我们设 

计代码。 

第 4.7 节逻辑小知识 : 谓词运算 

为了逻辑运算 , 逐步发展了谓词运算 , 如下表示 : 

这样 , 逻辑叙述可以用谓词运算来描述了 , 这是 Prolog 的逻辑运算基础。

第五章 Horn 语句 

第 5.1 节函数 

函数 , 是一个函数关系和一些参数构成的运算关系。比如 sin(X), 函数关系是 sin, 求正弦 , 

而 X 是参数。再如 , mod(A,B), 是描述 A 与 B 的模数关系。当我们描述函数时 , 总是可 

以用常数值替代参数或变量 , 从而获得相应的函数计算结果。 

函数的参数或变量的可能值定义范围 , 称为域 (domain)。 

有些函数的函子 ( 或函数关系 ) 写在函数参数之间。比如 5+3, 和 +(5,3) 是一样的。 

第 5.2 节谓词 

谓词是函数的一种特殊形式 , 它是特指那些值只可能为 “ 真 ” 或 “ 假 ” 的特殊函数。 

X > Y, 在 X 比 Y 大时为真 , 其他情况为假 

X < Y, 在 X 比 Y 小时为真 , 其他情况为假 

X = Y, 在 X 与 Y 相等时为真 , 其他情况为假 

这里 >、

city("Yellowstone", pnt(200, 100)). 

那么这个谓词 , 就可以用来检验 , 给定的城市的坐标位置与已知的 ( 数据库里预存的 ) 信息 

是否吻合 , 也可以用来找到指定城市的坐标 , 也可以用来根据某个坐标 , 寻找这个城市的名 

称是什么。 

city("Salt Lake", pnt(30, 40)) → true 

city("Logan", pnt(100, 200)) → false 

city("Provo", pnt(100, 200)) → true 

city("Salt Lake", P) → P= pnt(30, 40) 

我们通常约定大写字母开头的符号变量。比如 : 

X、Y、Wh、Who、B、A、Xs、Temperature、Humidity、Rate 

Project Settings. 在 VDE 主菜单下点击 Project/New 进入 Project Settings 对话框 

General 

Project Name: mapDataBase 

UI Strategy: Object-oriented (pfc/GUI) 

Target Type: Exe 

Base Directory: C:\vispro 

Sub-Directory: mapDataBase\ 

创建 Project Item:Form。我们在目录树的根目录下进行如下操作 File/New in New Package, 

选择 Form, 名字为 “map”。在这个面板上 , 设置三个按钮 Logan、Salt Lake、Provo, 回头 

用于显示这些城市。编辑窗口大小 , 留出画图的足够空间。 

Build/Build 在主菜单下点击 Build|Build 菜单项 , 以便下一步操作 , 否则会出错。 

Project Tree/TaskMenu.mnu 使菜单项 File/New 可以操作。 

Project Tree/TaskWindow.win/Code Expert 参照 Menu/TaskMenu/id_file/id_file_new/ 

onFileNew 指令增加代码 : 

predicates 


clauses 

onFileNew(S, _MenuTag) :- 

X= map::new(S), X:show(). 

这是为 File|New 菜单项编写代码的。然后在进行 Buile|Build 操作。 

增加 draw 模块 class File/New in New Package 指令 , 选择 class 增加 draw。在 draw.cl 文件

里增加代码后如下 : 

class draw : draw 

open core, vpiDomains 

predicates 


drawThem:(windowHandle, string) procedure. 

end class draw 

在文件 draw.pro 里 , 增加代码后如下所示 : 

implement draw 

open core, vpiDomains, vpi 

constants 

className = "draw". 

classVersion = "". 

class facts 

city:(string, pnt). 

clauses 

classInfo(className, classVersion). 

clauses 

city("Salt Lake", pnt(30, 40)). 

city("Logan", pnt(100, 120)). 

city("Provo", pnt(100, 200)). 

city("Yellowstone", pnt(200, 100)). 

drawThem(Win, Name) :- 

B= brush(pat_solid, color_red), 

winSetBrush(Win, B), 

city(Name, P), 

!, 

P= pnt(X1, Y1), 

X2= X1+20, Y2= Y1+20, 

drawEllipse(Win, rct(X1, Y1, X2, Y2)). 

drawThem(_Win, _Name). 

end implement draw

然后 , 编辑 map 对话框 ,map.frm/ Edit /Button Logan/Click Responder : onLoganClick 增加按钮 

Logan 的按下事件 , 增加如下代码 : 

predicates 

onLoganClick : button::clickResponder. 

clauses 

onLoganClick(S) = button::defaultAction() :- 

Parent= S:getParent(), 

P= Parent:getVPIWindow(), 

draw::drawThem(P, "Logan"). 

运行一下 , 点击 Logan 按钮 , 如图 5.3.1 所示 , 得到 : 

图 5.3.1 按钮 Logan 按下 , 画出城市坐标位置示意图 

其他几个城市的按钮以可以如法炮制。如图 5.3.2 所示 , 我们画出了三个城市的坐标位置。 

图 5.3.2 按下三个摁钮 , 画出三个城市的坐标位置示意图 

他们的代码是 : 

predicates 

onSaltLakeClick : button::clickResponder.

clauses 

onSaltLakeClick(S) = button::defaultAction() :- 



draw::drawThem(P, "Salt Lake"). 

predicates 

onProvoClick : button::clickResponder. 

clauses 

onProvoClick(S) = button::defaultAction() :- 



draw::drawThem(P, "Provo"). 

第 5.4 节答案不惟一 

上面我们遇到的谓词 city/2 是只有一个解的情况 , 实际上 , 我们要设计一个 conn/2, 来表示 

两个城市连接的描述 : 

conn(pnt(30, 40), pnt(100, 120)). 

conn(pnt(100, 120), pnt(100, 200)). 

conn(pnt(30, 40), pnt(200, 100)). 

这样 , 我们往往遇到 2 个以上的答案 : 

conn(pnt(30, 40), W). → W= pnt(100, 120) 

→W=pnt(200, 100) 

conn(X, Y). →X=pnt(30, 40)/Y=pnt(100, 120) 

→ X= pnt(100, 120)/Y=pnt(100, 200) 

→X=pnt(30, 40)/Y=pnt(200, 100)) 

当我们提出问题 : 

conn(pnt(30, 40), W)? 

那么显然我们可以有两个答案 :W= pnt(100, 120) 或者 W=pnt(200, 100)。 

第 5.4.1 节一个采用多解谓词的程序 

我们利用多解特性 , 利用 conn/2 来画出城市连接线 , 结果如图 5.4.1 所示。

图 5.4.1 画出连接线 , 利用 conn/2 的多解特性 

我们增加按钮 drawConnections, 并对他进行编码 : 

predicates 

onDrawConnections : button::clickResponder. 

clauses 

onDrawConnections(S) = button::defaultAction :- 



draw::drawConnections(P). 

在模块 draw 的 draw.pro 文件里增加 : 

class facts 

conn : (pnt, pnt). 

clauses 

conn(pnt(30, 40) , pnt(100, 120)). 

conn(pnt(100, 120), pnt(100, 200)). 

conn(pnt(30, 40), pnt(200, 100)). 

drawConnections(Win) :- conn(P1, P2), drawLine(Win, P1, P2), fail. 

drawConnections(_Win). 

并修改原来画城市的语句为 : 

drawThem(Win, Name) :- 

B= brush(pat_solid, color_red), 

winSetBrush(Win, B), 

city(Name, P), 

!, 

P= pnt(X1, Y1), 

X2= X1+10, Y2= Y1+10, 

drawEllipse(Win, rct(X1-10, Y1-10, X2, Y2)).

在 draw.cl 里增加 : 

drawConnections:(windowHandle) procedure. 

这样 , 我们利用 drawConnections(Win) :- conn(P1, P2), drawLine(Win, P1, P2), fail. 的强制回溯 

功能 , 把所存的连接数据全部画出了。注意 , 有些城市因为没有设置按钮 , 并没有画出来。 

如图 5.4.1 所示。 

第 5.5 节逻辑符号 

“P1 与 P2”, 这里 “ 与 ” 就是逻辑符号。这表明 , 只有 P1 和 P1 同时为真 , “P1 与 P2” 

才为真。在 Prolog 语言里 , 用逗号代表 “ 与 ”(and); 用分号代表 “ 或 ”(or)。这里 “ 与 ”、 

“ 或 ”, 就是逻辑符号。 

这样如果我们描述 (X>4) 与 (Y4),(Y

drawThem(Win) :- connections(Win), drawCities(Win). 

“:-” 符号之前的部分 , 我们称其为规则的 “ 头 ”, 之后的部分 , 称其为规则的 “ 尾 ”, 或者 

规则的 “ 体 ”。在这里是 drawThem(Win) 头 , 而是 “connections(Win), drawCities(Win)” 

尾。头和尾之间用 “:-” 符号连接 , 末尾 , 用 “.” 表示结束。 

第 5.7 节声明 

谓词定义如果没有输入输出流向说明 , 则其声明是不完整的。我们来看一个完整的谓词声明 : 

predicates 

drawThem:(windowHandle) procedure (i). 

这个声明说明 :drawThem 的参数 , 是输入的 , 是属于 windowHandle 类型的。通常情 

况下 , 你也可以不声明输入输出模式 , 而编译器会自动推理出合适的流模式。比 

如我们也可以定义成这样 : 


connections:( windowHandle). 

drawCities:(windowHandle). 

当然 ,Horn 句子也可以定义成事实的格式 : 

class facts 

city:(string Name, pnt Position). 

conn:(pnt, pnt). 

稍后我们可以会看到 , 事实 (facts) 是可以插入、删除的 , 它的参数类型说明和谓词的类型 

说明相同。关于类型说明 , 我可以用直接指明类型声明所在的模块的形式 , 如下 : 

class facts 

conn:(vpiDomains::pnt, vpi::Domains::pnt). 

也可以在 open 语句里 , 把相应的模块打开 , 这样 , 类型就不需要前缀来指明位置了。注意 

这里 pnt 用到两个不同的位置的说明 , 但从形式上 , 是一样的。 


确定式声明你可以用以下几种声明 , 来明确指出谓词是有一种解、多种解 : 

determ —— 指明这个谓词或真、或假 , 而且只有一种可能。 

procedure —— 说明这个谓词总是成功的。通常我们希望一些比较确定的过程 , 用到这样

的说明 , 比如前面我们定义的谓词 : 


connections:( windowHandle) procedure (i). 

drawCities:(windowHandle) procedure (i). 

multi —— 用到这样说明谓词 , 从事成功的 , 并且有多种解答。 

nondeterm —— 这样说明的谓词或事实 , 可能成功 , 也可能失败 , 有多种可能性。比如 : 

class facts 

city:(string Name, pnt Position) nondeterm. 

conn:(pnt, pnt) nondeterm. 

我们可以利用这类谓词的特性 , 设计回溯过程比如 : 

connections(Win) :- 

conn(P1, P2), 

drawLine(Win, P1, P2), 

fail. 

connections(_Win). 

这里 ,conn(P1, P2) 提供两个点 P1、P2, 而 drawLine(Win, P1, P2) 就利用这两个点 , 画线。 

遇到 fail 谓词 ,Prolog 就强制回溯 , 寻找下一个解 , 直到 conn(P1, P2) 也失败 , 那时 , 

connections(_Win) 是总要成功的 , 保证了 connections/1 总能成功。 

第 5.8 节绘图谓词 

计算机界面很重要部分就是绘图输出。前面我们遇到几个绘图谓词 , 比如 drawLine/3, 它的 

用法是 : 

drawLine(Win, P1, P2) 

它用来在点 P1 和 P2 之间划一条直线。而 P1、P2 用 pnt(X, Y) 来表示。而画椭圆就是用到这 

样的谓词 : 

drawEllipse(W, rct(X1, Y1, X2, Y2)) 

这里 rct(X1, Y1, X2, Y2) 表示一个矩形 , 用左上角坐标 X1, Y1 与右下角坐标 X2, Y2 来表示。 

而 W、Win 在这里代表要绘画窗口的句柄 (WindowHandle), 这不过是告诉程序 , 在哪里绘 

图 , 在窗口系统 , 用句柄来代表窗口。

第 5.8 节 GDI 实体 

其实 , 绘图除了用句柄之外 , 还可用到 GDI objects, 也就是 GDI 实体 , 来绘图。比如 , 前 

面的例子里 , 如果我们用 onPaint 谓词来处理事件 paintResponder, 如图 5.8.1 所示 , 它的编 

码如下所示 : 

clauses 

onPaint(_S, _Rectangle, GDIObject) :- 

draw::drawThem(GDIObject). 

图 5.8.1 增加 onPaint 谓词作为 PaintResponder 

那么我们可以重新改写 drawThem 谓词的声明 , 在 draw.cl 里这样声明 : 

class draw 

open core 

predicates 

drawThem:(windowGDI). 


在 draw.pro 里 , 谓词重新改写后如下 : 



class facts 




connections:( windowGDI). 

drawCities:(windowGDI). 

clauses 




conn(pnt(30, 40) , pnt(100, 120)).

conn(pnt(100, 120), pnt(100, 160)). 

drawCities(W) :- 

city(N, P), 

P= pnt(X1, Y1), 

X2= X1+10, Y2= Y1+10, 

W:drawEllipse(rct(X1, Y1, X2, Y2)), 

W:drawText(pnt(X1, Y1), N), fail. 

drawCities(_Win). 

connections(W) :- 

conn(P1, P2), W:drawLine(P1, P2), fail. 

connections(_W). 

drawThem(Win) :- 

connections(Win), drawCities(Win). 

end implement draw 

这里最大的变化是绘图语句 W:drawEllipse(rct(X1, Y1, X2, Y2)) 这样的引用与前面的引用有 

很大不同 drawEllipse(W, rct(X1, Y1, X2, Y2))。 

drawCities(W) :- 

city(N, P), 

P= pnt(X1, Y1), 

X2= X1+10, Y2= Y1+10, 

W:drawEllipse(rct(X1, Y1, X2, Y2)), 

W:drawText(pnt(X1, Y1), N), fail. 

drawCities(_Win). 

第 5.9 节 


我们这里介绍了谓词的声明、绘图语句及两种不同的方法 , 我们还介绍了 Horn 句子 , 

介绍了谓词的多解性 , 这里就慢慢接近真实的编程了。 

第 5.10 节逻辑小知识 :Horn 句子的意义 

Horn 句子 : 

H :- T1, T2, T3… 

它的意义是 :

如果 T1、T2、T3…… 分别都为真 , 则 H 为真。 

我们需要记住 “:-” 代表 “ 如果 ”; 而逗号 “,” 代表 “ 与 ”, 分号 “;” 代表 “ 或 ”。它们和谓 

词的混合语句 , 构成了 Horn 句子 , 表达一定的逻辑描述 , 也称为 “ 规则 ”。 

第六章控制台应用 

许多人喜欢图形界面 , 但是控制台界面虽然只有文字描述 , 但是更能说明程序的核心逻辑和 

计算方法 , 这一章 , 我们就用控制台应用 (Console Application) 来说明几个关键的 Prolog 

元素。 

第 6.1 节截断 

我们常常需要强制程序回溯 , 在找到一个答案之后 , 再去寻找另外一个 , 在前面我们介绍过 

的 fail 就是起这样功能。但是相反 , 有时候 , 我们却不需要它回溯 , 不需要再去寻找下一条 

规则、寻求另外的答案 , 这是我们就要用到 “ 截断 ”(cut), 我们在 Prolog 里 , 用叹号 “!” 

来表示。比如以下的阶乘递归算法描述 : 

factorial(0)→1 

factorial(n) → n ×factorial(n -1) 

用 Horn 子句来描述 , 可以表达为 : 

fact(N, 1) :- N

图 6.1.1 创建控制台应用 

然后 Build/Build, 编辑 main.pro 文件 , 这个文件开始的内容如下 : 

implement main 

open core 

constants 

className = "main". 


clauses 


clauses 

run():- 

console::init(), 

succeed(). % place your own code here 

end implement main 

经过编辑后 main.pro 如下所示 : 


open core 


fact:(integer N, integer Res) procedure (i,o). 

clauses 

classinfo("facfun", "1.0"). 

fact(N, 1) :- N

fact(X, F), 

stdio::write(" 控制台应用输出结果 

stdio::nl, 

!, 

run(). 

run(). % 按 Ctrl+Break 结束 


", " 输入数字 = ",X, " 其阶乘 = ", F), 

goal 

mainExe::run(main::run ). 

运行后 , 我们输入一个数字 , 就得到一个阶乘结果如图 6.1.2 所示 , 直至我们同时按下 Ctrl 

键和右上角的 Break 键结束。 

图 6.1.2 阶乘计算结果 

第 6.2 节表 

表是一群具有相似特征的元素的集合体 , 我们把其相似的特征成为元素的类型 , 而整个表用 

方括号括起来、用逗号相间隔的形式来表示 , 其类型用元素类型后加星号 “*” 来表示。每 

个不是空表的表 , 都会有表头和表尾 ; 空表是没有一个元素的表。例如 : 

List Type Head Tail 

[3, 4, 5, 6, 7] integer* 3 [4, 5, 6, 7] 

["wo3", "ni3", "ta1"] string* "wo3" ["ni3", "ta1"] 

[4] integer* 4 [] 

[3.4, 5.6, 2.3] real* 3.4 [5.6, 2.3] 

我们可以把任何不是空表的表写作 : 

[Head | Tail ] 

其中 ,head 是一个元素 ,Tail 是一个表。所以 , 你可以看到下面的匹配过程 :

Pattern List X Xs 

[X|Xs] [3.4,5.6,2.3] X = 3.4 Xs = [5.6,2.3] 

[X|Xs] [5.6,2.3] X = 5.6 Xs=[2.3] 

[X|Xs] [2.3] X = 2.3 Xs = [] 

[X|Xs] [] Does not match. 

同样 , 我们可以写出更多的元素 , 要求表匹配 , 从而进行删选 , 比如我们假定表形式为 [X1,X2 

| Xs], 这就是说 , 至少有两个元素的表 , 那么 ,2 个元素以下的表 , 就不匹配 : 

Pattern List X1,X2 Xs 

[X1,X2|Xs] [3,5,2,7] X1 = 3,X2 = 5 Xs = [2,7] 

[X1,X2|Xs] [2,7] X1 = 2,X2 = 7 Xs=[] 

[X1,X2|Xs] [7] Does not match. 

[X1,X2|Xs] [] Does not match. 

我们通过实例来体会表的处理 , 如下建立一个应用 “avg”: 

General 

Project Name: avg 

UI Strategy: console 

先 Build 一下 , 然后编辑 main.pro 最后如下所示 : 


open core, console 

domains 

rList= real*. 


len:(rList, real) procedure (i, o). 

clauses 

classInfo("avg", "1.0"). 

len([], 0) :- !. 

len([_X|Xs], 1.0+S) :- len(Xs, S). 

run():- 


List= read(), 

len(List, A), 

write(A), nl, 

run().


goal 

mainExe::run(main::run). 

运行后如图 6.2.1 所示 : 

图 6.2.1 正确输入一个实数表 , 则返回长度数字 

但是当不是表 , 或者不是实数表 , 程序会出错返回。下面我们还可以加入 sum/2 来计算所有 

元素的和 : 

sum([], 0) :- !. 

sum([X|Xs], S+X) :- sum(Xs, S). 

我们分析一下 sum([3.4, 5.6, 2.3], S) 的计算经过 : 

1. sum([3.4, 5.6, 2.3], S) 匹配 

sum([X|Xs], S+X) .- sum(Xs, S), with X=3.4, Xs=[5.6, 2.3], 

得到 sum([3.4, 5.6, 2.3], S[5.6,2.3] + 3.4) .- sum([5.6, 2.3], S[5.6,2.3]) 

2. sum([5.6, 2.3], S[5.6,2.3]) 匹配 

sum([X|Xs], S+X) .- sum(Xs, S), with X=5.6, Xs=[2.3], 

得到 sum([5.6, 2.3], S[2.3] + 5.6) .- sum([2.3], S[2.3]) 

3. sum([2.3], S[2.3]) 匹配 

sum([X|Xs], S+X) .- sum(Xs, S), with X=2.3, Xs=[], 

得到 sum([2.3], S[] + 2.3) .- sum([], S[]) 

4. sum([], S[]) 匹配 sum([], 0.0) 得到 S[] = 0. 

我们可以让程序写出过程如下图 6.2.2 所示。

图 6.2.2 计算一个表的元素之和的过程 

相应的程序如下所示 : 



domains 

rList= real*. 



sum:(rList, real) procedure (i, o). 

clauses 


len([], 0) :- !. 


sum([], 0) :- !. 

sum([X|Xs], S+X) :- 

write("now list = ", [X|Xs],"\n"), 

sum(Xs, S), 

write("now result =", S, "\n").

un():- 


List= read(), 

len(List, A), 

write(A), nl, 

sum(List,X), 

write("Final result = ", X),nl, 

run(). 


goal 


当然 , 我们还可以用另外一种办法来计算元素之和 : 

add([], A, A). 

add([X|Xs], A, S) :- add(Xs, X+A, S). 

但是我们调用的时候需要调用 add(List,0,Sum)。而说明此谓词 

add:(rList, real, real) procedure (i, i, o). 

程序如下 : 



domains 

rList= real*. 



add:(rList, real, real) procedure (i, i, o). 

clauses 


len([], 0) :- !. 


add([],A,A ) :- !. 

add([X|Xs],A , Sum) :-

write("original list=", [X|Xs],"result =", A,"\t\t now result=", A+X, "\n"), 

add(Xs, A+X, Sum). 

run():- 


List= read(), 

len(List, A), 

write(A), nl, 

add(List,0,X), 

write("Final result = ", X),nl, 

run(). 


goal 


运行结果如图 6.2.3 所示。 

图 6.2.3 另外一种计算方法 

第 6.3 节表相关的几个话题 

表示一个很重要的计算工具 , 我们这里要介绍几个比较重要的表相关的计算话题。 

简化 Reduction 

一个表 , 可以用于计算每个元素的和 , 这个过程 , 被称为简化过程 (reduction), 因为这个过 

程是把输入的维数减少了。我们可以把表看成是一维数据 , 而和结果是零维数据 , 求和过程 

是 1 维变 0 维的过程。有两种方法可以达成目标 : 递归式简化 (recursive) 和重复式简化 

(iterative)。我们展示这两种方法如下 : 

%Recursive reduction 


sum:(real*, real) procedure (i, o).

clauses 

sum([], 0) :- !. 


递归式是假定知道表尾的结果 , 推理获得当前表的结果 , 以此类推 , 而总是有一个表的结果 

是可知的 , 然后回退计算出最终结果 ; 重复式就是不断重复累加的过程 , 更接近人们计算的 

逻辑。 

%Iterative reduction 

red([], A, A) :- !. 

red([X|Xs], A, S) :- red(Xs, X+A, S). 

sumation(Xs, S) :- red(Xs, 0.0, S). 

当我们希望计算元素的乘积时 , 可以替换得到如下程序 : 

%Iterative reduction 

red([], A, A) :- !. 

red([X|Xs], A, S) :- red(Xs, X*A, S). 

product(Xs, S) :- red(Xs, 0.0, S). 

我们看到 , 比较两个代码 , 它们有很大的相似性 : 除了 “X+A” 和 “X*A” 的差别之外 , 两 

个计算过程几乎相似。在 Visual Prolog 里 , 我们就可以采用更高一级的算法描述 , 来实现两 

种不同算法的统一。我们定义 red/4, 代码如下 : 



domains 

pp2 = (real Argument1, real Argument2) -> real ReturnType. 

clauses 

classInfo("main", "hi_order"). 


sum : pp2. 

prod : pp2. 

red : (pp2, real*, real, real) procedure (i, i, i, o). 

clauses 

sum(X, Y)= Z :- Z=X+Y. 

prod(X, Y)= Z :- Z=X*Y. 

red(_P, [], A, A) :- !. 

red(P, [X|Xs], A, Ans) :- 

red(P, Xs, P(X, A), Ans). 

run():- console::init(), 

List =read(), 

red(prod, List, 1, Product), 

red(sum, List, 0, Sum), 

write("\n 您输入的实数表是 ", List,

"\n 其各个元素的乘积结果 =", Product, 

"\n 其各个元素的累加结果 =", Sum), 

nl, 

run(). 


goal 

mainExe::run(main::run 

我们运行一下 , 可以看到运行结果如下 , 当你输入一个实数表 , 得到不同的输出结果 , 如图 

6.3.1 所示。 

图 6.3.1 更高形式的统一算法 

ZIP 

一个很有名的算法是 , 求两个表的点积 (dotproduct), 算法描述如下 : 


dotproduct:(real*, real*, real) procedure (i, i, o). 

clauses 

dotproduct([], _, 0) :- !. 

dotproduct(_, [], 0) :- !. 

dotproduct([X|Xs], [Y|Ys], X*Y+R) :- dotproduct(Xs, Ys, R). 

这里 , 我们分析 X*Y+R, 实际上 , 可以看作两个数相乘、两个数相加的组合。这样 , 我们 

可以利用前面的成果 , 写出另外一种算法 , 设计一个 zip/4: 

zip(_P, [], _, []) :- !. 

zip(_P, _, [], []) :- !. 

zip(P, [X|Xs], [Y|Ys], [Z|As]) :- 

Z= P(X, Y), 

zip(P, Xs, Ys, As).

得到乘积表后 , 在计算这个表的元素相加的结果 , 利用前面的代码 : 

dotproduct(Xs, Ys, D) :- 

zip(prod, Xs, Ys, Z), 

red(sum, Z, 0, D). 

我们最后设计代码如下 : 



domains 

pp2 = (real Argument1, real Argument2) -> real ReturnType. 

clauses 

classInfo("main", "hi_order"). 


sum : pp2. 

prod : pp2. 

red : (pp2, real*, real, real) procedure (i, i, i, o). 

zip : (pp2, real*, real*, real*) procedure (i, i, i, o). 

dotproduct : ( real*, real*, real) procedure ( i, i, o). 

clauses 

sum(X, Y)= Z :- Z=X+Y. 

prod(X, Y)= Z :- Z=X*Y. 

red(_P, [], A, A) :- !. 

red(P, [X|Xs], A, Ans) :- 

red(P, Xs, P(X, A), Ans). 

zip(_P, [], _, []) :- !. 

zip(_P, _, [], []) :- !. 

zip(P, [X|Xs], [Y|Ys], [Z|As]) :- 

Z= P(X, Y), 

zip(P, Xs, Ys, As). 

dotproduct(Xs, Ys, D) :- 

zip(prod, Xs, Ys, Z), 

red(sum, Z, 0, D). 


write("\n 请输入第一个实数表 :"), 

List1 =read(), 

write(" 请输入第二个实数表 :"), 

List2 =read(), 

dotproduct(List1, List2, Product), 

write("\n 您输入的实数表是 ", List1, " 和 ", List2, 

"\n 其点积结果 =", Product), 

nl, 

run(). 


goal 

mainExe::run(main::run).

运行后如图 6.3.2 所示。 

图 6.3.2 计算两个表的点积 

第 6.4 节字符串操作 

这里我们将通过几个字符串操作的例子 , 展示如何在 Visual Prolog 里处理数据结构问题。 

Fronttoken concatlist concat/2/3 

Fronttoken 是一个用途广泛的字符串操作谓词。看看下面的描述的结果会是怎样 ? 

frontToken("break December", T, R) 

实际上我们得到 T="break"、R=" December"。这里我们设计一个小程序 , 来展示 fronttoken 

的效果 , 运行结果如图 6.4.1 所示。 


open core, string, console 


tokenize:(string, string_list) procedure (i, o). 

clauses 

classInfo("main", "string_example"). 

tokenize(S, [T|Ts]) :- 

frontToken(S, T, R), 

!, 

tokenize(R, Ts). 

tokenize(_, []). 

run():- 

console::init(),

L= ["it ", "was ", "in ", "the ", 

"bleak ", "December!"], 

S=concatList(L), 

UCase= toUpperCase(S), 

RR= concat("case: ", Ucase), 

R1= concat("It is ", "upper ", RR), 

write(R1), nl, 

tokenize(R1, Us), 

write(Us), 

_X = readline(), nl. 


goal 


这里用到 concat/2、concat/3, 它们是把 2 个或三个字符串按顺序连接在一起 , 中间不会有任 

何增添。而 concatlist 则是把字符串表的每个元素按 , 按照顺序连接在一起 , 而且字符串和 

字符串之间 , 增加一个空格作为间隔 , 形成一个字符串。toUpperCase 是把字符串的所有字 

符转换成为大写字母。 

图 6.4.1 fronttoken 把字符串分解成一个一个所谓的 token 

toterm 

我们还常常希望把输入的代表某个命令或功能的字符串 , 转换成一个可执行的术语 (term), 

这时 , 我们常常用到 toTerm。下面的例子里 ,Sx= stdio::readLine() 从命令行读取一个字符串 

到 Sx 里然后 toTerm 把这个字符串转换成实数 , 这里 hasdomain(real, IX) 是为了确保 toTerm 

转换的结果是我们要的实数。运行结果如图 6.4.2 所示。 


open core 

clauses 

classinfo("main", "toTerm_example"). 

run():- 


Sx= stdio::readLine(), 

hasdomain(real, IX), 

IX= toTerm(Sx), 

stdio::write("\n 你输入的数字 ", IX," 的平方值是 :", IX^2,"\n"), 

run().


goal 

mainExe::run(main::run) 

图 6.4.2 输入的字符串转换为实数 , 计算平方值 

hasdomain 

hasdomain 甚至于可以接受类似于表等更复杂的数据类型 , 下面的例子 , 我们制定一个整数 

表 , 注意的是 hasdomain 不接受 “*” 的表表示方法 , 这里我们不能够用 “integer*”, 而要 

用 core::integer_list, 这是预先定义的整数表数据类型。 


open core 

clauses 

classInfo("main", "hasdomain_example"). 


sum:(integer*, integer) procedure (i, o). 

clauses 

sum([], 0) :- !. 



hasdomain(integer_list, Xs), 

Xs= toTerm(stdio::readLine()), 

sum(Xs, Sum), 

stdio::write("\n 你输入的整数表 ", Xs, 

" \n 其各元素和是 :", Sum,"\n\n"), 

run(). 


goal 


一旦我们输入的与预先规定的不符 , 则程序出错退出。程序运行如图 6.4.3 所示。

图 6.4.3 输入整数表并计算表中各元素的和 

tostring 

我们知道怎么把输入的串转化成 Prolog 的数据类型 , 但是有时候 , 我们也需要把 Prolog 内 

的类型数据转换成字符串来表达。这时就需要 tostring 谓词了。下面这个例子演示如何把实 

数表转换成字符串 , 并与其他字符串合并 , 然后显示出来 , 后面的完全是字符串操作。只是 

为了证明已经转换成了字符串。 


open core 

clauses 

classInfo("main", "toString_example"). 


sum:(integer*, integer) procedure (i, o). 

clauses 

sum([], 0) :- !. 



hasdomain(integer_list, Xs), 

Xs= toTerm(stdio::readLine()), 

sum(Xs, Sum), 

stdio::write("\n Your input is a number list : ", Xs, 

" \n All the list member's sum is : ", Sum,"\n"), 

Str= toString(Xs), 

Msg= string::concat("String representation is : ", Str), 

stdio::write(Msg), 

stdio::nl, 

run(). 


goal 


可以看到运行结果如图 6.4.4 所示 , 我们故意把把输入表增加了很多空格 , 但是一旦表达成 

Prolog 的整数表 , 其格式是固定的。为了证明这个整数表是可以计算的 , 我们算出了它的元

素之和 , 这是我们之前介绍过的一种运算。这里 , 如果是定义实数表 , 则编译时会出问题。 

图 6.4.4 表格转换成字符串 

format 

格式化输出对数据的显示非常有用 , 下面这个程序 , 用 format 来构成格式化输出 , 结果如 

图 6.4.5 所示。 


clauses 

classInfo("main", "formatting"). 


Str1= string::format("%8.3f\n %10.1e\n", 3.45678, 35678.0), 

Str2= string::format("%d\n %10d\n", 456, 18), 

Str3= string::format("%-10d\n %010d\n", 18, 18), 

stdio::write(Str1, Str2, Str3), 

_=stdio::readline(). 


goal 


注意这里用到一些规定 : 

f 格式化输出固定小数位的实数 ( 如 123.4). 

e 用科学记数法表示的实数 ( 如 1.234e+002). 

g 用 f 或 e 的最短的格式输出实数 

d 带符号的十进制数字 

u 无符号的整数 

x 十六进制数字 

o 十进制 

c 字符 

B 用 Visual Prolog 二进制类型 

R 作为数据库参考数据类型 

P 作为程序参数

s 作为字符串 

程序里的 %8.3f 的 “%” 代表一个参数 ,f 代表固定位小数格式 ,“8.3” 代表这个小数固定 

为 8 个数字位长度 , 而小数部分占 3 个位长度 , 你看到时进行了四舍五入。“10.1e” 表示科 

学记数法表示小数点后部分用 1 位表示 , 整个数字用 10 个位表示。“%d”、“%10d” 输出的 

10 进制数字 , 前者不作位数限制 , 后者限制用 10 个位置来表达 , 不足部分前面留空。而 

“%-10d” 则展示了 10 个位置输出左对齐的情况 ,“%010d” 展示了 10 个位置输出 , 空余部 

分用 “0” 填满的情况。 

图 6.4.5 数据格式化输出展示 

第 6.4.1 节有用的字符串操作谓词 

这里我们将介绍几个有用的字符串操作谓词 :adjustBehaviour、adjustSide、caseSensitivity, 

其定义如下所示 : 

domains 

adjustBehaviour =expand();cutRear();cutOpposite(). 

adjustSide = left(); right(). 

caseSensitivity =caseSensitive();caseInsensitive();casePreserve(). 

predicates 

adjust : (string Src, charCount FieldSize, adjustSide Side) 

->string AdjustedString. 

adjust : (string Src, charCount FieldSize, string Padding, 

adjustSide Side) -> string AdjustedString. 

adjustLeft : (string Src, charCount FieldSize) 


adjustLeft : (string Src, charCount FieldSize, 

string Padding) -> string AdjustedString. 

adjustRight : (string Src, charCount FieldSize) 


adjustRight : (string Src, charCount FieldSize, 

string Padding) -> string AdjustedString. 

adjustRight : (string Src, charCount FieldSize, string Padding, 

adjustBehaviour Behaviour) -> string AdjustedString. 

它们已经定义在 string 模块里了。我们用下面的程序演示其中一个谓词 :


clauses 

classInfo("main", "adjust_example"). 


FstLn1=" 这是靠右格式 , 前面有空 ", 

Str1= string::adjust(FstLn1, 16, "◆", string::right), 

stdio::write(Str1), stdio::nl, 

FstLn2=" 这是靠左格式 , 后面有空 ", 

Str2= string::adjust(FstLn2, 16, "◆", string::left), 


FstLn10=" 这是靠右格式 , 前面有空 ", 

Str10= string::adjust(FstLn10, 16, string::right), 


FstLn20=" 这是靠左格式 , 后面有空 ", 

Str20= string::adjust(FstLn20, 16, string::left), 


Str21= string::adjustright(FstLn20, 16, " "), 


Str22= string::adjustleft(FstLn20, 16, " "), 




goal 


运行结果如图 6.4.6 所示 , 可以看到 , 我们可以指定字符串的宽度、对齐方向 , 并可以指定 

空余位置用什么字符串填满。adjust/3 和 adjustleft/3 或者 adjustright/3 的空格填余空相当。 

图 6.4.6 对齐和填空 

关于字符串连接、分拆、生产的相关谓词 , 有的我们前面已经提到过 , 汇总起来有 : 

concat : (string First, string Last) ->

string Output procedure (i,i). 

concatList : (core::string_list Source) -> 

string Output procedure (i). 

concatWithDelimiter : (core::string_list Source, 

string Delimiter) -> string Output procedure (i,i). 

create : (charCount Length) -> string Output procedure (i). 

create : (charCount Length, string Fill) -> string Output procedure (i,i). 

createFromCharList : (core::char_list CharList) -> string String. 

我们设计一个小程序来演示 , 如下所示 , 运行结果如图 6.4.7 所示。 


clauses 

classInfo("main", "stringops"). 

run():- 


SndLn= [ "murderous", "doomed", 

"that cost the Achaeans countless losses"], 

Str= string::concatWithDelimiter(SndLn, ", "), 

Rule= string::create(20, "-*&"), 

stdio::write("\n",SndLn,"\n",Str), stdio::nl, 

stdio::write(Rule), stdio::nl, 



goal mainExe::run(main::run). 

图 6.4.7 

以下这些谓词 , 都是字符串处理很重要的工具 : 

equalIgnoreCase : (string First, string Second) determ (i,i). 

front : (string Source, charCount Position, string First, string Last) 

procedure (i,i,o,o). 

frontChar : (string Source, char First, string Last) determ (i,o,o). 

frontToken : (string Source, string Token, 

string Remainder) determ (i,o,o). 

getCharFromValue : (core::unsigned16 Value) -> char Char. 

getCharValue : (char Char) -> core::unsigned16 Value. 

hasAlpha : (string Source) determ (i). 

hasDecimalDigits : (string Source) determ (i).

hasPrefix : (string Source, string Prefix, string Rest) determ (i,i,o). 

hasSuffix : (string Source, string Suffix, string Rest) determ (i,i,o). 

isLowerCase : (string Source) determ (i). 

isUpperCase : (string Source) determ (i). 

isWhiteSpace : (string Source) determ. 

lastChar : (string Source, string First, char Last) determ (i,o,o). 

length : (string Source) -> charCount Length procedure (i). 

replace : (string Source, string ReplaceWhat, 

string ReplaceWith, caseSensitivity Case) -> 

string Output procedure. 

replaceAll : (string Source, string ReplaceWhat, 

string ReplaceWith) -> string Output. 

replaceAll : (string Source, string ReplaceWhat, 

string ReplaceWith, caseSensitivity Case) -> 

string Output. 

search : (string Source, string LookFor) -> 

charCount Position determ (i,i). 

search : (string Source, string LookFor, caseSensitivity Case) -> 

charCount Position determ (i,i,i). 

split : (string Input, string Separators) -> string_list. 

split_delimiter : (string Source, string Delimiter) -> 

core::string_list List procedure (i,i). 

subString : (string Source, charCount Position, 

charCount HowLong) -> 

string Output procedure (i,i,i). 

toLowerCase : (string Source) -> 


toUpperCase : (string Source) -> 


trim : (string Source) -> string Output procedure (i). 

trimFront : (string Source) -> string Output procedure (i). 

trimInner : (string Source) -> string Output procedure (i). 

trimRear : (string Source) ->string Output procedure (i). 

我们举一个小例子如下 , 其运行结果如图 6.4.8 所示。 


clauses 

classInfo("main", "trim_example"). 

run():- 


Str= " I love Visual Prolog. How about you? ", 

T= string::trim(Str), 

stdio::write(T), stdio::nl, 

T1= string::trimInner(T), 

stdio::write(T1), stdio::nl, 

_=stdio::readline().


goal mainExe::run(main::run). 

图 6.4.8 把字符串内多余的空格去掉 

第 6.5 节逻辑小知识 : 谓词的语法 

Porolog 谓词描述 p(t1, t2, … tn-1, tn), 通常记做 p/n,n 是这个谓词的维数 , 不同维数 , 虽 

然名称相同 , 也是不同的谓词。p 称为谓词的名或符号 ,t1, t2, … tn-1, tn 称为谓词的 term, 

也可以称为其参数。这些参数可以是函数性的符号 , 也可以是字符串、符号、数字等等。如 

果 t1 和 t2 是 terms, 那么 t1 = t2、t1 > t2、 t1 < t2、 t1>=t2、t1=< t2 等描述就可以构成公式。 

谓词有严密的语法 , 从而保证逻辑推理的严谨性。 

第七章文本编辑器 

本章学习怎么用编辑器控件 editControl 模块建立一个文本编辑器。 

第 7.1 节建立文本编辑器程序 

我们建立一个 Project 名字叫做 “myEditor2008” 

Project Name: myEditor2008 

UI Strategy: Object-oriented GUI(pfc/gui) 

第二步 , 操作 File/Add 选择 “Visual Prolog 7.x\pfc\gui\controls\editorControl”, 出现如图 

7.1.1 所示。

图 7.1.1 加入 editorControl 控件 

然后 , 在根目录下创建 myEditor2008 为名字的 Form。然后 Build/Build, 再进行对文件 

myEditor2008.frm 的编辑 , 点击 Controls 对话框的钥匙按钮如图 7.1.2 所示 , 增加 Custom 

Control, 选择 editorControl, 得到如图 7.1.3 所示。 

图 7.1.2 增加 Custom Control, 拉出位置框后进入选择对话框 

图 7.1.3 增加了 editorControl 后 

如前所述 , 使菜单项 File/New 可用 , 并增加如下代码 : 

predicates 


clauses 

onFileNew(S, _MenuTag) :- F= myEditor2008:new(S), F:show().

运行一下 , 点击 File/New, 弹出编辑器对话框。可以看到这个编辑器里可以进行文字输入和 

编辑。如图 7.1.4 所示。 

第 7.2 节文件保存 

我们编辑 myEditor2008.frm, 增加一个按钮 “save”。如图 7.2.1 所示。然后增加 

clickResponder 为 onSaveClick, 然后双击 , 增加代码如下 : 

predicates 

onSaveClick : button::clickResponder. 

clauses 

onSaveClick(_Source) = button::defaultAction() :- 

Txt= editorControl_ctl:getEntireText(), 

FName= vpiCommonDialogs::getFileName("*.*", 

["Text", "*.txt"], 

"Save", [], ".", _X), !, 

file::writeString(FName, Txt). 

onSaveClick(_Source) = button::defaultAction(). 

图 7.2.1 增加 Save 按钮 , 增加 onSaveClick 事件处理 

然后运行一下 , 我们编辑一些内容 , 如图 7.2.2 所示 , 然后按 save 按钮 , 出现对话框如图 7.2.3 

所示。

图 7.2.2 编辑一些内容有了 save 按钮 

图 7.2.3 保存文件对话框 , 你可以起名字、选择位置 

图 7.2.4 在相应的位置 , 我们发现了刚才保存的文本文件 

第 7.3 节文件调入 

为了实现文件调入 , 我们在 myEditor2008 对话框里增加 “Load” 按钮。如图 7.3.1 所示。

图 7.3.1 增加 Load 按钮 

然后在 “Properties ” 对话框 , 设置 clickResponder 为 onLoadClick, 如图 7.3.2 所示 ; 然后 

双击该项目 , 在 myEditor2008.pro 里增加代码如下 : 

predicates 

onLoadClick : button::clickResponder. 

clauses 

onLoadClick(_Source) = button::defaultAction() :- 

FName= vpiCommonDialogs::getFileName("*.*", 

["Text", "*.txt"], 

"Load", [], ".", _X), 

file::existFile(FName), 

!, 

Str= file::readString(FName, _IsUnicodeFile), 

editorControl_ctl:pasteStr(1, Str). 

onLoadClick(_Source) = button::defaultAction(). 

图 7.3.2 设置 ClickResponder 为 onLoadClick 

然后运行一下 , 我们点击 Load 调入前面编辑过的文件 my2008.txt”, 结果如图 7.3.3 所示。 

图 7.3.3 调入了原来存过的文件

第 7.4 节编辑器的改进 

我们希望当 myEditor2008 对话框最大化后 , 编辑框也跟着扩大 , 这样就要变化设置 , 把原 

来的如图 7.4.1 所示 , 修改为如图 7.4.2 所示。 

图 7.4.1 原来编辑控件的设置 

图 7.4.2 四个角都和对话框的形状关联起来 

同时 , 我们要把 Load 和 Save 按钮的设置改成如图 7.4.3 所示。 

图 7.4.3 按钮 Load 的位置关联设置 , 相对于右下角 ,Save 也一样 

这样 , 当编辑对话框最大化后 , 我们看到运行结果如图 7.4.4 所示。

图 7.4.4 编辑窗口最大化后的效果 , 位置随之改变 , 而之前 , 很不理想。 

第八章绘图 

这一章 , 我们进一步探讨 onPaint 事件绘图的相关话题。首先我们创建一个带 Form 的工程 , 

在 Form 上绘图 , 我们需要进行如下操作 : 

◆ 创建 project: 

Project Name: painting 

Object-oriented GUI (pfc/gui) 

◆ 在根目录创建 paintPack 包 

◆ 创建 canvas.frm 到 paintPack 包里 , 并 Build/Build 程序 

◆ 改变菜单选项使任务菜单 File/New 可以工作 , 并按照操作 TaskWindow/Code 

Expert/Menu/TaskMenu/id_file/id_file_new 进行 , 增加代码 , 点击 New 菜单项显示 

Form: 

clauses 


X= canvas::new(S), X:show(). 

注意 , 这里 X= canvas::new(S) 创建一个实体 X, 它是任务窗口 S 的子窗口 , 命令 X:show() 

则是向 X 发布命令 show(), 意思是显示出来。这说明 , 创建存在的窗口实体 , 不一定是显 

示出来的 , 我们可以控制其状态。下面我们就利用 onPaint 在 canvas 里绘图。 

第 8.1 节 onPainting 相关的话题 

在上面的基础上 , 我们在 paintPack 包里创建模块 dopaint, 注意 , 把 “create objects” 选项 

不选 ( 缺省是选 ), 如图 8.1.1 所示。

图 8.1.1 创建 dopaint 模块 , 不选 “create objects” 

% File dopaint.cl 

class dopaint 

open core 

predicates 

bkg:(windowGDI). 

end class dopaint 

%File: dopaint.pro 

implement dopaint 


clauses 

bkg(W) :- 

P= [pnt(0,0), pnt(10,80), pnt(150, 100)], 

W:drawPolygon(P). 

end implement dopaint 

操作 canvas.frm/Edit/Events/Paintresponder/onPaint, 如图 8.1.2 所示增加代码 : 

predicates 


clauses 

onPaint(_Source, _Rectangle, GDIObj) :- 

dopaint::bkg(GDIObj). 

运行一下 , 看到如图 8.1.3 所示 :

图 8.1.3 画出三角形 

我们来看看它是怎么绘图的 , 首先 P= [pnt(0,0), pnt(10,80), pnt(150, 100)], 形成一个点位置 

构成的表 , 然后 W:drawPolygon(P) 按照 P 的规定来画出多边形图形。如果我们要把三角形绘 

成红色的 , 就要进一步改进程序。这时我们用到 brush/2: 

brush = brush( patStyle PatStyle, color Color). 

这里 PatStyle 有以下选择 : 

◆pat_Solid: 满色实心填充 

◆pat_Horz: 水平虚线填充 

◆pat_Vert: 垂直虚线填充 

◆pat_FDiag: 45 度下斜线填充 

而 Color 有 color_red、color_blue、color_green 等等可以选择。我们在 dopaint 里修改绘图谓 

词 bkg 如下 : 

bkg(W) :- 

Brush= brush(pat_Solid, color_Red), 

P= [pnt(0,0), pnt(10,80), pnt(150, 100)], 

W:setBrush(Brush), 

W:drawPolygon(P). 

得到图 8.1.4, 而 PatStyle 改变后 : 

图 8.1.4 红色和更改 PatStyle=FDiag 后的图形 

我们希望画一个椭圆 , 并把一个矩形面积用绿色涂满如图 8.1.5 所示 , 需要修改如下 : 

bkg(W) :- 

R= rct(40, 60, 150, 200), 

W:drawEllipse(R),

R1= rct( 60, 90, 140, 130), 

W:clear(R1, color_Green). 

图 8.1.5 更为复杂的操作 

我们还可以调入图片 , 比如我们把 frog.bmp 放在 paintPack 目录下 , 我们用下面代码把它显 

示在 (10,10) 开始处 ( 图片左上角位置 ): 

bkg(W) :- 

P= vpi::pictLoad("..\\paintPack\\frog.bmp"), 

W:pictDraw(P, pnt(10, 10), rop_SrcCopy). 

图 8.1.6 显示青蛙 

这里 pictLoad/1 起到图片载入功能 , 载入内存后 , 图片的代码是 P, 这是机器内部的一种标 

识 , 绘图时只需要指明图片的标识。 

图 8.1.7 鹰的黑背景图和白背景黑的剪影图 

我们把鹰显示在青蛙上面 , 如图 8.1.7 所示 , 是为了显示不带背景的鹰的图案。要去掉背景 

必须采取这样的方法 , 先制作一个黑背景的鹰 eagleBlackBack.bmp, 然后制作一个白背景的 

鹰外形的黑色剪影图 eagleMaskWhiteBack.bmp, 通过先把剪影图 eagleMaskWhiteBack.bmp 

用 rop_SrcAnd 画出 , 然后用 rop_SrcInvert 画出鹰 eagleBlackBack.bmp。如果两个动作次序 

相反 , 则结果就不同了 , 如图 8.1.8 所示。

图 8.1.7 画出不带背景的鹰 

图 8.1.8 次序反了 , 就不是要的结果了 

通过定义一个鼠标事件来记录鼠标点击位置 , 我们可以通过下面这个程序 , 实现 , 鼠标点击 

之处 , 鹰也动来动去。 

% dopaint.pro 



clauses 

bkg(W) :- P= vpi::pictLoad("..\\paintPack\\frog.bmp"), 

W:pictDraw(P, pnt(10, 10), rop_SrcCopy), 

Mask= vpi::pictLoad("..\\paintPack\\eagleMaskWhiteBack.bmp"), 

Eagle= vpi::pictLoad("..\\paintPack\\eagleBlackBack.bmp"), 

W:pictDraw(Mask,p,rop_SrcAnd), 

W:pictDraw(Eagle,p,rop_SrcInvert). 

rememberPnt(P):- 

p:=P. 

class facts 

p : pnt:=pnt(40,40). 


% dopaint.cl 

class dopaint 

open core 

predicates

kg:(windowGDI). 

rememberPnt : (vpiDomains :: pnt). 


% canvas.pro 增加的事件代码 

predicates 


clauses 

onPaint(_Source, _Rectangle, GDIObj) :- 

dopaint::bkg(GDIObj). 

predicates 


clauses 

onMouseDown(S, Point, _ShiftControlAlt, _Button):- 

dopaint :: rememberPnt(Point), 

S : invalidate(). 

第 8.2 节 Custom Control 的应用 

上节我们直接在 Form 上绘出了图案 , 但是通常图案的绘制 , 可以用 Custom Control 的方式 

进行。我们创建一个新的工程 : 

Project Name: customcontrol 

Object-oriented GUI (pfc/gui) 

选择 File/New in New Package, 进入 Create Project Item 对话框 , 在左侧选择 Control 标签选 

项 , 把控件的名字填作 canvas。Parent Directory 一项留为空白 , 然后点击 Create 按钮。如图 8.2.1 

所示 , 得到结果如图 8.2.2 所示。

图 8.2.1 创建 Custom Control 

图 8.2.2 创建 Canvas 后的目录树 

然后我们 Build/Build, 把 canvas 控件登记入 IDE, 再选择 File/New in New Package, 进入 

Create Project Item 对话框 , 在左侧选择 Form 标签选项 , 把控件的名字填作 Greeting。Parent 

Directory 一项留为空白 , 然后点击 Create 按钮。在编辑 greeting 对话框 Form 时 , 我们先如 

图 8.2.3 所示 , 点击 Controls 对话框的第三排最后一个显示为 “custom control” 的按钮 , 在 

greeting 对话框上画出位置和大小 , 得到如图 8.2.4 所示一个选择对话框 , 第一个控件就是 

我们刚刚创建的 canvas, 选择它 , 得到如图 8.2.5 所示 ( 大小调整后 )。 

图 8.2.3 选择 custom control 按钮 

图 8.2.4 选择我们创建的 canvas 控件

图 8.2.5 在 greeting 对话框里插入控件 canvas 

我们同时把 OK 按钮修改为 Hi 按钮 , 并改变为普通按钮 , 如图 8.2.6 所示。 

图 8.2.6 修改 OK 按钮为 Hi 普通按钮 

设置 Hi 按钮点击事件的侦听器如图 8.2.7 所示 , 并在 greeting.pro 文件里编写代码如后。 

图 8.2.7 设置 Hi 按钮的点击侦听器为 onHiClick 

predicates 

onHiClick : button::clickResponder. 

clauses 

onHiClick(_Source) = button::defaultAction :- 

W= canvas_ctl :getVPIWindow(), 

X= convert(integer, math::random(100)), 

Y= convert(integer, math::random(100)), 

vpi::drawText(W, X , Y, "Hello!").

对任务菜单项 File/New 进行修改使之可用 , 并用 Code Expert 增加代码到 taskWindow.pro 文 

件里如下 , 运行图如图 8.2.8 所示。按下 Hi 按钮 , 在指定区域显示 Hello, 位置是随机的 , 

但是不会超出我们画的边界 , 这个边界只有在编辑的时候看得到 , 并不显示。 

predicates 


clauses 


F= greeting::new(S), 

F:show(). 

图 8.2.8 按下 Hi 按钮 , 显示 Hello! 

第九章数据类型 

目前应用的高级语言 , 因为用到定义化的数据类型 , 可以高效的工作。Visual Prolog 编译器 

首先要检查数据类型是否和谓词或者函数的预先定义内容相符 ,x+y、x-y、a×b、p÷q 等 , 

这些算式可以工作于整数、实数、或者复数情况 , 你要确信你输入的数据符合这些要求 , 倘 

若程序接到字符串作为输入 , 就会发生逻辑错误。并非所有的高级语言的编译器检查这些逻 

辑错误 , 但是 Visual Prolog 确实这样做了 , 从而避免错误的机会提前了。这要求我们对数据 

类型有一个基本的认识。 

第 9.1 节原始数据类型 

Visual Prolog 有许多基本的数据类型 : 

integer ( 整数 ): 3、45、 65、 34、 0x0000FA1B、 845 等等 , 这些都是整数。需要说 

“0x0000FA1B” 是一个十六进制的整数 ,16 进制的数位可以是 1、2、3、4、5、6、7、8、 

9、A、B、C、D、E、F。 

real ( 实数 ): 3.45、3.1416、2.18E-18、1.6E-19 等等都是实数的具体例子。 

string ( 字符串 ): "pencil"、"John McKnight"、"Cornell University" 带西文引号的一串字符。 

symbol ( 符号 ): Na、Na_3、K、Kalium, 英文字母开头、可打印字符构成的连续字符串。 

符号看起来和字符串很近似 , 但是它们的存储格式不同。符号可以放在检索表里 ,Visual

Prolog 可以根据它们的存储地址来替代它 , 当你的程序里反复用到这个符号时 , 会节省很多 

存储内存。下面的例子展示如何用到这几个类型。运行结果如图 9.1.1 所示。 


open core 

constants 


classVersion = "primtype1". 

clauses 



energy:(real, real, real) procedure (i, i, o). 

family:(symbol, string) procedure (i, o). 

clauses 

energy(N, Z, E) :- E= -2.18E-19*Z*Z/(N*N). 

family("Na", "alkaline metal") :- !. 

family(_, "unknown"). 


energy(4, 1, E1), 

energy(2, 1, E2), 

DeltaE= E1-E2, 

stdio::write(DeltaE), stdio::nl, 

family("Na", F), 

stdio::write("Na", " is an ", F), stdio::nl, 

_ = stdio::readline(). 


goal 


图 9.1.1 计算显示不同的数据类型 

第 9.2 节集合 

集合 , 是一群东西的总称。把具有某些共同特征的数据 , 放在一起 , 可以简称为它们的集合 , 

这可以更方便地描述。所以集合 , 是描述重复事物的简单方法。 

第 9.3 节数字的集合 

我们可以用 N 自然数集合来描述无穷无尽的自然数 ,{0, 1, 2, … N, N+1…}。用 Z 来描述整

数集合 {… -N-1, -N, -N+1, …., -2, -1,0, 1, 2, … N, N+1…}。有了集合的概念 , 我们可以写出 

类似 “3∈N” 来表达 “3 属于整数 ” 这样的论述。我们创建一个程序来展示一个表的描述 , 

在 Visual Prolog 里 , 表 , 就是近似于集合的概念。注意这里 tuple(integer,integer) 是已经定 

义好的数据类型 , 如果改用其他 , 则不可。 


open core 

clauses 

classInfo("main", "zermelo"). 

run():- 


Q= [tuple(X, Y) || X= std::fromTo(1, 2), 

Y= std::fromTo(1, 3)], 

stdio::nl, 

stdio::write(Q), stdio::nl, stdio::nl, 

foreach tuple(Num, Den)= list::getMember_nd(Q) do 

stdio::write(Num, "/", Den,", ") 

end foreach, 

stdio::nl, 



goal 


图 9.3.1 展示一个自动形成的表 , 及其操作 

如果我们自己定义一个数据类型 , 也是可以的。注意 , 我们增加了数据定义 : 

domains 

fty=fty(integer, integer). 

程序改变后如下所示 : 


open core 

domains 

fty=fty(integer, integer). 

clauses 

classInfo("main", "zermelo"). 

run():- 

console::init(),

Q= [fty(X, Y) || X= std::fromTo(1, 2), 

Y= std::fromTo(1, 3)], 

stdio::nl, 

stdio::write(Q), stdio::nl, stdio::nl, 

foreach fty(Num, Den)= list::getMember_nd(Q) do 

stdio::write(Num, "/", Den,", ") 

end foreach, 

stdio::nl, 



goal 


图 9.3.2 自己定义的数据类型 , 也是可以的 

第 9.4 节实数 

实数是带小数点的数。比如 :3.1415926、100.34 等等 , 在 Visual Prolog 里它用 real 表示。 

而整数 integer 的范围是 -2147483648 ~ 2147483647 之间的一个数。string 字符串类型必须 

是引号内的可显示字符序列 , 注意这里引号是 ASCII 码引号 , 中文引号是不能识别的。Char 

是字符的类型代码 , 代表 ’a’、’B’ 等等这样单个字符 , 往往可以用单引号引起来。 

第 9.5 节格式 

格式 , 是为了输出时候 , 以比较理想的形式输出基本的数据类型。我们通常用 string::format/n 

来描述希望的格式 , 前面我们介绍一些。比如颜色的代码是十六进制数据 , 比如 :0x00FF0000 

(red 红 )、 0x0000FF00 (green 绿 ), and 0x000000FF (blue 蓝 ), 这三个原色的代码 , 如果直 

接拿 write 来显示 , 就会显示成 10 进制 , 但是如果我们用 format 加以格式化 , 就可以正确 

显示了。演示程序如下所示 , 运行结果如图 9.5.1 所示。注意 , 输入的时候 , 必须用引号把 

symbol 引起来 , 否则出错 ; 如果用 stdio::eradline() 来读取 , 因为读入的是串 , 必须转换为 

symbol 才可以。 


open core 

constants 


classVersion = "primtype2". 

clauses 


class predicates

color:(symbol, integer) procedure (i, o). 

clauses 

color("red", 0x00FF0000) :- !. 

color("blue", 0x000000FF) :- !. 

color("green", 0x0000FF00) :- !. 

color(_, 0x0). 


hasdomain(symbol , Name ), 

Name = console::read(), 

color(Name, C), 

S= string::format("%x\n", C), 

stdio::write(Name,"\t", C, "\tHex number : ", S), stdio::nl, 

run(). 

%_=stdio::readline(). 


goal 


图 9.5.1 有格式和没有格式的区别 

注意一下代码的意义 , 大家可以在 Visual Prolog 环境下一试。 

S= string::format("Pi=%4.3f\n", 3.14159) S=”Pi= 3.142” 

S= string::format("%4.3e\n", 33578.3) S= “3.358e+004” 

S= string::format("Fac(%d)=%d", 5, 120) S= "Fac(5)=120" 

S= string::format("%s(%d)=%d", "f", 5, 120) S= "f(5)=120" 

第 9.6 节域 

我们在 Visual Prolog 里可以定义自己的数据类型 , 而这个类型定义 , 就在 domains 字段里进 

行 , 也称为 “ 域 ” 声明、“ 域 ” 定义。 

第 9.6.1 节表 

我们定义表 , 是在基本类型后面增加 “*” 星号来表示的 : 

domains

eals= real*. % a list of reals 

integers= integer*. % a list of integers 

strings= string*. % a list of strings 

rr= reals*. % a list of lists of reals 

这里我们就定义了几个数据类型 :reals、integers、strings、rr。注意 , 虽然 reals 和 rr 看似一 

样 , 但是 , 它们属于不同的类型 , 如果混用 , 就会在类型检查时出错。 

第 9.6.2 节函子 

而函数型数据类型 , 在这里被称为函数型符号 , 也称为函子。例如 : 

author("Wellesley", "Barros", 1970) 

book( author("Peter", "Novig", 1960), 

"Artificial Intelligence") 

date("July", 15, 1875) 

entry("Prolog", "A functional language") 

index("Functors", 165) 

sunday 

这些都可以称为函子。我们可以这么定义数据类型 : 

domains 

year= integer. 

day= sun; mon;tue; wed; thu; fri; sat; err. 

month= jan;feb;mar;apr;may;jun;jul;aug;sep;oct;nov;dec. 

month_code= m(month, integer). 

numberOfDays= nd(integer); february. 

我们设计一个计算某一天是星期几的程序 , 计算 December 15, 2008 是星期几 , 运行结果如 

图 9.6.1 所示。程序如下 : 


open core 

constants 


classVersion = "dayOfWeek". 

domains 







dayOfWeek:(integer, day) procedure (i, o). 

calculateDay:( string Month,

integer Day_of_the_month, 

year Y, 

day D) procedure (i, i, i, o). 

class facts 

monthCode:(string, month_code, numberOfDays). 

clauses 


monthCode("January", m(jan, 6), nd(31)). 

monthCode("February", m(feb, 2), february ). 

monthCode("March", m(mar, 2), nd(31)). 

monthCode("April", m(apr, 5), nd(30)). 

monthCode("May", m(may, 0), nd(31)). 

monthCode("June", m(jun, 3), nd(30)). 

monthCode("July", m(jul, 5), nd(31)). 

monthCode("August", m(aug, 1), nd(31)). 

monthCode("September", m(sep, 4), nd(30)). 

monthCode("October", m(oct, 6), nd(31)). 

monthCode("November", m(nov, 2), nd(30)). 

monthCode("December", m(dec, 4), nd(31)). 

dayOfWeek(0, sun) :- !. 

dayOfWeek(1, mon) :- !. 

dayOfWeek(2, tue) :- !. 

dayOfWeek(3, wed) :- !. 

dayOfWeek(4, thu) :- !. 

dayOfWeek(5, fri) :- !. 

dayOfWeek(6, sat) :- !. 

dayOfWeek(_, err). 

calculateDay(Month, MD, Year, D) :- 

Y= Year-2000, % Last digits of Year. 

monthCode(Month, m(_M, C), _), % Get month code. 

!, 

S= Y+Y div 4+C+MD, 

R= S mod 7, /* Day of the week as an integer 

between 0 (sunday) and 6 (saturday) */ 

dayOfWeek(R, D). % Get functional symbol of the day 

calculateDay(_, _, _, err). 

run():- 


calculateDay("December", 15, 2008, R), 

stdio::write("December 15, 2008\nthe day of the week is : ", R), stdio::nl, 



goal 


图 9.6.1 正确计算出 2008 年 12 月 5 日是星期一 

经过我们改造 , 可以不断输入年月日格式 ” 2008-12-15”( 引号年 - 月 - 日 , 中间用连字符 ), 改 

造后的程序如下 , 运行画面见 9.6.2 所示。 


open core 

constants 


classVersion = "dayOfWeek". 

domains 







dayOfWeek:(integer, day) procedure (i, o). 

calculateDay:( string Month, 

integer Day_of_the_month, 

year Y, 

day D) procedure (i, i, i, o). 

class facts 

monthCode:(string, month_code, numberOfDays). 

clauses 


monthCode("January", m(jan, 6), nd(31)). 

monthCode("February", m(feb, 2), february ). 

monthCode("March", m(mar, 2), nd(31)). 

monthCode("April", m(apr, 5), nd(30)). 

monthCode("May", m(may, 0), nd(31)). 

monthCode("June", m(jun, 3), nd(30)). 

monthCode("July", m(jul, 5), nd(31)). 

monthCode("August", m(aug, 1), nd(31)). 

monthCode("September", m(sep, 4), nd(30)). 

monthCode("October", m(oct, 6), nd(31)). 

monthCode("November", m(nov, 2), nd(30)). 

monthCode("December", m(dec, 4), nd(31)). 

dayOfWeek(0, sun) :- !. 

dayOfWeek(1, mon) :- !. 

dayOfWeek(2, tue) :- !. 

dayOfWeek(3, wed) :- !. 

dayOfWeek(4, thu) :- !.

dayOfWeek(5, fri) :- !. 

dayOfWeek(6, sat) :- !. 

dayOfWeek(_, err). 

calculateDay(Month, MD, Year, D) :- 

Y= Year-2000, % Last digits of Year. 

monthCode(Month, m(_M, C), _), % Get month code. 

!, 

S= Y+Y div 4+C+MD, 

R= S mod 7, /* Day of the week as an integer 

between 0 (sunday) and 6 (saturday) */ 

dayOfWeek(R, D). % Get functional symbol of the day 

calculateDay(_, _, _, err). 


get_date : (string, string, integer, integer) procedure (i,o,o,o). 

clauses 

get_date(S, M, D, Y):- 

A=string::split_delimiter(S,"-"), 

A = [Y1, M0,D1], 

string::front(Y1, 1,_,Y0), 

string::front(D1, string::length(D1)-1,D0,_), 

Y=toterm(Y0), 

D=toterm(D0), 

hasdomain(core::positive, X), 

X = toterm(M0), 

M=list::nth(X, ["X", "January", "February", "March", 

"April", "May", "June", "July", "August", 

"September", "October", "November", "December"]), 

!. 

get_date(_, "December", 15, 2008) . 

run():- 


DateStr=stdio::readline(), 

get_date(DateStr,M, D, Y), 

calculateDay(M, D, Y, R), 

stdio::write(Y, " ", M, " ",D, " \nthe day of the week is : ", R), stdio::nl, 

!, 

run(). 

%_=stdio::readline(). 


goal 


图 9.6.2 改造后的计算日期界面 

第十章如何用 Prolog 解决问题 

这一章 , 我们展示 , 如何用 Prolog 解决问题 , 我们先提出问题 , 然后提出解决办法 , 并展 

示解决过程 , 目的是让读者更好认识 Prolog 是怎么解决问题的。我们这里用到的例子 , 全 

部是基于控制台 (Console) 程序 , 避免了图形界面的许多不必要的界面设置 , 直接触及 Prolog 

核心逻辑。我们创建 solveInProlog 工程如图 10.1, 在这个基础上进行尝试。建立之后 , 然 

后 Build/Build 一下 , 以后修改 main.pro 文件内容即可。 

图 10.1 建立一个 solveInProlog 工程 , 选择 Console 模式 

第 10.1 节搜索一个表的所有元素 

这个问题相对简单 , 我们利用表的描述 [Head|Tail] 的特性来即可。程序如下 : 


open core 


member:(integer, integer*) nondeterm anyflow. 

member:(string, string*) nondeterm anyflow. 

test:(string*) procedure (i). 

test:(integer*) procedure (i). 

clauses

classInfo("main", "searchList"). 

member(H, [H|X]):-stdio::write("\n\t[",H,"|", X,"]"). 

member(H, [X|T]) :- member(H, T),stdio::write("\t[",X,"|", T,"]"). 

test(L) :- 

stdio::write("\n", L, "============>"), 

member(H, L), 

stdio::write("\n\t", H), 

fail 

or 

succeed(). 

run():- 


L= [2,3,4,5], test(L), 

stdio::nl, 

S= ["a", "b", "c"], test(S), 



goal 


图 10.1.1 搜索表中所有元素的过程 

注意 , 这里在声明谓词时 ,member/2、test/1 都声明了两次 , 为了适应参数为 integer 和 string 

两种类型。计算显示 , 我们特意设置了把推理过程显示出来 , 在每个元素的上方 , 是推理过 

程 , 推理过程是倒排次序打印在屏幕上的。比如寻找 [2,3,4,5] 的第四个元素 “5”, 就经历了 

4 次尝试 , 才找到 :(1) 尝试 [2,3,4,5] 的头 , 结果 “2” 是已经有的解 ;(2) 尝试 [3,4,5] 的头 , 

结果 “3” 也是已经有的解 ;(3) 尝试 [4,5] 的头 , 结果 “4” 也是已经有的解 ;(4) 尝试 [5] 

的头 , 结果 “5” 是不曾有的解 , 成功。 

程序找到 4 个解之后还要尝试寻找第五个解 , 但是失败了 , 程序就终止了 , 不再寻求更多的 

解。所以 Visual Prolog 是不断尝试的过程 , 不断自我验证的过程。寻找所有解 , 和 test/1 里

用到的 fail 有关。member/2 要定义成 nondeterm 的 , 表示可能有多个解。 

第 10.2 节寻求两个表的交集表 

如果一个元素属于表 L1, 同时它也属于表 L2, 那么它就是这两个表共同的元素 , 它们共同 

的元素组成的表 , 称为它们的交集表。我们用下面的程序解答。 


open core, stdio 


isec:(integer*, integer*, integer*) nondeterm anyFlow. 

memb:(integer, integer*) nondeterm anyFlow. 

tst:(integer*, integer*, integer*, string) procedure(i, i, i, o). 

findsec:(integer*, integer*, integer*) procedure (i, i, o). 

length:(integer*, integer) procedure (i, o). 

clauses 

classInfo("main", "intersection"). 

memb(H, [H1|T]) :- H=H1; memb(H, T). 

isec(L1, L2, [H|U]) :- memb(H, L1), memb(H, L2), !, 

isec(L1, L2, U). 

isec(_, _, []). 

length([], 0) :- !. 

length([_|R], L+1) :- length(R, L). 

tst(L1, L2, U, R) :- 

findsec(L1, L2, S), 

length(U, LU), length(S, LS), LU= LS, 

isec(L1, L2, U), !, R= "yes"; R= "no". 

findsec([H|T], L, [H|U]) :- 

memb(H, L), 

write("\n\t","find ", H, " as a member ", [H|T]," ", L), 

!, findsec(T, L, U). 

findsec([X|T], L, U) :- 

write("\nfind ", X, " is not, then go to ... ","\t", T," ", L), 

findsec(T, L, U),!. 

findsec(_L1, _L2, []):-write("\n End search\n"). 

run():- 

console::init(), L1= [3, 6, 4, 5], 

L2= [4, 5, 6], U1= [4, 6, 5], U2= [4, 3], 

tst(L1, L2, U2, Resp2), tst(L1, L2, U1, Resp1), 

write("\nDoes ",L1," and ", L2, " have intersection list of ", 

U2, " ? ", "\nAnswer = ", Resp1), 

write("\nDoes ",L1," and ", L2, " have intersection list of ", 

U1, " ? ", "\nAnswer = ", Resp2), nl, 

findsec(L1, L2, I), 

write("\nI have found ",L1," and ", L2, " have intersection list of ", I,"\n"), 

nl, 

_=readline().


goal 


运行结果显示如图 10.2.1 所示。可见搜索交集的过程 , 就是拿第一个表的元素 , 挨个地询问 , 

它是否属于第二个表 ? 是 , 则进入交际表中 , 否则忽略该元素 , 进行下一个 , 直至表的所有 

元素都被尝试过。 

图 10.2.1 搜索表的交集过程。 

第 10.3 节两个表的合并 

把两个表的元素合在一起。程序如下所示 , 注意 app/3 的定义语句是这样写的 

“app :(Elem* L1, Elem* L2, Elem* L3) nondeterm anyFlow. ”。这里 Elem* 是一个预定义的 

类型 , 适合于各种类型的元素。 


open core 


app:(Elem* L1, Elem* L2, Elem* L3) 

nondeterm anyFlow. 

test1:(string*) procedure (i). 

test2:(integer*, integer*) procedure (i, i). 

clauses 

classInfo("main", "append"). 

app([], L, L). 

app([H|T], L, [H|U]) :- app(T, L, U). 

test1(U) :- 

stdio::write("\n",U,"\n"), 

app(L1, L2, U), 

stdio::write(L1, " ++ ", L2, " \t\t= ", U), stdio::nl, fail. 

test1(_). 

test2(L1, L2) :-

app(L1, L2, U), 

stdio::write(L1, " ++ ", L2, " = ", U), stdio::nl, fail. 

test2(_, _). 


test1(["a", "b", "c", "d"]), stdio::nl, 

test2([1, 2, 3], [4, 5, 6]), 



goal 


图 10.3.1 两表的合并 , 体验其过程 

第 10.4 节表的倒序排列 

同样利用表的 [Head|Tail] 特点 , 可以很容易把表倒过来排列 , 代码见下 , 运行结果见图 10.4.1。 

/******************************* 

Project Name: reverse 


********************************/ 


open core 


rev:(integer_list, integer_list) procedure (i, o). 

rev1:(integer_list, integer_list, integer_list) procedure (i, i, o). 

clauses 

classInfo("main", "reverse"). 

rev1([], L, L) :- !. 

rev1([H|T], L1, L) :- rev1(T, [H|L1], L). 

rev(L, R) :- rev1(L, [], R). 

run():- 


hasdomain(integer_list, L), 

L=console::read(), 

rev(L, R), stdio::write("\n Reverse of ", L, " is \n\t ", R), 

stdio::nl,

un(). 


goal 


图 10.4.1 输入一个整数表 , 得到其倒序排列表 

如果对 rev1/3 进行适当改造如下代码 , 可以显示过程 , 如图 10.4.2 所示。 

rev1([], L, L) :- !. 

rev1([H|T], L1, L) :- 

stdio::write("\n",[H|T], "---> ", [H|L1]), 

rev1(T, [H|L1], L) . 

rev(L, R) :- rev1(L, [], R). 

图 10.4.2 显示倒序排列的创造过程

第 10.5 节表的分割 

我们假设有这样的需求 , 按一定的标准 , 把一个表分成两个。下面的例子是用 split/4 把一个 

表分成大的、小的两个子表。程序如下 , 运行推演过程如图 10.5.1 所示。可见这个定义适用 

于数值表或者字符串表。 


open core 

clauses 

classInfo("main", "quicksort"). 


split:(E, E*, E*, E*) procedure (i, i, o, o). 

clauses 

split(P, [H|T], S, [H|B]) :- 

H>P, !, 

split(P, T, S, B), 

stdio::write("\n(", H, ">",P,") [",H,"|", T, "] Small",S, "Big", B). 

split(P, [H|T], [H|S], B) :- !, 

split(P, T, S, B), 

stdio::write("\n(", H,"

第 10.6 节表的快速排序 

基于上边我们设计的把表分成大小两个 split/4 以及 append/3, 我们可以设计一个快速表排序 

的程序 sort/2: 首先按照第一个元素 , 用 split/4 把表分成大小两个表 ; 然后分别用 sort./2 对 

这两个表进行排序 , 再用 append/3 把大小两个排好序的表合并起来。程序如下 , 推演过程 

及运行结果如图 10.6.1 所示。这个适用于数字表和文字表等各种可以比较大小的表。 


open core 

clauses 

classInfo("main", "quicksort"). 


split:(E, E*, E*, E*) procedure (i, i, o, o). 

app:(E*, E*, E*) procedure (i, i, o). 

sort:(E*, E*) procedure (i, o). 

clauses 

split(P, [H|T], S, [H|B]) :- 

H>P, 

!, split(P, T, S, B). 

split(P, [H|T], [H|S], B) :- 

!, split(P, T, S, B). 

split(_, [], [], []). 

app([], L, L) :- !. 

app([H|T], L, [H|U]) :- app(T, L, U). 

sort([P|L], S) :- 

!, split(P, L, Small, Big), 

stdio::write("\n[", P, "|", L, "] to ",P," S=", Small, " B=", Big), 

sort(Small, QSmall), stdio::write("\n>",P," ", Big, " =>", QBig), 

app(QSmall, [P|QBig], S). 

sort([], []). 

run():- 


L= [5, 3, 7, 4, 5, 8, 2], stdio::write(L), 

sort(L, S), stdio::write("\n after sorted = ", S), stdio::nl, 

Strs= ["b", "a", "c"], stdio::write("\n\n",Strs), 

sort(Strs, Qs), stdio::write("\n after sorted =", Qs), stdio::nl, 



goal 


图 10.6.1 快速排序方法 

第 10.7 节一年有多少天 ? 

通常一年有 365 天 , 但是每四年就会出现闰年 366 天。但是每百年不闰年 , 每四百年闰年。 

程序如下 , 运行图 10.7.1 所示。 


open core 


no_of_days_in:(integer, integer) procedure (i, o). 

member:(integer, integer_list) nondeterm (o, i). 

test:(integer_list) procedure (i). 

clauses 

classInfo("numdays", "1.0"). 

member(H, [H|_T]). 

member(H, [_|T]) :- member(H, T). 

no_of_days_in(Y, 366) :- 

0= Y mod 400, 

stdio::write(Y, "\n every 400 years "),!. 

no_of_days_in(Y, 366) :- 

0= Y mod 4,

stdio::write(Y, "\n every 4 years "), 

( not(0= Y mod 100), 

stdio::write(Y, "\n but not every 100 years "),! 

or stdio::write(Y, "\n same time every 100 years "),fail). 

no_of_days_in(Y, 365):-stdio::write(Y). 

test(L) :- 

member(X, L), 

no_of_days_in(X, N), 

stdio::write("\n Year ", X, " has ", N, " days."), 

stdio::nl, fail. 

test(_L). 

run():- 


test([1975, 1900, 1800, 2008, 1976, 2000]), 



goal 


图 10.7.1 计算每年有多少天 

第 10.8 节地图填色问题 

一个著名问题是 : 四种颜色可以为任意的地图涂上颜色 , 而任何相邻的地块颜色都不相同 , 

这就是著名的四色定理。我们设计一个程序 , 假设 L 表是描述地图上不同块相邻关系的表 ,

其元素用 nb(A,B) 来描述 ,A 和 B 相邻。这样 , 我们用反复尝试的方法 , 为不同的块设 

定不同的颜色。下面的程序求得一个解 , 我们假设有 A、B、C、D、E、F 六块地 ; 运行结 

果如图 10.8.1 所示。我们可以增加、减少颜色设置 , 来看看结果会怎么样 ? 有答案 , 则 L 

会是颜色表 ; 否则返回空表 , 表示没有答案。改变颜色是同步修改 

colors= blue;yellow;red;green. 和 generateColor(R) :- R= blue; R= yellow; R= green; R= red. 

语句 , 不再赘述。 



domains 

colors= blue;yellow;red;green. 

neighbors= nb(colors, colors). 

map= neighbors*. 


aMap:(map) nondeterm anyFlow. 

test:(map) procedure anyFlow. 

generateColor:(colors) multi (o). 

clauses 

classInfo("main", "fourcolors"). 

generateColor(R) :- 

R= blue; 

R= yellow; 

R= green; 

R= red. 

aMap([]). 

aMap([X|Xs]) :- 

X= nb(C1, C2), 

not(C1 = C2), 

aMap(Xs). 

class facts 

n : integer :=0. 

clauses 

test(L) :- 

n:=0, 

generateColor(A), 

generateColor(B), 

generateColor(C), 

generateColor(D), 

generateColor(E), 

generateColor(F), 

L= [ nb(A, B), nb(A, C), nb(A, E), nb(A, F), 

nb(B, C), nb(B, D), nb(B, E), nb(B, F),

nb(C, D), nb(C, F), nb(C, F)], 

n:=n+1, 

aMap(L) ,! 

; L= []. 

run():- 


test(L), 

stdio::write("\n",n ,"\n", L), 



goal 


图 10.8.1 经过 396 次组合验证 , 找到答案 

我们可以修改程序 , 看看到底有多少种填色方案。就本题而言 , 运行结果告诉我们 , 共有 

96 种方案。修改后程序如下 , 运行结果如图 10.8.2 所示 , 显示了每一种答案的尝试次数 , 

显示答案的具体内容如图 10.8.3 所示 , 还要再做少量修改 , 我们展示了最后两个方案的细节。 



domains 

colors= blue;yellow;red;green. 

neighbors= nb(colors, colors). 

map= neighbors*. 


aMap:(map) nondeterm anyFlow. 

test:(map) nondeterm anyFlow. % multi anyFlow. %procedure anyFlow. 

generateColor:(colors) multi (o). 

clauses 

classInfo("main", "fourcolors"). 

generateColor(R) :- 

R= blue; 

R= yellow; 

R= green; 

R= red. 

aMap([]). 

aMap([X|Xs]) :- 

X= nb(C1, C2), 

not(C1 = C2), 

aMap(Xs).

class facts 


k : integer :=0. 

clauses 

test(L) :- 

n:=0, 

generateColor(A), 

generateColor(B), 

generateColor(C), 

generateColor(D), 

generateColor(E), 

generateColor(F), 

L= [ nb(A, B), nb(A, C), nb(A, E), nb(A, F), 

nb(B, C), nb(B, D), nb(B, E), nb(B, F), 

nb(C, D), nb(C, F), nb(C, F)], 

%write(n," "), 

n:=n+1, 

aMap(L) . % ,! 

%; L= []. 

run():- 


k:=0, 

test(L), 

k:=k+1, 

N=string::format("%2 -%3 ",k, n), 

stdio::write("\n\n", N ,"\n", L), %), stdio::nl, 

n:=0, 

fail. 

run():- 



goal 


图 10.8.2 枚举出一共 96 种结果和它们验证的次数

图 10.8.3 第 95、96 结果的细节显示 

第 10.9 节翻子游戏 

有 6 个硬币 , 正面朝上 , 每次有一个硬币可以发口令 , 它自己状态不变 , 而其他五个得令则 

状态反转。问怎样做才能使六个硬币朝下 ? 下面是程序 , 运行结果见图 10.9.1 所示。 



domains 


change : (integer*, integer* , integer* ) determ (i,i,o). 

who_order : (integer* ) multi (o). 

test : () procedure. 

clauses 

classInfo("main", "turn"). 

class facts 


nowStatus : integer* :=[]. 

clauses 

who_order(A):- 

A=[1,0,0,0,0,0]; 

A=[0,1,0,0,0,0]; 

A=[0,0,1,0,0,0]; 

A=[0,0,0,1,0,0]; 

A=[0,0,0,0,1,0]; 

A=[0,0,0,0,0,1]. 

change(B,A,[]):-(A=[];B=[]),!. 

change([A|Ra],[B|Rb], [C|X]):- 

(B=1,A=1, C=1; 

B=1, A=0, C=0; 

B=0,A=0, C=1; 

B=0, A=1, C=0), 

!, 

change(Ra,Rb, X).

test():- 

Start= [1,1,1,1,1,1], 

End=[0,0,0,0,0,0], 

stdio::write("\n\t ", Start, " \t => \t", End, "\n"), 

nowStatus:=Start, 

n:=0, 

who_order(A), 

change(nowStatus, A, NewStatus), 

n:=n+1, 

stdio::write("\n", n ,"\t", nowStatus,"\t", A, "\t-->", NewStatus), 

nowStatus:=NewStatus, 

nowStatus=End, !; 

stdio::write("\n There is no solution........." ). 

run():- 


test(), 



goal 


图 10.9.1 六次反转就可以实现 1 代表正面 , 还代表发口令者 

第 10.10 节 NIM 游戏 

NIM 游戏的一种经典表述为 : 

有 n 堆火柴 , 每堆各有若干根。两人轮流取出火柴 , 每次取 

出的根数不限但至少取 1 根 , 每次也只能从 1 堆里取火柴。 

谁最后把火柴取完 , 谁就是获胜者。问如何才能保证获胜 ? 

获胜策略已由美国数学家 C.L.Bouton 分析完成 , 用到的是二进制和平衡状态概念。其结论 

是 : 

(1) 如果一开始火柴的总根数转化成二进制后各位数上的 

数字和都是偶数时 , 则是平衡状态 , 后取者必胜。最 

简单的平衡态是 (1,1), 即 2 堆火柴 , 每堆各 1 根。 

(2) 如果开始时火柴的状态处于不平衡状态 , 先取者必胜 , 

其策略是取完后使火柴根数保持为平衡状态。最简单

的不平衡态是 (1), 即 1 根火柴。 

Nim 游戏是组合游戏 (Combinatorial Games) 的一种 , 准确来说 , 属于 “Impartial Combinatorial 

Games”( 以下简称 ICG)。 

满足以下条件的游戏是 ICG( 可能不太严谨 ): 

1、有两名选手 ; 

2、两名选手交替对游戏进行移动 (move), 每次一步 , 选手可以在 

( 一般而言 ) 有限的合法移动集合中任选一种进行移动 ; 

3、对于游戏的任何一种可能的局面 , 合法的移动集合只取决于这 

个局面本身 , 不取决于轮到哪名选手操作、以前的任何操作、 

骰子的点数或者其它什么因素 ; 

4、如果轮到某名选手移动 , 且这个局面的合法的移动集合为空 ( 也 

就是说此时无法进行移动 ), 则这名选手负。根据这个定义 , 

很多日常的游戏并非 ICG。例如象棋就不满足条件 3, 因为红 

方只能移动红子 , 黑方只能移动黑子 , 合法的移动集合取决于 

轮到哪名选手操作。 

通常的 Nim 游戏的定义是这样的 : 有若干堆石子 , 每堆石子的数量都是有限的 , 合法的移 

动是 “ 选择一堆石子并拿走若干颗 ( 不能不拿 )”, 如果轮到某个人时所有的石子堆都已经被 

拿空了 , 则判负 ( 因为他此刻没有任何合法的移动 )。 

这游戏看上去有点复杂 , 先从简单情况开始研究吧。如果轮到你的时候 , 只剩下一堆石子 , 

那么此时的必胜策略肯定是把这堆石子全部拿完一颗也不给对手剩 , 然后对手就输了。如果 

剩下两堆不相等的石子 , 必胜策略是通过取多的一堆的石子将两堆石子变得相等 , 以后如果 

对手在某一堆里拿若干颗 , 你就可以在另一堆中拿同样多的颗数 , 直至胜利。如果你面对的 

是两堆相等的石子 , 那么此时你是没有任何必胜策略的 , 反而对手可以遵循上面的策略保证 

必胜。如果是三堆石子 „„ 好像已经很难分析了 , 看来我们必须要借助一些其它好用的 ( 最 

好是程式化的 ) 分析方法了 , 或者说 , 我们最好能够设计出一种在有必胜策略时就能找到必 

胜策略的算法。 

我们要用到表的合并谓词 : 


open core 

domains 

ms= integer*. 

hs= ms*. 


append:(E*, E*, E*) nondeterm anyFlow. 

clauses 

classInfo("main", "nimgame"). 

append([], Y, Y). 

append([U|X], Y, [U|Z]) :- append(X, Y, Z). 

clauses 

run():-


(append([[1],[1],[1],[1],[1]], [[1],[1],[1]], L), !, 

stdio::write(L), stdio::nl; 

succeed()), 



goal 


增加从一个表里取走一些元素的 takesome/3 谓词 , 看看它的运行结果如图 10.10.1 所示 : 


open core 

domains 

ms= integer*. 

hs= ms*. 



test:() procedure. 

takesome:(ms, hs, hs) nondeterm anyFlow. 

clauses 




takesome([_X], V, V). 

takesome([_X, X1|Y], V, [[X1|Y]|V]). 

takesome([_X|T], V, Y) :- takesome(T, V, Y). 

test() :- 

L= [1, 1, 1, 1, 1], 

V= [[1,1]], 

stdio::write("\n The original : ", L, " ", V,"\n"), 

takesome(L, V, Resp), 

stdio::write(Resp), stdio::nl, 

fail; succeed(). 

clauses 

run():- 


test(), 



goal 


图 10.10.1 从最前面的一堆里 , 取走至少一个、最多整个火柴棒 

我们再增加一个谓词 move/2, 表明从一个状态到另一个状态。比如从 [[1,1,1],[1,1]] 

中取走火柴棒 , 有多少种取法呢 ? 程序如下 , 运行结果如图 10.10.2 所示 : 


open core 

domains 

ms= integer*. 

hs= ms*. 





move:(hs, hs) nondeterm anyFlow. 

clauses 







move(X, Y) :- 

append(U, [X1|V], X), 

takesome(X1, V, R), 

append(U, R, Y). 

class facts 


clauses 

test() :- 

L= [[1, 1, 1], [1, 1]], 

n:=1, 

stdio::write("Possible moves from ", L, ": \n"), 

move(L, Resp), 

stdio::write(n,"\t", Resp, "\n"), 

n:=n+1, 

fail; 

succeed(),stdio::write("Total ",n-1, " methods\n\n").

clauses 

run():- 


test(), 



goal 


图 10.10.2 有 5 种取法 , 第一个表有 3 种 , 第二个表有 2 种。 

下面为寻求取胜方法 , 设立谓词 winningMove/2, 从而寻求有可能制胜的方法 , 程序如下 , 

运行图如图 10.10.3 所示。 


open core 

domains 

ms= integer*. 

hs= ms*. 






winningMove:(hs, hs) nondeterm (i, o). 

clauses 







move(X, Y) :- 




winningMove(X, Y) :- 

move(X, Y), 

not(winningMove(Y, _)).

class facts 


clauses 

test() :- 

L= [[1, 1, 1], [1, 1]], 

n:=1, 

stdio::write("Possible moves from ", L, ": \n"), 

winningMove(L, Resp), 

stdio::write(n,"\t", Resp, "\n"), 

n:=n+1, 

fail; 

succeed(),stdio::write("Total ",n-1, " methods\n\n"). 

clauses 

run():- 


test(), 



goal 


图 10.10.3 找到制胜方法是从第一堆里取走一个 

下面的程序是我们的交互版本 , 运行结果如图 10.10.4 所示。 


open core 

domains 

ms= integer*. 

hs= ms*. 





winningMove:(hs, hs) nondeterm (i, o). 

clauses 






takesome([_X|T], V, Y) :- takesome(T, V, Y).

move(X, Y) :- 




winningMove(X, Y) :- 

move(X, Y), 

not(winningMove(Y, _)). 


iwin:(hs) determ (i). 

youwin:(hs, hs) determ (i, o). 

game:(hs) determ (i). 

clauses 

iwin([]) :- !,stdio:: write("I win\n"). 

youwin(L, L2) :- winningMove(L, L2), !. 

youwin(_L, _L2) :- stdio::write("You win\n"), fail. 

class facts 


clauses 

game(L1) :- 

stdio::write("Your move: "), 

L= console::read(), 

move(L1, LTest), 

L= LTest, 

youwin(L, L2), !, 

stdio:: write("My move: "), 

stdio::write(L2, "\n"), 

not(iwin(L2)), 

game(L2). 

clauses 

run():- 


L= [[1, 1, 1], [1, 1]], 

stdio::write("Start : ", L, "\n"), 

( game(L),!; 

succeed()), 

_=stdio::readline(), 



goal 


图 10.10.4 交互的下棋过程

图 10.10.5 不同的初始状态 , 它总能取胜 

这个原理可以用于二人对弈的其它棋类。 

第十一章事实 

事实 , 是一种只有头、没有尾的 Horn 句子。事实 , 可以在运行时 , 动态的插入、删除 , 这 

也暗示了它可以被编辑、修改。我们需要用 facts 或者 class facts 来声明事实 , 而不是用 

predicates 来声明。 

第 11.1 节数据库记录的生成和保存 

下面我们来制作一个记录我们拥有的书籍信息的数据库应用 , 来看看 , 怎么应用事实。程序 

如下 , 运行结果如图 11.1.1 所示。我们记录了书名 - 出版社、书名 - 作者两种信息 , 并把记录 

保存在文件 bibliography.fac 里。 


open core 

domains 

name= string. 

author= n1(name); n2(name, name); etal(name). 

publisher= string. 

title= string. 

volume= journal(title, publisher); book(title, author). 

class facts - bib 

num:integer := 0. 

item:(volume, integer) nondeterm. 


addItem:(volume). 

prtDataBase:().

clauses 

classInfo("main", "facttest"). 

addItem(V) :- 

num := num+1, 

assert(item(V, num)). 

prtDataBase() :- 

item(V, I), 

stdio::write(I, " ", V), stdio::nl, 

fail. 

prtDataBase(). 

clauses 

run():- 


addItem(journal("AI in focus", "MIT Press")), 

addItem(book( "Databases in Prolog", 

n1("Wellesley Barros"))), 

file::save("bibliography.fac", bib), 

prtDataBase(), 



goal 


图 11.1.1 数据库操作、记录输入、保存、显示 

我们打开保存的数据库文件 “bibliography.fac” 可以看到如图 11.1.2 所示的记录 : 

图 11.1.2 保存的数据库记录

第 11.2 节数据库记录文件的读取 

有了这个保存的文件 , 我们就可以直接对其进行读取和显示。我们利用上节生成的数据记录 

文件 , 进行读取和显示 , 程序如下 , 运行结果如图 11.2.1 所示。 


open core 

domains 

name= string. 

author= n1(name); n2(name, name); etal(name). 

publisher= string. 

title= string. 

volume= journal(title, publisher); book(title, author). 

class facts - bib 

num:integer := 0. 

item:(volume, integer) nondeterm. 


prtDataBase:(). 

clauses 

classInfo("main", "factread"). 

prtDataBase() :- 

item(V, I), 

stdio::write(I, " ", V), stdio::nl, 

fail. 

prtDataBase(). 

clauses 

run():- 


F="bibliography.fac", 

file::consult(F, bib), 

stdio::write("We have read facts from file ", 

F, ".\nIt contains records as:\n\n"), 

prtDataBase(), 



goal 


图 11.2.1 读取数据库文件并显示其记录

我们把数据库文件读入内存用到 file::consult("bibliography.fac", bib)。这是关键。 

第 11.3 节 file 模块 : 读写字符串 readString/writeString 

前面我们存取数据到文件里时 , 都会用到 file 模块。这一节我们重点介绍这个模块的一些必 

要的谓词和特性。 

我们常常要对文本文件进行读写操作 , 过去计算机内存很宝贵 , 所以每次读取文件的一部分 

内容进行操作。如今内存很富裕 , 我们可以把整个文件读取到一个字符串里 , 利用 string 模 

块的强大处理能力进行处理 , 然后再把整个字符串 , 写到一个文件里。而在文件内容和字符 

串间传递信息的谓词是 : 

readString:(string FileName, boolean IsUnicodeFile) 

-> string String procedure (i,o). 

writeString:( string Filename, string Source, 

boolean IsUnicodeFile) procedure (i,i,i). 

这个版本是可以指定内容是否是 unicode 的编码形式。如果无需指定这个选项 , 我们通常用 

这两个谓词 : 

readString : (string FileName) -> string String procedure (i). 

writeString : (string Filename, string Source) procedure (i,i). 

下面我们在运行目录里建立一个 test.txt 文件如图 11.3.1 所示 , 然后 , 我们通过如下程序读 

取其内容并转换成全部大写字母 , 保存在 upper.txt 文件里。运行图如图 11.3.2 所示。

图 11.3.1 在 \exe 目录里建立文件 test.txt 


open core 

constants 


classVersion = "filetest". 

clauses 


clauses 

run():- 


Str= file::readString("test.txt", Unicode), 

S_Upper= string::toUpperCase(Str), 

file::writeString("upper.txt", S_Upper, Unicode), 

stdio::write(Str,"\n\n", S_Upper,"\n\n Save the result in upper.txt \n"), 



goal 


图 11.3.2 读取文件内容显示 , 转换成为全部大写字母后显示 , 保存在 upper.txt 里 

在运行目录里 , 我们发现多了一个文件 upper.txt, 打开看看其内荣如图 11.3.3 所示。

图 11.3.3 生成的大写字母的版本 , 保存在 upper.txt 里 

第 11.4 节常数 

在 Visual Prolog 里 , 我们常常可以用有意义的字符串 , 代替某些数字 , 把它们当作常数使用 , 

这样省去了书写、记忆的麻烦。在菜单系统里 , 系统也是把菜单项目用一个统一的命名方法 , 

把其内部代码用常数形式表示的。下面的例子我们我们来感受一下菜单项目常数的使用。这 

些系统生成的常数存在根目录的 resourceIdentifiers.res 里。 

创建一个新工程 : 

Project Name: constantTest 

UI Strategy: Object-oriented GUI (pfc/gui) 

选择 Create a New Form in New Package 创建 textWin Form。然后 Build/Build 这个工程 , 然 

后在 textWin 的 Properties 对话框 Properties 里选择 Menu 项目设置 TaskMenu, 在 Events 里 , 

选择 MenuItemListener 增加 onMenuItem 菜单项侦听器。如图 11.4.1 所示。 

图 11.4.1 增加菜单项目侦听器 

然后双击 , 在 textwin.pro 里增加代码如下 : 

predicates 

onMenuItem : window::menuItemListener. 

clauses

onMenuItem(_Source, M) :- 

Item= resourceIdentifiers::id_help_contents, 

M= Item, !, 

stdio::write("\nHello A"). 

onMenuItem(_Source, _M):-stdio::write("\nHello B"). 

按照这个操作 : 

TaskWindow.win/CodeExpert/Menu/TaskMenu/id_file/id_file_new 

把 taskmenu 的 File/New 菜单变成可以执行的 , 增加代码如下 : 

predicates 


clauses 


X= textWin::new(S), X:show(). 

执行一下看看 , 当我们点击 Help 菜单下的不同项目 , 在 Form 获得焦点情况下 , 运行结果 

如图 11.4.2 所示。 

图 11.4.2 不同的菜单项目的反应 

第十二章 class 和 object 

第 12.1 节存取社会保障号 

关于 class 和 object, 我们从例子里来搞清楚它们。我们先建一个 project 如下要求 : 

Project Name: classexample


然后 ,Build/Build 该 project, 之后增加一个新的 class, 名字为 account, 注意一定不要不选 

Creates Objects 选项如图 12.1 所示。我们修改 account.i 文件增加代码后如下所示 : 

图 12.1 创建 class 名为 account, 记得要保留选项 Create Objects 啊 

interface account 

open core 

predicates 

ssN:(string SocialSecurity) procedure (o). 

setSocialSecurity:(string SSN) procedure(i). 

deposit:(real). 

end interface account 

当我们调用方法 A= account::new() 时 ,account 就会产生一个新的 object 我们把它命名为 A, 

我们可以针对这个新的 object A, 进行信息操作 , 比如我们把一个社会保障号码发送给 A, 

就要这么调用 : 

A:setSocialSecurity("AA345"), 

之后 , 我们可以从 A 里获得社会保障号码 : 

A:ssN(SocialSecurity), 

可见 class 是模块的描述 , 而 object 是实体。一个更理论化 , 一个更具体。一个更通用 , 一 

个更个性。 

然后我们修改 account.pro 文件 , 得到这样的代码 : 

implement account 

open core 

facts - customer

funds:real := 3.0. 

personalData:(string Name, string SocialSecurity) single. 

clauses 

classInfo("account", "1.0"). 

personalData("", ""). 

ssN(SS) :- personalData(_, SS). 

setSocialSecurity(SSN) :- 

personalData(N, _), 

assert(personalData( N, SSN)). 

deposit(Value) :- 

funds := funds+Value. 

end implement account 

然后 , 我们修改 main.pro 代码如下 : 


open core 

clauses 

classInfo("classTest", "class 1.0"). 

clauses 

run():- 


A= account::new(), A:setSocialSecurity("AA345"), 

A:ssN(SocialSecurity), 

stdio::write(SocialSecurity), stdio::nl, 



goal 


运行之后 , 显示了我们输入的 AA345 这个号码。证明这个号码已经存储在这个实体里。 

第 12.2 节 Object 的事实 

Object 的特性是靠他的事实存储的特性来表现的 , 这也是实体 (object) 的特征。前面我们 

定义了 : 

facts - customer 

funds:real := 3.0. 

personalData:(string Name, string SocialSecurity) single. 

这就是指明了 account 实体的主要特征值。不同的值 , 代表不同的实体。而界面谓词 , 存在

account.i 里 , 是来存取这些特征值的。 

interface account 

open core 

predicates 

ssN:(string SocialSecurity) procedure (o). 

setSocialSecurity:(string SSN) procedure(i). 

deposit:(real). 

end interface account 

第十三章乌龟爬和语言处理 

第 13.1 节乌龟爬行 

乌龟爬过之后会留下痕迹 , 我们就设计一个程序 , 记录痕迹 , 仿佛乌龟爬过。建立一个 

Project, 如下描述 : 

General 

Project name: turtle 


Target type: Exe 

然后在新的包里建立一个 Form, 名字为 canvas。执行 File/New in Existing Package, 

在 canvas 目录下建立一个 class 名字为 curve, 注意把 “Create objects” 选项去掉。Build/Build 

这个 Project。 

执行 “TaskWindow.win/CodeExpert/Menu/TaskMnu/id_file/id_file_new” 和 

“TaskWindow.mnu/Edit/File/New/Enable” 操作 , 使 File|New 菜单项目可操作 , 并增加 

代码如下 : 

predicates 


clauses 


X= canvas::new(S), 

X:show(). 

编辑 curve.cl, 使代码如下 : 

class curve


predicates 


drawCurve:(windowHandle). 

end class curve 

编辑 curve.pro 文件 , 代码如下 : 

implement curve 

open core, vpi, vpiDomains, math 


star:(windowHandle, integer, real, integer) procedure (i, i, i, i). 

clauses 

classInfo("plotter/curve", "1.0"). 

star(_Win, 0, _A, _L) :- !. 

star(Win, N, A, L) :- 

turtle::right(A), 

turtle::forward(Win, L), 

star(Win, N-1, A, L). 

drawCurve(Win) :- star(Win, 10, 3*pi/5, 40). 

end implement curve 

执行 “File/New in New Package” 创建一个新的包 “turtleGraphics”, 注意目录选择 

为 “..\..\vispro” 根目录下 , 在这个包下面 , 创建一个 class 名字为 “turtle”。这个 class 的代码 

turtle.cl 如下 : 

class turtle 


predicates 


forward:(windowHandle, integer) procedure. 

move:(integer) procedure. 

right:(real) procedure. 

left:(real) procedure. 

end class turtle 

而 turtle.pro 代码如下 : 

implement turtle 

open core, vpiDomains, vpi, math 

class facts

turtle:(pnt, real) single. 

clauses 

classInfo("turtleGraphics/turtle", "1.0"). 

turtle(pnt(80, 80), -pi/2). 

forward(Win, L) :- 

turtle(P1, Facing), 

P1= pnt(X1, Y1), 

X2= math::round( X1+ L*cos(Facing)), 

Y2= math::round(Y1+L*sin(Facing)), 

P2= pnt(X2, Y2), 

drawline(Win, P1, P2), 

assert(turtle(P2, Facing)). 

move(L) :- 


P1= pnt(X1, Y1), 

X2= round( X1+ L*cos(Facing)), 

Y2= round(Y1+L*sin(Facing)), 

P2= pnt(X2, Y2), assert(turtle(P2, Facing)). 

right(A) :- 


NewAngle= Facing+A, 

assert(turtle(P1, NewAngle)). 

left(A) :- 


NewAngle= Facing-A, 


end implement turtle 

接下来 , 执行 “canvas.frm/Events/PaintRespont-onPaint” 并双击鼠标 , 在 canvas.pro 里 

增加代码 : 

predicates 


clauses 

onPaint(S, _Rectangle, _GDIObject) :- 

W= S:getVPIWindow(), 

curve::drawCurve(W). 

现在我们执行一下 , 执行 File/New 菜单选项得到图如 13.1.1 所示。

图 13.1.1 第一个龟行轨迹 

第 13.2 节乌龟的状态描述 

这里 , 乌龟的状态用两个变量来描述 : 

class facts 


clauses 

turtle(pnt(80, 80), -pi/2). 

一个是当前的位置坐标 , 一个是角度朝向 , 用于下一个位置的确立和运动方向的确立。 

在 turtle 模块里 , 设计了前行谓词 forward/2, 这是要画线的 : 



P1= pnt(X1, Y1), 



P2= pnt(X2, Y2), 



而 move/1 则是移动位置不画线 , 左、右行的 left/1、right/1 是改变方向 , 也是不画线。 

right(A) 表示增加角度 ,left(A) 表示减少角度值。 

move(L) :- 


P1= pnt(X1, Y1), 


Y2= round(Y1+L*sin(Facing)), 

P2= pnt(X2, Y2), assert(turtle(P2, Facing)).

ight(A) :- 




left(A) :- 




而我们主要控制画线的 curve 模块里 drawCurve/1 在这里这样描述 : 进行 10 次这样的动 

作 , 每次增加角度 3*pi/5, 径向长度为 40, 然后向前画线 , 如此反复直至 10 次结束。通过 

修改角度 , 次数 , 我们可以画出不同的规则图形 ; 通过修改长度 , 我们可以改变图形大小尺 

寸。 

star(_Win, 0, _A, _L) :- !. 





drawCurve(Win) :- star(Win, 10, 3*pi/5, 40). 

第 13.3 节画出其他的规则图形 

其实根据上面的分析 , 我们只要改变角度、次数 , 就可以画出不同的规则图形。 

图 13.3.1 drawCurve(Win) :- star(Win, 3, 2*pi/3,80). 画出正三角形

图 13.3.2 drawCurve(Win) :- turtle::left(pi/2),star(Win, 3, 2*pi/3,80). 则画出正的正三角形 

注意 , 我们绘图开始时并没有指定起始位置 , 这样 turtle 的起始位置是在这个实体里 , 

起始位置就是上一次绘图的最后位置。请你尝试着点击 canvas 的右上角关闭这个对话框 , 

然后在点击 File/New 生成新的 canvas, 如此反复 , 看看有什么不同。 

图 13.3.3 drawCurve(Win) :- turtle::left(pi/2),star(Win, 5, 2*pi/5,40). 五边形 

图 13.3.4 drawCurve(Win) :- turtle::right(1*pi/10), star(Win, 5, 4*pi/5,80). 五角星

第 13.4 节保证每次画出的是一样的图形 

我们通过在 turtle 模块里增加设置起始位置的谓词 setstart/2, 来保证每次起始位置相同 , 这 

样就可以保证每次画出的图形是一样的。如图 13.4.1 所示 , 而且我们还可以指定在什么位置 

画图 , 可以同时画出若干个图如图 13.4.2 所示。 

图 13.4.1 画出一致的图形 

图 13.4.2 在不同的位置 , 画出不同的图形 

修改后的程序文件如下所示。curve.cl 没有变化 ,curve.pro 如下所示 : 




star:(windowHandle, integer, real, integer) procedure (i, i, i, i). 

clauses 


star(_Win, 0, _A, _L) :- !.





drawCurve(Win) :- 

turtle::setstart(pnt(110, 50), -pi/2), 

turtle::right(1*pi/10), 

star(Win, 5, 4*pi/5,80), 


turtle::left(pi/2), 

star(Win, 3, 2*pi/3,80). 

end implement curve 

而 turtle.cl 如下所示 : 

class turtle 


predicates 


forward : (windowHandle, integer) procedure. 

move : (integer) procedure. 

right :(real) procedure. 

left : (real) procedure. 

setstart : (pnt, real) procedure. 

end class turtle 

文件 turtle.pro 如下所示 : 

implement turtle 


class facts 


clauses 

classInfo("turtleGraphics/turtle", "1.0"). 

turtle(pnt(80, 80), -pi/2). 



P1= pnt(X1, Y1), 



P2= pnt(X2, Y2), 



move(L) :- 


P1= pnt(X1, Y1), 


Y2= round(Y1+L*sin(Facing)),

P2= pnt(X2, Y2), assert(turtle(P2, Facing)). 

right(A) :- 




left(A) :- 




setstart(P1, NewAngle):- 


end implement turtle 

第 13.5 节递归 

和自然数相关的谓词 , 我们这样来描述递归方法 : 

(1) 证明它对于 0 是正确的。 

(2) 如果它对于 N-1 是正确的 , 那么对于 N 它也是正确的。 

在前面的绘图代码里 , 我们看到 star/4 就是这样 : 

star(_Win, 0, _A, _L) :- !. 





而前面我们计算阶乘时用到的 fact/2 也是这样 : 

clauses 

fact(0, 1) :- !. 

fact(N, N*F) :- 

fact(N-1, F). 

在 Visual Prolog 里 , 甚至于所有的 Prolog 语言里 , 递归是一个经常用到的方法 , 它使 

复杂问题得到简化的证明方法 , 而把冗长的过程交给速度很快的计算机来重复进行。

第 13.6 节利用递归方法画复杂曲线 

通过改变前面 curve.pro 内容 , 我们可以画出更为复杂的曲线 , 这就是递归方法产生的奇异 

效果。程序如下 : 




peano:(windowHandle, integer, real, integer) procedure (i, i, i, i). 

clauses 


peano(_Win, N, _A, _H) :- N

图 13.6.2 改变为 turtle::setstart(pnt(100, 80), -pi/4) 画出倾斜的曲线 

我们做一个有趣的实验 , 让我们体会更多。首先在 curve.cl 里增加谓词 addN/0: 

predicates 


drawCurve:(windowHandle). 

addN : () procedure. 

然后在 curve.pro 里增加 : 

class facts 

n:integer :=1. 

clauses 

addN():-n:=n+1,stdio::write(n). 

并修改 drawCurve/1 为如下 : 

drawCurve(Win) :- 


turtle::move(-60), peano(Win, n, pi/2, 5). 

最后双击 canvas.frm 进入 Properties/Events/MouseDblListener-onMouseDbl, 在双击增加 

代码如下到 canvas.pro 里 : 

predicates 

onMouseDbl : drawWindow::mouseDblListener. 

clauses 

onMouseDbl(Source, _Point, _ShiftControlAlt, _Button):- 

stdio :: write("\n You have double clicked, N ="), 

curve :: addN(), 

Source:invalidate(). 

们可以看到当 N 为不同值时 , 所画曲线的情况。当我们每次在 canvas 对话框上双击鼠 

标 ,Message 窗口就会显示当前 N 是几 , 双击一次增加 1, 图形也随之刷新。运行图如图 13.6.3

所示。 

图 13.6.3a N=1 图 13.6.3b N=2 

图 13.6.3c N=3 图 13.6.3d N=4 

图 13.6.3e N=5 图 13.6.3f N=6

图 13.6.3g N=7 图 13.6.3h N=8 

第 13.7 节语言处理 

Prolog 最大的特点是可以进行语言处理。下面我们我们按步骤这样操作 , 建立一个查字 

典提供语言帮助的小程序。 

按顺序操作 (1) 创建一个 language 为名字的 GUI Project。( 2)File/New in new package 

创建 editor 包 ; (3) 在 editor 包里增加 editorControl 模块。具体操作方法是 : 

File/Add—“\pfc\gui\controls\editorControl\editorcontrol.pack” 

接着 Build/Build。( 4) 在 editor 下创建 txtWin 对话框 Form, 并在其中增加 Custom Control, 

选择 editorControl (5) 在 editor 下创建 class “grammar”, 去掉 Create Objects 的选项。 

文件 grammar.cl 内容如下 : 

class grammar 

open core 

predicates 


dic:(string). 

end class grammar 

而 grammar.pro 文件内容如下 : 

implement grammar 

open core 

clauses 

classInfo( "editor/grammar", "1.0"). 

dic(S) :- 

stdio::write(S), stdio::nl. 

end implement grammar

使菜单项 File/New 为可用 , 并增加 File/New 点击事件代码 ( 操作方法为 “TaskWindow.win 

/Code Expert/Menu/TaskMenu/id_file/id_file_new”): 

predicates 


clauses 

onFileNew(S, _MenuTag) :- X= txtWin::new(S), X:show(). 

接下来 , 编辑 txtWin.frm, 点击 Help 按钮 , 选择其 Events 对话框 , 如图 13.7.1 所示 , 设置 

该按钮的点击反应器为 onHelpClick 双击增加代码到 txtwin.pro 里如下所示 : 

predicates 

onHelpClick : button::clickResponder. 

clauses 

onHelpClick(_Source) = button::defaultAction :- 

editorControl_ctl:getSelection(Start, End), 

Txt=editorControl_ctl:getText(Start, End), 

grammar::dic(Txt). 

图 13.7.1 增加 Help 按钮的代码 

打开 txtWin.pro, 看到原来 new/1 谓词如下 : 

clauses 

new(Parent):- 

formWindow::new(Parent), 

generatedInitialize(). 

我们把它修改为 : 

new(Parent):- 


generatedInitialize(), 

PossibleName= "Language.txt", 

tryGetFileContent(PossibleName, InputStr, _FileName), !, 

XX=string::concat("Here: ", InputStr),

editorControl_ctl:pasteStr(XX). 

增加谓词 tryGetFileContent/3 读取源文件到编辑器里。该谓词定义如下 : 


tryGetFileContent:( 

string FileName, 

string InputStr, 

string UpdatedFileName) procedure (i, o, o). 

clauses 

tryGetFileContent( "", "", "LsF.txt") :- !. 

tryGetFileContent(FileName, InputStr, FileName) :- 

trap(file::existFile(FileName), _TraceId, fail), !, 

InputStr= file::readString(FileName, _). 

tryGetFileContent(FileName, "", FileName). 

这里假设我们是对拉丁文进行帮助 , 我们预先把文件 language.txt 编辑好 , 放在当前的 exe 

目录里。放入下面文字如图 13.7.2 所示 , 这是程序运行如图 13.7.3 所示 , 可以把文件调入编 

辑器 , 并且在选中单词后 , 按钮 help 按下 , 会在 Message 窗口显示该单词。 

图 13.7.2 拉丁文原文

图 13.7.3 先测试选中文字的显示 

这时我们修改 grammar.pro 文件如下 : 

implement grammar 

open core, string 


strTok:(string, string_list) procedure (i, o). 

addExplanation:(string, string) procedure (i, o). 

class facts 

entry:(string, string). 

clauses 

classInfo( "editor/grammar", "1.0"). 

entry("que", "that"). 

entry("sine", "without"). 

entry("es", "am, are, is, was, were, to be"). 

entry("de", "of"). 

entry("et", "and"). 

addExplanation(T, R) :- 

entry(T, Meaning), !, 

R= format("%s= %s\n", T, Meaning). 

addExplanation(_T, ""). 

strTok(S, [T1|L]) :- 

frontToken(S, T, Rest), !, 

addExplanation(T, T1), 

strTok(Rest, L). 

strTok(_S, []). 

dic(S) :- strTok(S, SList), 

Resp= concatList(SList), 

stdio::write(Resp), stdio::nl. 

end implement grammar 

再运行 , 可以看到 , 它能够对选中的文字加以解释。如图 13.7.4 所示。

图 13.7.4 对原文进行解释 , 小小的帮助技巧 

第十四章 L- 系统 

人们总想办法寻求如何简单描绘植物。这里我们通过一个实例来说明。 

第 14.1 节画一棵树 

首先创建一个 GUI Project “Lsys”, 在其根目录下创建包 “aristid”; 在 “aristid” 下创建 

Form “canvas”, 另外创建一个 class “draw”, 不选择 “Create Objects”。使 File/New 可 

用 , 并用 Code Expert 增加代码在 taskWindow.pro 里如下所示 : 

predicates 


clauses 


X= canvas::new(S), X:show(). 

文件 draw.cl 内容如下 : 

class draw 


predicates 


tree:(windowHandle). 


文件 draw.pro 内容如下 : 



clauses 

classInfo("plotter/draw", "1.0"). 

domains 

command = t(commandList); f(integer); 

r(integer); m. 

commandList= command*. 

class facts 

pos:(real Delta, real Turn) single. 

grammar:(commandList) single. 


move:(windowHandle, pnt, real, commandList)

procedure (i, i, i, i). 

derive:(commandList, commandList) 

procedure (i, o). 

mv:(windowHandle, pnt, real, command, pnt, real) 

procedure (i,i, i, i, o, o). 

iter:(integer, commandList, commandList) 

procedure (i, i, o). 

clauses 

pos(4.0, 0.1745329). 

grammar([f(1)]). 

iter(0, S, S) :- !. 

iter(I, InTree, OutTree) :- 

derive(InTree, S), 

iter(I-1, S, OutTree). 

derive([], []) :- !. 

derive([f(0)|Rest], [f(0),f(0)|S]) :- !, 

derive(Rest, S). 

derive([f(_)|Rest], 

[f(0), t([r(1),f(1)]), f(0), 

t([r(-1),f(1)]), r(1), f(1)|S]) :- !, 


derive([t(Branches)|Rest], [t(B)|S]) :- !, 

derive(Branches, B), 


derive([X|Rest], [X|S]) :- derive(Rest, S). 

mv(Win, P1, Facing, f(_), P2, Facing) :- !, 

pos(Displacement, _Turn), 

P1= pnt(X1, Y1), 

X2= round( X1+ Displacement*cos(Facing)), 

Y2= round( Y1+Displacement*sin(Facing)), 

P2= pnt(X2, Y2), 

drawline(Win, P1, P2). 

mv(_Win, P1, Facing, m, P2, Facing) :- !, 


P1= pnt(X1, Y1), 


Y2= round(Y1+Displacement*sin(Facing)), 

P2= pnt(X2, Y2). 

mv(_Win, P1, Facing, r(Direction), P1, F) :- !, 

pos(_Displacement, Turn), 

F= Facing+ Direction*Turn. 

mv(Win, P1, Facing, t(B), P1, Facing) :- 

move(Win, P1, Facing, B). 

move(_Win, _P1, _Facing, []) :- !. 

move(Win, P1, Facing, [X|Rest]) :- 

mv(Win, P1, Facing, X, P, F), 

move(Win, P, F, Rest). 

tree(Win) :- grammar(Commands), 

iter(5, Commands, C), 

Facing= -pi/2, 

Point= pnt(100, 250),

move(Win, Point, Facing, C). 


先 Build/Build, 然后 , 编辑 canvas.frm, 在 Events 对话框里增加 onPaint 为 paintResponder 

的事件处理谓词 , 双击后在 canvas.pro 里增加代码如下 : 

predicates 


clauses 

onPaint(S, _Rectangle, _GDIObject) :- 

draw::tree(S:getVPIWindow()). 

运行一下 , 见图 14.1.1 所示。 

图 14.1.1 画出一棵树 

第 14.2 节如何才能画一棵树 

通过修改 tree/1 谓词 : 

tree(Win) :- grammar(Commands), 

iter(5, Commands, C), 

stdio::write("\nThe commands list is :\n",Commands,"==>", C), 

Facing= -pi/2, 

Point= pnt(100,100), 

move(Win, Point, Facing, C). 

我们看到 ,grammar/1 是提供了初始命令 , 由 iter/3 来形成最后的绘图命令 , 我们让形成的 

命令列表显示出来 , 它们是一串串命令序列如下所示 ( 部分 )。其中那个数字代表复杂程度。 

[f(1)]==> 

[f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0),

t([r(1),f(0),f(0),f(0),f(0),f(0),f(0),f(0),f(0), 

t([r(1),f(0),f(0),f(0),f(0), 

t([r(1),f(0),f(0), 

t([r(1),f(0), 

t([r(1),f(1)]),f(0), 

t([r(-1),f(1)]),r(1),f(1)]),f(0),f(0), 

t([r(-1),f(0), 

t([r(1),f(1)]),f(0), 

t([r(-1),f(1)]),r(1),f(1)]),r(1),f(0), 

t([r(1),f(1)]),f(0), 

t([r(-1),f(1)]),r(1),f(1)]),f(0),f(0),f(0),f(0), 

t([r(-1),f(0),f(0), 

t([r(1),f(0), 

t([r(1),f(1)]),f(0), 

t([r(-1),f(1)]),r(1),f(1)]),f(0),f(0), 

t([r(-1),f(0), 

………. 

而 pos(4.0, 0.1745329). 是指明了步长和倾角。我们执行 iter(1, Commands, C), 看到画树的命 

令序列是 :[f(0),t([r(1),f(1)]),f(0),t([r(-1),f(1)]),r(1),f(1)]。根据 : 

mv(Win, P1, Facing, f(_), P2, Facing) :- !, 


P1= pnt(X1, Y1), 


Y2= round( Y1+Displacement*sin(Facing)), 

P2= pnt(X2, Y2), 

drawline(Win, P1, P2). 

mv(_Win, P1, Facing, m, P2, Facing) :- !, 


P1= pnt(X1, Y1), 


Y2= round(Y1+Displacement*sin(Facing)), 

P2= pnt(X2, Y2). 

mv(_Win, P1, Facing, r(Direction), P1, F) :- !, 

pos(_Displacement, Turn), 

F= Facing+ Direction*Turn. 

mv(Win, P1, Facing, t(B), P1, Facing) :- 

move(Win, P1, Facing, B). 

可以解读为 f 代表画线 ,r 代表改变方向 , 其内数字代表方位改变的方向 ( 加角度还是减角 

度 ),t 代表分枝。所以这段命令可以解读为 : 向上画一段 , 然后画一个分枝 , 再上画一段 , 

另外一个方向画分枝 , 改变方向 , 画一段。把段长度改为 40, 比如 pos(40.0, 0.1745329). 如

下图 14.2.1 所示。 

图 14.2.1 画 3 个分枝最简单的图 

复杂的图不过是这些的反复而已如图 14.2.3 所示。N=2, 如图 14.2.2 所示。命令是 : 

[f(0),f(0), 

t([r(1), 

f(0), 

t([r(1),f(1)]), 

f(0), 

t([r(-1),f(1)]), 

r(1),f(1)]), 

f(0),f(0), 

t([r(-1),f(0), 

t([r(1),f(1)]), 

f(0), 

t([r(-1),f(1)]), 

r(1),f(1)]), 

r(1),f(0), 

t([r(1),f(1)]), 

f(0), 

t([r(-1),f(1)]), 

r(1),f(1)]。 

图 14.2.2 N=2 仿佛两个 N=1 的树形的复合

图 14.2.5 N=5 时 , 仿佛有 5 层这样的树复合而成 

第 14.3 节画出不同的树 

修改 derive/1, 可以改变分枝的方法 , 就可以画出不同的树。原来 : 


[f(0), t([r(1),f(1)]), f(0), 

t([r(-1),f(1)]), r(1), f(1)|S]) :- !, 


我们修改为 : 


[f(0), t([r(1),f(1),f(0),r(-1),f(1)]), f(0), 

t([r(-1),f(1)]), r(1), f(1)|S]) :- !, 


树就成了如图 14.3.1 所示形状。

图 14.3.1 改变树的形状 

第十五章游戏 

如果说普通的程序设计是写文章 , 那么编写游戏程序 , 就像写诗一样有难度。本章我们试图 

体验初步的游戏设计 , 也是为了证明 Visual Prolog 的超凡能力 : 游戏它也胜任。 

第 15.1 节游戏描述 

设计之前 , 要明确你的目标。在这里 , 我们要设计这样一个游戏 : 

(1) 有一个虫子 

(2) 在一个板子上爬 

(3) 我们可以通过上下左右来控制它的运动方向 

(4) 虫子触壁 , 则结束 ; 时间长 , 得分多。 

第 15.2 节游戏设计前的分析 

我们需要一个虫子的图像 , 需要设计一个 Form, 要在 Form 上设置边界、设置上下左右控 

制方向的按钮。要能显示计分、显示状态。程序逻辑分成两部分 : 一个描述虫子的状态和控 

制虫子运动的模块 , 一个计分和判断的模块。我们还需要定时器 , 让虫子不停地刷新状态 , 

不停前进。 

第 15.3 节游戏编程 

创建 Project “game”:

Project Name: game 

UI Strategy: Object-Oriented GUI (pfc/vpi) 

TargetType: Exe 

Base Directory: C\vip70 

Sub-Directory: game 

创建一个 Package “playground”, 在其下 , 首先创建 Form “lawn”, 设计成图 15.3.1 所示 

样子。 

图 15.3.1 游戏窗口 

然后 , 使 File/New 菜单项可用 , 并增加其代码到 taskWindow.pro 里 : 

predicates 


clauses 

onFileNew(S, _MenuTag) :- X= lawn::new(S), X:show(). 

接下来 , 在 playground 下创建 class “objState”, 保留 “Create Objects” 选项。该模块需要 

objstate.i 文件。该模块代码如下一一列举。 

文件 “objstate.i” 的代码 : 

interface objstate 


predicates 

init:(). 

turn:(integer, integer). 

mov:(). 

segm:(rct) nondeterm (o). 

end interface objstate 

文件 “objstate.cl” 的代码如下 : 

class objstate : objstate

end class objstate 

文件 “objstate.pro” 的代码如下 : 

implement objstate 


facts 

w:(integer, pnt) nondeterm. % worm 

d:(integer, integer) single. % direction 

clauses 

init() :- 

assert(w(1, pnt(110, 100))), 

assert(w(2, pnt(120, 100))), assert(w(3, pnt(130, 100))), 

assert(w(4, pnt(140, 100))), assert(w(5, pnt(140, 100))). 

d(10, 0). 

mov() :- 

retract(w(1, P)), P= pnt(X1, Y1), 

d(DX, DY), P1= pnt(X1+DX, Y1+DY), assert(w(1, P1)), 

retract(w(2, P2)), assert(w(2, P)), 

retract(w(3, P3)), assert(w(3, P2)), 


retract(w(5, _)), assert(w(5, P4)), !. 

mov(). 

segm(rct(X, Y, X+10, Y+10)) :- w(_, pnt(X, Y)). 

turn(DX, DY) :- assert(d(DX, DY)). 

end implement objstate 

在 playground 下创建 class “draw”, 这次去掉 “Create Objects” 选项。其代码如下。文件 

“draw.cl” 代码 : 

class draw 


predicates 


snapshot:(windowGDI Win, objstate). 


文件 “draw.pro” 代码 : 




draw:(windowHandle, objstate) procedure. 

clauses 

classInfo("playground/draw", "1.0"). 

draw(W, S) :- S:segm(Rectangle), 

vpi::drawEllipse(W, Rectangle), fail. 

draw(_W, _S).

snapshot(Win, S) :- 

S:mov(), !, 

Rectangle= rct(0, 0, 200, 200), 

W= pictOpen(Rectangle), 

draw(W, S), 

Pict= pictClose(W), 

Win:pictDraw(Pict, pnt(10, 10), rop_SrcCopy). 


增加一个 class “click” 来处理定时器工作。不选 “Create Objects”。文件 “click.cl” 代码如 

下 : 

class click 


predicates 

bip:(window). 

kill:(). 

end class click 

文件 “click.pro” 代码如下 : 

implement click 

open core 

class facts 

tm:vpiDomains::timerId := null. 

clauses 

bip(W) :- tm := W:timerSet(500). 

kill() :- vpi::timerKill(tm). 

end implement click 

然后 ,Build/Build 一下 , 编辑 lawn.frm, 进行如下设置 : 

图 15.3.2 关闭动作设置 

如图 15.3.2 所示 , 双击增加代码 : 

predicates 

onDestroy : window::destroyListener.

clauses 

onDestroy(_Source) :- click::kill(). 

图 15.3.3 显示动作设置 

如图 15.3.3 所示 , 双击增加代码如下 : 

predicates 

onShow : window::showListener. 

class facts 

stt:objstate := objstate::new(). 

clauses 

onShow(Parent, _CreationData) :- 

stt := objstate::new(), 

stt:init(), click::bip(Parent). 

图 15.3.4 设置 Up 按钮的代码 

如图 15.3.4 所示 , 双击增加按钮 Up 的代码如下 : 

predicates 

onUpClick : button::clickResponder. 

clauses 

onUpClick(_S) = button::defaultAction() :- 

stt:turn(0, -10).

图 15.3.5 向下按钮动作设置 


predicates 

onDownClick : button::clickResponder. 

clauses 

onDownClick(_S) = button::defaultAction() :- 

stt:turn(0, 10). 

图 15.3.6 向左按钮动作设置 


predicates 

onLeftClick : button::clickResponder. 

clauses 

onLeftClick(_S) = button::defaultAction() :- 

stt:turn(-10, 0). 

图 15.3.7 向右按钮动作设置 

如图 15.3.7 所示 , 双击增加代码如下 :

predicates 

onRightClick : button::clickResponder. 

clauses 

onRightClick(_S) = button::defaultAction() :- 


图 15.3.8 定时器动作设置 


predicates 

onTimer : window::timerListener. 

clauses 

onTimer(_Source, _TimerID) :- 

stt:mov(), 

R= rct(10, 10, 210, 210), 


图 15.3.9 重画动作设置 


predicates 


clauses 


draw::snapshot(GDIObject, stt).

运行图如图 15.3.10 所示。 

图 15.3.10 运行如图所示 

第 15.4 节游戏的说明 

在 draw.pro 里 ,snapshot/2 是绘出虫子所在位置的主要谓词。每次执行它 , 首先执行 S:mov(), 

它代表虫子的移动 , 先根据目前的方向 d(Dx,Dy), 来进行状态改变 , 然后 , 画出它的位置 

图。 

snapshot(Win, S) :- 

S:mov(), !, 

Rectangle= rct(0, 0, 200, 200), 

W= pictOpen(Rectangle), 

draw(W, S), 

Pict= pictClose(W), 

Win:pictDraw(Pict, pnt(10, 10), rop_SrcCopy). 

ectangle= rct(0, 0, 200, 200), W= pictOpen(Rectangle) 语句 , 是在 Rectangle 正方形区域内 , 

开辟一个绘图区域 , 代号为 W;draw(W, S) 则是在这个绘图区域内绘图 , 也即绘出虫子的位 

置状态 , 画出 5 个小圆圈。它们的实现是靠 draw/2 谓词实现的 : 

draw(W, S) :- S:segm(Rectangle), 

vpi::drawEllipse(W, Rectangle), fail. 

draw(_W, _S). 

draw/2 利用 S:segm(Rectangle) 获得目前虫子的位置正方形一个 10×10 的正方形 , 然后调用 

画出矩形中之椭圆方法 , 绘出虫子的 5 个圆的一个 , 用 fail 强制回溯 , 画出所有的 5 个部分。 

而 S:segm(Rectangle) 描述了虫子的各部分位置 , 在 objState.pro 里 : 

segm(rct(X, Y, X+10, Y+10)) :- w(_, pnt(X, Y)).

每次刷新 ,mov/0, 都会按照 d/2 的规定步长和方向 , 来修改各部分位置 : 头为新位置 , 其 

他部分后边的集成前边一节的位置。init/0 设定了虫子初始位置。 

clauses 

init() :- 

assert(w(1, pnt(110, 100))), 



d(10, 0). 

mov() :- 

retract(w(1, P)), P= pnt(X1, Y1), 

d(DX, DY), P1= pnt(X1+DX, Y1+DY), assert(w(1, P1)), 





mov(). 

所以可以看到 , 上下左右控制按钮 , 只是改变 d/2 而已。 

predicates 

onDestroy : window::destroyListener. 

clauses 

onDestroy(_Source) :- click::kill(). 

predicates 


class facts 


clauses 




predicates 

onUpClick : button::clickResponder. 

clauses 

onUpClick(_S) = button::defaultAction() :- 

stt:turn(0, -10). 

predicates 

onDownClick : button::clickResponder. 

clauses 

onDownClick(_S) = button::defaultAction() :- 


predicates 

onLeftClick : button::clickResponder.

clauses 

onLeftClick(_S) = button::defaultAction() :- 

stt:turn(-10, 0). 

predicates 

onRightClick : button::clickResponder. 

clauses 

onRightClick(_S) = button::defaultAction() :- 


predicates 


clauses 


stt:mov(), 

R= rct(10, 10, 210, 210), 


定时器的设置是在 click.pro 里 : 

class facts 


clauses 

bip(W) :- tm := W:timerSet(500). 

kill() :- vpi::timerKill(tm). 

而这样就把定时器和 lawn.frm 关联起来 : 

predicates 


class facts 


clauses 




第 15.5 节游戏的改进 

我们可以修改使虫子到达边界 , 就停止不动。在 objState.pro 里修改 mov/0 谓词如下 : 

mov() :- 

w(1, P),

P= pnt(X1, Y1), d(DX, DY), 

Xp1=X1+DX, Yp1=Y1+DY, 

not(Xp1199),not(Yp1199), 

P1= pnt(Xp1,Yp1 ), 

retract(w(1, P)),assert(w(1, P1)), 





mov(). 

注意我们增加了边界判断语句 not(Xp1199),not(Yp1199). 

而我们重新设计 lawn.frm 增加显示分数的 score 控件 , 如图 15.5.1 所示。 

图 15.5.1 增加计分控件 

然后修改 lawn.pro 里的 onPaint/3 如下 : 

predicates 


clauses 


draw::snapshot(GDIObject, stt), 

stt : getscore(X), Xx=string::format("%",X), 

score_ctl : settext(Xx). 

修改文件 objState.i 如下 , 增加 getScore/1 谓词 : 

interface objstate 


predicates 

init:(). 

turn:(integer, integer). 

mov:(). 

segm:(rct) nondeterm (o).

getscore:(integer)procedure (o). 

end interface objstate 

文件 ibjStae.pro 里修改 move/0, 增加 score 事实 , 增加语句 getScore/1, 修改后文件如下 : 

implement objstate 


facts 



score :integer :=0. 

clauses 

init() :- 

assert(w(1, pnt(110, 100))), 



d(10, 0). 

mov() :- 

w(1, P), 

P= pnt(X1, Y1), d(DX, DY), 

Xp1=X1+DX, Yp1=Y1+DY, 

not(Xp1199),not(Yp1199), 

P1= pnt(Xp1,Yp1 ), 

retract(w(1, P)),assert(w(1, P1)), 




retract(w(5, _)), assert(w(5, P4)), 

score:=score+100, 

!. 

mov():- 

score:=0, 

stdio::write("\nChange, change, it comes to the boundary!\n Score cleared."). 

segm(rct(X, Y, X+10, Y+10)) :- w(_, pnt(X, Y)). 

turn(DX, DY) :- assert(d(DX, DY)). 

clauses 

getscore(score). 

end implement objstate 

这样运行起来如图 15.5.2 所示。

图 15.5.2 带计分牌的虫子爬游戏 

第 15.6 节实体事实 Object Facts 

我们通常在一个 class 里声明 class facts, 比如前面用到的 : 

class facts 



clauses 




conn(pnt(30, 40) , pnt(100, 120)). 

conn(pnt(100, 120), pnt(100, 160)). 

这些事实 , 可以被 class 里所有的 obejcts 实体用到。实体谓词 (obejct predicates), 通常是指 

那些在 *.i 文件里声明的那些谓词 , 如果改变了这些事实 , 则 , 模块里所有实体都会接受到 

这种改变。这样 , 比如前面的虫子游戏 , 如果用 class facts 来保存虫子状态 , 则当一个游戏 

结束 , 另外一个要重新开始 , 会发现虫子不在初始状态位置。不同的实体之间 , 会共享 class 

facts。最好的办法是声明成 “facts”, 而不是 “class facts”。 

facts 



clauses 

init() :- assert(w(1, pnt(110, 100))),

d(10, 0). 



所以说 ,“facts” 声明的事实 , 可以称为实体事实 “Objects Facts”, 它们是实体私有的 , 

而不是同一类共有的特性。这一点 , 对于深入理解 class 很重要。 

第十六章几个有趣的部件 

这一章 , 我们介绍结果有趣的部件。 

第 16.1 节 TabControl 的应用 

创建一个 Project, 要求如下 : 

Name: tabForm 

UI Stategy: Object GUI 

然后 , 点击菜单项 File/Add, 从 Prolog 安装位置的目录开始 , 找到如下文件 : 

pfc\gui\controls\tabControl\tabControl.pack 

得到如图 16.1.1 所示的情形。 

图 16.1.1 加入 tabControl 到当前程序

第 16.1.1 节创建控件 

点击 File/New in Existing Package, 然后选择左边的 Controls 选项 , 建立一个控件 “helloTab”, 

如图 16.1.2 所示。 

图 16.1.2 建立控件 helloTab 

增加一个 Edit 控件、一个按钮 , 如图 16.1.3 所示 , 设计 helloTab 控件。 

图 16.1.3 设计 helloTab 控件 , 当前文件结构如图 16.1.4 所示 

图 16.1.4 程序文件树图状态 

然后 ,Build/Build 一下程序 , 这时程序文件结构图如 16.1.5 所示。然后双击进入编辑 

helloTab.ctl, 对按钮 “Your Name” 进行 ClickResponder 事件处理器设置为 onYourNameClick, 

增加程序代码到 helloTab.pro 里 , 如下 :

predicates 

onYourNameClick : button::clickResponder. 

clauses 

onYournameClick(_Source) = button::defaultAction :- 

Name= edit_ctl:getText(), 

Ans= string::concat("Hello, ", Name, "!\n"), 

stdio::write(Ans). 

图 16.1.6 设置 ClickResponder 为 onYourNameClick 

图 16.1.5 Build 后的文件结构图 

和这个控件创建方法一样 , 我们创建一个 “fibTab” 控件如图 16.1.6 所示。为 Fib 按钮增加 

代码如下所示 : 


fibo:(integer, integer) procedure (i, o). 

clauses 

fibo(N, F) :- 

if N

Num= edit_ctl:getText(), 

I= toTerm(Num), fibo(I, F), 

Ans= string::format("fibo(%d)= %d", I, F), 

edit_ctl:setText(Ans). 

图 16.1.6 fibTab 的设计样式 

第 16.1.2 使用 TabControl 

我们已经创建了两个控件 , 我们希望通过 TabControl 把他们组合在一起。首先创建一个名字 

为 tab 的 Form。并通过插入 Custom Control 的方法把 TabControl 放在对话框里 , 如图 16.1.7 

所示。 

图 16.1.7 增加 TabControl 到 tab Form 里 

Build/Build 一下程序 , 在目录树里点击 tab.pro, 右边会显示其谓词列表 , 如图 16.1.8 所示双 

击 new/1 谓词 , 然后进入 tab.pro, 发现 new/1 原来是这样的 : 

clauses 

new(Parent):- 


generatedInitialize().

图 16.1.8 双击 tab.pro 的 new 谓词 , 进入该文件相应谓词位置 

我们修改 new/1 的代码为如下 : 

clauses 

new(Parent):- 



% add tabControl content 

Page1 = tabPage::new(), 

Tab1 = helloTab::new(Page1:getContainerControl()), 

Page1:setText(Tab1:getText()), 

tabControl_ctl:addPage(Page1), 

Page2 = tabPage::new(), 

Tab2 = fibTab::new(Page2:getContainerControl()), 

Page2:setText(Tab2:getText()), 


succeed. 

然后修改任务菜单 File/New 使它能够操作 , 并增加代码如下 : 

predicates 


clauses 


W= tab::new(S), W:show(). 

运行一下 , 点击 File/New, 看看我们得到如图 16.1.9 所示。

图 16.1.9 得到 2 个页面的 Tab 

图 16.1.10 第一个页面输入名字按按钮得到问候 , 第二个页面可以对输入数字进行运算 

第 16.2 节 ListControl 的应用 

为了学习语言 , 西方语言有很多语气、时态的变化比如 : 

Latin 

Spanish 

Present Imperfect Present Imperfect 

amo amabam amo amaba 

amas amabas amas amabas 

amat amabat ama amaba 

amamus amabamus amamos amabamos 

我们来设计一个对照查询系统。 

我们创建一个 “myTab” 的 GUI project, 然后创建一个 “tabPackage” 包 , 在其下建立一个 

控件 “verbTab”, 如图 16.2.1 所示 ( 因为要使用 editorControl, 所以在应用 Custom Control 之 

前要用 File/Add 加入 “pfc\gui\controls\editorControl\editorControl.pack”)。注意 , 这些 

控件的代码名称分别设置为 : 

listVerb_ctl : listEdit. 

mood_ctl : editControl. 

tense_ctl : editControl. 

check_ctl : button. 

editorControl_ctl : editorcontrol.

图 16.2.1 verbTab 的设计 

我们如图 16.2.2 所示 , 对 verbTab 控件的 showListener 进行设置 , 并双击后增加如下代码 : 

predicates 


clauses 

onShow(_Source, _Data) :- 

VerbList= listVerb_ctl : tryGetVpiWindow(), 

verbs::allVerbs(L), 

vpi::lboxAdd(VerbList, L), 

vpi::lboxSetSel(VerbList, 0, 1), !, 

verbs:: get_verb_state(Tense, Mood), 

mood_ctl:setText(Mood), 

tense_ctl:setText(Tense). 

onShow(_Source, _Data). 

图 16.2.2 verbTab 的显示事件设置 

关于 listEdit Control 的使用 , 一下几点需要知道 : 

获得控件相对应的 Window, 要用 : 

“VerbList= listVerb_ctl : tryGetVpiWindow()” 

要获得当前选中的项目的索引要用 : 

“IV= vpi::lboxGetSelIndex(VerbList)”

删除某一个索引号对应的项目 , 要用 : 

“vpi::lboxDelete (VerbList, IV)” 

要获得列表中所有的项目总数 , 则用到 : 

“C= vpi::lboxCountAll(VerbList)”。 

当然 , 我们还要给 check 按钮增加代码 : 

predicates 

onCheckClick : button::clickResponder. 

clauses 

onCheckClick(_Source) = button::defaultAction :- 


Verb= listVerb_ctl:getText(), 

VerbList= listVerb_ctl : tryGetVpiWindow(), 

IV= vpi::lboxGetSelIndex(VerbList), !, 

Mood= mood_ctl:getText(), 

Tense= tense_ctl:getText(), 

verbs::pres_root_conj(Verb, Tense, Mood, L), 

if template::check_it(Txt, L, Ans) then 

editorControl_ctl:pasteStr(" "), 

vpi::lboxDelete (VerbList, IV) , 

C= vpi::lboxCountAll(VerbList), 

if C= 0 then 

verbs::next_verb_state(), 

verbs::get_verb_state(NewTense, NewMood), 

mood_ctl:setText(NewMood), 

tense_ctl:setText(NewTense), 

verbs::allVerbs(NewList), 

vpi::lboxAdd(VerbList, NewList) 

else 

succeed() 

end if, 

vpi::lboxSetSel(VerbList, 0, 1) 

else 

template::check_present(Txt, L, Ans), 

editorControl_ctl:pasteStr(Ans) 

end if. 

onCheckClick(_Source) = button::defaultAction.

图 16.2.3 设置 check 按钮的点击动作侦听器 

我们建立另外一个 Control, 名字叫做 “declensionTab”, 如图 16.2.4 所示。这个控件 , 它和 

前面建立的 verbTab 模样近似 , 我们可以用 Copy 的方法 , 复制某些控件及其布局 , 方法是 

打开前者按住 Ctrl 键 , 用鼠标点击所有控件 , 选中后按 “Ctrl+C”, 到新的对话框里 , 按 

“Ctrl+V”。这是一个技巧。 

图 16.2.4 declensionTab 控件的布局设计 

增加 check 按钮的 ClickResponder 为 onCheckClick, 代码如下 : 

predicates 

onCheckClick : button::clickResponder. 

clauses 

onCheckClick(_Source) = button::defaultAction :- 


Num= num_ctl:getText(), 

W= word_list_ctl:getText(), 

WordList=word_list_ctl: tryGetVpiWindow(), 

IV= vpi::lboxGetSelIndex( WordList), !, 

cases::declension(W, Num, L), 

if template::check_it(Txt, L, Ans) then 

editorControl_ctl:pasteStr(" "), 

vpi::lboxDelete (WordList, IV) , 

C= vpi::lboxCountAll(WordList), 

if C=0 then

cases::next_number_state(), 

cases::get_number_state(NewNum), 

num_ctl:setText(NewNum), 

cases::allWords(NewWs), 

vpi::lboxAdd(WordList, NewWs) 

else 

succeed() 

end if, 

vpi::lboxSetSel(WordList, 0, 1) 

else 

template::check_present(Txt, L, Ans), 

editorControl_ctl:pasteStr(Ans) 

end if. 

onCheckClick(_Source) = button::defaultAction. 

而整个控件显示 ShowListener 设为 onShow, 代码如下 : 

predicates 


clauses 


cases::get_number_state(Number), 

num_ctl:setText(Number), 

WordList= word_list_ctl : tryGetVpiWindow(), 

cases::allWords(Ws), 

vpi::lboxAdd(WordList,Ws), 

vpi::lboxSetSel(WordList, 0, 1), !. 


注意这里几个控件的代码名字为 : 

facts 

check_ctl : button. 

editorControl_ctl : editorcontrol. 

word_list_ctl : listEdit. 

num_ctl : editControl. 

同时 , 我们还要建立第三个控件 “pronunciationTab”。设计如图 16.2.5 所示。

图 16.2.5 pronunciationTab 控件增加 play 按钮 

这个控件 onShow 代码如下 : 

predicates 


clauses 


EditListHandle= listEdit_ctl : tryGetVpiWindow(), !, 

vpi::lboxAdd(EditListHandle, ["joubert", "newtoni", "newtonii", "newtoniii"]). 


而按钮 play 的 onPlayClick 代码如下 : 

predicates 

onPlayClick : button::clickResponder. 

clauses 

onPlayClick(_Source) = button::defaultAction :- 

File= listEdit_ctl:getText(), 

_ = playSound(File, 

null, /*snd_nodefault*/ snd_async+snd_filename). 

控件内的两个部件命名 : 

facts 

listEdit_ctl : listEdit. 

play_ctl : button. 

这个控件完成从列表框里选择声音文件然后播放 , 播放声音。用到 playSound/3 谓词 , 但这 

是一个外部程序 , 我们需要在控件开头声明 : 

resolve playSound externally 

然后还要增加如下定义 : 

domains 

soundFlag = unsigned32.


playSound : (string Sound, 

pointer HModule, 

soundFlag SoundFlag) 

-> booleanInt Success 

language apicall. 

constants 

snd_sync : soundFlag = 0x0000. 

/* play synchronously (default) */ 

snd_async : soundFlag = 0x0001. 

/* play asynchronously */ 

snd_nodefault : soundFlag = 0x0002. 

/* silence (!default) if sound not found */ 

snd_memory : soundFlag = 0x0004. 

/* Sound points to a memory file */ 

snd_loop : soundFlag = 0x0008. 

/* loop the sound until next sndplaysound */ 

snd_nostop : soundFlag = 0x0010. 

/* don't stop any currently playing sound */ 

snd_nowait : soundFlag = 0x00002000. 

/* don't wait if the driver is busy */ 

snd_alias : soundFlag = 0x00010000. 

/* name is a registry alias */ 

snd_alias_id : soundFlag = 0x00110000. 

/* alias is a predefined id */ 

snd_filename : soundFlag = 0x00020000. 

/* name is file name */ 

snd_resource : soundFlag = 0x00040004. 

/* name is resource name or atom */ 

snd_purge : soundFlag = 0x0040. 

/* purge non-static events for task */ 

snd_application : soundFlag = 0x0080. 

/* look for application specific association */ 

只有这样 , 播放声音才能正常工作 , 它是调用 Windows API 程序。这个例子对于我们有很 

重要的参考价值。然后创建一个 “query”Form, 其中 , 和第 16.1 节一样 ,File/Add 加入 

tabControl, 然后 Build/Build 一下啊 , 在编辑 query.frm, 插入 tabControl, 其界面如图 16.2.6 

所示。

图 16.2.6 query 插入 tabControl 

把 query.pro 里 new/1 语句修改为如下 : 

clauses 

new(Parent):- 



Page1= tabPage::new(), 

_Pronunciation = pronunciationTab::new(Page1:getContainerControl()), 

Page1:setText("Pronunciation"), 



_Declension = declensionTab::new(Page2:getContainerControl()), 

Page2:setText("Declension"), 



_Verb = verbTab::new(Page3:getContainerControl()), 

Page3:setText("Verbs"), 

tabControl_ctl:addPage(Page3). 

我们还要增加几个相应的模块 ,verbs、cases、template, 它们都要去掉 “Create Objects” 选 

项。其相应的代码如下罗列 : 

% verbs.cl 

class verbs 

open core 

predicates 


% @short Class information predicate. 

% @detail This predicate represents information predicate of this class. 

% @end 

read:(string File) procedure (i). 

allVerbs:(string* L) procedure (o). 

pres_root_conj:(string, string, string, string*) procedure (i, i, i, o).

get_verb_state:(string, string) procedure (o, o). 

next_verb_state:() procedure. 

end class verbs 

%verbs.pro 

implement verbs 


constants 

className = "verbs/verbs". 


domains 

conj= prima; secunda; tertia; quarta; mixta. 

class facts - verb_base 

verb:(string, string, string, string*) nondeterm. 

presRoot:(string, string, conj) nondeterm. 

verb_state:(string, string). 


dic_entry:(string) nondeterm (o). 

pres_ind:(string, string*) procedure (i, o). 

pres_subj:(string, string*) procedure (i, o). 

imperf_ind:(string, string*) procedure (i, o). 

imperf_subj:(string, string*) procedure (i, o). 

clauses 


verb_state("pres", "ind"). 

verb_state("pres", "subj"). 

verb_state("imperf", "ind"). 

verb_state("imperf", "subj"). 

pres_root_conj(V, "pres", "ind", L) :- !, pres_ind(V, L). 

pres_root_conj(V, "imperf", "ind", L) :- !, imperf_ind(V, L). 

pres_root_conj(V, "pres", "subj", L) :- !, pres_subj(V, L). 

pres_root_conj(V, "imperf", "subj", L) :- !, imperf_subj(V, L). 

pres_root_conj(_, _, _, []). 

pres_ind(V, L) :- verb(V, "ind", "pres", L), !. 

pres_ind(V, L) :- presRoot(V, Rt, prima), !, 

A1= concat(Rt, "O"), A2= concat(Rt, "AS"), A3= concat(Rt, "AT"), 

A4= concat(Rt, "AMUS"), A5= concat(Rt, "ATIS"), A6= concat(Rt, "ANT"), 

L= [A1, A2, A3, A4, A5, A6]. 

pres_ind(V, L) :- presRoot(V, Rt, secunda), !, 

A1= concat(Rt, "O"), A2= concat(Rt, "S"), A3= concat(Rt, "T"), 

A4= concat(Rt, "MUS"), A5= concat(Rt, "TIS"), A6= concat(Rt, "NT"), 

L= [A1, A2, A3, A4, A5, A6]. 

pres_ind(V, L) :- presRoot(V, Rt, tertia), !, 

A1= concat(Rt, "O"), A2= concat(Rt, "IS"), A3= concat(Rt, "IT"), 

A4= concat(Rt, "IMUS"), A5= concat(Rt, "ITIS"), A6= concat(Rt, "UNT"), 

L= [A1, A2, A3, A4, A5, A6]. 

pres_ind(V, L) :- presRoot(V, Rt, quarta), !, 

A1= concat(Rt, "IO"), A2= concat(Rt, "IS"), A3= concat(Rt, "IT"),

A4= concat(Rt, "IMUS"), A5= concat(Rt, "ITIS"), A6= concat(Rt, "IUNT"), 

L= [A1, A2, A3, A4, A5, A6]. 

pres_ind(V, L) :- presRoot(V, Rt, mixta), !, 

A1= concat(Rt, "IO"), A2= concat(Rt, "IS"), A3= concat(Rt, "IT"), 

A4= concat(Rt, "IMUS"), A5= concat(Rt, "ITIS"), A6= concat(Rt, "IUNT"), 

L= [A1, A2, A3, A4, A5, A6]. 

pres_ind(_V, []). 

pres_subj(V, L) :- verb(V, "subj", "pres", L), !. 

pres_subj(V, L) :- presRoot(V, Rt, prima), !, 

A1= concat(Rt, "EM"), A2= concat(Rt, "ES"), A3= concat(Rt, "ET"), 

A4= concat(Rt, "EMUS"), A5= concat(Rt, "ETIS"), A6= concat(Rt, "ENT"), 

L= [A1, A2, A3, A4, A5, A6]. 

pres_subj(V, L) :- presRoot(V, Rt, secunda), !, 

A1= concat(Rt, "AM"), A2= concat(Rt, "AS"), A3= concat(Rt, "AT"), 


L= [A1, A2, A3, A4, A5, A6]. 

pres_subj(V, L) :- presRoot(V, Rt, tertia), !, 

A1= concat(Rt, "AM"), A2= concat(Rt, "AS"), A3= concat(Rt, "AT"), 


L= [A1, A2, A3, A4, A5, A6]. 

pres_subj(V, L) :- presRoot(V, Rt, quarta), !, 

A1= concat(Rt, "IAM"), A2= concat(Rt, "IAS"), A3= concat(Rt, "IAT"), 

A4= concat(Rt, "IAMUS"), A5= concat(Rt, "IATIS"), A6= concat(Rt, "IANT"), 

L= [A1, A2, A3, A4, A5, A6]. 

pres_subj(V, L) :- presRoot(V, Rt, mixta), !, 

A1= concat(Rt, "IAM"), A2= concat(Rt, "IAS"), A3= concat(Rt, "IAT"), 

A4= concat(Rt, "IAMUS"), A5= concat(Rt, "IATIS"), A6= concat(Rt, "IANT"), 

L= [A1, A2, A3, A4, A5, A6]. 

pres_subj(_V, []). 

imperf_ind(V, L) :- verb(V, "ind", "imperf", L), !. 

imperf_ind(V, L) :- presRoot(V, Rt, prima), !, 

A1= concat(Rt, "ABAM"), A2= concat(Rt, "ABAS"), A3= concat(Rt, "ABAT"), 

A4= concat(Rt, "ABAMUS"), A5= concat(Rt, "ABATIS"), A6= concat(Rt, "ABAN 

T"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_ind(V, L) :- presRoot(V, Rt, secunda), !, 

A1= concat(Rt, "BAM"), A2= concat(Rt, "BAS"), A3= concat(Rt, "BAT"), 

A4= concat(Rt, "BAMUS"), A5= concat(Rt, "BATIS"), A6= concat(Rt, "BANT"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_ind(V, L) :- presRoot(V, Rt, tertia), !, 

A1= concat(Rt, "EBAM"), A2= concat(Rt, "EBAS"), A3= concat(Rt, "EBAT"), 

A4= concat(Rt, "EBAMUS"), A5= concat(Rt, "EBATIS"), A6= concat(Rt, "EBAN 

T"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_ind(V, L) :- presRoot(V, Rt, quarta), !, 

A1= concat(Rt, "IEBAM"), A2= concat(Rt, "IEBAS"), A3= concat(Rt, "IEBAT"), 

A4= concat(Rt, "IEBAMUS"), A5= concat(Rt, "IEBATIS"), A6= concat(Rt, "IEBA 

NT"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_ind(V, L) :- presRoot(V, Rt, mixta), !, 

A1= concat(Rt, "IEBAM"), A2= concat(Rt, "IEBAS"), A3= concat(Rt, "IEBAT"), 

A4= concat(Rt, "IEBAMUS"), A5= concat(Rt, "IEBATIS"), A6= concat(Rt, "IEBA 

NT"), 

L= [A1, A2, A3, A4, A5, A6].

imperf_ind(_V, []). 

imperf_subj(V, L) :- verb(V, "subj", "imperf", L), !. 

imperf_subj(V, L) :- presRoot(V, Rt, prima), !, 

A1= concat(Rt, "AREM"), A2= concat(Rt, "ARES"), A3= concat(Rt, "ARET"), 

A4= concat(Rt, "AREMUS"), A5= concat(Rt, "ARETIS"), A6= concat(Rt, "AREN 

T"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_subj(V, L) :- presRoot(V, Rt, secunda), !, 

A1= concat(Rt, "REM"), A2= concat(Rt, "RES"), A3= concat(Rt, "RET"), 

A4= concat(Rt, "REMUS"), A5= concat(Rt, "RETIS"), A6= concat(Rt, "RENT"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_subj(V, L) :- presRoot(V, Rt, tertia), !, 

A1= concat(Rt, "EREM"), A2= concat(Rt, "ERES"), A3= concat(Rt, "ERET"), 

A4= concat(Rt, "EREMUS"), A5= concat(Rt, "ERETIS"), A6= concat(Rt, "ERENT 

"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_subj(V, L) :- presRoot(V, Rt, quarta), !, 

A1= concat(Rt, "IREM"), A2= concat(Rt, "IRES"), A3= concat(Rt, "IRET"), 

A4= concat(Rt, "IREMUS"), A5= concat(Rt, "IRETIS"), A6= concat(Rt, "IRENT"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_subj(V, L) :- presRoot(V, Rt, mixta), !, 

A1= concat(Rt, "EREM"), A2= concat(Rt, "ERES"), A3= concat(Rt, "ERET"), 

A4= concat(Rt, "EREMUS"), A5= concat(Rt, "ERETIS"), A6= concat(Rt, "ERENT 

"), 

L= [A1, A2, A3, A4, A5, A6]. 

imperf_subj(_V, []). 

dic_entry(V) :- verb(V, "ind", "pres", _). 

dic_entry(V) :- presRoot(V, _, _). 

verb("SUM", "ind", "pres", ["SUM", "ES", "EST", "SUMUS", "ESTIS", "SUNT"]). 

verb("SUM", "ind", "imperf", ["ERAM", "ERAS", "ERAT", "ERAMUS", "ERATIS", "ERANT"]). 

verb("VOLO", "ind", "pres", ["VOLO", "VIS", "VULT", "VOLUMUS", "VULTIS", "VOLUNT"]). 

verb("VOLO", "ind", "imperf", ["VOLEBAM", "VOLEBAS", "VOLEBAT", "VOLEBAMUS", "V 

OLEBATIS", "VOLEBANT"]). 

verb("SUM", "subj", "pres", ["SIM", "SIS", "SIT", "SIMUS", "SITIS", "SINT"]). 

verb("SUM", "subj", "imperf", ["ESSEM", "ESSES", "ESSET", "ESSEMUS", "ESSETIS", "ESSE 

NT"]). 

verb("VOLO", "subj", "pres", ["VELIM", "VELIS", "VELIT", "VELIMUS", "VELITIS", "VELIN 

T"]). 

verb("VOLO", "subj", "imperf", ["VELLEM", "VELLES", "VELLET", "VELLEMUS", "VELLET 

IS", "VELLENT"]). 

presRoot("AMO", "AM", prima). 

presRoot("VIDEO", "VIDE", secunda). 

read(File) :- 

retractFactDb(verb_base), 

file::consult(File, verb_base). 

allVerbs(L) :- L= [Q || dic_entry(Q)]. 

next_verb_state() :- retract(verb_state(_,_)), !. 

next_verb_state(). 

get_verb_state(X, Y) :- verb_state(X, Y), !. 

get_verb_state("none", "none").

end implement verbs 

%cases.cl 

class cases 

open core 

predicates 




% @end 

read:(string File) procedure (i). 

allWords:(string* L) procedure (o). 

declension:(string, string, string*) procedure (i, i, o). 

get_number_state:(string) procedure (o). 

next_number_state:() procedure. 

end class cases 

%cases.pro 

implement cases 


constants 

className = "cases/cases". 


domains 

declens= prma; snda; trtum; trtium; trtii; qrta; qnta; nsnda; ntrtum; ntrtium. 

class facts - noun_base 

wrd:(string, string, string*) nondeterm. 

decl:(string, string, declens) nondeterm. 

num_state:(string). 

clauses 


num_state("singular"). 

num_state("plural"). 

wrd("ROSA", "singular", ["ROSA", "ROSAE", "ROSAE", "ROSA", "ROSAM"]). 

wrd("ROSA", "plural", ["ROSAE", "ROSARUM", "ROSIS", "ROSIS", "ROSAS"]). 

wrd("PUER", "singular", ["PUER", "PUERI", "PUERO", "PUERO", "PUERUM"]). 

wrd("PUER", "plural", ["PUERI", "PUERORUM", "PUERIS", "PUERIS", "PUEROS" 

]). 

decl("DOMINUS", "DOMIN", snda). 

declension(W, N, L) :- wrd(W, N, L), !. 

declension(W, "singular", L) :- decl(W, Root, prma), !, 

N= W, G= concat(Root, "AE"), D= concat(Root, "AE"), 

Abl= concat(Root, "A"), Acc= concat(Root, "AM"), 

L= [N, G, D, Abl, Acc]. 

declension(W, "plural", L) :- decl(W, Root, prma), !,

N= concat(Root, "AE"), G= concat(Root, "ARUM"), D= concat(Root, "IS"), 

Abl= concat(Root, "IS"), Acc= concat(Root, "AS"), 


declension(W, "singular", L) :- decl(W, Root, snda), !, 

N= W, G= concat(Root, "I"), D= concat(Root, "O"), 

Abl= concat(Root, "O"), Acc= concat(Root, "UM"), 


declension(W, "plural", L) :- decl(W, Root, snda), !, 

N= concat(Root, "I"), G= concat(Root, "ORUM"), D= concat(Root, "IS"), 

Abl= concat(Root, "IS"), Acc= concat(Root, "OS"), 


declension(W, "singular", L) :- decl(W, Root, nsnda), !, 

N= W, G= concat(Root, "I"), D= concat(Root, "O"), 

Abl= concat(Root, "O"), Acc= concat(Root, "UM"), 


declension(W, "plural", L) :- decl(W, Root, nsnda), !, 

N= concat(Root, "A"), G= concat(Root, "ORUM"), D= concat(Root, "IS"), 

Abl= concat(Root, "IS"), Acc= concat(Root, "A"), 


declension(W, "singular", L) :- decl(W, Root, trtium), !, 

N= W, G= concat(Root, "IS"), D= concat(Root, "I"), 

Abl= concat(Root, "E"), Acc= concat(Root, "EM"), 


declension(W, "plural", L) :- decl(W, Root, trtium), !, 

N= concat(Root, "ES"), G= concat(Root, "IUM"), D= concat(Root, "IBUS"), 

Abl= concat(Root, "IBUS"), Acc= concat(Root, "ES"), 


declension(W, "singular", L) :- decl(W, Root, trtum), !, 


Abl= concat(Root, "E"), Acc= concat(Root, "EM"), 


declension(W, "plural", L) :- decl(W, Root, trtum), !, 

N= concat(Root, "ES"), G= concat(Root, "UM"), D= concat(Root, "IBUS"), 



declension(W, "singular", L) :- decl(W, Root, ntrtum), !, 


Abl= concat(Root, "E"), Acc= W, 


declension(W, "plural", L) :- decl(W, Root, ntrtum), !, 

N= concat(Root, "A"), G= concat(Root, "UM"), D= concat(Root, "IBUS"), 

Abl= concat(Root, "IBUS"), Acc= concat(Root, "A"), 


declension(W, "singular", L) :- decl(W, Root, ntrtium), !, 


Abl= concat(Root, "I"), Acc= W, 


declension(W, "plural", L) :- decl(W, Root, ntrtium), !, 

N= concat(Root, "IA"), G= concat(Root, "IUM"), D= concat(Root, "IBUS"), 

Abl= concat(Root, "IBUS"), Acc= concat(Root, "IA"), 


declension(W, "singular", L) :- decl(W, Root, trtii), !, 


Abl= concat(Root, "I"), Acc= concat(Root, "EM"), 


declension(W, "plural", L) :- decl(W, Root, trtum), !, 

N= concat(Root, "ES"), G= concat(Root, "IUM"), D= concat(Root, "IBUS"),



declension(_W, _, []). 

read(File) :- 

retractFactDb(noun_base), 

file::consult(File, noun_base). 

allWords(Wrds) :- Wrds= [Q || wrd(Q, "singular", _); decl(Q, _, _)]. 

next_number_state() :- retract(num_state(_)), !. 

next_number_state(). 

get_number_state(X) :- num_state(X), !. 

get_number_state("none"). 

end implement cases 

%template.cl 

class template 

open core 

predicates 




% @end 

check_present:(string, string*, string) procedure (i, i, o). 

check_it:(string, string*, string) determ (i,i,o). 

end class template 

%template.pro 

implement template 

open core 

constants 

className = "template/template". 


class facts 

points:integer := 0. 


compare:(string*, string*, string, string) procedure (i, i, i, o). 

checkAnswer:(string, string, string) procedure (i, i, o). 

clauses 


checkAnswer(X, Y, Ans) :- string::equalIgnoreCase(X, Y), !, Ans= string::concat(X, "=" 

, Y, "\n").

checkAnswer(X, Y, Ans) :- Ans= string::concat(X, "", Y, "\n"), points := points+1, st 

dio::write("Points= ", points), stdio::nl. 

compare([""|R], L, Partial, Ans) :- !, compare(R, L, Partial, Ans). 

compare([X|Xs], [Y|Ys], Partial, Ans) :- !, 

checkAnswer(X, Y, T), 

PP= string::concat(Partial, T), 

compare(Xs, Ys, PP, Ans). 

compare([], [], Partial, Ans) :- !, Ans= Partial. 

compare(_, _, Partial, Ans) :- Ans= string::concat(Partial, "\nsomething is wrong"). 

check_present(Txt, L, Ans) :- Ts= string::split(Txt, " \n"), 

compare(Ts, L, "", Ans). 

check_it(Txt, L, Ans) :- points := 0, 

Ts= string::split(Txt, " \n"), 

compare(Ts, L, "", Ans), 

points=0. 

end implement template 

我们创建一个 needs 包 , 把这三个模块放在其中 , 最后修改 File/New, 增加 : 

predicates 


clauses 


W= query::new(S), W:show(). 

还要把需要调用的几个声音文件 , 放到 exe 文件夹里 , 如图 16.2.7 所示。 

图 16.2.7 声音文件放到 exe 文件夹里 

运行一下啊。我们看到一个 TAB 框 , 既可以验证你的答案 , 也可以播放声音。 

第 16.3 节 treeView Control、listView Control 

这一节 , 通过例子我们来接触 treeView Control 的使用。我们设计一个浏览 Prolog 源文件的 

对话框。建立一个工程 “proFileViewer”。创建一个包 “viewerDialog”, 在其下建立一个

“browserDialog” 的 Dialog, 如图 16.3.1 所示。 

图 16.3.1 创建 browserDialog,rct(20,20,372,396) 设置外形参数 

用 “File/Add” 逐个加入 treeViewControl、EditorControl、MessageControl、listViewControl 

后 ,Build/Build 一下 , 设计成如图 16.3.2 所示外形。 

图 16.3.2 设计对话框外形 

我们用 Code Expert 增加 onShow 代码到 taskWindow.pro 里 , 如下 : 

predicates 


clauses 

onShow(_, _CreationData):- 

BrowserDialog = browserDialog::new(This), 

BrowserDialog:show(), 

destroy().

运行一下 , 界面如图 16.3.3, 直接进入对话框 ; 而当我们关闭对话框 , 则程序也关闭。这个 

技巧 , 是我们去掉程序外壳的一个办法。 

图 16.3.3 界面图 

然后我们把各个控件定义成如下名字 ( 当然可以按照自己的爱好 ): 

facts 

ok_ctl : button. 

location_ctl : editControl. 

go_ctl : button. 

treeView_ctl : treeviewcontrol. 

listView_ctl : listviewcontrol. 

editor_ctl : editorcontrol. 

msg_ctl : messagecontrol. 

设置 onShow, 在显示对话框时的代码 : 

predicates 


clauses 

onShow(_Source, _CreationData) :- 

setIcon(application_icon), 

_ = onGo(go_ctl). 

而 onGo 按钮 , 是对输入框的地址输入做出的反应 : 

predicates 

onGo : button::clickResponder.

clauses 

onGo(_Source) = button::defaultAction() :- 

treeView_ctl:deleteItem(wcc_Null), 

listView_ctl:deleteAllItems(), 

cursorSet(cursor_Wait), 

checkValidPath(), 

!, 

processDirectory(location_ctl:getText(), wcc_null), 

cursorSet(cursor_Arrow), 

treeView_ctl:expand(treeView_ctl:getChildItem(wcc_null)), 

treeView_ctl:select(treeView_ctl:getChildItem(wcc_null)). 

onGo(_) = button::defaultAction :- 

vpiCommonDialogs::error( 

string::format("Cannot show \"%s\" directory!", location_ctl:getText())). 

在这里我们可以看到 : 

treeView_ctl:deleteItem(wcc_Null), 



是对树形浏览器、列表浏览器清空、设置光标。然后检查地址输入的是否合适 ? 用到内部谓 

词 checkValidPath() 其代码如下 : 

predicates 

checkValidPath : () determ. 

clauses 

checkValidPath() :- 

Text = location_ctl:getText(), 

trap( string::front(Text, string::length(Text) - 1, Text1, End), 

_TraceId,fail), 

End = "\\", 

location_ctl:setText(Text1), 

fail. 

checkValidPath() :- 

directory::existDirectory(location_ctl:getText()). 

然后是 processDirectory/2 处理对当前目录的显示等 : 

predicates 

processDirectory : (string DirectoryToInspect, treeViewControl::itemId ParentId). 

clauses 

processDirectory(DirectoryToInspect, ParentId):- 

ItemId = getNextId(),

treeView_ctl:insertItem(ItemId, ParentId, treeViewControl::sorted(), 

nameOrFullName(ParentId, DirectoryToInspect), 

[/*treeViewControl::expanded()*/], resId(idb_OpenFileBitmap), resId(idb_Ope 

nFileBitmap)), 

SubDirectory = directory::getSubDirectories_nd(DirectoryToInspect), 

SubDirectoryShort = fileName::getName(SubDirectory), 

SubDirectoryShort "", 

SubDirectoryShort ".", 

processDirectory(SubDirectory, ItemId), 

fail. 

processDirectory(_, _). 

predicates 

nameOrFullName : (treeViewControl::itemId, string) -> string procedure. 

clauses 

nameOrFullName(wcc_null, FullName) = FullName :- 

!. 

nameOrFullName(_, Directory) = Name :- 

filename::getPathAndName(Directory, _, Name). 

predicates 

addFiles : (string DirectoryToInspect). 

clauses 

addFiles(DirectoryToInspect):- 

File = directory::getFilesInDirectory_nd(DirectoryToInspect), 

file::getFileProperties(File, _, Size, _, _, GmtTimeValue), 

Time = time::newFromGMT(GmtTimeValue), 

Size = unsigned64(Size1,_), 

fileName::getPathAndName(File, _, Name), 

Id = getNextId(), 

FT = Time:formatTime(), 

listView_ctl:insertItem(item(Id, Name, 

idb_NewFileBitmap, %resid(idb_NewFileBitmap), 

[], [FT, toString(Size1)])), 

fail. 

addFiles(_). 

facts 

lastId : treeViewControl::itemId := 10. 

predicates 

getNextId : () -> treeViewControl::itemId. 

clauses 

getNextId() = lastId :- 

lastId := lastId + 1.

要对 Dialogue 的 new() 进行修改 : 

clauses 

new(Parent) :- 

dialog::new(Parent), 


stdio::setOutputStream(msg_ctl:getOutputStream()), 

listView_ctl:insertColumnList(1, columnList), 

listView_ctl:setLvType(lvs_report), 

listView_ctl:setStyle([lvs_showselalways,lvs_editlabels,lvs_autoarrange,lvs_singl 

esel]), 

listView_ctl:addSelectEndListener(onListSelectEnd), 

listView_ctl:setSelectBeginResponder(onListSelectBegin), 

treeView_ctl:addSelectEndListener(onTreeSelect), 

location_ctl:setText(initialPath(directory::getCurrentDirectory())), 

editor_ctl:setFileName("file.pro"). % for coloring 

然后对 listControl 进行设置 : 

constants 

columnList : listViewControl::column_list = [ 

column("File",100,alignleft), 

column("Time",70,alignright), 

column("Size",70,alignright) ]. 

prologExtensions : core::string_list = ["cl","i","pro","pack","ph","txt"]. 

predicates 

onListSelectEnd : listViewControl::selectEndListener. 

clauses 

onListSelectEnd(List, ItemId, true) :- 

item(_,Name,_,_,_) = List:getItem(ItemId), 

File = string::concat(folder_FullPath(treeView_ctl:getSelected()), @"\", Name), 

file::existFile(File), 

editor_ctl:pasteStr(""), 

trap(String = file::readString(File, _), _TraceId, 

fail), 

!, 

editor_ctl:pasteStr(String). 

onListSelectEnd(_, _, _). 

predicates 

onListSelectBegin : listViewControl::selectBeginResponder. 

clauses 

onListSelectBegin(List, ItemId, true) = listViewControl::acceptSelect :-

item(_,Name,_,_,_) = List:getItem(ItemId), 

member(string::toLowerCase(filename::getExtension(Name)), prologExtensions), 

!. 

onListSelectBegin(_, _, true()) = listViewControl::cancelSelect() :- 

!. 

onListSelectBegin(_, _, _) = listViewControl::acceptSelect(). 

图 16.3.4 设置 ListViewControl 的选择 

再对 treeViewControl 进行设置 : 

predicates 

onTreeSelect : treeViewControl::selectEndListener. 

clauses 

onTreeSelect(_, _, ItemId) :- 

ItemId wcc_null, 

!, 

DirectoryToFill = folder_FullPath(ItemId), 



addFiles(DirectoryToFill), 

cursorSet(cursor_Arrow). 

onTreeSelect(_,_,_). 

predicates 

folder_FullPath : (treeViewControl::itemId) -> string procedure. 

clauses 

folder_FullPath(ItemId) = Text :- 

wcc_null = treeView_ctl:getParentItem(ItemId), 

!, 

treeView_ctl:getItem(ItemId, Text, _, _, _). 

folder_FullPath(ItemId) = string::concat(ParentPath, "\\", Text) :- 

ParentPath = folder_FullPath(treeView_ctl:getParentItem(ItemId)), 

treeView_ctl:getItem(ItemId, Text, _, _, _). 

class predicates

member : (string, string_list) determ. 

clauses 

member(S, [S|_]) :- 

!. 

member(S, [_|L]) :- 

member(S, L). 

图 16.3.5 设置 treeViewControl 的选择后动作 

然后 , 把 open 语句修改为 : 

open core, vpiDomains, resourceIdentifiers, listViewControl, treeViewControl, stdio 

增加 initialPath/1 

predicates 

initialPath : (string) -> string. 

clauses 

initialPath(S) = InitialPath :- 

Path = fileName::getPath(S), 

Len = string::length(Path), 

Len > 2, 

string::front(Path, Len-1, InitialPath, Slash), 

Slash = "\\", 

!. 

initialPath(S) = S. 

这样就可以了。运行如图所示。

图 16.3.6 运行效果 , 浏览文件 

第十七章动画 

我们还要复习使用 GDIobjects 来实现动画。我们创建一个 project, 描述如下 : 

Project Name: rattlesnake 


创建一个包 “snake”。在此包内创建一个 Form, 名字 “canvas”。然后建立一个 class, 名字 

“click”, 注意不选中 “Create Objects”。这个模块的代码如下 : 

%click.cl 

class click 

open core 

predicates 

bip:(window). 

kill:(window). 

end class click 

%click.pro 

implement click 

open core 

class facts 


clauses

ip(W) :- tm := W:timerSet(1000). 

kill(W) :- W:timerKill(tm). 

end implement click 

这个模块是一个定时器模块。设定 1000ms 触发一次 ,bip/1 来实现 ;kill/1 来清除定时器。 

然后我们操作 “ TaskWindow.win/CodeExpert/Menu/TaskMenu/id_file/id_file_new ” 设置 

File/New 菜单项 : 

predicates 


clauses 


F= canvas::new(S), F:show(), click::bip(F). 

第 17.1 节 

绘图 

我们创建 “dopaint”class 来处理绘图。文件 dopaint.cl 如下 : 

class dopaint 

open core 

predicates 


draw:(windowGDI). 

invalidrectangle:(vpiDomains::rct) procedure (o). 


而文件 “dopaint.pro” 如下 : 



constants 

className = "snake/snakestate". 


class facts 

yesno:integer := 0. 


flipflop:(picture Picture, 

picture Mask) determ (o, o). 

clauses 

classInfo(className, classVersion).

flipflop(Pict, Mask) :- yesno= 0, 

yesno := 1, 

Pict= vpi::pictLoad("figs\\n0.bmp"), 

Mask= vpi::pictLoad("figs\\n0Mask.bmp"), !. 


yesno := 0, 


Mask= vpi::pictLoad("figs\\n1Mask.bmp"). 

draw(W) :- 

P= vpi::pictLoad("figs\\frogs.bmp"), 


flipflop(Snake, Mask), !, 

W:pictDraw(Mask, pnt(40, 50), rop_SrcAnd), 

W:pictDraw(Snake, pnt(40, 50), rop_SrcInvert). 

draw(_). 

invalidRectangle(rct(40, 50, 100, 100)). 


我么还要准备几个图片文件放在 “exe\figs” 目录之下 , 如图 17.1.1 所示。 

图 17.1.1 相关的 5 个图片 

第 17.2 节定时器的使用 

在 canvas 面板启动时 , 应该启动定时器 : 

clauses 


F= canvas::new(S), F:show(), click::bip(F).

在 canvas 关闭时 , 也应该销毁定时器 : 

predicates 

onDestroy : window::destroyListener. 

clauses 

onDestroy(W) :- click::kill(W). 

而定时器出发时 , 执行 onTimer 任务 : 

predicates 


clauses 


dopaint::invalidRectangle(R), 


绘图任务是由 onPaint 来执行的 , 它调用 dopaint 的 draw/1 谓词实现绘图 : 

predicates 


clauses 


dopaint::draw(GDIObject). 

这些事件都要在 canvas.frm 的 Events 对话框设置 , 如图 :

图 17.2.1 设置和定时器工作有关的事件侦听器 

第 17.3 节动画是怎么实现的 ? 

执行一下 , 如图 17.3.1 所示。 

图 17.3.1 每隔一秒钟 , 这两幅图画交替出现 , 仿佛蛇在扭头的动画 

谓词 draw/1 在绘制图形 : 

flipflop(Pict, Mask) :- yesno= 0,

yesno := 1, 


Mask= vpi::pictLoad("figs\\n0Mask.bmp"), !. 


yesno := 0, 


Mask= vpi::pictLoad("figs\\n1Mask.bmp"). 

draw(W) :- 




W:pictDraw(Mask, pnt(40, 50), rop_SrcAnd), 

W:pictDraw(Snake, pnt(40, 50), rop_SrcInvert). 

draw(_). 

先绘青蛙背景 , 然后判断该画哪个蛇 ,flipflop/2 是根据 yesno 标志 , 来确定应该用那两张图 

片。Mask 在背景上挖出一个蛇形 , 然后在这个位置合并上蛇图片。如此交替 , 就有动画效 

果了。 

第 17.4 节改进动画程序 

我们设置一个鼠标事件 : 

在 dopaint.pro 里增加 : 

class facts 

snake : pnt :=pnt(40,50). 

clauses 

setSnake(X):-snake:=X. 

修改 : 

draw(W) :- 




W:pictDraw(Mask, snake, rop_SrcAnd), 

W:pictDraw(Snake, snake, rop_SrcInvert). 

draw(_). 

invalidRectangle(rct(0, 0, 200, 200)).

在 dopaint.cl 里增加 setSnake/1: 

setSnake: (vpiDomains::pnt) procedure (i). 

在 canvas.frm 下设置鼠标点击事件 , 增加代码 : 

predicates 


clauses 

onMouseDown(_Source, Point, _ShiftControlAlt, _Button):- 

dopaint::setsnake(Point), 

invalidate(). 

这样鼠标点击之处 , 蛇也会移动到这里。如图 17.4.1 所示。 

图 17.4.1 点击后蛇位置移动 

第十八章相关资料介绍、索引 

这一章 , 希望通过介绍一下相关的资料 , 希望能对学习者 , 有进一步的帮助。因为这本书只 

是起步 , 而更进一步的学习 , 是一个不断积累的过程。 

第 18.1 节 Prolog 书籍 

我这里对 Visual Prolog 5 的读者或者爱好者 , 推荐这样几本书 , 但恐怕也很难买到了。 

我知道在国内 , 这个语言并不很商业化 , 这是国人之不幸也。本人此小书 , 不过稍稍弥补缺 

憾而已。

《Visual Prolog 语言教程》 

作者 : 雷英杰 , 张雷 , 邢清华 , 孙金萍 

出版社 : 陕西科学技术出版社 

本书全面系统介绍 Visual Prolog 语言及其编程。全书共分四个部分 , 第一部分简短介绍 

Visual Prolog 可视化开发环境 ; 第二部分包括教程的第 2 章至第 11 章 , 教你如何学会用 Visual 

Prolog 编程 ; 第三部分包括第 12 章至第 16 章 , 详细叙述 Visual Prolog 的预定义特性 ; 第四 

部分包括第 17 章至第 18 章 , 完整而系统地叙述语言元素和模块化程序设计 , 以及与其它语 

言的接口。 

《Visaul Prolog 编程、环境及接口》 

作者 : 雷英杰 , 邢清华 , 孙金萍 , 张雷 

出版社 : 国防工业出版社 

出版时间 :2004 年 1 月 

ISBN: 7118032824/TP848 

本书系统介绍 VisualProlog(VP) 语言的功能特点、编 

程方法、开发环境及编程接口。全书分为三篇 : 编程指 

南、开发环境和编程接口。第一篇编程指南 , 详细介绍 

VP 编程方法 , 叙述如何使用应用程序专家、对话框与窗 

口专家、对话框包装专家和工具栏专家等代码专家 , 以 

及代码浏览器、资源标识符浏览器、项目浏览器、图形 

编辑器和菜单编辑器等工具进行智能化应用软件的工程 

开发。第二篇开发环境 , 详细介绍 VP 的开发环境 VDE, 

包括项目管理代码浏览器、资源标识符浏览器等实用程序和应用程序专家、资源编辑器等代 

码专家及帮助生成器、VP 调试器等。第三篇编程接口 , 详细介绍 VP 的编程接口 VPI。这 

个 VPI 是专为 Prolog 应用程序设计的高级 API, 基本上不受平台限制 , 其内容包括处理诸 

如窗口、控件、菜单及事件等 GUI 元素的所有 VPI 谓词和各种支持包。 

《人工智能 (AI) 程序设计 ( 面向对象语言 )》 

作者 : 雷英杰 , 邢清华 , 王涛等编著 

出版社 : 清华大学出版社 

出版时间 : 2005-3-1 

本书主要介绍人工智能的基础知识和应用于人工智能与专家系统领域的面向对象逻辑 

程序设计语言 Visual Prolog 等内容。第 1 部分主要介绍人工智能的基础知识、知识的表示方 

法以及 AI 的编程基础。第 2 部分介绍 VisualProlog 的编程基础 , 主要包括 Visual Prolog 的 

类与对象机制、程序结构、GUI 编程、逻辑层编辑、数据层编程、CGI 编程等。第 3 部分介 

绍 Visual Prolog 的语言特性 , 主要包括 Visual Prolog 语言元素、Visual Prolog 数据元素、Visual 

Prolog 程序元素以及 Visual Prolog 与其他编程语言接口等。

第 18.2 节本书的例子程序的获得 

强烈建议 , 读者自己按照书中叙述 , 自己键入代码 , 进行实际操作。我以为这也是一个 

很好的学习过程。但是如果读者希望节省时间 , 可以发邮件给 fan_gending@126.com , 注 

明 “ 索求例子程序源代码 ”, 我们会通过邮件的形式 , 为需要者发送电子格式的。当然 , 如 

果您下载 Visual Prolog 7.1 不顺畅 , 我们也可提供帮助 , 但不推荐这样 , 因为这个属于 PDC 

的发布。 

第 18.3 节中国的知识基系统研究 

中国有大量的计算机大学毕业生 , 但是却少有真正的计算机研究者 , 尤其是软件的理想 

主义者。大家为商业而忙碌 , 连教授也忙于捞钱了。所以 , 在中国 , 知识基系统的研究还基 

本上是空白 , 有些所谓的成就 , 也不过是山中无老虎的自称而已。所以这个领域我们不但落 

后国外几十年 , 而且是大大地可惜呀。我们有这么多人 , 我们最应该善于做知识基系统 , 我 

们最应该在这里发轫超越式发展 , 但是很不幸。如有几个爱好者能够作为星星之火 , 也许在 

知识基系统 , 我们还有机会。如果您读了这书 , 我劝您挤出更多时间思考我们的未来 , 不仅 

仅把这作为嬉闹一番而已 , 做些什么吧。 

附录 - 要点索引 

自序 

下载一个免费 Visual Prolog 7 的版本 

Visual Prolog 爱好者一个聚会的交流的平台。 

第一章简介 

创建一个新的程序 

编译和运行你的程序 

Excute 菜单项 

把程序的显示标题改成我的名字 

文件树 

程序的文件和目录列表 

希腊人发明了逻辑

Visual Prolog 遵从的逻辑学方法 

第二章 Forms 

创建一个新的 Form 

控件工具箱 

控件版面编辑安置工具箱 

任务菜单的项目工作起来 

用 Code Expert 添加程序 

TaskWindow.win 文件 

自动生成的代码 

亚里士多德的符号逻辑 

三段论 

第三章鼠标事件 

增加鼠标按下事件侦听器 

query.frm 文件 

进入对话框 Form 的编辑状态 

Form 编辑状态下的特性设置和事件设置对话框 

EventsMouseDownLisener 侦听器 

重画功能 onPaint 

说明文字 

数据库记录 mousePoint 

保存鼠标点击时的坐标数值 

类型 pnt 

invalidate(R) 启动重画 R 所指的矩形区域 

rct(X-8, Y-8, X+60, Y+8) 

处理一个事件 

鼠标事件分四类 

布尔代数 

论证的形式 

第四章基本图例 

工程 factorial

VIP 编程环境 IDE 

任务菜单 

Prolog Setting 对话框 

目录树 

Code Expert 代码专家 

通过树形结构来选择具体编码的项目 

创建一个工程项目 

程序包 

编辑控件 

按钮 

创建一个新的 class 

设置控件属性 

选择按钮事件的反应器 

算出阶乘得数 

谓词运算 

第五章 Horn 语句 

函数 

函子 

谓词 

逻辑运算关系 

求解 

2 元谓词 ( 两个参数的谓词 ) 

定义谓词 

变量 

draw 模块 class 

答案不惟一 

一个采用多解谓词的程序 

利用多解特性 

fail 的强制回溯功能 

Horn 句子分为两种 

事实 

规则语句 

“:-” 符号 

规则的 “ 头 ” 

规则的 “ 尾 ” 

规则的 “ 体 ” 

声明 

谓词输入输出流向说明 

事实 (facts) 插入、删除 

open 语句

determ 

procedure 

multi 

nondeterm 

class facts 

绘图谓词 

drawLine/3 

drawEllipse/2 

GDI objects 

PaintResponder 

绘图语句的引用有很大不同 

Horn 句子的意义 

第六章控制台应用 

控制台应用 (Console Application) 

截断 

stdio::read() 

stdio::write 

stdio::nl 

表 

表头 

表尾 

空表 

匹配 

计算元素之和 : 

简化 Reduction 

递归式 

两个表的点积 (dotproduct) 

字符串操作 

Visual Prolog 里处理数据结构问题 

Fronttoken 

concatlist 

concat/2/3 

toterm 

hasdomain(real, IX) 

输入的字符串转换为实数 

“integer*” 

core::integer_list 

tostring 

format

格式化输出 

数据格式化输出 

adjustBehaviour 

adjustSide 

caseSensitivity 

把字符串内多余的空格去掉 

谓词的语法 

Porolog 谓词描述 

第七章文本编辑器 

编辑器控件 editorControl 

建立文本编辑器程序 

File/Add 加入 editorControl 控件 

文件保存 

保存文件对话框 

文件调入 

编辑器的改进 

四个角都和对话框的形状关联起来 

第八章绘图 

onPaint 

创建 dopaint 模块 , 不选 “create objects” 

画出三角形 

brush/2 

PatStyle 

Color 

调入图片 

画出不带背景的鹰 

记录鼠标点击位置 

鼠标点击之处 , 鹰也动来动去 

Custom Control 

不会超出我们画的边界 

第九章数据类型

基本的数据类型 

integer ( 整数 ) 

real ( 实数 ) 

string ( 字符串 ) 

symbol ( 符号 ) 

显示不同的数据类型 

集合 

数字的集合 

展示一个自动形成的表 

自己定义的数据类型 

格式 

域 

domains 字段 

定义表 

函数型数据类型 

计算某一天是星期几的程序 

改造后的计算日期界面 

第十章如何用 Prolog 解决问题 

搜索一个表的所有元素 

寻求两个表的交集表 

两个表的合并 

表的倒序排列 

表的分割 

表的快速排序 

一年有多少天 ? 

地图填色问题 

四色定理 

修改程序 , 看看到底有多少种填色方案 

翻子游戏 

NIM 游戏 

交互的下棋过程 

第十一章事实 

用 facts 或者 class facts 来声明事实 

数据库记录的生成和保存 

数据库文件读入内存

file::consult/2 

读写字符串 readString/writeString 

string::toUpperCase/1 

file::writeString、3 

stdio::readline() 

常数 

resourceIdentifiers.res 

增加菜单项目侦听器 

Form 获得焦点 

第十二章 class 和 object 

存取社会保障号 

Object 的事实 

第十三章乌龟爬和语言处理 

乌龟爬行程序 

位置坐标 

角度朝向 

math::round/1 

cos/1 

sin/1 

assert/1 

画出正三角形 

五边形 

五角星 

保证每次画出的是一样的图形 

在不同的位置 , 画出不同的图形 

递归 

复杂问题得到简化 

利用递归方法画复杂曲线 

画出倾斜的曲线 

语言处理

第十四章 L- 系统 

画一棵树 

如何才能画一棵树 

画 3 个分枝最简单的图 

画出不同的树 

改变树的形状 

第十五章游戏 

游戏描述 

游戏设计前的分析 

游戏编程 

处理定时器 

关闭动作设置 

显示动作设置 

定时器动作设置 

重画动作设置 

游戏的说明 

游戏的改进 

增加计分控件 

带计分牌的虫子爬游戏 

实体事实 Object Facts 

第十六章几个有趣的部件 

TabControl 的应用 

创建控件 

使用 TabControl 

ListControl 的应用 

listEdit Control 

播放声音 

playSound/3 

Windows API 程序 

treeView Control 

listView Control 

open 语句修改

第十七章动画 

GDIobjects 来实现动画 

定时器模块 

设定 1000ms 触发一次 

绘图 

准备几个图片文件 

定时器的使用 

canvas 面板启动时 , 启动定时器 

canvas 关闭时 , 也应该销毁定时器 

定时器触发时 , 执行 onTimer 任务 

动画是怎么实现的 ? 

两幅图画交替出现 , 仿佛蛇在扭头的动画 

改进动画程序 

点击后蛇位置移动 

第十八章相关资料介绍、索引 

《Visual Prolog 语言教程》 

《Visaul Prolog 编程、环境及接口》 

《人工智能 (AI) 程序设计 ( 面向对象语言 )》 

本书的例子程序的获得 

中国的知识基系统研究

Visual Prolog 7ç»ä¸­å­¦ - PDC Download site

Create successful ePaper yourself

Delete template?

Save as template?

Visual Prolog 7ç»ä¸å¦ - PDC Download site