LISP语言教程
LISP语言教程
LISP语言教程作者:牛魔王—上次修改时间: 2007-03-22 13:13Scheme 语言是LISP语言的一个方言(或说成变种),它诞生于1975年的MIT,对于这个有近三十年历史的编程语言来说,它并没有象C++,java,C#那样受到商业领域的青睐,在国内更是显为人知。
但它在国外的计算机教育领域内却是有着广泛应用的,有很多人学的第一门计算机语言就是Scheme语言。
Scheme 语言概要Author: 宋国伟吉林省德惠市信息中心Date: 2003 年 12 月 01 日Scheme 语言是LISP语言的一个方言(或说成变种),它诞生于1975年的MIT,对于这个有近三十年历史的编程语言来说,它并没有象C++,java,C#那样受到商业领域的青睐,在国内更是显为人知。
但它在国外的计算机教育领域内却是有着广泛应用的,有很多人学的第一门计算机语言就是Scheme语言。
作为Lisp 变体,Scheme 是一门非常简洁的计算语言,使用它的编程人员可以摆脱语言本身的复杂性,把注意力集中到更重要的问题上,从而使语言真正成为解决问题的工具。
本文分为上、下两部分来介绍 scheme 语言。
一.Scheme语言的特点Scheme 语言是LISP语言的一个方言(或说成变种),它诞生于1975年的MIT,对于这个有近三十年历史的编程语言来说,它并没有象C++,java,C#那样受到商业领域的青睐,在国内更是显为人知。
但它在国外的计算机教育领域内却是有着广泛应用的,有很多人学的第一门计算机语言就是Scheme语言。
它是一个小巧而又强大的语言,作为一个多用途的编程语言,它可以作为脚本语言使用,也可以作为应用软件的扩展语言来使用,它具有元语言特性,还有很多独到的特色,以致于它被称为编程语言中的"皇后"。
下面是洪峰对Scheme语言的编程特色的归纳:∙词法定界(Lexical Scoping)∙动态类型(Dynamic Typing)∙良好的可扩展性∙尾递归(Tail Recursive)∙函数可以作为值返回∙支持一流的计算连续∙传值调用(passing-by-value)∙算术运算相对独立本文的目的是让有编程基础(那怕是一点点)的朋友能尽快的掌握Scheme语言的语法规则,如果您在读完本文后,发现自己已经会用Scheme语言了,那么我的目的就达到了。
CAD二次开发lisp教程《第一章》
集成环境下可以便捷, 程序, 在VLISP集成环境下可以便捷,高效地开发 集成环境下可以便捷 高效地开发AutoLISP程序, 程序 可以经过编译得到运行效率更高,代码更加紧凑, 可以经过编译得到运行效率更高 ,ual LISP是新一代 是新一代AutoLISP语言,它对 语言, 是新一代 语言 它对AutoLISP语言进行 语言进行 了 扩 展 , 可 以 通 过 Microsoft ActiveX Automation 接 口 与 AutoCAD对象交互,可以通过反应器函数扩展 对象交互,可以通过反应器函数扩展AutoLISP响应事 对象交互 响应事 件的能力. 件的能力. 如果使用Visual LISP对AutoLISP扩展功能的部份,必须调用 扩展功能的部份, 如果使用 对 扩展功能的部份 vl-load-com 函 数 , 或 者 将 调 用 该 函 数 的 表 达 式 写 在 acad2006doc.lsp 文件内. 文件内.
第1章 章
AutoLISP和Visual LISP 和
1.1 关于 关于LISP
LISP是人工智能领域中广泛采用的一种程序设计语言.主要用于人工智 是人工智能领域中广泛采用的一种程序设计语言. 是人工智能领域中广泛采用的一种程序设计语言 机器人,专家系统,博奕,定理证明等领域. 能,机器人,专家系统,博奕,定理证明等领域. LISP也被称为符号式语言,因为它处理的对象是符号表达式.LISP语言 也被称为符号式语言,因为它处理的对象是符号表达式. 语言 也被称为符号式语言 的程序和数据都是以符号表达式的形式来表示,因此,一个LISP程序可以把 的程序和数据都是以符号表达式的形式来表示,因此,一个 程序可以把 另一个LISP程序作为它的数据来处理. 程序作为它的数据来处理. 另一个 程序作为它的数据来处理 LISP语言语法简单,编写程序便捷,灵活,数据类型丰富.利用 语言语法简单,编写程序便捷,灵活,数据类型丰富.利用LISP语 语言语法简单 语 言可以很容易地定义或调用新的函数.这就是Autodesk公司早在 公司早在1985年的 年的2.1 言可以很容易地定义或调用新的函数.这就是 公司早在 年的 版本就引用了LISP语言的宏操作, 在 1986年的 版本就推出了比较完整的 版本就引用了 语言的宏操作, 年的2.5版本就推出了比较完整的 语言的宏操作 年的 AutoLISP语言的原因. 语言的原因. 语言的原因 LISP在它几十年的发展过程中产生了多种版本,如MacLISP,InterLISP 在它几十年的发展过程中产生了多种版本, 在它几十年的发展过程中产生了多种版本 , ,ZetaLISP,和CommonLISP等.其中 , 等 其中CommonLISP是近几年美国的几所大 是近几年美国的几所大 如麻省理工,斯坦福等)和工业界( 实验室, 公司, 公司 学(如麻省理工,斯坦福等)和工业界(如Bell实验室,DEC公司,HP公司 实验室 公司 等 ) 的人工智能研究人员协同推出的 , 它概括了MacLISP, InterLISP, 它概括了 , , ZetaLISP等版本的特点,因而功能较强且拥有其它版本的一些优点,是目前 等版本的特点, 等版本的特点 因而功能较强且拥有其它版本的一些优点, LISP语言较完整的版本. 语言较完整的版本. 语言较完整的版本
LISP语言教程(1)
(quote x)返回x.为了可读性我们把(quote x)简记为'x.
> (quote a)
a
> 'a
a
> (quote (a b c))
(a b c)
atom
(atom x)返回原子t如果x的值是一个原子或是空表,否则返回().在Lisp中我们按惯例用原子t表示真,而用空表表示假.
> (atom 'a)
(cond ((atom z)
(cond ((eq z y) x)
('t z)))
('t (cons (subst x y (car z))
(subst x y (cdr z))))))
偶然地我们在这儿看到如何写cond表达式的缺省子句.第一个元素是't的子句总是会成功的.于是
(cond (x y) ('t z))
等同于我们在某些语言中写的
if x then y else z
一些函数
既然我们有了表示函数的方法,我们根据七个原始操作符来定义一些新的函数.为了方便我们引进一些常见模式的简记法.我们用cxr,其中x是a或d的序列,来简记相应的car和cdr的组合.比如(cadr e)是(car(cdr e))的简记,它返回e的第二个元素.
示例
假设我们要定义函数(subst x y z),它取表达式x,原子y和表z做参数,返回一个象z那样的表,不过z中出现的y(在任何嵌套层次上)被x代替.
> (subst 'm 'b '(a b (a b c) d))
(a m (a m c) d)
我们可以这样表示此函数
(label subst (lambda (x y z)
Visual_LISP指南
Visual_LISP指南目录第一章简介 (1)1.1 使用 Visual LISP (1)1.2教程概述.............................................................1 第二章设计和开始编程. (2)2.1定义整个程序的目标 (2)2.2Visual LISP 入门 (2)2.2.1查看Visual LISP 等待控制从AutoCAD 返回的步骤 (2)2.2.2使用Visual LISP 开始编写应用程序的步骤 (3)2.3Visual LISP 代码格式设置 (4)2.4分析代码 (4)2.5填补程序 (4)给应用程序加上简单空函数的步骤 (4)2.6让Visual LISP 检查您的代码 (5)2.7在Visual LISP 中运行程序 (6)2.8第一课回顾...........................................................6 第三章使用Visual LISP 调试工具.. (7)3.1局部变量和全局变量的区别 (7)3.1.1在程序中使用局部变量 (7)3.1.2检查gp:getPointInput 函数 (8)3.2使用关联表来捆绑数据 (9)3.2.1使用关联表 (10)将gp:getPointInput 的返回值保存到变量中 (10)3.3检查程序变量 (11)3.4修改程序代码 (12)3.5给程序代码加注释 (14)3.6设置断点并进行更多监视 (15)3.6.1使用“调试”工具栏 (15)3.6.2单步执行代码 (17)3.6.3单步执行程序时监视变量 (17)3.6.4跳出函数gp:getPointInput 并进入C:Gpmain (18)3.7第二课回顾..........................................................19 第四章绘制小路边界.. (20)4.1规划可重用的实用程序函数 (20)4.1.1将度转换为弧度 (20)4.1.2将三维点转换为二维点......... (20)4.2绘制 AutoCAD 图元 (22)4.2.1使用ActiveX 函数创建图元 (22)4.2.2使用entmake 创建图元 (22)4.2.3使用AutoCAD 命令行 (22)4.3启用边界轮廓绘制函数 (22)4.3.1向函数传递参数 (23)4.3.2使用关联表 (23)4.3.3使用角度并设置点 (24)4.3.4理解gp:drawOutline 中的ActiveX 代码 (25)4.3.5确保已加载ActiveX (26)4.3.6获取指向模型空间的指针 (26)4.3.7构造多段线端点数组 (27)4.3.8由点表构造变体 (28)4.3.9程序集成 (28)4.4第三课回顾..........................................................30 第五章创建工程和添加界面.. (32)5.1模块化代码 (32)5.2使用 Visual LISP 工程 (33)5.3添加对话框界面 (33)5.3.1用DCL 定义对话框 (33)3.5.2保存DCL 文件 (36)3.5.3预览对话框 (36)5.4用AutoLISP 代码与对话框交互 (37)5.4.1设置对话框的值 (37)5.4.2加载对话框文件 (37)5.4.3将指定对话框加载到内存中 (38)5.4.4初始化默认的对话框值 (38)5.4.5给控件指定动作 (38)5.4.6启动对话框 (40)5.4.7卸载对话框 (40)5.4.8确定下一步的动作 (40)5.4.9代码集成 (41)5.4.10更新简单空函数 (41)5.5提供可选的边界线类型 (42)5.6清除反应器 (43)5.7运行应用程序 (43)5.8第四课回顾..........................................................44 第六章绘制砖. (45)6.1更多的Visual LISP 编辑工具 (45)6.1.1括号匹配 (45)6.1.2自动完成词语 (45)6.1.3按系统匹配完成词语 (46)6.1.4获取函数帮助 (46)6.2在花园小路中添加砖 (47)6.2.1应用逻辑知识 (47)6.2.2几何分析 (47)6.2.3绘制一行砖 (47)6.2.4绘制每一行砖 (50)6.2.5阅读代码 (51)6.3测试代码 (53)6.4第五课回顾..........................................................54 第七章使用反应器. (55)7.1反应器基础 (55)7.1.1反应器类型 (55)7.2设计花园小路应用程序的反应器 (55)7.2.1选择花园小路应用程序的反应器事件 (55)7.2.2规划回调函数 (56)7.2.3规划多重反应器 (57)7.2.4附着反应器 (57)7.2.5用反应器存储数据 (58)7.2.6更新C:GPath 函数 (58)7.2.7添加反应器的回调函数 (61)7.2.8清除反应器 (61)7.3测试反应器 (62)7.3.1详细检查反应器的行为 (63)7.4第六课回顾..........................................................63 第八章程序集成.. (64)8.1规划反应器整体过程 (64)8.1.1响应更多的用户调用命令 (65)8.1.2将信息保存在反应器对象中 (66)8.2添加新的反应器功能 (68)8.2.1实现对象反应器的回调函数 (69)8.2.2设计gp:command-ended 回调函数 (70)8.2.3处理多种图元类型 (70)8.2.4在反应器回调函数中使用ActiveX 方法 (71)8.2.5处理非线性的反应器序列 (71)8.2.6编写command-ended 函数 (73)8.2.7更新gp:Calculate-and-Draw-Tiles (76)8.2.8修改其他调用gp:Calculate-and-Draw-Tiles 函数的代码 (78)8.3重新定义多段线边界 (79)8.3.1查看gppoly.lsp 文件中的函数 (79)8.3.2理解gp:RedefinePolyBorder 函数 (80)8.3.3理解gp:FindMovedPoint 函数 (80)8.3.4理解gp:FindPointInList 函数 (81)8.3.5理解gp:recalcPolyCorners 函数 (82)8.3.6理解gp:pointEqual 、gp:rtos2 和gp:zeroSmallNum 函数 (82)8.4代码回顾 (82)8.5生成应用程序 (83)8.5.1启动“生成应用程序”向导启动“生成应用程序”向导 (83)8.6教程回顾 (84)8.7LISP 和AutoLISP 参考书 (84)第一章简介本教程用于示范 AutoCAD.的 AutoLISP. 编程环境的一些强大功能,并介绍 AutoLISP 语言的新功能。
lisp教程
一.Lisp基础知识二.对话框基础一.基本知识第1节--------------------------------------------------------------------------------基本知识AutoLISP是一种针对扩充及自订AutoCAD函数机能而产生,以LISP为基础的程序设计语言.LISP本身于50年代末期出现,是一种擅于处理串行文字(List of Processing),属第四代「人工智能(Artificial Intelligence)」的计算机语言.目的是令使用者充份利用AutoCAD进行开发,直接增加及修改AutoCAD指令.AutoLisp语言建基于普通的LISP语言上,并扩充了许多适用于CAD的特殊功能而形成.是一种能以直译方式(不须先行编译)亦可于AutoCAD内部执行的直译性程序语言.程序容易学习及撰写,程序即使出错亦不会对操作系统(如DOS,WINDOWS)有不良影响.数据及程序均统一以串行 (List)结构表示.可直接调用几乎全部的AutoCAD命令.既具备一般高级语言的基本结构和功能,亦有一般高级语言没有的强大图形处理能力.内建于AutoCAD应用程序,不须另行购买;亦不须使用特定的编辑器或开发环境.可配合AutoCAD提供的PDB,建立DCL(Dialog Control Language)文件创建对话框.缺点 : 执行速度较ObjectArx(旧称ARX,以C或C++程序开发,取代以前的ADS)程序慢;原程序不易保护;对低阶的硬件数据不易存取.第2节--------------------------------------------------------------------------------函数 (Function)在AutoLISP程序语言中所有的成份都是以函数的形式出现,AutoLISP程序就是顺序执行连串的函数.函数的运行过程就是对函数的求值(结果)过程;函数的基本语法如下:(函数名称参数1 参数2....)e.g. (PRINC "AutoLISP Programming")每一个完整的函数必须包在一对小括号( )内,左边为开括号,右边为关括号;如有若干数量的开括号,则一定有同等数量的关括号对应.左边开括号后紧随函数名称.函数名称与参数之间,或参数与参数之间须最少留一个空格.第3节--------------------------------------------------------------------------------数据型态 (Data Type)整数 (INT)没有小数字的数值,32位有号数,范围从+2,147,483,647到-2,147,483,648实数 (REAL)带小数字的数值,以倍精度浮点格式储存(最少14位小数) e.g. 12.5当数值在1与-1之间时,必须加上前导零 e.g. 0.05可以科学记号表示 : 在E或e后加上次方值 e.g. 4.1e-6字符串 (STR)一般文字,其前后必须加上双引号" e.g. "AutoCAD"控制字符或脱逸码必须为小写,且须在字符前加上反斜线 \ e.g. "\AutoCAD"像素名称 (ENAME)是指定给图文件内对象的指针(Pointer,为16进位的数字卷标)e.g. <Entity name:14e5180>像素名称在图文件内是唯一的,不会重复对象的像素名称只在目前作业中有效,再开启图档时,会指定新的像素名称予该对象档案 (FILE)以OPEN函数所开启档案的指针,作为其它函数(读写该档案)的自变量选集 (PICKSET)用SSGET等函数建立的一个或多个对象的集合或群组转化 (V ARIANT)可将像素名称转换为可与ActiveX配搭使用的VLA-Object对象符号 (SYM)用以储存静态数据的名称;例如内建或使用者定义的函数符号名称不分大小写,可由任意长度的可打印字符组成;但下列的字符除外:左括号( 右括号 ) 句点 . 单引号' 双引号 " 分号 ;表 (LIST)亦称为串行,是放在一对小括号 ( ) 内,一个或多个元素的有序集合e.g. (1.0 "Lisp" ( ) (5.6 7))元素可以是字符串,符号,整数或实数;也可以是另一个表元素与元素之间要用空格隔开,但元素与小括号之间则可以不隔空格为便于存取表内各元素,每个元素均有其序号;从表的左边开始,第一个元素序号为0,依此类推表的大小即为其顶层元素的数量(内层嵌套式的表,视为单一元素)点对(Dotted Pair)亦是表的一种;表内有2个元素,中间以一圆点分隔,且元素与圆点之间亦须以空格分开若表内没有任何元素,称为空串行或空表;以 ( ) 或 (NIL) 表示第4节--------------------------------------------------------------------------------变数 (Variable)为程序执行中动态储存数据的符号名称;主要分为2类:变量名称与符号的限制相同,使用时宜采用有意义及易于辨别的名称变量在赋值或使用前无须先行设定相同的变量可以储存不同型态的数据(但同一时间内只可储存一种型态)在指定新的数据之前,变量储存的内容会保持不变赋值将数据给予指定的变量储存以内建函数SETQ进行(可用于绘图模式的指令行或AutoLISP程序),其语法如下:(SETQ 变量名称1 资料1 [变量名称2 资料2 ....] )e.g. (SETQ NAME "David" AGE 37 WEIGHT 72.5 POINT (LIST 10 20))在函数名称之后,各参数以两个一组,每组左边为变量名称,右边为存入变量的数据亦可将变量名称赋以空值(NIL) :e.g. (SETQ OCCUPATION NIL)要显示变量所储存的数据,可以使用内建函数PRINC(可用于绘图模式的指令行或AutoLISP程序),其语法如下 : (PRINC 变量名称 )e.g. COMMAND : (PRINC NAME) Result : David"David"在绘图模式中,亦可于指令行中使用感叹号 ! 来显示变量内容,或作为指令选项的输入值;语法如下 : !变量名称e.g. COMMAND : !NAME Result : "David"在Visual LISP的主控台窗口中,于提示符号 _$ 后键入要显示的变量名称_$变量名称e.g. _$NAME要检查变量所储存的数据型态,可使用内建函数TYPE;语法如下:(TYPE 变量名称)e.g. COMMAND : (TYPE NAME) Result : STR若检查的变量没有储存数据,则会传回NIL第5节--------------------------------------------------------------------------------练习 (Exercises)将四个坐标分别存入四个变量中,并以LINE或PLINE指令,配合四个坐标变量,画出正四边形.COMMAND : (SETQ POINT1 (LIST 0 0) POINT2 (LIST 0 10) POINT3 (LIST 10 10) POINT4 (LIST 10 0)) COMMAND : LINE ;直线段指令COMMAND : !POINT1 ;第一点(左下角起点)COMMAND : !POINT2 ;第二点(左上角)COMMAND : !POINT3 ;第三点(右上角)COMMAND : !POINT4 ;第四点(右下角)COMMAND : C ;自动联机至起点以关闭四边形画圆 : 将圆心坐标及半径长度分别存入两个变量中(变量名称及数据型态自订)COMMAND : (SETQ CEN (LIST 0 0) RAD 20) ;将圆心点设为坐标0,0;半径为20COMMAND : CIRCLE ;执行划圆指令Specify center.... : !CEN ;在提示后以变量CEN响应输入Specify radius.... : !RAD ;在提示后以变量RAD响应输入将不同型态的数据,分多次存入相同的变数内;每次均以PRINC及TYPE函数显示变量内容及其数据型态COMMAND : (SETQ TEMP 1.2) ;将实数1.2存入变数TEMPCOMMAND : !TEMP Result : 1.2COMMAND : (TYPE TEMP) Result : REALCOMMAND : (TYPE TEMP) Result : STR二数值资料第1节--------------------------------------------------------------------------------基本运算加函数(+ [数值参数1 数值参数2 ....] )e.g. (+ 2.5 4 6) Result : 12.5函数的结果为各参数之总和若仅提供一个参数,则以0加上此参数的结果为返回值若没有提供任何参数则传回0;各参数须为整数或实数型态若所有参数均为整数,结果亦为整数;若其中一个参数为实数型态,结果会转换为实数减函数(- [数值参数1 数值参数2 ....] )e.g. (- 10 2 3) Result : 5结果为第一个(最左边)参数减去其右边各参数的总和若只提供一个参数,返回值为0减去该参数的结果若没有提供任何参数则传回0;各参数须为整数或实数型态若所有参数均为整数,结果亦为整数;若其中一个参数为实数型态,结果会转换为实数乘函数(* [数值参数1 数值参数2 ....] )e.g. (* 2 3 4) Result : 24结果为所有参数的乘积若只提供一个参数,则返回值为该参数乘以1的结果若没有提供任何参数则传回0;各参数须为整数或实数型态若所有参数均为整数,结果亦为整数;若其中一个参数为实数型态,结果会转换为实数除函数(/ [数值参数1 数值参数2 ....] )e.g. (/ 24 2 3) Result : 4结果为第一个(最左边)参数除以其右边各参数的乘积若仅提供一个参数,则返回值为该参数除以1的结果若没有提供任何参数则传回0;各参数须为整数或实数型态若所有参数均为整数,结果亦为整数;若其中一个参数为实数型态,结果会转换为实数注意 : 在本篇教程中,各函数的数值参数,均可以变量(储存值只可以是整数或实数,且不可以是空值 nil)取代第2节--------------------------------------------------------------------------------练习 (Exercises)计算式 (2+4)*3COMMAND : (* 3 (+ 2 4)) Result : 18计算式 (50-8*5)/4COMMAND : (/ (- 50 (* 8 5)) 4) Result : 2注意 : 上式的正确答案应是2.5,因为函数中的各参数均为整数,所以传回的结果亦为整数递增及递减递增(1+ 数值参数 )e.g. (1+ 2) Result : 3递减三角函数 (Trinagular Function)正弦值(SIN 弧度参数)e.g. (SIN 1) Result : 0.841471余弦值(COS 弧度参数)e.g. (COS 1) Result : 0.540302反正切值(ATAN 弧度参数)e.g. (ATAN 1) Result : 0.785398第3节--------------------------------------------------------------------------------其它数值处理次方值(EXPT 数值参数次方值 )e.g. (EXPT 2 4) Result : 16若参数及次方值两个均为整数,返回值亦是整数;若其中一个为实数,结果为实数开方根(SQRT 数值参数 )e.g. (SQRT 30) Result : 5.47723绝对值(ABS 数值参数 )e.g. (ABS -123) Result : 123余数(REM [数值参数1 数值参数2 ....] )e.g. (REM 50 26 5) = (REM (REM 50 26) 5) Result : 4将参数1整除参数2的余数若参数多于2个时,则会将余数再整除下一个参数,再得出余数;依此类推若其中一个参数为实数时,则结果为实数;否则为整数最大公约数(GCD 数值参数1 数值参数2 )e.g. (GCD 81 57) Result : 3两个参数均必须为整数值型态自然对数(LOG 数值参数 )e.g. (LOG 3.5) Result : 1.25276是EXP函数的反函数;传回值为实数型态自然反对数(EXP 数值参数 )e.g. (EXP 1.25276) Result : 3.49999是LOG函数的反函数;传回值为实数型态第4节--------------------------------------------------------------------------------数值资料转型实数转整数只会截去小数部份(小数字不会4舍5入)整数转实数(FLOAT 数值参数 )e.g. (FLOAT 12) Result : 12.0整数转字符串(ITOA 数值参数 )e.g. (ITOA -17) Result : "-17"数值转字符串(RTOS 数值参数[模式[小数字] ] )e.g. (RTOS 17.23333 2 3) Result : 12.266若不设定模式,则依系统变量 LUNITS 的设定值转换数值为字符串若不设定小数字,则依系统变量 LUPREC 的设定值转换模式设定值可以是下列数值之一 :1 = 科学记号2 = 十进制3 = 英呎及十进制英吋4 = 英呎及分数位英吋5 = 分数当选用的模式为3,4或5,则传回的字符串受系统变量UNITMODE影响弪度转字符串(ANGTOS 角度参数[模式[小数字] ] )e.g. (ANGTOS 0.785398 0) Result : "45"e.g. (ANGTOS 0.785398 4) Result : "N 45d E"若不设定模式,则依系统变量AUNITS的设定值转换数值为字符串若不设定小数字,则依系统变量AUPREC的设定值转换模式设定值可以是下列数值之一 :0 = 度1 = 度/分/秒2 = 分度量3 = 弪度4 = 土地测量单位当选用的模式为4,则传回的字符串受系统变量UNITMODE影响反函数为ANGTOF;参阅第5篇教程第5节--------------------------------------------------------------------------------数值资料检查数值(NUMBERP 数值参数 )e.g. (NUMBERP -3.45) Result : Te.g. (NUMBERP "AutoLISP") Result : nil注意 : 在范例的传回值中,T表示函数的结果为真(成立),nil表示结果为假(不成立) 负数值(MINUSP 数值参数 )e.g. (MINUSP -3.45) Result : Te.g. (MINUSP 0) Result : nile.g. (MINUSP 3.45) Result : nil零值e.g. (ZEROP 3.45) Result : nil其它应用最大值(MAX [数值参数1 数值参数2 ....] )e.g. (MAX -88 5 2) Result : 5若没有提供任何参数,则传回值为0最小值(MIN [数值参数1 数值参数2 ....] )e.g. (MIN -88 5 2) Result : -88若没有提供任何参数,则传回值为0第6节--------------------------------------------------------------------------------练习 (Exercises)计算下列算式 :(+ 1234567890 1234567890) Result : -1825831516上式中两个数值参数均为整数,而结果值大于整数型态所能容许之范围;固导致发生溢位问题,产生无效的结果.修正算式如下 : 只要将其中一个参数改为实数型态即可.(+ 1234567890.0 1234567890) Result : 2.46914e+009计算下列算式 :(+ 9876543210 1234567890) Result : 1.11111e+010上式中两个数值参数均为整数,但其中一个(第一个)参数巳大于整数型态所能容许之范围;系统会自动将此参数先行转为实数型态才计算.计算下列算式 :(FIX (SQRT (+ 1 (MAX 20 10 40 30)))) Result : 6---- 最先执行的是最内层的算式(MAX 20 10 40 30) ,求出最大值为40---- 其次执行加函数,将MAX函数所得的最大值加1,结果为41---- 再利函数SQRT,将41开方根,结果为6.4031---- 最后使用FIX函数,截去其小数字,得到最后的结果为6三程序设计第1节--------------------------------------------------------------------------------使用者定义函数是将一群表示式组合成一个函数或指令可应用于绘图模式的指令行提示,Visual LISP主控台,或供其它自定义函数内的表示式呼叫使用AutoLISP原始程序代码均以纯文字格式存盘,扩展名为LSP(2000版可编译成扩展名为FAS的档案可以一般文字编辑器进行开发,如DOS的EDIT,WINDOWS的WORD或WORDPAD等一个自定函数内最少要有一个表达式在原程序文件(LSP)里,自定义函数以DEFUN函数开始;其语法如下 :(DEFUN [C:] 函数名称 ( [自变量串行 ...] [/ 局部变数串行 ...] ) 表达式 ...)在呼叫带有自变量的自定函数时,必须同时提供与定义函数时,同等数量的参数,使各参数传入自定函数的各自变量中自变量被视为一种特殊类型的局部变量,无法用于该自定函数以外的其它函数若自定函数中无须设定任何自变量,亦必须以空串行 ( )加在函数名称之后若有提供局部变量,必须以斜线 / 加在局部变量的开头(即使前面没有自变量串行)各自变量,斜线,局部变量之间要以空格分隔;但与左右小括号之间则不须以空格分开若自变量串行中有相同名称的自变量出现,则会忽略第一个以后的相同自变量;变数亦是一样若在函数名称前没有加上C:,在指令行提示下,必须将函数名称包在一对小括号中才可执行不可以在执行一自定函数时,以通透方式执行另一自定函数第2节--------------------------------------------------------------------------------加载程序自定函数在使用前,都要将其所在的程序文件(扩展名为LSP)加载才可执行ACAD.LSP程序文件(预设在SUPPORT子目录内)会在启动AutoCAD时自动加载(LOAD "程序文件名称" [加载失败] )e.g. (LOAD "TEST")若程序文件之文件名为LSP,则在程序文件名称之后,可以不加上扩展名若有需要,系统会顺序尝试其它的扩展名 : VLX FAS LSP若程序文件不在系统的支持目录下,则需在文件名前加上目录路径注意 : 必须以正斜线 / 或两个反斜线 \\ 作为目录的分隔符可以在加载失败的参数中提供字符串,以供加载失败时显示;亦可提供有效的自定函数,该函数在加载程序文件失败时会被执行e.g. (LOAD "TEST" "Load Fail") 或 (LOAD "TEST" (DOERROR))注意 :在程序文件加载后,在提示行显示的返回值,一般是该程序文件中,最后被定义的函数名称或是在程序文件内没有包含在自定函数中,最后一个表达式的执行结果第3节--------------------------------------------------------------------------------练习 (Exercises)启动文字编辑器,编写一AutoLISP程序作两个同心圆(第1个圆半径为50,第2个圆半径为80),程序代码如下所示 : (DEFUN C: 2CIRCLE () (SETQ CEN (LIST 0 0) RAD 50)(COMMAND CIRCLE CEN RAD)(COMMAND CIRCLE CEN (+ RAD 30)))---- 输入后以纯文字格式存盘(C:\TEST.LSP)---- 在AutoCAD绘图模式的指令行提示后,用LOAD函数将程序文件加载COMMAND : (LOAD "C:/TEST")---- 在指令行提示后,输入程序(函数)名称执行COMMAND : 2CIRCLE程序说明1 使用DEFUN建立自定函数的名称,并用SETQ函数将中心点(LIST 0 0)存入变数CEN,半径(50)存入变数RAD中2 使用COMMAND函数执行AutoCAD内建指令CIRCLE,并以变量CEN(圆的中心点)及变数RAD(圆的半径)回应3 与第2行大致相同,但在指定其半径时,先将储存半径的变量加30,使划出半径为80的圆;注意最右边的关括号,与第1行DEFUN左边的开括号是一对的启动文字编辑器,开启TEST.LSP程序文件,复制2CIRCLE至新程序2C,并改为传入自变量方式执行;程序代码如下 : (DEFUN 2C (CEN RAD) (COMMAND CIRCLE CEN RAD)(COMMAND CIRCLE CEN (+ RAD 30)))---- 输入后以纯文字格式存盘---- 在AutoCAD绘图模式的指令行提示后,用LOAD函数将程序文件重新加载---- 在指令行提示后,输入程序(函数)名称执行COMMAND : (2C (LIST 0 0) 50)第4节--------------------------------------------------------------------------------表示在分号右边(同一行)的字符均为批注,程序执行时会将其忽略多行批注;| |;表示在两个批注符号中间所有字符皆为批注,即使字符跨越多行关系运算在各个关系运算中,都会传回一逻辑值;若关系成立,传回 T,否则会传回 nil各参数可以是字符串,整数或实数型态;若以字符串进行比较,则会以字符串的ASCII码为准若函数中只有一个参数,传回值恒为 T等于函数(= 参数1 [参数2 ....] )会将参数1与其后各个参数比较,若全部相等则传回 T,否则传回 nil e.g. (= 2 2.0) Result : Te.g. (= "A" CHR(65)) Result : T不等于函数(/= 参数1 [参数2 ....] )若参数1不等于其后任何一个参数,即传回T e.g. (/= 1 2.0) Result : Te.g. (/= "a" CHR(65)) Result : Te.g. (/= 10 30 40 10 20) Result : T小于函数(< 参数1 [参数2 ....] )各参数顺序以2个为一组比较,若各组左边的参数均小于右边的参数,即传回 Te.g. (< 1 2) Result : Te.g. (< "a" CHR(65)) Result : T大于函数(> 参数1 [参数2 ....] )各参数顺序以2个为一组比较,若各组左边的参数均大于右边的参数,即传回 Te.g. (> 1 2) Result : nile.g. (> "a" CHR(65)) Result : nil小于或等于函数(<= 参数1 [参数2 ....] )各参数顺序以2个为一组比较,若各组左边的参数均小于或等于右边的参数,即传回 Te.g. (<= 1 2) Result : Te.g. (<= 2 2) Result : Te.g. (<= "a" CHR(65)) Result : T大于或等于函数(>= 参数1 [参数2 ....] )各参数顺序以2个为一组比较,若各组左边的参数均大于或等于右边的参数,即传回 Te.g. (>= 1 2) Result : nile.g. (>= 2 2) Result : Te.g. (>= "a" CHR(65)) Result : nil第5节--------------------------------------------------------------------------------逻辑运算且运算(AND [表达式 ....] )若各表达式的传回值均为 T,函数即返回 T 值;若其中一个传回值为 nil,函数传回 nil(OR [表达式 ....] )若各表达式的传回值均为 nil,函数即返回 nil 值;若其中一个传回值为 T,函数传回 Te.g. (OR (> 1 2) (> 8 5)) Result : T否定运算(NOT 表达式 )若表达式的传回值为 T,函数即返回 nil 值;相反若表达式传回值为 nil,函数传回 T可用于检查传回值是否为 nil另有一NULL函数与NOT函数功能相似e.g. (NOT (< 1 2)) Result : nil练习 (Exercises)试求出50减25,与625的开方根值是否相等COMMAND : (= (- 50 25) (SQRT 625)) Result : T设计一简单程序(名称为AIR),在呼叫程序时,检查传入的数值自变量(为空气污染指数)是否大于200(即严重空气污染)---- 启动文字编辑器,开启TEST.LSP程序文件,输入下列程序代码 :(DEFUN AIR (NUM) (> NUM 200))---- 输入后存盘(纯文字格式)---- 在AutoCAD绘图模式的指令行提示符号后,使用LOAD函数重新加载程序文件COMMAND : (LOAD "C:/TEST")---- 在AutoCAD绘图模式的指令行提示符号后,输入自定函数名称及参数执行COMMAND : (AIR 175) Result : nilCOMMAND : (AIR 215) Result : T四流程控制第1节--------------------------------------------------------------------------------条件判断是利用条件函数,配合关系及逻辑运算所设定的一些准则,令程序自行分析,因应情况作出适当行动.单一条件(IF 条件表达式是表达式[否表达式] )函数先检查条件表达式,若其传回值为 T,便会执行其后的是表达式若有提供否表达式,且条件表达式的传回值为 nil,函数将不会执行(跳过)是表达式而执行否表达式若没有提供否表达式,且条件表达式的传回值为 nil时,函数将不作任何事情IF函数可以巢状方式嵌套,即在是或否的表达式中加入另一个IF函数练习 (Exercises)判断空气污染指数 : 大于100 = Very High, 51至100 = High, 26至50 = Medium, 25或以下 = Low---- 启动编辑器,开启C:/TEST.LSP程序文件;新增AIR-1自定函数,程序代码如下 :(DEFUN AIR-1 (NUM) (IF (> NUM 100) (PRINC "Very High"))(IF (AND (> NUM 50) (<= NUM 100)) (PRINC "High"))(IF (AND (> NUM 25) (<= NUM 50)) (PRINC "Medium"))(IF (<= NUM 25)) (PRINC "Low"))程序说明1 设定函数名称,并将数据存入自变量NUM内;用IF函数判断变量NUM是否大于100;若是则显示字符串Very High 响应2 用IF函数判断变量NUM是否大于50且(AND)小于或等于100;若是则显示High响应3 用IF函数判断变量NUM是否大于25且(AND)小于或等于50;若是则显示Medium4 用IF函数判断变量NUM是否小于或等于25;若是则显示Low5 是一个没有提供任何自变量的PRINC函数;用以抑制显示答案时尾部符加的 nil 或重复的传回值;而最右一个关括号,是用以对应第1行最左边的开括号IF函数的巢状练习 : 修改上一课的程序练习,将多个IF函数合并成巢状嵌套---- 启动文字编辑器,开启C:/TEST.LSP程序文件---- 新增程序AIR-2,其程序代码如下 :(DEFUN AIR-2 (NUM) (IF (> NUM 50) (PRINC (IF (> NUM 100) "Very high" "High"))(PRINC (IF (> NUM 25) "Medium" "Low")))(PRINC))程序说明1 设定函数名称,并将数据存入自变量NUM内;用IF函数判断变量NUM是否大于50;若条件成立(变量NUM大于50)时,再用另一个IF函数判断变量是否大于100;若条件成立(变量NUM大于100)时,使用PRINC函数显示字符串Very High,否则显示High2 若在第1个IF函数判断中,条件不成立(变量NUM不大于50)时;再用另一个IF函数判断变量是否大于25;若条件成立(NUM大于25)时,显示字符串Medium,否则显示字符串Low3 是一个没有提供任何自变量的PRINC函数;用以抑制显示答案时尾部符加的 nil 或重复的传回值;而最右一个关括号,是用以对应第1行最左边的开括号注意 :第1行最后一个关括号是对应前面的PRINC函数,尾2的关括号则是对应IF函数(判断NUM是否大于100) 第2行最后一个关括号是对应第1行的IF函数(判断NUM是否大于50),尾2的关括号则是对应PRINC函数,尾3的关括号则是对应IF函数(判断NUM是否大于25)最右边的关括号是对应第1行最左边的开括号PROGN 函数在以上各范例中,执行的表达式均为单一的函数运算;若要在表达式中顺序执行一连串的函数,便要将各函数包含在一个PROGN函数内;函数的传回值会是该PROGN函数中,最后一个表达式的运算结果---- 修改TEST.LSP程序文件的AIR-1程序,第1个IF函数如下,其余的IF函数请自行修改e.g. (IF (> NUM 100) (PROGN (SETQ DISP "Very High") (PRINC DISP)))注意 : 最后一个关括号是对应前面的IF函数(判断变量NUM是否大于100)尾2的关括号是对应PROGN函数(用以包含SETQ及PRINC函数)尾3的关括号是对应PRINC函数的第2节--------------------------------------------------------------------------------条件判断多重条件(COND [ (条件表达式是表达式) ....] )函数会顺序检查各条件表达式;直到其中一个条件成立(传回 T),即执行该条件式所对应的是表达式每个条件表达式只对应一个是表达式,而没有否表达式若条件式成立且执行对应的是表达式后,则不会再对余下的其它条件表达式进行检查若只有条件表达式而没有对应之是表达式,则只会传回条件表达式的逻辑值若没有提供任何条件表达式及是表达式,函数传回值恒为 nil练习 (Exercises)新增程序AIR-3,以改善上一课AIR-1程序;用一个COND函数判断多个条件表达式DEFUN AIR-3 (NUM) (COND((> NUM 200) (PRINC "Severe"))((> NUM 100) (PRINC "Very High"))((> NUM 50) (PRINC "High"))((> NUM 25) (PRINC "Medium"))((> NUM 0) (PRINC "Low"))(T (PRINC "Cannot Check")))(PRINC))程序说明1 设定函数名称,并将数据存入自变量NUM内;用COND函数进行多重判断2 判断变量NUM是否大于200,若条件成立,则显示 Severe 讯息;第3至6行依此类推7 注意条件式为一个 T 字母,表示条件式恒为真(成立),显示讯息 Cannot Check作用是当以上各条件式均不成立时(变量小于或等于0),即执行此一表达式第3节--------------------------------------------------------------------------------循环 (Loop)配合条件判断,关系及逻辑运算,令程序不断重复一些动作,以提高效率及减少重复动作时的人为错误可以多个循环形成巢状(嵌套式)循环,即在一个循环内嵌套另一个(或多个)循环指定的重复次数必须为正整数,亦可以是储存正整数的变量名称重复指定次数(REPEAT 重复次数[表达式 ....] )e.g. (REPEAT 10 (PRINC "David")) ;重复显示David字符串10次重复(WHILE 条件表达式[是表达式 ....] )若条件表达式的传回值为 T,即会顺序执行函数内各表达式各表达式顺序执行完后,程序会返回函数的开头,重新检查条件表达式的传回值若条件表达式的传回值为 nil,函数内各表达式将不会被执行e.g. (SETQ COUNT 1) ;将1存入变数COUNT(WHILE (<= COUNT 10) ;WHILE函数并检查变量COUNT是否<=10(PRINC "David") ;若条件成立则以PRINC函数显示David字符串(SETQ COUNT (1+ COUNT))) ;变量COUNT递增1,并将新值重新存入变量COUNT中取代原值注意 : 第4行最右边的关括号,是对应第2行WHILE函数的开括号无限循环又称为死循环,即循环的条件判断式传回值恒为 T,令循环不断重复而无法结束;在上例中 :---- 若WHILE函数的条件表达式设定为 (T) ;即条件永远成立---- 不作SETQ函数,或不将变量COUNT递增;变量COUNT储存值恒久不变,导致条件式永远成立第4节--------------------------------------------------------------------------------练习 (Exercises)编写一程序SUM并将自变量存在NUM变量内,计算1+2+3+4 ....至变数NUM的总和(DEFUN SUM (NUM) (SETQ COUNT 1 TOTAL 0)(WHILE (<= COUNT NUM)(SETQ TOTAL (+ TOTAL COUNT)COUNT (1+ COUNT)))(PRINC TOTAL) (PRINC))程序说明1 设定函数SUM并将自变量存入变量NUM,设定变量COUNT以将数目由1开始递增,变量TOTAL(储存总和)初始值为02 WHILE循环函数,并设定进入循环的条件式(变量COUNT小于或等于变量NUM)3 若条件成立即进入循环内部,先将变量TOTAL加上变量COUNT,再用SETQ函数存回变量TOTAL中,覆盖原值4 将变量COUNT递增1,存回变数COUNT并覆盖原值5 关括号与第2行的WHILE函数左边的开括号对应6 循环结束后,用PRINC函数显示变量TOTAL(总和)的内容程序流程假设执行程序时传入变量NUM的数值为10---- 变数初始值 COUNT = 1 TOTAL = 0---- 判断变量COUNT是否<=变量NUM COUNT = 1 TOTAL = 0---- 变量COUNT(现值1)小于NUM,进入循环;将TOTAL(现值0)加上COUNT,存回变数TOTAL COUNT = 1 TOTAL = 1---- 变数COUNT(现值1)递增1变为2,存回变数COUNT COUNT = 2 TOTAL = 1---- 返回WHILE函数的开头,重新判断条件式---- 变量COUNT(现值2)小于NUM,进入循环;将TOTAL(现值1)加上COUNT,存回变数TOTAL COUNT = 2 TOTAL = 3---- 变数COUNT(现值2)递增1变为3,存回变数COUNT COUNT = 3 TOTAL = 3---- 返回WHILE函数的开头,重新判断条件式---- 变量COUNT(现值3)小于NUM,进入循环;将TOTAL(现值3)加上COUNT,存回变数TOTAL COUNT = 3 TOTAL = 6部份过程省略---- 返回WHILE函数的开头,重新判断条件式---- 变量COUNT(现值10)仍等于NUM,进入循环;将TOTAL(现值45)加上COUNT,存回变数TOTAL COUNT = 10 TOTAL = 55---- 变数COUNT(现值10)递增1变为11,存回变数COUNT COUNT = 11 TOTAL = 55---- 返回WHILE函数的开头,重新判断条件式---- 变量COUNT(现值11)巳大于NUM(本范例假设为10),条件判断不成立,循环结束 COUNT = 11 TOTAL = 55---- 显示变量TOTAL的现存值,程序结束尝试用IF函数检查输入的自变量是否小于或等于0;若条件成立则不执行余下的程序(DEFUN SUM (NUM) (IF (<= NIM 0) (PRINC "Input Error")(PROGN略过 WHILE 及 PRINC 函数))(PRINC))程序说明。
lisp语言入门
Lisp语言入门Lisp是一门历史悠久的语言,全名叫LISt Processor,也就是“表处理语言”,它是由John McCarthy于1958年就开始设计的一门语言。
和Lisp同时期甚至更晚出现的许多语言如Algo等如今大多已经消亡,又或者仅仅在一些特定的场合有一些微不足道的用途,到现在还广为人知的恐怕只剩下了Fortran和COBOL。
但唯独Lisp,不但没有随着时间而衰退,反倒是一次又一次的焕发出了青春,从Lisp分支出来的Scheme、ML等语言在很多场合的火爆程度甚至超过了许多老牌明星。
那么这颗常青树永葆青春的奥秘究竟在哪里呢?如果你只接触过C/C++、Pascal这些“过程式语言”的话,Lisp可能会让你觉得十分不同寻常,首先吸引你眼球(或者说让你觉得混乱的)一定是Lisp程序中异常多的括号,当然从现在的角度来讲,这种设计的确对程序员不大友好,不过考虑到五六十年代的计算机处理能力,简化语言本身的设计在那时算得上是当务之急了。
Lisp的基本语法很简单,它甚至没有保留字(有些语言学家可能对这一点有异议,别怕,我听你们的),它只有两种基本的数据,仅有一种基本的语法结构就是表达式,而这些表达式同时也就是程序结构,但是正如规则最简单的围棋却有着最为复杂的变化一样,Lisp使用最基本的语言结构定义却可以完成其它语言难于实现的、最复杂的功能。
废话少说,现在我们就来看看Lisp语言中的基本元素。
Lisp的表达式是一个原子(atom)或表(list),原子(atom)是一个字母序列,如a b c;表是由零个或多个表达式组成的序列,表达式之间用空格分隔开,放入一对括号中,如:a b c()(a b c x y z)(a b(c)d)最后一个表是由四个元素构成的,其中第三个元素本身也是一个表。
正如算数表达式1+1有值2一样,Lisp中的表达式也有值,如果表达式e得出值v,我们说e返回v。
如果一个表达式是一个表,那么我们把表中的第一个元素叫做操作符,其余的元素叫做自变量。
AutoLISP Visual LISP教程《第五章》
(b)
图5-2 用鼠标移动和复制文本时的光标 -
4. 查找文本
选择下拉菜单Search→ ind, 选择下拉菜单Search→Find,或单击工具栏按钮 示查找对话框. 示查找对话框. ,将弹出图5-3所 将弹出图5
图5-3查找对话框 查找对话框 有关查找文本对话框的说明如下: 有关查找文本对话框的说明如下: What编辑框 用于输入要查找的字符串, 编辑框: ( 1 ) Find What 编辑框 :用于输入要查找的字符串 , 如果在查找操作前选 取了文本,被选文本将会自动出现在Find What文本框内 文本框内. 取了文本,被选文本将会自动出现在Find What文本框内.
(2)Search栏:确定查找范围.该栏有四个互锁按钮.依次是: Search栏 确定查找范围.该栏有四个互锁按钮.依次是: selection:在文本编辑器窗口中亮显的文本中查找; ● Current selection:在文本编辑器窗口中亮显的文本中查找; file:仅在活动编辑器窗口中的文件中查找; ● Current file:仅在活动编辑器窗口中的文件中查找; Project:在随后指定的工程文件所包含的全部文件中查找, ● Project : 在随后指定的工程文件所包含的全部文件中查找 , 并在新的输出窗 口中显示所有与查找字符串匹配的表达式. 口中显示所有与查找字符串匹配的表达式. ● Files : 在指定要查找文件目录和文件类型的所有文件中查找 , 并在新的输出 Files:在指定要查找文件目录和文件类型的所有文件中查找, 窗口中显示所有与查找字符串匹配的表达式. 窗口中显示所有与查找字符串匹配的表达式 . 在这个新的输出窗口用鼠标左键双击 任意亮显的表达式, LISP将打开与其相关的LISP文件 将打开与其相关的LISP文件. 任意亮显的表达式,Visual LISP将打开与其相关的LISP文件.文件的类型可以用通 配符. 配符. (3)Direction栏:确定查找方向.该栏有两个互锁按钮.依次是: Direction栏 确定查找方向.该栏有两个互锁按钮.依次是: Down:从光标当前位置处开始向下查找; ● Down:从光标当前位置处开始向下查找; ● Up:从光标当前位置处开始向上查找. :从光标当前位置处开始向上查找.
LISP编程语言教学手册说明书
1About the T utorialLISP is the second-oldest high-level programming language after Fortran and has changed a great deal since its early days, and a number of dialects have existed over its history. Today, the most widely known general-purpose LISP dialects are Common LISP and Scheme.This tutorial takes you through features of LISP Programming language by simple and practical approach of learning.AudienceThis reference has been prepared for the beginners to help them understand the basic to advanced concepts related to LISP Programming language.PrerequisitesBefore you start doing practice with various types of examples given in this reference, we assume that you are already aware of the fundamentals of computer programming and programming languages.Copyright & DisclaimerCopyright 2014 by Tutorials Point (I) Pvt. Ltd.All the content and graphics published in this e-book are the property of Tutorials Point (I) Pvt. Ltd. The user of this e-book is prohibited to reuse, retain, copy, distribute or republish any contents or a part of contents of this e-book in any manner without written consent of the publisher.You strive to update the contents of our website and tutorials as timely and as precisely as possible, however, the contents may contain inaccuracies or errors. Tutorials Point (I) Pvt. Ltd. provides no guarantee regarding the accuracy, timeliness or completeness of our website or its contents including this tutorial. If you discover any errors on our website or in this tutorial, please notify us at **************************iT able of ContentsAbout the Tutorial (i)Audience (i)Prerequisites (i)Copyright & Disclaimer (i)Table of Contents (ii)1.OVERVIEW (1)Features of Common LISP (1)Applications Developed in LISP (1)2.ENVIRONMENT SETUP (3)How to Use CLISP (3)3.PROGRAM STRUCTURE (4)A Simple LISP Program (4)LISP Uses Prefix Notation (5)Evaluation of LISP Programs (5)The 'Hello World' Program (6)4.BASIC SYNTAX (7)Basic Elements in LISP (7)Adding Comments (8)Notable Points (8)LISP Forms (8)Naming Conventions in LISP (9)Use of Single Quotation Mark (9)5.DATA TYPES (11)Type Specifiers in LISP (11)6.MACROS (14)Defining a Macro (14)7.VARIABLES (15)Global Variables (15)Local Variables (16)8.CONSTANTS (18)9.OPERATORS (19)Arithmetic Operations (19)Comparison Operations (20)Logical Operations on Boolean Values (22)Bitwise Operations on Numbers (24)10.DECISION MAKING (27)The cond Construct in LISP (28)The if Construct (29)The when Construct (30)The case Construct (31)11.LOOPS (32)The loop Construct (33)The loop for Construct (33)The do Construct (35)The dotimes Construct (36)The dolist Construct (37)Exiting Gracefully from a Block (38)12.FUNCTIONS (40)Defining Functions in LISP (40)Optional Parameters (41)Keyword Parameters (43)Returning Values from a Function (43)Lambda Functions (45)Mapping Functions (45)13.PREDICATES (47)14.NUMBERS (51)Various Numeric Types in LISP (52)Number Functions (53)15.CHARACTERS (56)Special Characters (56)Character Comparison Functions (57)16.ARRAYS (59)17.STRINGS (66)String Comparison Functions (66)Case Controlling Functions (68)Trimming Strings (69)Other String Functions (70)18.SEQUENCES (73)Creating a Sequence (73)Generic Functions on Sequences (73)Standard Sequence Function Keyword Arguments (76)Finding Length and Element (76)Modifying Sequences (77)Sorting and Merging Sequences (78)Sequence Predicates (79)19.LISTS (81)The Cons Record Structure (81)Creating Lists with list Function in LISP (82)List Manipulating Functions (83)Concatenation of car and cdr Functions (85)20.SYMBOLS (86)Property Lists (86)21.VECTORS (89)Creating Vectors (89)Fill Pointer Argument (90)22.SET (92)Implementing Sets in LISP (92)Checking Membership (93)Set Union (94)Set Intersection (95)Set Difference (96)23.TREE (98)Tree as List of Lists (98)Tree Functions in LISP (98)Building Your Own Tree (100)Adding a Child Node into a Tree (100)24.HASH TABLE (103)Creating Hash Table in LISP (103)Retrieving Items from Hash Table (104)Adding Items into Hash Table (104)Applying a Specified Function on Hash Table (106)25.INPUT & OUTPUT (107)Input Functions (107)Reading Input from Keyboard (108)Output Functions (110)Formatted Output (113)26.FILE I/O (115)Opening Files (115)Writing to and Reading from Files (116)Closing a File (118)27.STRUCTURES (119)Defining a Structure (119)28.PACKAGES (122)Package Functions in LISP (122)Creating a Package (123)Using a Package (123)Deleting a Package (125)29.ERROR HANDLING (127)Signaling a Condition (127)Handling a Condition (127)Restarting or Continuing the Program Execution (128)Error Signaling Functions in LISP (131)MON LISP OBJECT SYSTEMS (133)Defining Classes (133)Providing Access and Read/Write Control to a Slot (133)Defining a Class Method (135)Inheritance (136)LISP8LISP stands for LIS t P rogramming. John McCarthy invented LISP in 1958, shortly after the development of FORTRAN. It was first implemented by Steve Russell on an IBM 704 computer. It is particularly suitable for Artificial Intelligence programs, as it processes symbolic information efficiently.Common LISP originated during the decade of 1980 to 1990, in an attempt to unify the work of several implementation groups, as a successor of Maclisp like ZetaLisp and New Implementation of LISP (NIL) etc.It serves as a common language, which can be easily extended for specific implementation. Programs written in Common LISP do not depend on machine-specific characteristics, such as word length etc.Features of Common LISP∙ It is machine-independent∙ It uses iterative design methodology∙ It has easy extensibility∙ It allows to update the programs dynamically∙ It provides high level debugging.∙ It provides advanced object-oriented programming.∙ It provides convenient macro system.∙ It provides wide-ranging data types like, objects, structures, lists, vectors, adjustable arrays, hash-tables, and symbols.∙ It is expression-based.∙ It provides an object-oriented condition system.∙ It provides complete I/O library.∙ It provides extensive control structures.1. OVERVIEWLISPApplications Developed in LISPThe following applications are developed in LISP: Large successful applications built in LISP.∙Emacs: It is a cross platform editor with the features of extensibility, customizability, self-document ability, and real-time display.∙G2∙AutoCad∙Igor Engraver∙Yahoo Store9LISP10CLISP is the GNU Common LISP multi-architechtural compiler used for setting up LISP in Windows. The Windows version emulates Unix environment using MingW under Windows. The installer takes care of this and automatically adds CLISP to the Windows PATH variable.You can get the latest CLISP for Windows at:/projects/clisp/files/latest/downloadIt creates a shortcut in the Start Menu by default, for the line-by-line interpreter.How to Use CLISPDuring installation, CLISP is automatically added to your PATH variable if you select the option (RECOMMENDED). It means that you can simply open a new Command window and type "clisp" to bring up the compiler. To run a *.lisp or *.lsp file, simply use: clisp hello.lisp2. ENVIRONMENT SETUPLISP11LISP expressions are called symbolic expressions or S-expressions. The S-expressions are composed of three valid objects:∙ Atoms ∙ Lists ∙StringsAny S-expression is a valid program. LISP programs run either on an interpreter or as compiled code.The interpreter checks the source code in a repeated loop, which is also called the Read-Evaluate-Print Loop (REPL). It reads the program code, evaluates it, and prints the values returned by the program.A Simple LISP ProgramLet us write an s-expression to find the sum of three numbers 7, 9 and 11. To do this, we can type at the interpreter prompt ->: (+7911)LISP returns the following result: 27If you would like to execute the same program as a compiled code, then create a LISP source code file named myprog.lisp and type the following code in it: (write(+7911))When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result is: 273. PROGRAM STRUCTURELISP Uses Prefix NotationIn prefix notation, operators are written before their operands. You might have noted that LISP uses prefix notation. In the above program, the ‘+’ symbol works as a function name for the process of summation of the numbers.For example, the following expression,a * (b +c ) / dis written in LISP as:(/ (* a (+ b c) ) d)Let us take another example. Let us write code for converting Fahrenheit temperature of 60o F to the centigrade scale:The mathematical expression for this conversion is:(60 * 9 / 5) + 32Create a source code file named main.lisp and type the following code in it:(write(+ (* (/ 9 5) 60) 32))When you click the Execute button, or type Ctrl+E, MATLAB executes it immediately and the result is:140Evaluation of LISP ProgramsThe LISP program has two parts:∙Translation of program text into LISP objects by a reader program.∙Implementation of the semantics of the language in terms of LSIP objects by an evaluator program.The evaluation program takes the following steps:∙The reader translates the strings of characters to LISP objects or s-expressions.12∙The evaluator defines syntax of LISP forms that are built from s-expressions.∙This second level of evaluation defines a syntax that determines which s-expressions are LISP forms.∙The evaluator works as a function that takes a valid LISP form as an argument and returns a value. This is the reason why we put the LISP expression in parenthesis, because we are sending the entire expression/form to the evaluator as argument.The 'Hello World' ProgramLearning a new programming language does not really take off until you learn how to greet the entire world in that language, right ?Let us create new source code file named main.lisp and type the following code in it:(write-line "Hello World")(write-line "I am at 'Tutorials Point'! Learning LISP")When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result is:Hello WorldI am at 'Tutorials Point'! Learning LISP13LISP14This chapter introduces you to basic syntax structure in LISP.Basic Elements in LISPLISP programs are made up of three basic elements:∙ atom ∙ list ∙stringAn atom is a number or string of contiguous characters. It includes numbers and special characters. The following examples show some valid atoms: hello-from-tutorials-point name 123008907 *hello* Block#221 abc123A list is a sequence of atoms and/or other lists enclosed in parentheses. The following examples show some valid lists: ( i am a list) (a ( a b c) d e fgh)(father tom ( susan bill joe)) (sun mon tue wed thur fri sat) ( )A string is a group of characters enclosed in double quotation marks. The following examples show some valid strings:4. BASIC SYNTAX" I am a string""a ba c d efg #$%^&!""Please enter the following details:""Hello from 'Tutorials Point'! "Adding CommentsThe semicolon symbol (;) is used for indicating a comment line.Example(write-line "Hello World") ; greet the world; tell them your whereabouts(write-line "I am at 'Tutorials Point'! Learning LISP")When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result returned is:Hello WorldI am at 'Tutorials Point'! Learning LISPNotable PointsThe following important points are notable:∙The basic numeric operations in LISP are +, -, *, and /∙LISP represents a function call f(x) as (f x), for example cos(45) is written as cos 45∙LISP expressions are not case-sensitive. Means, cos 45 or COS 45 are same.∙LISP tries to evaluate everything, including the arguments of a function. Only three types of elements are constants and always return their own value:o Numberso The letter t, that stands for logical trueo The value nil, that stands for logical false, as well as an empty list.15LISP FormsIn the previous chapter, we mentioned that the evaluation process of LISP code takes the following steps:∙The reader translates the strings of characters to LISP objects or s-expressions.∙The evaluator defines syntax of LISP forms that are built from s-expressions.This second level of evaluation defines a syntax that determines which s-expressions are LISP forms.A LISP form can be:∙An atom∙An empty list or non-list∙Any list that has a symbol as its first elementThe evaluator works as a function that takes a valid LISP form as an argument and returns a value.This is the reason why we put the LISP expression in parenthesis,because we are sending the entire expression/form to the evaluator as argument.Naming Conventions in LISPName or symbols can consist of any number of alphanumeric characters other than whitespace, open and closing parentheses, double and single quotes, backslash, comma, colon, semicolon and vertical bar. To use these characters in a name, you need to use escape character (\).A name can have digits but must not be made of only digits, because then it would be read as a number. Similarly a name can have periods, but cannot be entirely made of periods.Use of Single Quotation MarkLISP evaluates everything including the function arguments and list members.At times, we need to take atoms or lists literally and do not want them evaluated or treated as function calls. To do this, we need to precede the atom or the list with a single quotation mark.16The following example demonstrates this:Create a file named main.lisp and type the following code into it:(write-line "single quote used, it inhibits evaluation")(write '(* 2 3))(write-line " ")(write-line "single quote not used, so expression evaluated")(write (* 2 3))When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result is:single quote used, it inhibits evaluation(* 2 3)single quote not used, so expression evaluated617LISP18LISP data types can be categorized as:Scalar types - numbers, characters, symbols etc. Data structures - lists, vectors, bit-vectors, and strings.Any variable can take any LISP object as its value, unless you declare it explicitly. Although, it is not necessary to specify a data type for a LISP variable, however, it helps in certain loop expansions, in method declarations and some other situations that we will discuss in later chapters.The data types are arranged into a hierarchy. A data type is a set of LISP objects and many objects may belong to one such set.The typep predicate is used for finding whether an object belongs to a specific type. The type-of function returns the data type of a given object.T ype Specifiers in LISPType specifiers are system-defined symbols for data types.Array fixnum package simple-string Atom float pathname simple-vector Bignum function random-state single-float Bit hash-table Ratio standard-char bit-vector integer Rational stream Character keyword readtable string [common]listsequence[string-char]5. DATA TYPESLISP compiled-function long-float short-float symbolComplex nill signed-byte tCons null simple-array unsigned-bytedouble-float number simple-bit-vector vectorApart from these system-defined types, you can create your own data types. When a structure type is defined using defstruct function, the name of the structure type becomes a valid type symbol.>/p>Example 1Create new source code file named main.lisp and type the following code in it:(setq x 10)(setq y 34.567)(setq ch nil)(setq n 123.78)(setq bg 11.0e+4)(setq r 124/2)(print x)(print y)(print n)(print ch)(print bg)(print r)When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result returned is:1034.567123.78NIL19LISP110000.062Example 2Next let us check the types of the variables used in the previous example. Create new source code file named main.lisp and type the following code in it:(setq x 10)(setq y 34.567)(setq ch nil)(setq n 123.78)(setq bg 11.0e+4)(setq r 124/2)(print (type-of x))(print (type-of y))(print (type-of n))(print (type-of ch))(print (type-of bg))(print (type-of r))When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result is:(INTEGER 0 281474976710655)SINGLE-FLOATSINGLE-FLOATNULLSINGLE-FLOAT(INTEGER 0 281474976710655)20LISP 21LISP22This chapter introduces you about macros in LISP.A macro is a function that takes an s-expression as arguments and returns a LISP form, which is then evaluated. Macros allow you to extend the syntax of standard LISP.Defining a MacroIn LISP, a named macro is defined using another macro named defmacro. Syntax for defining a macro is:(defmacro macro-name (parameter-list)"Optional documentation string."body-form)The macro definition consists of the name of the macro, a parameter list, an optional documentation string, and a body of LISP expressions that defines the job to be performed by the macro.ExampleLet us write a simple macro named setTo10, which takes a number and sets its value to 10.Create new source code file named main.lisp and type the following code in it: defmacro setTo10(num)(setq num 10)(print num))(setq x 25)(print x)(setTo10 x)When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result is:6. MACROSLISP251023LISP24In LISP, each variable is represented by a symbol. The name of the variable is the name of the symbol and it is stored in the storage cell of the symbol. Global V ariablesGlobal variables are generally declared using the defvar construct. Global variables have permanent values throughout the LISP system and remain in effect until new values are specified.Example(defvar x 234)(write x)When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result is:234As there is no type declaration for variables in LISP, you need to specify a value for a symbol directly with the setq construct.Example->(setq x 10)The above expression assigns the value 10 to the variable x. You can refer to the variable using the symbol itself as an expression.The symbol-value function allows you to extract the value stored at the symbol storage place.ExampleCreate new source code file named main.lisp and type the following code in it: (setq x 10)(setq y 20)7. VARIABLES(format t "x = ~2d y = ~2d ~%" x y)(setq x 100)(setq y 200)(format t "x = ~2d y = ~2d" x y)When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result is:x = 10 y = 20x = 100 y = 200Local V ariablesLocal variables are defined within a given procedure. The parameters named as arguments within a function definition are also local variables. Local variables are accessible only within the respective function.Like the global variables, local variables can also be created using the setq construct. There are two other constructs - let and prog for creating local variables.The let construct has the following syntax:(let ((var1 val1) (var2 val2).. (varn valn))<s-expressions>)Where var1, var2,…,varn are variable names and val1, val2,…, valn are the initial values assigned to the respective variables.When let is executed, each variable is assigned the respective value and at last, the s-expression is evaluated. The value of the last expression evaluated is returned.If you do not include an initial value for a variable, the variable is assigned to nil. ExampleCreate new source code file named main.lisp and type the following code in it:(let ((x 'a)(y 'b)(z 'c))(format t "x = ~a y = ~a z = ~a" x y z))25When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result is:x = A y = B z = CThe prog construct also has the list of local variables as its first argument, which is followed by the body of the prog,and any number of s-expressions.26End of ebook previewIf you liked what you saw…Buy it from our store @ https://27。
AutoLISP-Visual-LISP教程《第六章》
单击按钮 ,光标停在(getdist p1 "输入矩形的宽:") 之前,并亮显该表达式。注意,指示按钮内的"I"回到"()"之 前。监视窗口内的变量p1=[100.0 80.0 0.0]。重复类似的操 作,在AutoCAD窗口输入矩形的宽度为200、高度为150,旋转角 为30。在操作过程中指示按钮随时显示着光标相对于表达式的 位置,监视窗口显示着这些变量的当前值(注意,alf的单位为 弧度)。也说明单击按钮 只执行了一步表达式求值。
2. 监视窗口的快捷菜单
选择监视列表中的某一项并单击鼠标右键,可显示图6-4所示监视窗口 的快捷菜单。
调用检验功能,查看所选值。 将所选变量的值复制到系统变量 *obj* 中。 将所选变量值加上一个单引号前缀”,打印到把握台窗口。 对所选变量调用符号效劳对话框。 调用自动匹配选项对话框,用所选变量名作自动匹配参数。 从监视窗口中删除所选变量。
从断点循环退出,将恢复上一层循环。假设在该断 点循环中修改了某变量的值,程序连续运行时将使用变 量修改后的值。
断点循环分为可连续断点循环和不行连续断点循环。
1. 可连续的断点循环 可连续的断点循环是指可以在程序中断处,连续向下执行剩
余的表达式。用以下方法进入可连续断点循环: 〔1〕翻开Stop Once模式,遇到带调试信息的表达式时。 〔2〕遇到带Debug on Entry〔进入时调试〕标志的函数时。 〔3〕遇到程序中设置的断点时。 〔4〕单击暂停按钮进入断点循环时。 〔5〕在前一个断点循环状态下,执行Step Into、Step Over或 Step Out时。
图6-2 Debug下拉菜单
下下跳连退重设添显调
一一出续出置置加示试
层个表执当为或监上指
LISP教程
14.1 关于AutoLISPAutoLISP是由Autodesk公司开发的一种LISP程序语言(LISP是List Processor的缩写)。
第一篇关于LISP 的参考文献是由John McCarthy 在1960年4月的《ACM通讯》中发表的。
除了FORTRAN和COBOL,大多数在六十年代早期开发出来的语言都过时了,可是LISP却生下来,并且已经成为人工智能(AI)的首选程序序言。
AutoLISP解释程序位于AutoCAD软件包中,然而AutoCAD R2.17及更低版本中并不包含AutoLISP解释程序,这样,只有通过AutoCAD R2.18及更高版本才可以使用AutoLISP 语言。
AutoCAD软件包中包含大多数用于产生图形的命令,但仍有某些命令末被提供。
例如,AutoCAD中没有在图形文本对象内绘制矩形及作全局改变的命令。
通过AutoLISP,你可以使用AutoLISP程序语言编制能够在图形文本对象内绘制矩形或作全局选择性改变的程序。
事实上,可以用AutoLISP编制任何程序,或把它嵌入到菜单中,这样定制你的系统会取得更高的效率。
现在,已经有数以百计的第三方软件开发人员使用AutoLISP语言编制各种应用程序软件包,例如,本文作者开发了一个名为SMLayout的软件包,用它可以产生各种复杂几何图形的平面布局图,这些几何图形包括管道的交叉部、过渡都、圆柱、弯管接头、圆锥以及罐顶。
目前社会上非常需要AutoLISP程序员为应用软件及客户菜单的开发提供顾问。
在本章中,我们假定读者已经熟悉了AutoCAD命令及AutoCAD的系统变量。
但是,在开始学习AutoLISP时,却并不需要你是一位AutoCAD或编程专家。
同时,本章还假定读者并无编程方面的知识。
如果你熟悉任何一种编程语言,那么学习AutoLISP就会很容易。
对各种函数的评细探讨以及对例题的逐步讲解会使你学起来很有兴趣。
本章讨论常用的AutoLISP函数以及它们S程序编制中的应用。
Lisp教程(下册 DCL编程)彩版
DCL(D i alog Control Languag e)语言教程课程简介课程主要介绍AutoLISP程序的编写,配合使用DC L(Dialog Control Language)语言,作对话方框的开发及应用.本课程只适合对AutoLISP程序设计有相当认识之人仕.全课共分为12篇,每篇一个主题;而每篇再分为若干小节,每天顺序显示.内文若有错漏,敬祁见谅,欢迎来函赐教,多谢!!课程大纲第一篇(0 - 4 课) AutoLISP及Dialog程序设计基本知识第二篇(5 - 8 课)开启对话方框第三篇(9 - 13 课)设定及取得对话框内组件的值第四篇(14 - 19 课)按钮(button)及核取框(切换钮,toggle)第五篇(20 - 25 课)横列(row),直行(colum n),空白(spacer)及文字组件(text)第六篇(26 - 30 课)滑杆(滚动条)组件(sli d er)第七篇(31 - 36 课)其它按钮及影像按钮组件(image_button)第八篇(37 - 43 课)列表选框组件(list_bo x)第九篇(44 - 48 课)下拉式(弹出式)列表选框组件(popup_list)第十篇(49 - 52 课)选台钮(radio_button)第十一篇(53- 57 课)影像组件(image)第十二篇(58- 60 课)其它组件注意事项在各篇课程所介绍的语法结构中,包含在方括号[]中的数据,表示为选择性项目;可因应情况,自行决定是否须要加上.字型为紫色的项目,表示可自行设定其名称或内容定义文件为设定对话框组件的纯文本文件(扩展名为DCL),程序文件则是编写AuotLISP程序的纯文本文件(扩展名LSP)在定义档中,批注以双除号//开始,批注符号及其右边的文字可以不输入;但在程序文件中,批注以分号;开始,批注符号及其右边的文字可以不输入.第一篇基本知识基本知识对话框是现今最流行的人机互动面接口;在早期的AutoCAD版本中巳经使用,但只有在R12版本开始,才提供给用户自行编程的对话框开发功能.对话框的描述定义在一纯文本檔(扩展名为DC L)内,无须特别的开发环境定义文件中的对话框描述,均以对话控制语言(D ialog Control Language,简称DCL语言) 所建立在AutoLISP程序中,配合可编程对话框(Porg r ammable Dialog Box,简称PDB)函数,激活及操控对话框可以在一个定义档(扩展名DCL)中定义多个对话框对话框由方块本身,及包含于其内的组件(或称为控件,构件)所组成每个组件的属性定义均包含在一对大括号{}中在定义文件中,各组件及其属性均为小写;只有在赋值给属性,或设定对话框名称时才可使用大写字母属性以等号=赋值,并以分号;结束(注意: 在A u toLISP程序中,分号是作为批注) 一般要在组件名称前加上一个冒号:,但若组件并不设定属性,则不需要在组件名称前加冒号,但却要以分号结束空行会被忽若定义档发生严重的错误,会在当前的目录下,产生ACAD.DCE文件,以指明所发生的错误.定义档BASE.DCL默认在SUPPORT的目录中,它包含了各组件的原型定义,及各类型巳定义的其它基本组件;而所有自行开发的对话框定义文件,都可以使用在BASE.DCL定义文件中的各个组件ACAD.DCL默认在SUPPORT的目录中,它包含了AutoCAD中所有标准对话框的定义参考定义档可在自行开发的对话框定义文件中,经由inclu de指令,取得指定DCL文件中所定义的组件;其语法如下:@include "对话框定义档"e.g. @include "david.dcl"定义档名称要包含在双引号"中,可以在檔名前加上定的目录路径会先在当前的目录中搜寻该定义文件,然后是定义文件所在的目录;若有指定档案的路径,则只会在指定的目录内寻找不可以参考ACAD.DCL所定义的对话框,即不可以使用@include"acad.dcl"预视对话框若在Visual LISP中开启一对话框定义文件,即可使用:工具-- 接口工具-- 预览编辑器DCL在下拉式列示框中,选取该定义文件中所设定的对话框名称,即可预视对话框亦可直接输入该对话框的名称(要注意大小写)批注///**/表示其右边(至该行末端)的文字视为注释包括在两个批注符号中间的所有文字(可跨越多行)均视为注释语义检核提供4个等级的检核,该些检核会在对话框载入时完成;可以将下列语句放在定义档中的任何位置,但不能在任何对话框的定义内.dcl_settings : default_dcl_settin g s {audit_level = 3;}等级0 不检查: 只有在该定义档巳被检核且不会再作修改时使用等级1 错误: 找出可能造成AutoCAD终止的错误,此等级也是默认值等级2 警告: 找出配置或行为模式的错误,所有定义在修改后,最少应执行此等级的检查一次等级3 提示: 找出多余的属性定义对话框的设计美观性颜色配比,组件整齐排列等方便性相同功能的项目要编排在一起,或使用线框包围使用频繁的项目应设置在最显眼及方便的位置适当设置快捷键及默认值(默认值,省缺值)除非对话框中的项目过多,否则应避免使用巢状(嵌套)式对话方框互锁或互换项目选取(或不选取)时,会否引致其它项目功能的改变(enable或disable...等)对话框定义文件内容模式对话框名称:dialog{label="对话框标题";:组件名称{属性名称=属性值;}//组件定义结束}//对话框结束定义说明1 对话框名称就是由AutoLISP程序,启动对话框时所呼叫的名称;可以自行设定,要区分大小写字母dialog为对话框中,最外层的组件(即整个对话框),其它的组件均包含在其中一般组件要以冒号:开始,并为小写字母;因为不是属性,所以不须使用分号;结束2 开大括号{紧随组件名称之后,以包含该组件的属性或其它组件label为属性名称,并以等号=赋以其右边的属性值,最后以分号;结束该行叙述3 包含在对话框中的其它组件组件要以冒号:开始,并为小写字母;因为不是属性,所以不须使用分号;结束4 开大括号{紧随组件名称之后,以包含组件的属性或其它组件包含在组件中的属性,要以等号=赋以其右边的属性值;最后以分号;结束该行叙述5 以关大括号}与第4行的开大括号}对应,以结束该组件(第3行)之定义双除号//右边的文字即为批注6 以关大括号}与第2行的开大括号}对应,以结束该组件之定义(在本例中为整个对话框的定义,即第1行的dialog组件注意: 上例中缩排只为方便观察及维护,不作缩排亦可包含在对话框中的组件及组件中的属性可以不只一个练习(Exercises)请输入以下的对话框定义,并命名为RECT.DCL(纯文本格式),存在C盘的根目录中RECT:dialog{label="Rectangle" ;:text//文字组件{label="Rectangle width :" ; //组件的属性}ok_only;}定义说明:1 设定对话框的名称为RECT,紧接一个以冒号开始的组件dialog2 最左边为dialog组件的开大括号,右边是其属性label,并以等号设定其属性值为"Rectangle",以分号结束此行叙述3 text为"字符串"组件,其作用是在对话框中显示文字,组件名称前要加冒号4 最左边为text组件的开大括号,右边是其属性l a bel,并以等号设定其属性值为"Rectanglewidth",最后以分号结束此行叙述5 关大括号是对应第4行的开大括号,这对大括号同属于第3行的text组件6 ok_only为一"按钮组件",它的作用是在对话框中显示一个"确定(OK)"按钮;在一个对话框中,必需提供最少一个"确定"按钮,或一个"取消"按钮(组件名称为cancel_button),以作为结束对话框之用;本例中不设定按钮之属性,固不需以冒号放在组件名称的前面,但却需要以分号结束7 关大括号是对应第2行的开大括号,这对大括号同属于第1行的dialog组件注意:虽然定义档巳经完作,但仍要待学习完第2篇的课程后,才能开启及显示该对话框第二篇开启对话框AutoLISP函数加载DCL定义文件函数(LOAD_DIALOG "对话框定义档名称")e.g. (LOAD_DIALOG "C:/RECT.DCL")自变量是要加载的对话框定义文件名称字符串(所以要在前后加双引号);若不设定扩展名则预设为.DCL 函数会依资源搜寻路径找寻该定义文件;不在搜寻路径中的档案,要在文件名前加上指定的路径函数若成功加载该定义档,会传回一正整数值的档案处理码,供其它函数呼叫使用;无法载入时则传回负整数值一般会将传回的档案处理码以SETQ函数存入变量中e.g. (SETQ DCL_ID (LOAD_DIALO G"C:/R E CT.DCL"))开启并显示对话框(NEW_DIALOG "对话框名称"档案处理码["预设动作"[对话框位置]])e.g. (NEW_DIALOG "RECT" DCL_ID)对话框名称为字符串,要在前后加双引号;要注意一个定义檔中,可包含多个对话框名称及其定义档案处理码是经由LOAD_DIALOG函数取得默认动作为字符串表示式;函数可以不加默认动作,或以空字符串""表示如果要设定对话框显示时的位置,则必须同时设定默认动作对话框位置为2D的点串行,指定对话框左上角的X,Y坐标如果以'(-1 -1)为对话框位置,则会在绘图屏幕的中心点开启对话框如果成功开启对话框,函数会传回T,否则传回N IL开始接受使用者输入(START_DIALOG)函数不须提供任何自变量使前一个用NEW_DIALOG函数开启的对话框开始作用,直至操作表示式或回复函数呼叫DONE_DIALOG函数为止一般DONE_DIALOG与关键词accept(一般是按下确定按钮)或关键词cancel(一般是按下取消按钮)相关若传回值为1,表示使用者按下确定钮结束对话框;0表示按下取消钮;-1表示全部对话框都以TERM_DIALOG函数终止;大于1的整数,其意义由应用程序决定释放(卸除)对话框(UNLOAD_DIALOG "档案处理码")e.g. (UNLOAD_DIALOG DCL_ID)从内存释放档案处理码(经由LOAD_DIALOG函数取得)指定的对话框定义档函数传回值一定是NIL对话框开启方式(DEFUN C:函数名称()(SETQ 变量(LOAD_DIALOG "对话框定义档"))(NEW_DIALOG "对话框名称"变量)(START_DIALOG) (UNLOAD_DIALOG 变数))程序说明:1 以DEFUN函数定义程序的名称,使用LOAD_DIALOG函数加载指定的对话框定义档使用SETQ函数,将LOAD_DIALOG传回的档案处理码存入变量中,以方便其它函数使用2 使用NEW_DIALOG,开启及显示定义文件中(档案处理码),指定的对话框3 使用START_DIALOG函数,使对话框开始作用并接受使用者输入使用UNLOAD_DIALOG函数以结束对话框4 关括号是对应第1行DEFUN函数左边的开括号,结束整个程序练习(Exercises)编写一AutoLISP程序,以开启上一课所定义的对话框;并将该程序命名为RECT.LSP,存在C盘的根目录中,程序代码如下:(DEFUN C:RECT() (SETQ DCL_ID (LOAD_DIALOG "C:/RECT.DCL"))(NEW_DIALOG "RECT" DCL_ID)(START_DIALOG) (UNLOAD_DIALOG DCL_ID))程序说明:1 以DEFUN函数定义程序的名称为RECT,使用LOAD_DIALOG函数将对话框定义文件RECT.DCL载入;使用SETQ函数,将LOAD_DIALOG传回的档案处理码存入变量DCL_ID中,以方便其它函数使用2 使用NEW_DIALOG,开启及显示定义文件中(档案处理码)名称为RECT的对话框3 使用START_DIALOG函数,使对话框开始作用并接受使用者输入(在本例中只有确定钮可按);使用UNLOAD_DIALOG函数以结束对话框4 关括号是对应第1行DEFUN函数左边的开括号,结束整个程序编辑框组件(edit_box)可供用户直接输入字符串的矩形方框;注意在编辑框中所显示及输入的数据均为字符串型态,而数字则要在取得编辑框的字符串内容后(在下一篇中介绍),使用AutoLISP函数将其转为数值型态的数据:edit_box//组件名称{属性="属性值";}属性label显示在编辑框前面(左边)的提示文字key 其属性值即为使用该组件的关键词,使在AutoL I SP程序中操控此组件;在同一个对话框定义中,不能有相同名称的关键词定义edit_limit指定在编辑框中,可输入字符串的最大字符长度edit_width指定编辑框显示时的阔度(通常与fixed_width属性一拼使用)value 指定编辑框显示时,当中的默认值(注意显示数值数据时,要先用AutoLISP 函数将数据(或变量)转为字符串型态)fixed_width通常与width属性一拼使用,以固定编辑框显示时的阔度(其属性值可设定为true或false)is_enable 可设定编辑框是否可以使用(其属性值可设定为true或false,默认值为true)alignment 如果组件成水平方向排列,属性值可设定为lef t,right或centere d如果组件成垂直方向排列,属性值可设定为top,bottom或centere d(水平方向的默认值为left,垂直方向则为cent e red)其它属性action allow_accept fixed_height heightis_tab_stop mnemonic width练习(Exercises)将上一课的RECT.DCL对话框定义档复制至RECT1.DCL,开启新的定义檔并作如下的修改,使其可以输入四边形的阔度及高度;将AutoLISP程序文件RECT.LSP复制至RECT1.LSP,开启新的程序文件,并将要加载的对话框定义档改为RECT1(程序第1行);完成后即可加载及执行新的程序文件RECT:dialog{label="Rectangle" ;:edit_box//编辑框组件{label="Rectangle width : " ;key="RECT_W" ;edit_limit=16;edit_width=10;fixed_width=true;}:edit_box//编辑框组件{label="Rectangle heigth :" ;key="RECT_H" ;edit_limit=16;edit_width=10;fixed_width=true;}ok_only;}定义说明:1 设定对话框的名称为RECT,紧接一个以冒号开始的组件dialog2 最左边为dialog组件的开大括号,右边是其属性label,并以等号设定其属性值为"Rectangle",以分号结束此行叙述3 edit_box为"编辑框"组件,组件名称前要加冒号4 最左边为edit_box组件的开大括号,右边是其属性label,并以等号设定其属性值为"Rectangle width : ",最后以分号结束此行叙述5 设定属性key的属性值为RECT_W(即设定此编辑框的名称)6 设定属性edit_limit的属性值为16(即最多可以在编辑框中输入16个数字)7 设定属性edit_width的属性值为10(编辑框只会显示10个字的长度)8 设定属性fixed_width的属性值为true,表示表将编辑框以固定的阔度显示9 关大括号是对应第4行的开大括号,这一对大括号同属于第3行的edit_box组件10至16 与3至9行相似,设定另一个编辑框以输入高度的数据;只有属性label及key的属性值不同17 以ok_only组件,在对话框中显示一个确定(OK)按钮,作为结束对话框之用18 关大括号是对应第2行的开大括号,这一对大括号同属于第1行的dialog组件注意1 在第一个编辑框(输入四边形的阔度)的label属性值中,在字符串最后的冒号后面,加多了一个空格,目的是方更与下一个编辑框对齐第三篇设定及取得对话框组件内的值AutoLISP函数设定组件的值(SET_TILE "组件关键词"设定值)e.g. (SET_TILE "RECT_W" "50.0")组件的初始值可在定义文件中以属性value设定,但在程序文件中则以此函数设定组件关键词即是在对话框定义文件中,以组件属性key所定义的属性值,以赋予该组件一个操作名称组件关键词是有区分大小写的此函数要在START_DIALOG函数之后才能使用取得组件的值(GET_TILE "组件关键词")e.g. (GET_TILE "RECT_W")作用是在AutoLISP程序文件中取得组件(以关键词指定)的设定值组件关键词的说明与SET_TILE函数相同此函数要在DONE_DIALOG函数之前使用(即要在对话框结束前使用)设定组件的状态(MODE_TILE "组件关键词"状态模式)e.g. (MODE_TILE "RECT_W" 0)作用是在AutoLISP程序文件中设定组件(以关键词指定)的使用状态,其状态模式可以设定为下列任一整数值:0 使指定的组件成为使用状态1 使指定的组件成为禁用状态(组件以灰色显示)2 使指定的组件成为焦点3 选取指定编辑框组件的内容4 图像高亮度显示的开关组件关键词的说明与SET_TILE函数相同练习(Exercises)以修改对话框定义档的方式,设定输入阔度的编辑框其初始值为50,输入高度的编辑框其初始值为25定义档将RECT1.DCL复制至RECT2.DCL,在关键词为REC T_W的组件中,加入value属性并设定其初始值为50;在关键词为RECT_H的组件中,加入value属性并设定其初始值为25程序文件将RECT1.LSP复制至RECT2.LSP,只须修改其加载的定义档名称为RECT2.DCL即可;完成后存盘,进入AutoCAD并载入RECT2.LSP程序文件,执行RECT2程序RECT:dialog{label="Rectangle" ;:edit_box{"Rectangle width : " ;key="RECT_W" ;edit_limit=16;edit_width=10;fixed_width=true;value="50.0"//注意设定值为字符串型态,要在前后加双引号}:edit_box{"Rectangle height :" ;key="RECT_H" ;edit_limit=16;edit_width=10;fixed_width=true;value="25.0"//注意设定值为字符串型态,要在前后加双引号}}以修改AutoLISP程序文件的方式,使输入阔度的编辑框其初始值为50,输入高度的编辑框其初始值为25定义档将RECT1.DCL(不是RECT2.DCL)复制至RECT3.DC L,不作任何修改程序文件将RECT1.LSP复制至RECT3.LSP,程序代码如下:(DEFUN C:RECT() (SETQ DCL_ID (LOAD_DIALOG "C:/RECT3.DCL"))(NEW_DIALOG "RECT" DCL_ID)(SET_TILE "RECT_W" "50.0") (SET_TILE"RECT_H" "25.0")(START_DIALOG)(UNLOAD_DIALOG DCL_ID))程序说明:1 以DEFUN函数定义程序的名称RECT,使用LOAD_D I ALOG函数将对话框定义文件RECT3.DCL载入;使用SETQ函数,将LOAD_DIALOG传回的档案处理码存入变量DCL_ID中,以方便其它函数使用2 使用NEW_DIALOG,开启及显示定义文件中(档案处理码)名称为RECT的对话框3,4 使用SET_TILE函数,设定输入阔度的编辑框组件RECT_W(组件关键词,在定义文件中key设定的属性值)为50,设定输入高度的编辑框组件RE C T_H为255 使用START_DIALOG函数,使对话框开始作用并接受使用者输入(在本例中只有确定钮可按);使用UNLOAD_DIALOG函数以结束对话框6 关括号是对应第1行DEFUN函数左边的开括号,结束整个程序AutoLISP函数组件指定动作(ACTION_TILE "组件关键词""指定动作")e.g. (ACTION_TILE "RECT_W" "(S ETQ TEMP 1)")当焦点在指定的组件(关键词)上并按下接受键时,即会执行函数所指定的动作指定动作会取代定义文件中,该组件的action属性之默认动作组件关键词"accept"在默认情况下是与确定按钮组件关连(即是确定按钮的默认关键字),"cancel"则与取消按钮组件关连(即是取消按钮的默认关键词)终止对话框(DONE_DIALOG [指定传回值])e.g. (DONE_DIALOG)此函数的传回值为一个2D点串行坐标,为结束对话框时,对话框的所在位置;可作为下次启动同一个对话框的位置自变量,使对话框在之前结束时的位置再次显现练习(Exercises)将定义档RECT3.DCL复制至RECT4.DCL,但不作任何修改.将程序文件RECT3.LSP复制至RECT4.LSP,并修改为: 使用ACTION_TILE函数,指定在按下确定钮时,执行一辅助程序;在该辅助程序中,使用GET_TILE函数最得对话框中四边形的阔度及高度,并在用户选取的位置上绘画出四边形.(DEFUN C:RECT() (SETQ DCL_ID (LOAD_DIALOG "C:/RECT4.DCL"))(NEW_DIALOG "RECT" DCL_ID)(SET_TILE "RECT_W" "50.0")(SET_TILE "RECT_H" "25.0")(ACTION_TILE "accept" "(S_RECT)(DONE_DIA L OG)")(START_DIALOG)(UNLOAD_DIALOG)(SETQ PT_0 (GETPOINT "\nSelect rectangle lower left point :"))(SETQ PT_1 (POLAR PT_0 0 TMP_W)PT_2 (POLAR PT_1 (/ PI 2) TMP_H)PT_3 (POLAR PT_2 PI TMP_W))(COMMAND "PLINE" PT_0 PT_1 PT_2 PT_3 "C")(PRINC))(DEFUN S_RECT() (SETQ TMP_W (ABS (ATOF (GET_TILE "RECT_W")))TMP_H (ABS (ATOF (GET_TILE "RECT_H")))))主程序(RECT)说明:1 注意将LOAD_DIALOG函数所加载的对话框定义档改为RECT4.DCL2- 4参阅RECT3程序的说明5 使用ACTION_TILE函数设定关键词为accept的组件(默认为确定按钮)的指定动作: 先执行辅助程序S_RECT,取得输入的数据,再使用DO N E_DIALOG函数结束对话框6 参阅RECT3程序,第5行的说明7 使用GETPOINT函数让用户选取四边形的左下角位置坐标,存入变量PT_08使用POLAR函数取得新坐标点: 从选取点PT_0开始,向右(角度为0),距离为四边形的阔度(变量TMP_W,在辅助程序中取得),存入变量PT_19 使用POLAR函数取得新坐标点: 从上一点PT_1开始,向上(角度90,等于PI除2),距离为四边形的高度(变量TMP_H,在辅助程序中取得),存入变量PT_210 使用POLAR函数取得新坐标点: 从上一点PT_2开始,向左(角度1800,等于PI),距离为四边形的阔度(变量TMP_W,在辅助程序中取得),存入变量PT_3;注意最右边的关括号,是对应第8行SETQ函数左边的开括号11 使用COMMAND函数执行PLINE指令,并分别设定四个坐标变量,最后以"C"选项封闭聚合线12 以一个不带参数的PRINC函数,抑制多余的显示及传回值;最右边的关括号是对应第1行DEFUN函数左边的开括号辅助程序(S_RECT)说明:1 设定函数名称;使用GET_TILE函数取得指定关键词(RECT_W,代表输入阔度的编辑框组件)的值,并将该值使用ATOF函数由字符串型态转为实数型态(有小数);再使用ABS函数取得实数的绝对值,以防止使用者输入负数;最后将数据存入变量TMP_W2 使用GET_TILE函数取得指定关键词(RECT_H,代表输入高度的编辑框组件)的值,转型及取得绝对值后,存入变数TMP_H3 用一个关括号,对应第1行DEFUN函数左的开括号第四篇按钮及核取框(切换钮)按钮组件(button)一个矩形的按钮,可显示指定的讯息在按钮上:button//组件名称{属性="属性值";}属性label显示在按钮中的提示文字key 其属性值即为使用该按钮组件的关键词width 指定按钮的显示阔度height 指定按钮的显示高度fixed_width通常与width属性一并使用,以固定按钮的显示阔度fixed_height通常与height属性一并使用,以固定按钮的显示高度is_enable 可设定按钮是否可以使用,其属性值可设定为t r ue(可使用)或false(禁用,按钮中的消息正文变为灰色显示),默认值为tr ueis_default属性值可设定为true或false;当使用者按下接受键(大部份的情况,ENTER 被用作接受键)时,本属性设定为true的组件会自动被选取.当使用者在allow_accept属性设为true的编辑框,列表框或图像按钮中.按下接受键或双击鼠标键(只对列表框及图像按钮有效)时,本属性设定为true的组件亦会自动被选取alignment 如果组件成水平方向排列,属性值可设定为lef t,right或centered(若不设定则预设为left);如果组件成垂直方向排列,属性值可设定为top,bottom 或centered(若不设定则预设为centered)其它属性action is_cancel is_tab_top mnemonic核取框(切换钮)组件(toggle)是一个启用或关闭的切换方框,当方框中没有剔勾符号时,表示该功能为关闭状态,其组件的值为0;当方框中有剔勾符号时,表示该功能为启用状态,其组件的值为1:toggle//组件名称{属性="属性值";}属性label显示在切换钮后面(右边)的提示文字key 其属性值即为使用该按钮组件的关键词is_enable 可设定切换钮是否可以使用,其属性值可设定为true(可使用)或false(禁用),默认值为truevalue 方框中没有剔勾符号时,表示该功能为关闭状态,其组件的值为0(亦是预设值);相反则为启用状态,组件的值为1alignment 如果组件成水平方向排列,属性值可设定为lef t,right或centered(若不设定则预设为left);如果组件成垂直方向排列,属性值可设定为top,bottom或centered(若不设定则预设为centered)其它属性action is_tab_stop width heigthfixed_width fixed_heigth练习(Exercises)在四边形的对话框中,增加一核取框,以确定是否在四边形中加上交叉的对角线;另在对话框的底部增加两个按钮,按下时可使核取框作用或禁用定义档将RECT4.DCL复制至RECT5.DCL,在新的定义档中增加核取框及按钮定义RECT:dialog{label="Rectangle" ;:edit_box{"Rectangle width : " ;key="RECT_W" ;edit_limit=16;edit_width=10;fixed_width=true;value="50.0"}:edit_box{"Rectangle heigh t:" ;key="RECT_H" ;edit_limit=16;edit_width=10;fixed_width=true;value="25.0"}:toggle//新增的核取框(切换钮)组件{label="X line in rectangle" ;key="RECT_X" ;}:button//新增的按钮组件{label="&Enable" ;key="RECT_E" ;width=10;fixed_width=true;}:button//新增的按钮组件{label="&Disable" ;key="RECT_D" ;width=10;fixed_width=true;}ok_only;}定义说明:第1至第18行的定义,与上一课练习RECT4.DCL定义相同,不再叙述19 以冒号开始,定义一个切换钮组件20 切换钮的开大括号,以label属性定义切换钮右边的消息正文21 以key属性设定切换钮的操作关键词22 关大括号是对应第20行的开大括号,此对大括号同属于第19行的切换钮组件23 以冒号开始,定义一个按钮组件24 按钮的开大括号,以label属性定义按钮上显示的消息正文.注意: 字符串的&符号,表示设定在该符号右边的一个字母为快捷键;在显示时,&符号不会出现,但&符号右边的一个字符会以加底线显示25 以key属性设定按钮的操作关键词26 以width属性设定按钮的阔度,否则按钮会自动加长并占用整列的长度27 fixed_width属性设定为true,使按钮以固定的阔度显示28 关大括号是对应第24行的开大括号,此对大括号同属于第23行的按钮组件29至34 与上个按钮的定义类似(23至28行),但其label及key的属性值不同35 定义一个确定按钮,以结束对话框36 关大括号是对应第2行的开大括号,此对大括号同属于第1行的dialog组件程序文件将RECT4.LSP复制至RECT5.LSP,其程序代码如下:(DEFUN C:RECT() (SETQ DCL_ID (LOAD_D I ALOG "C:/RECT5.DCL"))(NEW_DIALOG "RECT" DCL_ID)(SET_TILE "RECT_W" "50.0")(SET_TILE "RECT_H" "25.0")(ACTION_TILE "accept" "(S_RECT)(DONE_DIALOG)")(ACTION_TILE "RECT_E" "(MODE_TILE \"RECT_X\" 0)");设定使用按钮的动作(ACTION_TILE "RECT_D" "(MODE_TILE \"RECT_X\" 0)");设定禁用按钮的动作(START_DIALOG)(UNLOAD_DIALOG)(SETQ PT_0 (GETPOINT "\nSelec t rectangle lower left point : "))(SETQ PT_1 (POLAR PT_0 0 TMP_W)PT_2 (POLAR PT_1 (/ PI 2)TMP_H)PT_3 (POLAR PT_2 P I TMP_W))(COMMAND "PLINE" PT_0 PT_1 PT_2 PT_3 "C")(IF (= TMP_X 1) (COMMAND"LINE" PT_0 PT_2 "" "LINE" PT_1 PT_3 ""))(PRINC))(DEFUN S_RECT() (SETQ TMP_W (ABS (AT O F(GET_TILE "RECT_W")))TMP_H (ABS (ATOF (GET_TILE "RECT_H")))TMP_X (ATOI (GET_TILE "RECT_X"))) ;取得切换钮的状态)主程序(RECT)说明:1至5 与程序RECT4.LSP相同,主要是加载及显示对话框,并设定其中的组件6 使用ACTION_TILE函数,设定当按下ENABLE按钮(关键词为RECT_E)时,所执行的动作: 使用MODE_TILE函数,设定切换钮(关键词为RECT_X)的状态为0,使其处于作用状态.注意指定的动作为字符串型态,前后要加上双引号";而包含在字符串中的双引号,则必须以反斜杠加双引号\"表示7 与第6行相似,设定按下DISABLE按钮(关键词为R ECT_D)时,将切换钮的状态设为1,使其处于禁用状态8至13 与程序RECT4.LSP相同,主要是用作绘画出四边形14 使用IF函数检查变量TMP_X(在辅助程序中取得,表示切换钮的状态)是否为1;若是则以COMMAND函数,执行两个LINE指令,绘画出四边形的对角线15 以一个不带参数的PRINC函数,抑制多余的显示及传回值;最右边的关括号是对应第1行DEFUN函数左边的开括号辅助程序(S_RECT)说明:1,2 大致与RECT4.LSP的辅助程序相同,都是用以取得编辑框内的数据并存入变量中3 使用GET_TILE函数取得切换钮(关键词为RECT_X)的状态(传回值是字符串,"0"是使用,"1"是禁用),再用ATOI函数将传回的字符串变为整数,存入变量TMP_X,供主程序第14行的IF函数,判断是否需要加上对角线.注意: 传回值转型后,结果只会是1或0,固不须使用ABS函数取其绝对值4 关括号与1行DEFUN函数左边的开括号对应第五篇横列,直行,空白及文字组件横列(row)及直行(column)组件其实这两个都不算是实体的组件,只是用作指定后续的其它组件的排列格式指定为横列时,则包含在此组件一对大括号中的所有组件,均作水平左至右排列;直行时则呈垂直上至下排列。
VisualLisp编程基础教程
华南理工大学化学与化工学院方利国 lgfang@
8
2、基本运算
(6)普通数求幂 格式: (expt <底数> <幂>) 功能:求<底数>的 <幂>次方值 实例:(expt 3 3)结果为27 (expt 5 2)结果为25 (expt 2 4)结果为16 (expt 2 1.3)结果为 2.46229
2018/10/19 华南理工大学化学与化工学院方利国 lgfang@ 17
(6)赋值函数SETQ 格式:(setq <变量1> <表达式1> [<变量2> <表达式 2>]…..) 功能:将表达式的值赋给变量,变量和表达式需成对出现 实例: (setq a 10) 结果 a=10 (setq s “it” ) 结果 s=“it” (setq b 123 c 10 d 45) 结果 b=123 c=10 d=45 (setq t (+ 34 45)) 结果 t=79 (setq P1 ' ( 34 45)) 结果是P1点x轴的坐标为34,y轴的坐标为45, 其中在表(34 45)前面加了单引号“' ”号,是为了禁止对表(34 45)的求值,需要注意的是所有的单引号和双引号必须在英文状态 下输入,否则就会出现错误。如果不用“'”,也可以用quote表示, 例如用下面的小程序就可以绘制一条从(130,140)到(200,400) 的直线。 (setq p1 '(130 140)) //确定点P1的坐标 (setq p2 '(200 400)) //确定点P2的坐标 (command “line” p1 p2 “”) //绘制从P1点到P2点的直线是AutoLISP程序 中应用程度较高的一个函数,希望读者引起注意
lsp教程
Lisp入门 [转]Lisp是一门历史悠久的语言,全名叫LISt Processor,也就是“表处理语言”,它是由John McCarthy于1958年就开始设计的一门语言。
和Lisp同时期甚至更晚出现的许多语言如Algo 等如今大多已经消亡,又或者仅仅在一些特定的场合有一些微不足道的用途,到现在还广为人知的恐怕只剩下了Fortran和COBOL。
但唯独Lisp,不但没有随着时间而衰退,反倒是一次又一次的焕发出了青春,从Lisp分支出来的Scheme、ML等语言在很多场合的火爆程度甚至超过了许多老牌明星。
那么这颗常青树永葆青春的奥秘究竟在哪里呢?如果你只接触过C/C++、Pascal这些“过程式语言”的话,Lisp可能会让你觉得十分不同寻常,首先吸引你眼球(或者说让你觉得混乱的)一定是Lisp程序中异常多的括号,当然从现在的角度来讲,这种设计的确对程序员不大友好,不过考虑到五六十年代的计算机处理能力,简化语言本身的设计在那时算得上是当务之急了。
Lisp的基本语法很简单,它甚至没有保留字(有些语言学家可能对这一点有异议,别怕,我听你们的),它只有两种基本的数据,仅有一种基本的语法结构就是表达式,而这些表达式同时也就是程序结构,但是正如规则最简单的围棋却有着最为复杂的变化一样,Lisp使用最基本的语言结构定义却可以完成其它语言难于实现的、最复杂的功能。
废话少说,现在我们就来看看Lisp语言中的基本元素。
Lisp的表达式是一个原子(atom)或表(list),原子(atom)是一个字母序列,如abc;表是由零个或多个表达式组成的序列,表达式之间用空格分隔开,放入一对括号中,如:abc()(abc xyz)(a b (c) d)最后一个表是由四个元素构成的,其中第三个元素本身也是一个表。
正如算数表达式1+1有值2一样,Lisp中的表达式也有值,如果表达式e得出值v,我们说e返回v。
如果一个表达式是一个表,那么我们把表中的第一个元素叫做操作符,其余的元素叫做自变量。
数字测图原理与应用——Lisp语言的学习和使用
数字测图原理与应用——Lisp语言的学习和使用主要内容AutoLisp语言介绍AutoLisp语言的基本知识赋值与数值计算函数自定义函数程序分支与循环函数逻辑运算函数字符串与类型转换函数表处理函数交互数据输入函数及相关的计算函数与文件有关的函数实体和设备访问类函数其它函数一、AutoLisp语言介绍LISP(List Processing)是一种计算机的表处理语言。
LISP语言是人工智能领域中广泛应用的一种程序语言。
AutoLISP语言是一种运行在AutoCAD环境下的LISP编程语言,或称为AutoCAD的一种嵌入式语言。
它采用了与CommandLISP(一种通用的LISP语言版本)相近的语法及习惯约定,并吸收了LISP语言的主要函数,同时增加了针对AutoCAD特点的许多功能,如:可以把AutoLISP和AutoCAD的绘图命令透明地结合起来,使设计和绘图完全融为一体。
利用AutoLISP语言编程可以实现对AutoCAD当前图形数据库进行直接访问和修改。
在LISP语言中,最基本的数据类型是符号表达式。
LISP语言的特点是程序和数据都采用符号表达式的形式,即一个LISP程序可以把另一个LISP程序作为它的数据进行处理。
因此使用LISP语言编程十分灵活,看起来是一个一个的函数调用。
支持递归定义也是Auto LISP语言的重要特性。
AutoLISP语言是提供给用户的主要二次开发工具之一。
用AutoLISP语言编写应用程序,可以为AutoCAD增加新的命令或修改AutoCAD,以适应用户的特殊需要。
AutoCAD软件的开发者——AutoDesk公司许诺,将保证今后AutoCAD 软件对AutoLISP语言的支持。
掌握使用和编制AutoLISP应用程序的方法和技术将大大提高用户的工作效率和二次开发水平,增强AutoCAD的灵活性,并将得到长期、稳定的技术支持。
二、AutoLISP语言的基本知识2.1 AutoLISP语言的特性AutoLISP语言是一种解释型语言,它的特点如下:1.解释型语言编程语言有两种基本类型:解释型和编译型。
lisp教程
面积统计.LSP
不错的小程序,关键还是源代码,谢谢,很实用!不会用的朋友可以将文件打开后,直接将程序内容,拷到你的cad安装目录下support文件夹里的acad2004.lsp(cad2006是acad2006.lsp)里,这个文件用记事本打开,将程序的内容贴到后面就行了,注意简化命令是defun C:后的、(前面的那几个字符,谢谢楼主!
亩和平方米的互换.lsp
删除鼠标框内交点之间的线段.LSP
动态查询信息程序.LSP
单独提取图层程序.
把面积写在图上.lsp
文字对齐程序.lsp
直接在图上写出这个范围的面积.LSP
自动计算面积.lsp
计算总长度的程序.lsp
调整对象XY比例.LSP
lisp教程
lisp教程Lisp 是一种编程语言,源自于Lambda演算,并且被广泛应用于人工智能领域。
本教程将介绍Lisp的基本概念和语法,帮助初学者快速入门。
1. 表达式和函数调用在Lisp中,所有的计算都是通过表达式和函数调用完成的。
表达式由一个或多个函数和参数组成,并用括号括起来。
例如,(加 2 3) 表示将2和3相加。
2. 变量和赋值在Lisp中,可以使用变量来存储数据,并使用赋值操作符将一个值赋给一个变量。
例如,(setq x 5) 表示将5赋给变量x。
3. 条件语句Lisp提供了条件语句来根据不同的条件执行不同的代码块。
最常用的条件语句是(if-else)语句,它根据一个条件判断是否执行某个代码块。
例如,(if (= x 5) (print "x是5") (print "x不是5")) 表示当x等于5时输出"x是5",否则输出"x不是5"。
4. 循环Lisp提供了多种循环结构来重复执行一段代码。
最常用的循环结构是(do)循环,它可以设置一个计数器,并执行一段代码块指定的次数。
例如,(do ((i 0 (+ i 1))) ((= i 10)) (print i)) 表示从0到9输出i的值。
5. 函数定义和调用在Lisp中,可以使用(define)关键字来定义一个函数,并使用函数名和参数列表来调用这个函数。
例如,(defun square (x) (* x x)) 定义了一个计算平方的函数,并可以使用(square 5)来调用这个函数。
6. 列表和操作Lisp中的列表是一种特殊的数据结构,可以包含多个元素。
可以使用(list)函数创建一个列表,并使用(car)和(cdr)函数来获取列表的第一个元素和剩余元素。
例如,(setq numbers (list 1 2 3)) 定义了一个包含三个元素的列表,并可以使用(car numbers)获取第一个元素。
猫老师Lisp入门教程(opendcl部分)
51
不死猫老师 Lisp 教程
第二十八章 OpenDCL-高级对话框解决方案
最简单范例: 1、 2、 打开 opendcl 直接保存为 D:\test.odcl 在 opendcl 界面左下角的空白区鼠标右键添加一个 add Modeless
dialog 非模态对话框
3、
拖个按钮
49
不死猫老师 Lisp 教程
4、
在右面 properties 属性页改引发事件为 1、在 event 事件页里点一下 clicked 然后点击下面的 clipboard copy 复制点击 dc贴一下刚才复制的代码,然后写这几个代码
50
不死猫老师 Lisp 教程
6、
加载 lsp 执行 tt 即可
ATUOLISP-入门
AUTO-LISP入门1.养成良好的书写习惯众所周知,Lisp是一种表结构语言,括号必须成对出现,在调试时往往为遗漏了一个括号大费周折,所以,养成一个好的编程习惯是学好Lisp所必须的。
⑴选择一个较好的编辑器,这是一个基本条件,建议使用Visual Lisp编辑器或Lisplink等专用编辑器,此类编辑器可以对函数突出显示。
⑵按Lisp(DCL)专有格式书写,并经常对程序进行“格式化”,及时发现语法错误,并有利于调试是查找错误。
⑶使用自定义函数,并辅助以适当得注释,在较大程序中按功能使用自定义函数可以使得程序条理化。
2.函数中循环与转移的使用在高级语言中一般有类似“goto”的语句实现转移,在AutoLisp中没有转移的函数。
我们可以使用自定义函数实现转移,用if及cond辅助实现条件转移。
当我们需要实现在满足一定条件时进行循环的功能,一般使用while函数,但有时需要判断的条件较复杂时,使用while函数往往不能实现或使得程序不够简洁。
这时我们可以使用“转移”,将需要实现的功能作为(子)函数,使用恰当,可以在程序中任意“转移”。
一般认为,当一段代码在不同处重复使用时,我们才会使用子函数定义,其实,利用函数的更大的优点是使得程序更加结构化。
这就使得我们不必拘泥于程序中的循环语句,而使用函数的循环调用,辅助适当的判断,实现“转移”,如A->B->A。
当然也可以进行自身调用,构成一个“标准的”循环。
如例一中,“程序执行完毕返回”与“空选返回”两种情况如果使用循环语句,其条件是完全不同的,而将函数本身作为子函数调用,程序简洁明了。
3.initget函数中关键字“”(空格)的使用空格可以被用作关键字,一般多用来定义鼠标右键退出。
⑴当用户输入函数不支持控制位(如entsel、nentsel、nentselp)时,可直接使用“(initget " ")”。
⑵当用户输入函数支持控制位(如getpoint等)时,可使用“(initget 1 " ")”禁止空输入,而将回车等空输入作为关键字使用。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
LISP语言教程作者:牛魔王 — 上次修改时间: 2007-03-22 13:13Scheme 语言是LISP语言的一个方言(或说成变种),它诞生于1975年的MIT,对于这个有近三十年历史的编程语言来说,它并没有象C++,java,C#那样受到商业领域的青睐,在国内更是显为人知。
但它在国外的计算机教育领域内却是有着广泛应用的,有很多人学的第一门计算机语言就是Scheme语言。
Scheme 语言概要Author:宋国伟吉林省德惠市信息中心Date:2003 年12 月01 日Scheme 语言是LISP语言的一个方言(或说成变种),它诞生于1975年的MIT,对于这个有近三十年历史的编程语言来说,它并没有象C++,java,C#那样受到商业领域的青睐,在国内更是显为人知。
但它在国外的计算机教育领域内却是有着广泛应用的,有很多人学的第一门计算机语言就是Scheme语言。
作为Lisp 变体,Scheme 是一门非常简洁的计算语言,使用它的编程人员可以摆脱语言本身的复杂性,把注意力集中到更重要的问题上,从而使语言真正成为解决问题的工具。
本文分为上、下两部分来介绍scheme 语言。
一.Scheme语言的特点Scheme 语言是LISP语言的一个方言(或说成变种),它诞生于1975年的MIT,对于这个有近三十年历史的编程语言来说,它并没有象C++,java,C#那样受到商业领域的青睐,在国内更是显为人知。
但它在国外的计算机教育领域内却是有着广泛应用的,有很多人学的第一门计算机语言就是Scheme语言。
它是一个小巧而又强大的语言,作为一个多用途的编程语言,它可以作为脚本语言使用,也可以作为应用软件的扩展语言来使用,它具有元语言特性,还有很多独到的特色,以致于它被称为编程语言中的"皇后"。
下面是洪峰对Scheme语言的编程特色的归纳:•词法定界(Lexical Scoping)•动态类型(Dynamic Typing)•良好的可扩展性•尾递归(Tail Recursive)•函数可以作为值返回•支持一流的计算连续•传值调用(passing-by-value)术运对•算算相独立本文的目的是让有编程基础(那怕是一点点)的朋友能尽快的掌握Scheme语言语规则读发现经Scheme语言了,那么我的的法,如果您在完本文后,自己已会用目的就达到了。
二.Scheme语言的标准与实现R5RS (Revised(5) Report on the Algorithmic Language Scheme) Scheme语言的语法规则的第5次修正稿,1998年制定,即Scheme语言的现行标准,目前大多数Scheme语言的实现都将达到或遵循此标准,并且几乎都加入了一些属于自己的扩展特色。
Guile (GNU's extension language)扩语库Scheme语言的一Guile是GNU工程的一个项目,它是GNU展言,它也是个具体实现;如果你将它作为一个库打包,可以把它链接到你的应用程序中去,使你的应用程序具有自己的脚本语言,这个脚本语言目前就是Scheme语言。
Guile可以在LINUX和一些UNIX系统上运行,下面是简单的安装过程:下载guile-1.6.4版,文件名为guile-1.6.4.tar.gz,执行下面的命令:tar xvfz guile-1.6.4.tar.gzcd guile-1.6.4./configuremakemake install如此,即可以执行命令guile,进入guile>提示符状态,输入调试Scheme程序代码了,本文的所有代码都是在guile下调试通过。
其它实现除了Guile外,Scheme语言的实现还有很多,如:GNU/MIT-Scheme,SCI,Scheme48,DrScheme等,它们大多是开源的,可以自由下载安装使用,并且跨平台的实现也很多。
你会发现既有象basic的Scheme语言解释器,也有将Scheme语言编译成C语言的编译器,也有象JAVA那样将Scheme语言代码成虚机代的器。
编译拟码编译三.基本概念注释Scheme语言中的注释是单行注释,以分号[;]开始一直到行尾结束,其中间的内容为注释,在程序运行时不做处理,如:; this is a scheme comment line.标准的Scheme语言定义中没有多行注释,不过在它的实现中几乎都有。
在Guile中就有多行注释,以符号组合"#!"开始,以相反的另一符号组合"!#"结束,其中内容为注释,如:#!there are scheme comment area.you can write mulity lines here .!#注意的是,符号组合"#!"和"!#"一定分做两行来写。
Scheme用做脚本语言Scheme语言可以象sh,perl,python等语言那样作为一种脚本语言来使用,用它来编写可执行脚本,在Linux中如果通过Guile用Scheme语言写可执行脚本,它的第一行和第二行一般是类似下面的内容:#! /usr/local/bin/guile -s!#这样的话代码在运行时会自动调用Guile来解释执行,标准的文件尾缀是".scm"。
块(form)块(form)是Scheme语言中的最小程序单元,一个Scheme语言程序是由一个或多个form构成。
没有特殊说明的情况下form 都由小括号括起来,形如:(define x 123)(+ 1 2)(* 4 5 6)(display "hello world")一个form 也可以是一个表达式,一个变量定义,也可以是一个过程。
form嵌套这轻实现杂达时Scheme语言中允许form的嵌套,使它可以松的复的表式,同也是一种非常有自己特色的表达式。
下图示意了嵌套的稍复杂一点的表达式的运过算程:变量定义可以用define来定义一个变量,形式如下:(define 变量名值)如:(define x 123) ,定义一个变量x,其值为123。
更改变量的值可以用set!来改变变量的值,格式如下:(set! 变量名值)值为"hello" 。
如:(set! x "hello") ,将变量x的改Scheme语言是一种高级语言,和很多高级语言(如python,perl)一样,它的变量类型不是固定的,可以随时改变。
四.数据类型1. 简单数据类型逻辑型(boolean)最基本的数据类型,也是很多计算机语言中都支持的最简单的数据类型,只能取两个值:#t,相当于其它计算机语言中的TRUE;#f,相当于其它计算机语言中的FALSE。
Scheme语言中的boolean类型只有一种操作:not。
其意为取相反的值,即:(not #f) => #t(not #t) => #f逻辑运类not的引用,与非算操作似guile> (not 1)#fguile> (not (list 1 2 3))#fguile> (not 'a)#f逻辑值为从上面的操作中可以看出来,只要not后面的参数不是型,其返回均#f。
数字型(number)它又分为四种子类型:整型(integer),有理数型(rational),实型(real),复数型们统为类(number)。
(complex);它又被一称数字型如:复数型(complex) 可以定义为(define c 3+2i) 实数型(real)可以定义为(define f 22/7) 有理数型(rational)可以定义为(define p 3.1415) 整数型(integer) 可以定义为(define i 123)Scheme 语言中,数字类型的数据还可以按照进制分类,即二进制,八进制,十进制和十六进制,在外观形式上它们分别以符号组合#b、#o、#d、#x 来作进为表示数字进制类型的前缀,其中表示十进制的#d可以省略不写,如:二制的#b1010 ,八进制的#o567,十进制的123或#d123,十六进制的#x1afc 。
Scheme语言的这种严格按照数学定理来为数字类型进行分类的方法可以看出Scheme语言里面渗透着很深的数学思想,Scheme语言是由数学家们创造出来这现较鲜的,在方面表得也比明。
字符型(char)Scheme语言中的字符型数据均以符号组合"#\" 开始,表示单个字符,可以是字母、数字或"[ ! $ % & * + - . / : < = > ? @ ^ _ ~ ]"等等其它字符,如:#\A 表示大写字母A,#\0表示字符0,其中特殊字符有:#\space 表示空格符和#\newline 表示换行符。
符号型(symbol)符号类型是Scheme语言中有多种用途的符号名称,它可以是单词,用括号括起来的多个单词,也可以是无意义的字母组合或符号组合,它在某种意义上可以理解为C中的枚举类型。
看下面的操作:guile> (define a (quote xyz)) ; 定义变量a为符号类型,值为xyzguile> axyzguile> (define xyz 'a) ; 定义变量xyz为符号类型,值为aguile> xyza此处也说明单引号' 与quote是等价的,并且更简单一些。
符号类型与字符串不同的是符号类型不能象字符串那样可以取得长度或改变其中某一成员字符的值,但二者之间可以互相转换。
2. 复合数据类型可以复合数据型是由基本的数据型通某种方式加以合形成的数说类简单类过组据类型,特点是可以容纳多种或多个单一的简单数据类型的数据,多数是基于某一种数学模型创建的。
字符串(string) 由多个字符组成的数据类型,可以直接写成由双引号括起的内容,如:"hello" 。
下面是Guile中的字符串定义和相关操作:guile> (define name "tomson")guile> name"tomson"guile> (string-length name) ; 取字符串的长度6guile> (string-set! name 0 #\g) ; 更改字符串首字母(第0个字符)为小写字母g (#\g)guile> name"gomson"guile> (string-ref name 3) ; 取得字符串左侧第3个字符(从0开始)#\s还义字符串可以用下面的形式定:guile> (define other (string #\h #\e #\l #\l #\o ))guile> other"hello"字符串中出引号用反斜加引号代替,如:现时线"abc\"def" 。