Lu系统扩展动态库LuSystem
目 录
2 lu表luu | |
sys::luu | 整数常量,用在函数new[sys::luu,... ...]中,申请luu表对象。该对象的基本类型为lu,扩展类型为luu。 |
sys::luu[...] | 生成luu表对象并初始化。该对象的基本类型为lu,扩展类型为luu。 |
new | 该函数是重载函数,但直接调用了lu的new函数。用于申请luu表对象,该对象的基本类型为lu,扩展类型为luu。 |
+ | 重载运算符+。连接两个luu表,或者将一个简单数加到luu表的前面或后面。 |
len | 该函数是重载函数,但直接调用了lu的len函数。返回luu表的长度。 |
o | 该函数是重载函数。输出luu表的内容。运行错误:1:不可识别对象。 |
oset | 该函数是重载函数,但直接调用了lu的oset函数。设a是一个luu表,则执行形如a[i]=2的赋值语句时将调用该函数。 |
oget | 该函数是重载函数,但直接调用了lu的oget函数。设a是一个luu表,则执行形如a[i]的语句时将调用该函数。 |
3 字符串String | |
4 字典dict | |
sys::dict | 整数常量,用在函数new[sys::dict,... ...]中,申请字典对象。 |
sys::dict["a":2, "b":8, ...] | 生成字典对象并初始化。运行错误:1:字典元素不匹配;2:字典元素的键应为字符串;3:内存错误。 |
new | 该函数是重载函数,用于申请字典对象。一般用法:new[sys::dict, "a":2, "b":8, ... ...] |
o | 该函数是重载函数。输出字典的内容。运行错误:1:不可识别对象。 |
oset | 该函数是重载函数。设a是一个字典,则执行形如a."b"=2的赋值语句时将调用该函数。运行错误:1:参数太多或者太少;2:不可识别对象;3:非法的字符串;4:内存错误。 |
oget | 该函数是重载函数。设a是一个字典,则执行形如a."b"的语句时将调用该函数,获得字典 元素的值。运行错误:1:参数太多或者太少;2:不可识别对象;3:非法的字符串。 |
len | 该函数是重载函数。设a是一个字典,len(a)求a的所有元素数目。 |
sys::dict_del[p:"a","bc",...] | 删除字典p的元素"a","bc",...。运行错误:1:参数太少;2:不可识别对象;3:非法的字符串。 |
sys::dict_clear[p] | 清空字典p的所有元素。运行错误:1:不可识别对象。 |
sys::dict_reverse[p] | 字典反序。 |
5 结构struct | |
sys::struct | 整数常量,用在函数new[sys::struct,... ...]中,申请结构对象。 |
sys::struct[#a, #b:8, ...] | 生成结构对象并初始化 ,结构成员必须以#开头。运行错误:1:非法的结构成员;2:结构成员重名。 |
new | 该函数是重载函数,用于申请结构对象。一般用法:new[sys::struct, #a, #b:8, ...] |
o | 该函数是重载函数。输出结构的内容。运行错误:1:不可识别对象。 |
oset | 该函数是重载函数。设a是一个结构,则执行形如a.#b=2的赋值语句时将调用该函数。运行错误:1:参数太少;2:不可识别对象或成员;3:没有找到成员。 |
oget | 该函数是重载函数。设a是一个结构,则执行形如a.#b的语句时将调用该函数,获得 结构成员的值。运行错误:1:参数太少;2:不可识别对象或成员;3:没有找到成员。 |
len | 该函数是重载函数。设a是一个结构,len(a)求a的所有成员数目。 |
copy | 该函数是重载函数。设a和b是结构,copy(a)求a的副本,copy(a,b)复制b的内容到a(执行a.=b时将自动调用该函数),copy(a: #ab,2, #b:8, ...)求a的副本并进行初始化,初始化参数要成对。运行错误:1:不可识别对象 ;2:对象结构不相同;3:非法的成员标识;4:没有找到成员;5:参数不匹配。 |
set | 该函数是重载函数,设置结构的成员。设a是一个结构,a.set(#ab,2, #b:8, ...)设置a的成员,注意参数要成对。运行错误:1:参数太少;2:不可识别对象 ;3:非法的成员标识;4:没有找到成员;5:参数不匹配。 |
6 类class | |
sys::class | 整数常量,用在函数new[sys::class,... ...]中,申请类定义。 |
sys::obj | 整数常量,用在函数new[sys::obj,pclass,... ...]中,申请类对象,其中pclass是类定义。 |
sys::class | 创建类定义。 |
sys::obj | 创建类对象。 |
sys::class_handle(#AA) | 根据类名称得到类句柄,该句柄可用在函数obj中创建类对象。 |
new | 该函数是重载函数,用于申请类定义及类对象。 |
o | 该函数是重载函数。输出类定义及类对象的内容。运行错误:1:不可识别对象;2:找不到类定义。 |
oset | 该函数是重载函数。设a是一个类对象,则执行形如a.#b=2的赋值语句时将调用该函数。运行错误:1:参数太少;2:不可识别成员 标识;3:不可识别对象标识;4:没有找到类成员;5:不可识别的结构对象;6:没有找到结构成员;7:不可识别数据类型;8:成员函数参数不匹配 ;9:不可更改基类对象。 |
oget | 该函数是重载函数。设a是一个类对象,则执行形如a.#b的语句时将调用该函数,获得 类成员的值。运行错误:1:参数太少;2:不可识别成员标识;3: 不可识别对象标识;4:没有找到类成员;5:不可识别的结构对象;6:没有找到结构成员;7:不可识别数据类型;8:成员函数参数不匹配。 |
copy | 该函数是重载函数。设a和b是对象,copy(a,b)复制b的内容到a,执行a.=b时将自动调用该函数。运行错误:1: 参数太多或者太少;2:不可识别对象;3:对象结构不相同;4:对象的成员函数#__copy__参数不是2个;5:没有找到成员 函数#__copy__的句柄。 |
sys::obj_method | 调用类对象的方法。 |
7 其他 | |
sys::isnil(a) | 判断一个数据是否是nil,若是返回true,否则返回false。 |
sys::lufun | 以Lu表的元素为自变量进行函数调用。 |
1 什么是LuSystem [返回页首]
LuSystem32.dll是一个Lu系统扩展动态库,包含一些增强Lu系统功能的函数、对系统内置类型的扩展以及一些新增数据类型等等。LuSystem不仅是对Lu系统的扩充,更在于演示Lu是极易扩充其功能的脚本,很少有脚本允许用户能方便地添加像字典、结构、类等高级的数据结构,但Lu允许,而且实现这些很容易,因而,LuSystem也是编程用户极佳的练手工具。
主要的数据类型有:
luu:系统内置类型lu表的扩展类型。
String:系统内置类型字符串string的扩展类型(尚未添加)。
dict:字典。
struct:结构。
class:类。
regex:正则表达式(尚未添加)。
file:文件类型(尚未添加)。
... ...
在LuSystem中的函数是通过二级函数命名空间“sys”输出的,所有函数均具有类似“sys::lufun(...)”的格式。使用!!!using("sys");可简化LuSystem中的函数访问。
LuSystem目前还不完善,主要用来演示Lu系统的可扩充性,但一些实用的功能或函数会不断添加进来,欢迎大家给出各种改进的建议!
LuSystem的源代码是开放的,源代码下载:http://www.forcal.net/xiazai/lu1/lu1code.rar
luu是系统内置类型lu表的扩展类型。luu表是一个可直接存取的线性表,可以存放若干任意的Lu数据。
(1)新建luu表
!!!using("sys");
new[luu,5 : 1,1.2,"abc"].o[]; //用函数new生成luu表,长度为5,有三个初始化数据。函数o用于输出luu表。
用函数luu生成luu表更为方便:
!!!using("sys");
luu[1+2i,1.2,"abc"].o[]; //用函数luu生成luu表,长度为3,有三个初始化数据。函数o用于输出luu表。
(2)元素存取
!!!using("sys");
main(:a)= a=luu[1+2i,1.2,"abc"], a[1]=a[2]+"luuuu", o[a];
(3)luu表连接:可用加号+连接两个luu表,或者将一个简单数加到luu表的前面或后面
!!!using("sys");
main(:a,b)= a=luu[1,1,1], b=luu[2,2], o[a+b, 3+a, a+3];
字典(dict)是一个可直接存取的双向链表,可以存放若干任意的Lu数据。字典元素由“键-值”对组成,键只能是字符串,但值可以是任何Lu数据类型。
(1)新建字典
!!!using("sys");
new[dict, "aa":1.2, "abc":"luuu"].o[]; //用函数new生成字典,有2组初始化数据。函数o用于输出字典。
用函数dict生成字典更为方便:
!!!using("sys");
dict["aa":1.2, "abc":"luuu"].o[]; //用函数dict生成字典,有2组初始化数据。函数o用于输出字典。
(2)得到字典元素
!!!using("sys");
main(:a)= a=dict["aa":1.2, "abc":"luu"], o[a."aa", a."abc"];
(3)增加字典元素
!!!using("sys");
main(:a)= a=dict["aa":1.2, "abc":"luu"], a."cc"=a."abc"+"88", o[a];
说明:当往字典中增加元素时,若已存在该键,则进行更新。
(4)删除字典
删除指定键-值对:a.dict_del["aa","abc"];
清空字典:a.dict_clear();
删除字典对象,但暂存在缓冲区:del[a];
立即彻底删除字典对象:delete[a];
(5)字典反序
!!!using("sys");
main(:a)= a=dict["aa":1.2, "abc":"luu"], o[a], o[a.dict_reverse()];
结果:
dict{aa : 1.2 , abc : luu}dict{abc : luu , aa : 1.2}
(6)字典存取效率测试:在字典a中添加若干元素,元素的键通过变换字符串str的值得到,sum用于求所有元素的值的和。
!!!using("sys");
main(:a,i,j,str,t0,sum)= t0=clock(), a=dict[], str="aaaa", sum=0,
i=0, while{++i<=100, str[1]=i,
j=1000, while{j<2000, str[2]=j, sum=sum+i+j, a.str=i+j, j++}
},
o{"\r\n创建字典耗时", [clock()-t0]/1000., "秒。共", len(a), "个元素。sum=", sum},
t0=clock(), sum=0,
i=0, while{++i<=100, str[1]=i,
j=1000, while{j<2000, str[2]=j, sum=sum+a.str, j++}
},
o{"\r\n查询字典耗时", [clock()-t0]/1000., "秒。共", len(a), "个元素。sum=", sum, "\r\n"};
结果:
创建字典耗时0.89000000000000001秒。共100000个元素。sum=155000000
查询字典耗时9.4e-002秒。共100000个元素。sum=155000000
结构(struct)是一个线性表,可以存放若干任意的Lu数据。结构成员必须以#开头。结构成员的存储顺序与其定义顺序不一定相同。
(1)新建结构:相当于结构定义
!!!using("sys");
new[struct, #num, #姓名 : "luuu", #年龄].o[]; //用函数new生成结构,有3个成员,其中“姓名”成员进行了初始化。函数o用于输出结构。
用函数struct生成结构更为方便:
!!!using("sys");
struct[#num, #姓名 : "luuu", #年龄].o[]; //用函数new生成结构,有3个成员,其中“姓名”成员进行了初始化。函数o用于输出结构。
(2)复制结构:相当于生成结构对象
!!!using("sys");
main(:a)= a=struct[#num, #姓名 : "luuu", #年龄], o[a,"\r\n",copy(a),"\r\n",copy(a, #num:22, #年龄:33),"\r\n"];
结果:
struct{#num : nil , #姓名 : luuu , #年龄 : nil}
struct{#num : nil , #姓名 : luuu , #年龄 : nil}
struct{#num : 22 , #姓名 : luuu , #年龄 : 33}
(3)复制结构:要求有相同的结构成员,依次复制结构成员的值
!!!using("sys");
main(:a,b)= a=struct[#num : 55, #姓名 : "luuu", #年龄 : 33], b=struct[#num, #姓名, #年龄], b.=a, o[a,"\r\n",b,"\r\n"];
结果:
struct{#num : 55 , #姓名 : luuu , #年龄 : 33}
struct{#num : 55 , #姓名 : luuu , #年龄 : 33}
(4)设置结构:批量对结构成员赋值,注意次序是任意的,并且可设置部分成员或全部成员
!!!using("sys");
main(:a)= a=struct[#num, #姓名, #年龄], o[a,"\r\n"], a.set(#年龄:33, #num:22).o["\r\n"];
结果:
struct{#num : nil , #姓名 : nil , #年龄 : nil}
struct{#num : 22 , #姓名 : nil , #年龄 : 33}
(5)结构成员单独赋值,获取结构成员的值
!!!using("sys");
main(:a)= a=struct[#num, #姓名, #年龄], a.#姓名="王强", a.#年龄=33, a.#num=22, o[a,"\r\n",a.#姓名,"\r\n",a.#年龄,"\r\n"];
结果:
struct{#num : 22 , #姓名 : 王强 , #年龄 : 33}
王强
33
(6)结构嵌套
!!!using("sys");
main(:a)= a=struct[#num, #班级], a.#num=22, a.#班级=struct[#num, #姓名, #年龄],
a.#班级.#num=88,
a.#班级.#姓名="王强",
a.#班级.#年龄=33,
o[a,"\r\n",a.#num,"\r\n",a.#班级,"\r\n",a.#班级.#num,"\r\n",a.#班级.#姓名,"\r\n",a.#班级.#年龄,"\r\n"];
结果:
struct{#num : 22 , #班级 : struct[...]}
22
struct{#num : 88 , #姓名 : 王强 , #年龄 : 33}
88
王强
33
(7)效率测试
!!!using("sys");
main(:a,i,t0,sum)=
a=struct{
#January,
#February,
#March,
#April,
#May,
#June,
#July,
#August,
#September,
#October,
#November,
#December
},
t0=clock(), sum=0,
i=0, while{++i<=100000,
a.#January=1,
a.#February=2,
a.#March=3,
a.#April=4,
a.#May=5,
a.#June=6,
a.#July=7,
a.#August=8,
a.#September=9,
a.#October=10,
a.#November=11,
a.#December=12,
sum=sum+a.#January+a.#February+a.#March+a.#April+a.#May+a.#June+a.#July+a.#August+a.#September+a.#October+a.#November+a.#December
},
o{"\r\n耗时", [clock()-t0]/1000., "秒。sum=", sum, "\r\n"};
结果:
耗时0.75秒。sum=7800000
Matlab2009a代码:
a=struct('January',1,'Febrary',2,'March',3,'April',4,'May',5,'June',6,'July',7,'August',8,'September',9,'October',10,'November',11,'December',12);
tic;
sum=0;
for i=1:100000
a.January=1;
a.February=2;
a.March=3;
a.April=4;
a.May=5;
a.June=6;
a.July=7;
a.August=8;
a.September=9;
a.October=10;
a.November=11;
a.December=12;
sum=sum+a.January+a.February+a.March+a.April+a.May+a.June+a.July+a.August+a.September+a.October+a.November+a.December;
end
toc,
sum
结果:
Elapsed time is 3.275743 seconds.
sum =
7800000
类(class)是一个具有数据成员和方法成员的自定义数据结构。类可以继承和派生,类的层次结构是一棵树。
类对象(obj)是类的实例。
(1)类定义
!!!using("sys");
new[class, #人, public : #姓名, private : #性别, #年龄].o[]; //用函数new定义类,有1个公有成员,2个私有成员。函数o用于输出类定义。
结果:
class{#人 :
private:
#性别, #年龄,
public:
#姓名,
method:
#__init__ : 0, #__del__ : 0
}
用函数class定义类更为方便:
!!!using("sys");
class[#人, public : #姓名, private : #性别, #年龄].o[]; //用函数new定义类,有1个公有成员,2个私有成员。函数o用于输出类定义。
输出结果与上面相同。
(2)单一继承
!!!using("sys");
class[#人, public : #姓名, private : #性别, #年龄],
class[#学生, #人, public : #学校, #班级].o[];
结果:
class{#学生 : #人,
private:
public:
#学校, #班级,
method:
#__init__ : 0, #__del__ : 0
}
(3)类对象
!!!using("sys");
main(:a,b)=
class[#人, public : #姓名, #性别, #年龄],
a=class[#学生, #人, public : #学校, #班级],
b=obj[a],
b.#学校="实验中学", b.#班级="二年级", b.#姓名="王强", b.#性别="男", b.#年龄=12,
o[b, b.#学校," ", b.#班级," ", b.#姓名," ", b.#性别, " ", b.#年龄, "\r\n"];
结果:
class obj{#学生 : #人,
private:
public:
#学校 : 实验中学,
#班级 : 二年级
}
实验中学 二年级 王强 男 12
说明:如果基类“#人”中#性别和#年龄被定义为私有成员,将无法直接进行存取。
(4)多重继承及构造函数和析构函数
例子1:
!!!using("sys");
initA(p)= o["\r\nA的构造函数!"];
initB(p)= o["\r\nB的构造函数!"];
initC(p)= o["\r\nC的构造函数!"];
initD(p)= o["\r\nD的构造函数!"];
delA(p) = o["\r\nA的析构函数!"];
delB(p) = o["\r\nB的析构函数!"];
delC(p) = o["\r\nC的析构函数!"];
delD(p) = o["\r\nD的析构函数!"];
main()=
class[#A, method : #__init__ : @initA, #__del__ : @delA],
class[#B, #A, method : #__init__ : @initB, #__del__ : @delB],
class[#C, #A, method : #__init__ : @initC, #__del__ : @delC],
class[#D, #B, #C, method : #__init__ : @initD, #__del__ : @delD].obj[].delete[];
结果:
A的构造函数!
B的构造函数!
A的构造函数!
C的构造函数!
D的构造函数!
D的析构函数!
B的析构函数!
A的析构函数!
C的析构函数!
A的析构函数!
例子2:
!!!using("sys");
initA(p)= p.#a=0;
initB(p)= p.#a=1;
initC(p)= p.#a=2;
initD(p)= p.#a=3;
main(:c)=
class[#A, public: #a, method : #__init__ : @initA],
class[#B, #A, public: #a, method : #__init__ : @initB],
class[#C, #A, public: #a, method : #__init__ : @initC],
c=class[#D, #B, #C, public: #a, method : #__init__ : @initD].obj[],
o[c.#a," ",c.#B.#a," ",c.#C.#a," ",c.#B.#A.#a," ",c.#C.#A.#a,"\r\n"],
c.#B.#A.#a=5, c.#C.#A.#a=6, o[c.#B.#A.#a," ",c.#C.#A.#a,"\r\n"];
结果:
3 1 2 0 0
5 6
例子3:
!!!using("sys");
initA(p)= p.#a=0;
initB(p)= p.#b=1;
initC(p)= p.#c=2;
initD(p)= p.#d=3;
main(:c)=
class[#A, public: #a, method : #__init__ : @initA],
class[#B, #A, public: #b, method : #__init__ : @initB],
class[#C, #A, public: #c, method : #__init__ : @initC],
c=class[#D, #B, #C, public: #d, method : #__init__ : @initD].obj[],
o[c.#a," ",c.#b," ",c.#c," ",c.#d,"\r\n"],
c.#a=5, c.#b=6, c.#c=7, c.#d=8,
o[c.#a," ",c.#b," ",c.#c," ",c.#d,"\r\n"],
c.#B.#A.#a=11, c.#C.#A.#a=12, o[c.#a," ",c.#B.#A.#a," ",c.#C.#A.#a,"\r\n"];
结果:
0 1 2 3
5 6 7 8
11 11 12
(5)成员函数:第一个参数为对象指针
例子1:
!!!using("sys");
setA(p,x)= p.#a=x;
setB(p,x)= p.#a=x;
setC(p,x)= p.#a=x;
getA(p)= p.#a;
getB(p)= p.#a;
getC(p)= p.#a;
main(:c)=
class[#A, private: #a, method : #mGetA : @getA, #mSetA : @setA],
class[#B, private: #a, method : #mGetB : @getB, #mSetB : @setB],
c=class[#C, #A, #B, private: #a, method : #mGetC : @getC, #mSetC : @setC].obj[],
c.#mSetA=5, c.#mSetB=6, c.#mSetC=7,
o[c.#mGetA," ",c.#mGetB," ",c.#mGetC,"\r\n"];
结果:
5 6 7
说明:类的方法成员和数据成员用法几乎相同,但方法可以接受多个参数,如下例。
例子2:
!!!using("sys");
out(p,x,y,z)= o[x,y,z,"\r\n"];
main(:c)=
c=class[#A, method : #mOut : @out].obj[],
c.#mOut := [5,6,7],
c.#mOut."***".(888)."***";
结果:
567
***888***
(6)类对象复制
!!!using("sys");
setA(p,x,y)= p.#a=x, p.#b=y;
sumA(p)= p.#a+p.#b;
copyAB(s,t)= s.#a=t.#a, s.#b=t.#b;
class[#A, private : #a, public : #b, method : #__copy__ : @copyAB, #setA : @setA, #sumA : @sumA],
class[#B, #A, private : #a, public : #b, method : #__copy__ : @copyAB];
main(:a,b)=
a=obj[class_handle(#B)], b=obj[class_handle(#B)],
a.#a=1, a.#b=2, a.#setA:=[8,9],
b.=a,
b.#a+b.#b+b.#sumA;
结果:
20
(7)多态性
!!!using("sys");
getA()= 1;
getB()= 2;
getC()= 3;
class[#A, method : #mGet : @getA],
class[#B, #A, method : #mGet : @getB],
class[#C, #B, method : #mGet : @getC];
main(:a,b,c)=
c=obj[class_handle(#C)],
o[c.#mGet," ",c.#B.#mGet," ",c.#B.#A.#mGet,"\r\n"],
b=c.#B, a=b.#A, //获得基类对象
o[c.#mGet," ",b.#mGet," ",a.#mGet,"\r\n"];
结果:
3 2 1
3 2 1
(8)效率测试
!!!using("sys");
main(:a,i,t0,sum)=
a=class{#A,
public:
#January,
#February,
#March,
#April,
#May,
#June,
#July,
#August,
#September,
#October,
#November,
#December
}.obj[],
t0=clock(), sum=0,
i=0, while{++i<=100000,
a.#January=1,
a.#February=2,
a.#March=3,
a.#April=4,
a.#May=5,
a.#June=6,
a.#July=7,
a.#August=8,
a.#September=9,
a.#October=10,
a.#November=11,
a.#December=12,
sum=sum+a.#January+a.#February+a.#March+a.#April+a.#May+a.#June+a.#July+a.#August+a.#September+a.#October+a.#November+a.#December
},
o{"\r\n耗时", [clock()-t0]/1000., "秒。sum=", sum, "\r\n"};
结果:
耗时0.85999999999999999秒。sum=7800000
比较:前面使用struct的耗时0.75秒,故class比struct稍慢。
[返回页首] sys::class{... ...}:创建类定义
类定义格式如下:
class{#cMyClass: #cBase1, #cBase2, ... //定义类cMyClass,继承自cBase1和cBase2, ...
private: //私有数据成员
#pvMem1, #pvMem2, ...
public: //公有数据成员
#plMem1, #plMem2, ...
method: //方法(函数成员)
#__init__ : @init, #__del__ : @delme, #mFun1 :@Fun1, #mFun2 :@Fun2, ...
};
类定义中,类名称、基类名称、成员及方法都是以#开头的标识符,不可重复。类名称在最前面,其次是基类名称;private、public及method的次序是任意的,且可多次定义;方法标识符后必须提供函数句柄。类成员的存储顺序与其定义顺序不一定相同。
#__init__和#__del__只可被定义为方法,其中#__init__用于定义构造函数,#__del__用于定义析构函数。若这两个方法被缺省,其函数句柄被自动指定为0。构造函数和析构函数只有一个参数,即对象本身。
若方法有不止一个参数,则方法被调用时,第一个参数总是传入对象本身,相当于C++的this指针。
运行错误:1:非法的类名;2:__init__和__del__只能是方法成员;3:类名或基类名有重名;4:不可识别关键字;5:缺少函数句柄;6:不可识别关键字或成员;7:基类没有定义或循环定义。
约定:类名称以字母c开头;私有数据成员以pv开头;公有数据成员以pl开头;方法成员以m开头。
pClass是类定义的句柄。
创建类对象时,将自动调用每一个基类的构造函数#__init__初始化基类对象。对象被销毁时,将自动调用每一个基类的析构函数#__del__销毁基类对象。
语句 a.=b 将对象b的内容复制到对象a,要求a和b具有相同的类定义,若类定义中定义了方法#__copy__(有且只有2个参数),将自动调用该方法进行对象复制,否则仅依次复制类成员的值。
运行错误:1:不可识别类定义。
[返回页首] sys::obj_method(#FunName : pObj,... ...):调用类对象的方法。
#FunName:以#开头的标识符指出函数名。
pObj:类对象。
运行错误:1:参数太少;2:不可识别的函数标识或对象;3:不可识别类对象;4:参数不匹配;5:找不到指定的方法。
[返回页首] sys::lufun(hFor:x1,x2,...,xn : xx):以Lu表的元素为自变量进行函数调用。
hFor为函数句柄;x1,x2,...,xn : xx为等长的Lu表;xx用于存放结果,可缺省。若缺省xx,返回一个Lu表存放结果,否则该函数返回xx。该函数以x1,x2,...,xn的第i个元素为自变量,用函数hFor进行计算,结果存入xx的第i个单元。
运行错误:1:至少需要2个参数;2:指定的表达式不存在;3:Lu表个数与自变量个数不相等;4:不是Lu表;5:Lu表长度不匹配;6:内存错误。
例子:
!!!using("sys");
f(x,y)=x+y;
lufun[@f,luu(1.,"aa",5),luu(2.,"bb",5)].o[];
版权所有© Lu程序设计 2011-2011,保留所有权利
E-mail: forcal@sina.com QQ:630715621
最近更新: 2011年11月29日