更为灵活，这样可以给某个对象而不是整个类添加一些功能。
UML图：

原理是：增加一个修饰类包裹原来的类，包裹的方式一般是通过在将原来的对象作为修饰类的构造函数的参数。装饰类实现新的功能，但是，在不需要用到新功能的地方，它可以直接调用原来的类中的方法。修饰类必须和原来的类有相同的接口。

修饰模式是类继承的另外一种选择。类继承在编译时候增加行为，而装饰模式是在运行时增加行为。

直接看代码更直观些：
测试用例：

头文件与实现：//filename: decorator.h

在《如何设计一门语言》里面，我讲了一些语言方面的东西，还有痛快的喷了一些XX粉什么的。不过单纯讲这个也是很无聊的，所以我开了这个《跟vczh看实例学编译原理》系列，意在科普一些编译原理的知识，尽量让大家可以在创造语言之后，自己写一个原型。在这里我拿我创造的一门很有趣的语言 https://github.com/vczh/tinymoe/ 作为实例。

商业编译器对功能和质量的要求都是很高的，里面大量的东西其实都跟编译原理没关系。一个典型的编译原理的原型有什么特征呢？

1. 性能低
2. 错误信息难看
3. 没有检查所有情况就生成代码
4. 优化做得烂
5. 几乎没有编译选项

等等。Tinymoe就满足了上面的5种情况，因为我的目标也只是想做一个原型，向大家介绍编译原理的基础知识。当然，我对语法的设计还是尽量靠近工业质量的，只是实现没有花太多心思。

为什么我要用Tinymoe来作为实例呢？因为Tinymoe是少有的一种用起来简单，而且库可以有多复杂写多复杂的语言，就跟C++一样。C++11额标准库在一起用简直是愉快啊，Tinymoe的代码也是这么写的。但是这并不妨碍你可以在写C++库的时候发挥你的想象力。Tinymoe也是一样的。为什么呢，我来举个例子。

Hello, world!

Tinymoe的hello world程序是很简单的：

module hello world

using standard library

sentence print (message)

    redirect to "printf"

end

phrase main

    print "Hello, world!"

end

module指的是模块的名字，普通的程序也是一个模块。using指的是你要引用的模块——standard library就是Tinymoe的STL了——当然这个程序并没有用到任何standard library的东西。说到这里大家可能意识到了，Tinymoe的名字可以是不定长的token组成的！没错，后面大家会慢慢意识到这种做法有多么的强大。

后面是print函数和main函数。Tinymoe是严格区分语句和表达式的，只有sentence和block开头的函数才能作为语句，而且同时只有phrase开头的函数才能作为表达式。所以下面的程序是不合法的：

phrase main

    (print "Hello, world!") + 1

end

原因就是，print是sentence，不能作为表达式使用，因此他不能被+1。

Tinymoe的函数参数都被写在括号里面，一个参数需要一个括号。到了这里大家可能会觉得很奇怪，不过很快就会有解答了。为什么要这么做，下一个例子就会告诉我们。

print函数用的redirect to是Tinymoe声明FFI（Foreign Function Interface）的方法，也就是说，当你运行了print，他就会去host里面找一个叫做printf的函数来运行。不过大家不要误会，Tinymoe并没有被设计成可以直接调用C函数，所以这个名字其实是随便写的，只要host提供了一个叫做printf的函数完成printf该做的事情就行了。main函数就不用解释了，很直白。

1加到100等于5050

这个例子可以在Tinymoe的主页（https://github.com/vczh/tinymoe/）上面看到：

module hello world

using standard library

sentence print (message)

redirect to "printf"

end

phrase sum from (start) to (end)

set the result to 0

repeat with the current number from start to end

add the current number to the result

end

end

phrase main

print "1+ ... +100 = " & sum from 1 to 100

end

为什么名字可以是多个token？为什么每一个参数都要一个括号？看加粗的部分就知道了！正是因为Tinymoe想让每一行代码都可以被念出来，所以才这么设计的。当然，大家肯定都知道怎么算start + (start+1) + … + (end-1) + end了，所以应该很容易就可以看懂这个函数里面的代码具体是什么意思。

在这里可以稍微多做一下解释。the result是一个预定义的变量，代表函数的返回值。只要你往the result里面写东西，只要函数一结束，他就变成函数的返回值了。Tinymoe的括号没有什么特殊意思，就是改变优先级，所以那一句循环则可以通过添加括号的方法写成这样：

repeat with (the current number) from (start) to (end)

大家可能会想，repeat with是不是关键字？当然不是！repeat with是standard library里面定义的一个block函数。大家知道block函数的意思了吧，就是这个函数可以带一个block。block有一些特性可以让你写出类似try-catch那样的几个block连在一起的大block，特别适合写库。

到了这里大家心中可能会有疑问，循环为什么可以做成库呢？还有更加令人震惊的是，break和continue也不是关键字，是sentence！因为repeat with是有代码的：

category

    start REPEAT

    closable

block (sentence deal with (item)) repeat with (argument item) from (lower bound) to (upper bound)

    set the current number to lower bound

    repeat while the current number <= upper bound

        deal with the current number

        add 1 to the current number

    end

end

前面的category是用来定义一些block的顺序和包围结构什么的。repeat with是属于REPEAT的，而break和continue声明了自己只能直接或者间接方在REPEAT里面，因此如果你在一个没有循环的地方调用break或者continue，编译器就会报错了。这是一个花边功能，用来防止手误的。

大家可能会注意到一个新东西：(argument item)。argument的意思指的是，后面的item是block里面的代码的一个参数，对于repeat with函数本身他不是一个参数。这就通过一个很自然的方法给block添加参数了。如果你用ruby的话就得写成这个悲催的样子：

repeat_with(1, 10) do |item|

    xxxx

end

而用C++写起来就更悲催了：

repeat_with(1, 10, [](int item)

{

    xxxx

});

block的第一个参数sentence deal with (item)就是一个引用了block中间的代码的委托。所以你会看到代码里面会调用它。

好了，那repeat while总是关键字了吧——不是！后面大家还会知道，就连

if xxx

    yyy

else if zzz

    www

else if aaa

    bbb

else

    ccc

end

也只是你调用了if、else if和else的一系列函数然后让他们串起来而已。

那Tinymoe到底提供了什么基础设施呢？其实只有select-case和递归。用这两个东西，加上内置的数组，就图灵完备了。图灵完备就是这么容易啊。

多重分派（Multiple Dispatch）

讲到这里，我不得不说，Tinymoe也可以写类，也可以继承，不过他跟传统的语言不一样的，类是没有构造函数、析构函数和其他成员函数的。Tinymoe所有的函数都是全局函数，但是你可以使用多重分派来"挑选"类型。这就需要第三个例子了（也可以在主页上找到）：

module geometry

using standard library

phrase square root of (number)

    redirect to "Sqrt"

end

sentence print (message)

    redirect to "Print"

end

type rectangle

    width

    height

end

type triangle

    a

    b

    c

end

type circle

    radius

end

phrase area of (shape)

    raise "This is not a shape."

end

phrase area of (shape : rectangle)

    set the result to field width of shape * field height of shape

end

phrase area of (shape : triangle)

    set a to field a of shape

    set b to field b of shape

    set c to field c of shape

    set p to (a + b + c) / 2

    set the result to square root of (p * (p - a) * (p - b) * (p - c))

end

phrase area of (shape : circle)

    set r to field radius of shape

    set the result to r * r * 3.14

end

phrase (a) and (b) are the same shape

    set the result to false

end

phrase (a : rectangle) and (b : rectangle) are the same shape

    set the result to true

end

phrase (a : triangle) and (b : triangle) are the same shape

    set the result to true

end

phrase (a : circle) and (b : circle) are the same shape

    set the result to true

end

phrase main

    set shape one to new triangle of (2, 3, 4)

    set shape two to new rectangle of (1, 2)

    if shape one and shape two are the same shape

        print "This world is mad!"

    else

        print "Triangle and rectangle are not the same shape!"

    end

end

这个例子稍微长了一点点，不过大家可以很清楚的看到我是如何定义一个类型、创建他们和访问成员变量的。area of函数可以计算一个平面几何图形的面积，而且会根据你传给他的不同的几何图形而使用不同的公式。当所有的类型判断都失败的时候，就会掉进那个没有任何类型声明的函数，从而引发一场。嗯，其实try/catch/finally/raise都是函数来的——Tinymoe对控制流的控制就是如此强大，啊哈哈哈哈。就连return都可以自己做，所以Tinymoe也不提供预定义的return。

那phrase (a) and (b) are the same shape怎么办呢？没问题，Tinymoe可以同时指定多个参数的类型。而且Tinymoe的实现具有跟C++虚函数一样的性质——无论你有多少个参数标记了类型，我都可以O(n)跳转到一个你需要的函数。这里的n指的是标记了类型的参数的个数，而不是函数实例的个数，所以跟C++的情况是一样的——因为this只能有一个，所以就是O(1)。至于Tinymoe到底是怎么实现的，只需要看《如何设计一门语言》第五篇（http://www.cppblog.com/vczh/archive/2013/05/25/200580.html）就有答案了。

Continuation Passing Style

为什么Tinymoe的控制流都可以自己做呢？因为Tinymoe的函数都是写成了CPS这种风格的。其实CPS大家都很熟悉，当你用jquery做动画，用node.js做IO的时候，那些嵌套的一个一个的lambda表达式，就有点CPS的味道。不过在这里我们并没有看到嵌套的lambda，这是因为Tinymoe提供的语法，让Tinymoe的编译器可以把同一个层次的代码，转成嵌套的lambda那样的代码。这个过程就叫CPS变换。Tinymoe虽然用了很多函数式编程的手段，但是他并不是一门函数是语言，只是一门普通的过程式语言。但是这跟C语言不一样，因为它连C#的yield return都可以写成函数！这个例子就更长了，大家可以到Tinymoe的主页上看。我这里只贴一小段代码：

module enumerable

using standard library

symbol yielding return

symbol yielding break

type enumerable collection

    body

end

type collection enumerator

    current yielding result

    body

    continuation

end

略（这里实现了跟enumerable相关的函数，包括yield return）

block (sentence deal with (item)) repeat with (argument item) in (items : enumerable collection)

    set enumerator to new enumerator from items

    repeat

        move enumerator to the next

        deal with current value of enumerator

    end

end

sentence print (message)

    redirect to "Print"

end

phrase main

    create enumerable to numbers

        repeat with i from 1 to 10

            print "Enumerating " & i

            yield return i

        end

    end

    repeat with number in numbers

        if number >= 5

            break

        end

        print "Printing " & number

    end

end

什么叫模拟C#的yield return呢？就是连惰性计算也一起模拟！在main函数的第一部分，我创建了一个enumerable（iterator），包含1到10十个数字，而且每产生一个数字还会打印出一句话。但是接下来我在循环里面只取前5个，打印前4个，因此执行结果就是

当！

CPS风格的函数的威力在于，每一个函数都可以控制他如何执行函数结束之后写在后面的代码。也就是说，你可以根据你的需要，干脆选择保护现场，然后以后再回复。是不是听起来很像lua的coroutine呢？在Tinymoe，coroutine也可以自己做！

虽然函数最后被转换成了CPS风格的ast，而且测试用的生成C#代码的确也是原封不动的输出了出来，所以运行这个程序耗费了大量的函数调用。但这并不意味着Tinymoe的虚拟机也要这么做。大家要记住，一个语言也好，类库也好，给你的接口的概念，跟实现的概念，有可能完全不同。yield return写出来的确要花费点心思，所以《序言》我也不讲这么多了，后续的文章会详细介绍这方面的知识，当然了，还会告诉你怎么实现的。

尾声

这里我挑选了四个例子来展示Tinymoe最重要的一些概念。一门语言，要应用用起来简单，库写起来可以发挥想象力，才是有前途的。yield return例子里面的main函数一样，用的时候多清爽，清爽到让你完全忘记yield return实现的时候里面的各种麻烦的细节。

所以为什么我要挑选Tinymoe作为实例来科普编译原理呢？有两个原因。第一个原因是，想要实现Tinymoe，需要大量的知识。所以既然这个系列想让大家能够看完实现一个Tinymoe的低质量原型，当然会讲很多知识的。第二个原因是，我想通过这个例子向大家将一个道理，就是库和应用 、编译器和语法、实现和接口，完全可以做到隔离复杂，只留给最终用户简单的部分。你看到的复杂的接口，并不意味着他的实现是臃肿的。你看到的简单的接口，也不意味着他的实现就很简洁。

Tinymoe目前已经可以输出C#代码来执行了。后面我还会给Tinymoe加上静态分析和类型推导。对于这类语言做静态分析和类型推导又很多麻烦，我现在还没有完全搞明白。譬如说这种可以自己控制continuation的函数要怎么编译成状态机才能避免掉大量的函数调用，就不是一个容易的问题。所以在系列一边做的时候，我还会一边研究这个事情。如果到时候系列把编译部分写完的同时，这些问题我也搞明白的话，那我就会让这个系列扩展到包含静态分析和类型推导，继续往下讲。

OpenCascade Tcl vs. ACIS Scheme

eryar@163.com

摘要Abstract：本文通过OpenCascade的Tcl/Tk和ACIS的Scheme的对比来说明脚本语言在程序中的重要作用。及通过在Tcl中实现自定义的命令来理解Draw Test Harness的实现，在此基础上更有利于对OpenCascade的理解，其中Draw Test Harness一些命令的实现可以做为程序实现的参考。

关键字Key Words：OpenCascade, Tcl/Tk, ACIS, Scheme, Test

一、引言 Introduction

解释型的语言为程序开发提供了快速原型方法，由于是解释型的程序开发语言，所以用它编写的程序不需要编译和链接就可以在解释器中直接运行，用这种方式可以快速验证一些想法，用来测试程序等。

解释型的脚本开发语言有很多，流行的有Python、Tcl/Tk、Perl、Lua、LISP、Javascript等等。在应用程序中嵌入这些脚本语言，方便程序的扩展，用户可以根据需要对程序进行定制。像应力分析软件Abaqus中就使用了Python对其进行二次开发；绘图软件AutoCAD中可使用AutoLISP对其进行二次开发；造船软件KCS Tribon中也使用了Python；AVEVA Marine/Plant中使用了PML；许多游戏程序中使用了Lua等等。程序有了脚本这个二次开发的强有力工具，软件开发者只需要关注核心领域，其它各种客户化的需求，可以通过这些脚本来实现，既能满足用户花样繁多的需求，也可确保程序质量。

ACIS对Scheme的扩展为Scheme解释器提供了调用ACIS内部函数和访问ACIS内部数据的功能，其中，每个Scheme函数都调用相应的ACIS C++函数。开发者可以利用Scheme来熟悉ACIS的基本功能、测试某些思想或者产生应用程序原型。Scheme语言的初学者可以通过它来熟悉和掌握ACIS的Scheme程序开发方法。

OpenCascade中使用Tcl/Tk来实现的Draw Test Harness提供了交互创建、显示和修改形状的功能。可以编写Tcl的脚本来自定义Draw或者实现程序的自动化测试。

本文通过OpenCascade的Tcl/Tk和ACIS的Scheme的对比来说明脚本在程序中的重要作用。及通过在Tcl中实现自定义的命令来理解Draw Test Harness的实现，在此基础上更有利于对OpenCascade的理解，其中一些命令的实现代码可以做为程序实现的参考。

二、ACIS Scheme

ACIS中的Scheme接口是一些函数的集合，基于Scheme的应用程序可以通过这些函数调用ACIS的API、类的公共成员函数及访问ACIS的数据。ACIS系统中含有一个Scheme解释器，Scheme应用程序就在这个解释器上运行，所以该解释器负责Scheme应用程序与ACIS系统之间的通信。ACIS中的Scheme解释器是按Elk版的Scheme语言规则设计的，它被用来解释Scheme命令并调用相关的C++代码。

Figure 2.1 Scheme and ACIS

Scheme的多功能性来自解释器语言的可扩展能力。应用程序开发者可以快速地将Scheme语言用于自己的开发任务，他们可以用C++扩展Scheme，然后就可以利用这些扩展写可解释执行的Scheme过程。开发者也可以构造特殊的Scheme数据类型和相应的操作方法，Scheme应用程序和C++函数可以使用这些自定义的Scheme数据类型。

Figure 2.2 ACIS Scheme pipeline

与C++相比Scheme是一种快速程序设计语言。尽管C++语言有很多优点，但是也不得承认它的复杂性，例如要用C++开发ACIS应用程序，需要包含所需的组件头文件并在程序中初始化这些组件，除此之外还要进行复杂的程序调试，所以使用C++开发应用程序的速度就受到较大影响。与其相反，Scheme可以进行交互式程序开发，一段程序或一个命令的执行结果会及时反映出来，正是这种机制使我们可以利用Scheme语言进行快速的程序开发。虽然Scheme不能替代C++成为主要的软件开发工具，但是在开发一个软件系统之前可以利用它进行算法的测试。

Scheme语言与C++语言相比有三个特点：没有指针、不需要头文件及可进行交互式程序设计，程序员可以在解释器中立即执行这些程序，从这个特点来看Scheme更像Basic和Prolog等程序设计语言。

在ACIS中使用Scheme来生成一个立方体的命令如下所示：

上述命令生成一个正方体，总共调用两个ACIS Scheme过程position和solid:block，#[entity 1 0]是该正方体的默认名称。

Figure 2.3 The block made by ACIS Scheme

三、OpenCascade Tcl

Tcl是一种用于控制和扩展应用程序的动态语言，也称为脚本语言。它的名字代表“工具命令语言”Tool Command Language。Tcl提供的通用编程能力可以满足大多数应用程序的需要。而且Tcl既是可嵌入的（embeded），也是可扩展的（extensible）。它的解释器是一个C函数库，可以很容易地整合到应用程序中；而任何一个应用程序都可以通过增加命令来扩展Tcl内核的功能。Tcl最有用的一个扩展就是Tk，这是一个用于开发图形用户界面（Graphical User Interface, GUI）应用程序的工具集。Tk扩展了Tcl内核的功能，增加了构建用户界面的命令，使您可以使用Tcl脚本来构建图形用户界面，而不必写C代码。

Tcl/Tk一起为应用程序开发者和使用者提供了很多好处。首先是快速开发。很多有意思的程序完全可以用Tcl脚本编写。这使您可以在比C/C++或Java更高的层次上进行开发，Tk隐藏了C或Java程序员必须关心的很多细节。与低级工具相比，使用Tcl/Tk所需要学习的知识更少，需要编写的代码更少。通过几个小时的学习，Tcl/Tk新手用户就可以创建有意思的用户界面，很多开发人员从其他工具集转而使用Tcl/Tk工具集后，应用程序开发所需的代码数量和开发时间都减少了90%。

Tcl/Tk适于快速开发的另一个原因在于Tcl是解释型语言。使用Tcl应用程序时，可以在运行中生成和使用新的脚本，而无需重新编译和重启程序。这使您可以迅速尝试新的想法，迅速修正程序中的错误。因为Tcl是解释型语言，它的运行速度比C程序慢。但是通过内部优化，与编译语言相比的大部分性能差距都可以消除。例如，您可以运行有数百条Tcl命令的脚本，鼠标的每一次移动都不会有能感知的延迟。在一些特别的场合，当性能成为重要问题时，可以把Tcl脚本中影响性能的部分替换为C代码。

Tcl的第二个好处是在于它是跨平台的语言，它的大多数扩展包括Tk也是如此。这意味着在一个平台（如Linux）上开发的程序，在大多数情况下可以不加改动地在另一个平台上运行，如在Macintosh或Windows上运行。

Tcl还是第一种拥有原生Unicode支持的动态语言。因此，Tcl可以处理这个世界上几乎所有的书面语言。Tcl无需扩展就可以处理Unicode支持的所有文本。

使用Tcl的另一个显著优点在于它和它的大多数扩展都是免费的开源软件。Tcl和Tk遵循BSD授权，允许所有人免费下载、查看、修改及再发布。

Tcl是一种绝妙的“胶合语言”，可以让应用程序很容易地拥有强大的脚本语言功能。例如，要为一个已经存在的应用程序添加脚本能力，只需要实现几条新的Tcl命令，用来为应用程序提供相应的基本功能。然后再把您的新命令和Tcl库链接起来生成全功能的脚本语言，该语言就包含了Tcl提供的命令（称为Tcl内核）和您编写的那些命令。

Tcl还为用户提供了方便。一旦学习了Tcl/Tk，就能为任何Tcl/Tk应用程序编写脚本，只需要学习该应用程序特有的少数几条命令即可。这使得更多的用户有能力对应用程序进行个性化改造和强化。

在Tcl中实现自定义命令很方便，只需要按Tcl的格式定义一个命令函数。基于对象的命令函数的声明如下：

为了能在Tcl中调用一个命令函数，必须先调用Tcl_CreateObjCommand注册它，格式如下所示：

这就是把Tcl中的字符串与实现它的C函数关联起来“魔术”。更详细内容请参考：《Create New Commands in Tcl》。下面主要来分析一下Draw Test Harness代码实现：

首先在Draw_PInterp.hxx中将Tcl_Interp定义为*Draw_PInterp，并在类Draw_Interpretor中对Tcl解释器进行了简单封装，在Init时创建一个新的Tcl_Interp，并可管理自定义的命令；

然后，在Draw_Main中来加载Tcl的解析器。程序代码如下所示：

自定义了main函数，实现如下所示：

Draw Test Harness中自定义的命令是通过类Draw_Commands来添加的，程序如下所示：

分别对应的定义文件为：

l Draw_BasicCommands.cxx：基本命令；

l Draw_VariableCommands.cxx：变量命令；

l Draw_GraphicCommands.cxx：图形命令；

l Draw_PloadCommands.cxx：加载命令；

l Draw_UnitCommands.cxx：单位命令；

如可以打开Draw_BasicCommands可以看到OpenCascade定义了哪些基本命令，我发现一个查看OpenCascade编译时的配置信息的命令dversion：

运行结果如下图所示：

Figure 3.1 dversion command in Draw Test Harness

由上图可知编译OpenCascade时的相关配置信息，如版本号、使用了哪些第三方库、编译器类型及版本、系统类型x86/AMD64、操作系统等等。

Figure 3.2 The OS OpenCascade supported

由上图可知OpenCascade可识别的操作系统涵盖发当今主流的操作系统，如Windows、Mac OS、Android、Linux等。

最后以一个实现光线追踪的脚本来演示一下使用脚本的灵活性，Tcl脚本如下所示：

# Script reproducing creation of bottle model as described in OCCT Tutorial
pload MODELING VISUALIZATION
puts "Writing \"eryar@163.com\""
box body 0 0 0 130 20 8
# define text Courier Consolas
text2brep text2d eryar@163.com Times-Roman 18 bold composite=0
#text2brep text2d eryar@163.com Consolas 18 bold composite=0
#text2brep text2d eryar@163.com Courier 18 bold composite=0
prism text text2d 0 0 2
ttranslate text 4 5 6

# cut operation
bcut bodytext body text
ttranslate text 0 20 0

puts "Showing result"
# display result
vdisplay bodytext
vdisplay text
vzfit
vfit
vsetdispmode 1
# set ray tracing
if { [regexp {HAVE_OPENCL} [dversion]] } {
    puts "Trying raytrace mode"
    if { ! [catch {vraytrace 1}] } {
        vtextureenv on 1
        vfit
    }
}

脚本实现了在一个box上cut掉文本后的光线跟踪效果，如下图所示：

Figure 3.3 Ray Tracing Rendering by Tcl

理解了Tcl的作用之后，我认为OpenCascade提供的最快速的的开发方式应该就是全部使用Tcl/Tk来开发程序。利用OpenCascade已经定义好的命令，包括操作ApplicationFramework的自定义命令。在此基础上，使用Tk来实现GUI及用户交互操作，这样开发程序事办功倍，而且还可提供用户二次开发功能，即使用Tcl/Tk来对程序进行二次开发，扩展能力强。

四、结论 Conclusion

造型程序中引入脚本语言的共同优点有：脚本语言是解释执行，不需要编译链接，可以即时验证一些想法。还可使用脚本来执行自动化测试，保证算法质量。便于扩展，提供用户二次开发的工具。

与ACIS的Scheme相比，OpenCascade的Tcl/Tk有着明显的优势。其中最明显的就是源代码开放，可以通过查看源程序，来完全理解脚本的实现。而这在ACIS中是不可能的。

理解如何在Tcl实现自定义的命令后，可以查看OpenCascade在Draw Test Harness中相关程序的实现方法，对学习一些造型算法的使用还是很有帮助的。

五、后记 Postscript

在曹金凤《Python语言在Abaqus中的应用》的序言一中看到这样一段话：“我还想顺便谈一个体会：同50年前有限元方法出现的时代相比，现在有了大量有效的计算力学软件。既然已经有了大家公认的很优秀的分析平台，研究者不应再奋力去开发具有竞争力的新软件了，而应当把精力花在基于这些平台进行二次开发上面了。从科学技术共同体的角度去思考，这应当是如今计算力学软件研发的最佳策略。”——隋允康于北京工业大学。

对于这段话的大部分内容是赞同的，即站在巨人的肩上才能看得更远。但纵观当今力学分析的CAE软件优秀的大都是国外产品，如ANSYS、Abaqus、COADE.CAESAR、MSC/PATRAN、ADINA等等，而国内同类产品鲜有耳闻。原因可能是CAE软件的开发涉及的知识很多，需要计算机图形学、软件工程、力学、数学等等多学科知识的结合，所以开发具有自主知识产权的CAE软件也是国家科技实力的一个表现。若只是在外国人的平台上二次开发，总是会受制于人。也许有些狭隘，如今世界已然是个地球村，科学无国界。

六、参考资料 References

1. Tcl and the Tk Toolkit

2. Practical Programming in Tcl and Tk

3. Tcl/Tk A Developer’s Guide

4. http://sourceforge.net/projects/tcl/

5. http://www.tcl.tk/

6. 詹海生等, 基于ACIS的几何造型技术与系统开发, 清华大学出版社, 2002

7. 曹金凤, 王旭春, 孔亮. Python语言在Abaqus中的应用. 机械工业出版社, 2011

致谢：
    感谢王婷让我接触到ABAQUS这个软件。

Comparison

Due to rounding errors, most floating-point numbers end up being slightly imprecise. As long as this imprecision stays small, it can usually be ignored. However, it also means that numbers expected to be equal (e.g. when calculating the same result through different correct methods) often differ slightly, and a simple equality test fails. For example:

	float a = 0.15 + 0.15 	float b = 0.1 + 0.2 	if(a == b) // can be false! 	if(a >= b) // can also be false! 

Don’t use absolute error margins

The solution is to check not whether the numbers are exactly the same, but whether their difference is very small. The error margin that the difference is compared to is often called epsilon. The most simple form:

	if( Math.abs(a-b) < 0.00001) // wrong - don't do this 

This is a bad way to do it because a fixed epsilon chosen because it “looks small” could actually be way too large when the numbers being compared are very small as well. The comparison would return “true” for numbers that are quite different. And when the numbers are very large, the epsilon could end up being smaller than the smallest rounding error, so that the comparison always returns “false”. Therefore, it is necessary to see whether the relative error is smaller than epsilon:

	if( Math.abs((a-b)/b) < 0.00001 ) // still not right! 

Look out for edge cases

There are some important special cases where this will fail:

• When both a and b are zero. 0.0/0.0 is “not a number”, which causes an exception on some platforms, or returns false for all comparisons.
• When only b is zero, the division yields “infinity”, which may also cause an exception, or is greater than epsilon even when a is smaller.
• It returns false when both a and b are very small but on opposite sides of zero, even when they’re the smallest possible non-zero numbers.

Also, the result is not commutative (nearlyEquals(a,b) is not always the same as nearlyEquals(b,a)). To fix these problems, the code has to get a lot more complex, so we really need to put it into a function of its own:

	public static boolean nearlyEqual(float a, float b, float epsilon) { 		final float absA = Math.abs(a); 		final float absB = Math.abs(b); 		final float diff = Math.abs(a - b);  		if (a == b) { // shortcut, handles infinities 			return true; 		} else if (a == 0 || b == 0 || diff < Float.MIN_NORMAL) { 			// a or b is zero or both are extremely close to it 			// relative error is less meaningful here 			return diff < (epsilon * Float.MIN_NORMAL); 		} else { // use relative error 			return diff / (absA + absB) < epsilon; 		} 	} 

This method passes tests for many important special cases, but as you can see, it uses some quite non-obvious logic. In particular, it has to use a completely different definition of error margin when a or b is zero, because the classical definition of relative error becomes meaningless in those cases.

There are some cases where the method above still produces unexpected results (in particular, it’s much stricter when one value is nearly zero than when it is exactly zero), and some of the tests it was developed to pass probably specify behaviour that is not appropriate for some applications. Before using it, make sure it’s appropriate for your application!

Comparing floating-point values as integers

There is an alternative to heaping conceptual complexity onto such an apparently simple task: instead of comparing aand b as real numbers, we can think about them as discrete steps and define the error margin as the maximum number of possible floating-point values between the two values.

This is conceptually very clear and easy and has the advantage of implicitly scaling the relative error margin with the magnitude of the values. Technically, it’s a bit more complex, but not as much as you might think, because IEEE 754 floats are designed to maintain their order when their bit patterns are interpreted as integers.

However, this method does require the programming language to support conversion between floating-point values and integer bit patterns. Read the Comparing floating-point numbers paper for more details.

Key Principles of Customize Pipe Support Program

eryar@163.com

Abstract: The article show one customize pipe support method in AVEVA Marine/Plant. Follow the method you can create a pipe support modeling program to meet your company’s specific need.

Key Words: AVEVA Marine, AVEVA Plant, PDMS, Pipe Support, PML

I have already used AVEVA Marine for years. It is convenience and efficiency. But only the MDS module does not meet our design standard. There are so many pipe support models in the database, in order to meet the plant and marine pipe support design requirement. When creating a support model, you must wait for a while for the program to find the needed support, it's so boring. So I decided to develop a support program by myself.

To do such a program, you must know the knowledge below:

l The Design Element Hierarchy

l Event-Driven Graphics Utilities

l How to create component and specification in paragon module

l PML (the AVEVA Programmable Macro Language)

l General Commands for Creating the Model

1. The Design Element Hierarchy

Figure 1.1 The Equipment and Piping hierarchy

The hierarchy is very important concept in AVEVA productions. It restricts that which element can hold what elements.

To know all data model and its attributes in AVEVA software, you can see the "Data Model Reference Manual" for reference.

2. Event-Driven Graphics Utilities

Event-Driven graphical interaction allows cursor picks in 3D views to be used intelligently as part of some overall rather than just being used for navigation or element identification purposes.

Once you have selected an option which puts you into event-driven graphics mode, such as measuring distances between calculated positions, you can carry out unrelated actions using non-graphical forms and menus without interrupting the logical sequent picking actions.

When you are in event-driven graphics mode, a Positioning Control form lets you control how your pointer picks are translated into the coordinates of required positions (which need not be at the actual cursor position).

Click in the 3D View and then press the Esc key to leave event-driven graphics mode.

Note: EDG functions are not available within Model Editor mode.

When use the Distance Measure from the toolbar, a Positioning Control will display automatically.

Figure 2.1 Distance Measure on the Utilities toolbar

Figure 2.2 Positioning Control

In PML, the object EDGPACKET is used for this facility. You can reference to : componentcreation.pmlfrm for detail. I will list the simplest code to demonstrate the utility.

To use your own PML program, you can put the following code in a text file named pickdemo.pmlfrm, and put it to the PMLLIB path, my PMLLIB  path is set to :

Then in the Design module's command window input the command:

List 1 : The simplest PML code for Event-Driven Graphics pick

When the command : Show !!pickdemo applied, the pick demo form will show like follow:

Figure 2.3 Pick Demo Form

When you push the button and pick a flange model, the information will display in the Command Window like follow figure:

Figure 2.4 Position in the Command window

3. Create Component and Specification

Like the pipe model in Design Module which its components are all from paragon database, we will save our support model in paragon database too. This is also MDS does.

You can save the pipe clamp data:

Figure 3.1 Pipe clamp model in paragon

Figure 3.2 Pipe clamp model in paragon

After doing this, you add specifications for support component like pipe component, so you can use the support via the specification.

For more information about Catalogues and Specifications please see: Catalogues and Specifications Reference Manual.

4. PML

You can learn more from the manual: Software Customisation Guide.

The manual describes how to use PML, the AVEVA Programmable Macro Language. You should use it together with the Software Customisation Reference Manual. 

You do not have to be a professional programmer to start to learn PML, 

although you may find the manual difficult to follow unless you have 

some understanding of programming concepts such as if statements and 

do loops. If you have no programming experience, you should consider 

attending a PML Training Course. For details, contact your local support office, whose address is given on the AVEVA website. 

5. General Commands for Creating the Model

You can use the command: NEW to create new element. The command also can be used in PML.

Figure 4.1 Use new command to create element

Then assign the spref and position attribute and others to the element, the spref attribute set for component's shape and position attribute set for the component's position.

Figure 4.2 Attributes of the component

You can use PML command:

/Your_Support_Specification is created in the paragon module.

The result is in the below picture:

Figure 4.3 Support model in Design module

So if you understand the 5 key principles you can build your support models by your own program, this will be wonderful. When the pipe supports models are build, then can generate pipe support sketches and material automatically.

Enjoy!

If you find any mistakes or have any suggestions, feel free to contact with me: eryar@163.com.