====================================================================
Lu核心库：

			lu32.dll

====================================================================
#global{
[lu32.dll] global(p)：将局部动态对象p转换为全局动态对象。另外，在global(true),... ...,global(false)之间生成的动态对象都为全局动态对象。
}#
--------------------------------------------------------------------
#local{
[lu32.dll] local(x)：将全局动态对象p转换为局部动态对象。
}#
--------------------------------------------------------------------
#sin{
[lu32.dll] sin(x)：正弦函数。
}#
--------------------------------------------------------------------
#cos{
[lu32.dll] cos(x)：余弦函数。
}#
--------------------------------------------------------------------
#tan{
[lu32.dll] tan(x)：正切函数。
}#
--------------------------------------------------------------------
#asin{
[lu32.dll] asin(x)：反正弦函数。
}#
--------------------------------------------------------------------
#acos{
[lu32.dll] acos(x)：反余弦函数。
}#
--------------------------------------------------------------------
#atan{
[lu32.dll] atan(x)：反正切函数。
}#
--------------------------------------------------------------------
#sqrt{
[lu32.dll] sqrt(x)：平方根函数。
}#
--------------------------------------------------------------------
#exp{
[lu32.dll] exp(x)：指数函数。
}#
--------------------------------------------------------------------
#ln{
[lu32.dll] ln(x)：自然对数函数。
}#
--------------------------------------------------------------------
#lg{
[lu32.dll] lg(x)：常用对数函数。
}#
--------------------------------------------------------------------
#sinh{
[lu32.dll] sinh(x)：双曲正弦函数，[exp(x)-exp(-x)]/2
}#
--------------------------------------------------------------------
#cosh{
[lu32.dll] cosh(x)：双曲余弦函数，[exp(x)+exp(-x)]/2
}#
--------------------------------------------------------------------
#tanh{
[lu32.dll] tanh(x)：双曲正切函数，[exp(x)-exp(-x)]/[exp(x)+exp(-x)]
}#
--------------------------------------------------------------------
#abs{
[lu32.dll] abs(x)：绝对值函数。
}#
--------------------------------------------------------------------
#floor{
[lu32.dll] floor(x)：返回不大于x的最大整数。
}#
--------------------------------------------------------------------
#ceil{
[lu32.dll] ceil(x)：返回不小于x的最小整数。
}#
--------------------------------------------------------------------
#itor{
[lu32.dll] itor(x)：将整数转换成实数，大数转换时有精度损失。
}#
--------------------------------------------------------------------
#rtoi{
[lu32.dll] rtoi(x)：将实数转换成整数，大数转换时有误差。
}#
--------------------------------------------------------------------
#con{
[lu32.dll] con(x)：求复数的共轭复数。
}#
--------------------------------------------------------------------
#atan2{
[lu32.dll] atan2(x,y)：反正切函数，求x/y的反正切值，所在象限由x和y的符号确定。
}#
--------------------------------------------------------------------
#fmod{
[lu32.dll] fmod(x,y)：求x/y的余数。
}#
--------------------------------------------------------------------
#A{
[lu32.dll] A(p,...)：数组元素存取。

    该函数效率很高，但仅对如下数组元素进行存取（存取时仅对数据的基本类型做检查，忽略扩展类型）：

    （1)静态字符串（一维静态字符数组）

    例子：(:p)= p="   ", A[p,1]=66, A[p,1];

    （2)静态（一维）整数数组

    例子：(:p)= p=intss("\&\[5]"), A[p,1]=66, A[p,1];

    （3)静态（一维）实数数组

    例子：(:p)= p=realss("\&\[5]"), A[p,1]=66.77, A[p,1];

    （4)静态（一维）lu表

    例子：(:p)= p=lu[1,1,1], A[p,1]=66.77, A[p,1];

    （5)动态字符串（一维动态字符数组）

    例子：(:p)= p=new[string,5], A[p,1]=66, A[p,1];

    （6)动态（多维）整数数组

    例子：(:p)= p=new[ints,3,5], A[p,1,3]=66, A[p,1,3];

    （7)动态（多维）实数数组

    例子：(:p)= p=new[reals,3,5], A[p,1,3]=66.77, A[p,1,3];

    若LuErr=1：对象类型不可识别；LuErr=2：参数不匹配；LuErr=3：对象不存在；LuErr=4：元素地址错误；LuErr=5：赋值参数不符合要求；LuErr=6：数组维数非法。
}#
--------------------------------------------------------------------
#A2{
[lu32.dll] A2(p,...)：复数数组元素存取。

    该函数仅对如下数组元素进行存取（存取时仅对数据的基本类型做检查，忽略扩展类型）：

    （1)静态字符串（看作一维静态复数数组，一个数组元素占16个字节，相当于8个Unicode字符长度）

    例子：(:p)= p="\[32]", A2[p,1]=66+77i, A2[p,1];

    （2)静态（一维）实数数组（看作一维静态复数数组，一个数组元素占16个字节，相当于2个实数长度）

    例子：(:p)= p=realss("\&\[6]"), A2[p,1]=66+77i, A2[p,1];

    （3)动态多维实数数组（最后一维必须为2，看作动态复数数组，即实数数组a[i,j,2]相当于复数数组a[i,j]）

    例子：(:p)= p=new[reals,3,5,2], A2[p,1,3]=66-77i, A2[p,1,3];

    若LuErr=1：对象类型不可识别；LuErr=2：参数不匹配；LuErr=3：对象不存在；LuErr=4：元素地址错误；LuErr=5：赋值参数不符合要求；LuErr=6：数组维数非法。
}#
--------------------------------------------------------------------
#A3{
[lu32.dll] A3(p,...)：三维向量数组元素存取。

    该函数仅对如下数组元素进行存取（存取时仅对数据的基本类型做检查，忽略扩展类型）：

    （1)静态字符串（看作一维静态三维向量数组，一个数组元素占24个字节，相当于12个Unicode字符长度）

    例子：(:p)= p="\[36]", A3[p,1]=(3$5$7), A3[p,1];

    （2)静态（一维）实数数组（看作一维静态三维向量数组，一个数组元素占24个字节，相当于3个实数长度）

    例子：(:p)= p=realss("\&\[6]"), A3[p,1]=(3$5$7), A3[p,1];

    （3)动态多维实数数组（最后一维必须为3，看作动态三维向量数组，即实数数组a[i,j,3]相当于三维向量数组a[i,j]）

    例子：(:p)= p=new[reals,3,5,3], A3[p,1,3]=(3$5$7), A3[p,1,3];

    若LuErr=1：对象类型不可识别；LuErr=2：参数不匹配；LuErr=3：对象不存在；LuErr=4：元素地址错误；LuErr=5：赋值参数不符合要求；LuErr=6：数组维数非法。
}#
--------------------------------------------------------------------
#clock{
[lu32.dll] clock()：获取流逝过去的时钟脉冲数
}#
--------------------------------------------------------------------
#sum{
[lu32.dll] sum(@F,y1min,y1max,y1dy,y2min,y2max,y2dy,... ...)：求和函数。

    用法1：F为求和函数句柄；y1min,y1max,y1dy为第一个自变量的初值、终值和参数增量[初值<终值，参数增量>0]，依次类推。

    用法2：该函数可被重载。

    例子：

      F(x,y)=sin[x]+0.8-y;
      sum(@F,1.,2.,0.01,2.,5.,0.1);

    LuErr=1：参数太少；LuErr=2：非法表达式句柄或者找不到重载函数；LuErr=3：常量表达式无法求和；LuErr=4：参数个数不匹配；LuErr=5：内存分配失败；LuErr=6：自变量参数非法；LuErr=7：求和函数应返回一个实数。
}#
--------------------------------------------------------------------
#pro{
[lu32.dll] pro(@F,y1min,y1max,y1dy,y2min,y2max,y2dy,... ...)：求积函数。

    用法1：F为求积函数句柄；y1min,y1max,y1dy为第一个自变量的初值、终值和参数增量[初值<终值，参数增量>0]，依次类推。

    用法2：该函数可被重载。

    例子：

      F(x,y)=sin[x]+0.8-y;
      pro(@F,1.,2.,0.2,2.,5.,0.3);

    LuErr=1：参数太少；LuErr=2：非法表达式句柄或者找不到重载函数；LuErr=3：常量表达式无法求积；LuErr=4：参数个数不匹配；LuErr=5：内存分配失败；LuErr=6：自变量参数非法；LuErr=7：求积函数应返回一个实数。
}#
--------------------------------------------------------------------
#SetStackMax{
[lu32.dll] SetStackMax(n)：设置整数堆栈最大数目。

    在使用递归函数之前，需要先设置一定数目的堆栈。通常n的值不能取得太大，当n取得很大时，函数递归调用虽不会溢出Lu的堆栈，但会使系统堆栈溢出，这样会使程序运行中断。该函数返回实际设置的堆栈数目。

    若LuErr=1：内存分配失败；LuErr=2：在函数递归时使用该函数；LuErr=2：需要整数参数。
}#
--------------------------------------------------------------------
#const{
[lu32.dll] const("ConstStr",ConstValue)或const("ConstStr",ConstValue,bMode)：设置常量

    ConstStr：常量名，要符合Lu标识符的命名规定，否则编译器找不到该常量。可使用常量命名空间的方式命名，例如："ConstName::MyConst"。
    ConstValue：常量的值。当bMode为逻辑假时，不使用该值。
    bMode：逻辑值，指出工作方式。若缺省该参数（函数const只有两个参数），创建一个永久性常量，无法删除一个永久性常量，除非Lu重新初始化。若bMode为true，创建一个暂时性常量；若bMode为false，删除一个暂时性常量。暂时性常量保持常量的基本意义，在编译表达式时不可改变其值，但可被const函数删除。
    该函数返回值的意义如下：

      0：设置成功。
      1：已存在该常量。
      2：内存分配失败。
      3：不能用空字符串作为常量名。
      4：参数不符合要求。
      5：需用字符串指出常量名。
      6：不能删除该常量。
}#
--------------------------------------------------------------------
#Module{
[lu32.dll] Module("NameSpace":"name1","name2",... ...)：创建模块命名空间；

    该函数为调用该函数的模块创建模块命名空间。NameSpace为空间名称，继承自"name1","name2",... ...。模块命名空间可以循环继承。模块命名空间是一棵树或者是一个连通图。

    该函数返回值的意义如下：

      0：创建成功。
      1：至少需要一个参数，不能缺省模块命名空间名称。
      2：不能重复创建模块命名空间，模块命名空间只能创建一次。
      3：须用字符串指出模块命名空间名称。
      4：内存错误。
      5：该命名空间已被其他模块使用。
      6：要创建的命名空间不能是空字符串。
}#
--------------------------------------------------------------------
#OutFun{
[lu32.dll] OutFun("fun1","fun2",... ...)：输出模块命名空间中的表达式；

    该函数为模块命名空间输出表达式。模块命名空间即调用函数OutFun的模块的命名空间。须用字符串参数指出表达式的名称。

    该函数返回值的意义如下：

      0：操作成功。
      i：其他正整数：前i-1个参数操作成功，第i个参数操作失败，其他参数未进行操作。
}#
--------------------------------------------------------------------
#HFor{
[lu32.dll] HFor("ForName",bType,&nPara,&hModule,&bParaModify)：获得表达式的句柄。

    ForName：表达式的名称。可以是简单名称，也可以是包含模块命名空间访问符::（该访问符可简化为一个或多个:）的复杂名称。
    bType：名称的类型。如果bType为true，只能取简单名称。如果bType为false，名称可包含模块命名空间访问符::。若缺省该参数，默认为true。
    nPara：返回表达式的参数个数。该参数可以缺省。
    hModule：返回表达式所在的模块。该参数可以缺省。
    bParaModify：返回一个逻辑值，表示表达式的自定义参数在执行过程中是否可能被修改，逻辑真表示可能被修改。该参数可以缺省。
}#
--------------------------------------------------------------------
#using{
[lu32.dll] using("NameSpace1","NameSpace2","NameSpace::name",... ...)：访问命名空间

    命名空间（包括模块命名空间、二级函数命名空间和常量命名空间）比较长时，输入比较麻烦，使用using函数可简化命名空间的访问。

    执行过函数using("NameSpace1","NameSpace2","NameSpace::name","ConstSpace",... ...)后，如果有一个命名空间中的函数NameSpace2::fun(x,y)，不必写出该命名空间，直接使用函数fun(x,y)就可以了；如果有一个常量命名空间中的常量ConstSpace::MyConst，也不必写出该命名空间，直接使用常量MyConst就可以了。函数命名空间若与常量命名空间相同，只写出一个即可。如下列：

      using("NameSpace1","NameSpace2","NameSpace::name","ConstSpace");
      2+fun(5,6)+MyConst+3;

    注意：如果有一个非命名空间中的函数fun(x,y)，将优先调用该函数，遇到这种情况，应使用函数的全名：NameSpace2::fun(x,y)。如果有一个非命名空间中的常量MyConst，将优先调用该常量，遇到这种情况，应使用常量的全名：ConstSpace::MyConst。

    可使用using函数一次指定多个命名空间，当再一次调用using函数时，以前指定的命名空间将被删除，可访问的命名空间被重新设定。用using函数指定的命名空间仅在本模块中起作用，换句话说，可在不同的模块中使用using函数而互不影响。
}#
--------------------------------------------------------------------
#free{
[lu32.dll] free(p)：标记需自动销毁的对象。

    函数free(p)可将对象p自动记录下来，在销毁表达式时销毁对象p。函数free(p)仍然返回对象p，若标记失败返回0。用法举例如下：

      ConstObj(:static,obj)=
      {
        if{!obj, obj=new[...].free()}, //第一次调用函数ConstObj()时，用函数new申请一个对象obj，并用函数free()标记在销毁表达式时销毁它
        obj                            //返回对象obj
      };
      ConstObj();                      //每次调用函数ConstObj()，都会得到同一个对象
      ConstObj();                      //每次调用函数ConstObj()，都会得到同一个对象

    注意：函数free(p)并不立即销毁对象p，而是在销毁表达式时销毁该对象。并不是所有的对象都可由函数free销毁，这取决于主程序和Lu扩展库的设计。函数free(p)只适合销毁少量的数据，故不要将其放在循环中使用。

    注意：静态变量free和函数free(p)不必同时使用，同时使用将降低效率。
}#
--------------------------------------------------------------------
#o{
[lu32.dll] o(p1,p2,p3,... ...)：获得对象信息。

    获得对象p1,p2,p3,... ...的信息。函数返回输出的信息串的长度。

    o函数是被重载的，故该函数执行时，对象p1,p2,p3,... ...的重载o函数将被依次调用。

    可直接通过o函数输出的内置对象有：整数、实数、复数、三维向量、nil、表达式句柄、逻辑值、字符串。

    不是所有的对象都支持o函数，具体请查看该对象的说明。
}#
--------------------------------------------------------------------
#oset{
[lu32.dll] oset(p,... ...)：对象赋值

    p是一个对象指针，函数oset(p,... ...)可对对象p赋值。oset函数的调用是与等号相关联的。

    若LuErr=1：参数不匹配；LuErr=2：没有为对象重载该函数；LuErr=3：非法的对象指针；LuErr=4：参数不符合要求。

    不是所有的对象都支持oset函数，具体请查看该对象的说明。

    例子：设A、B是二维数组对象，i=2，j=3

    A(2,3)=1;    //相当于 oset[A,2,3 : 1]

    A.i.j=1;     //相当于 oset[A,i,j : 1]

    A.=A+B;      //相当于 oset[A : A+B]
}#
--------------------------------------------------------------------
#oget{
[lu32.dll] oget(p,... ...)：获得对象的值。

    p是一个对象指针，函数oget(p,... ...)可获得对象p的值；p也可以是一个自定义函数的指针，此时将产生一个函数调用。oget函数的调用不与等号相关联。

    该函数的返回值请参考对象的有关说明。若p是函数指针，则该函数返回函数调用的值。

    若LuErr=1：参数不匹配；LuErr=2：没有为对象重载该函数；LuErr=3：非法的对象指针；LuErr=4：参数不符合要求；LuErr=5：调用函数时参数不匹配；LuErr=6：非法的函数句柄。

    不是所有的对象都支持oget函数，具体请查看该对象的说明。

    例子1：对象指针。设A是一个二维数组对象，i=2，j=3

    A(2,3)=A(2,3)+1;    //相当于 oset[A,2,3 : oget(A,2,3)+1]

    A.i.j=A.i.j+1;      //相当于 oset[A,i,j : oget(A,i,j)+1]

    例子2：函数指针

    a(x)=x+2;
    (:p)= p=HFor("a"), p(3);    //p(3)相当于oget(p,3)，即调用函数a(3)
}#
--------------------------------------------------------------------
#gc{
[lu32.dll] gc()：垃圾收集。

    立即扫描并销毁垃圾对象，释放所占空间。函数返回0表示运行成功，否则表示不允许运行垃圾收集器。

    在Lu中，一个对象用一个指针标识，该指针存放在一个Lu数据中，此时，我们称这个数为指向该对象的指针。若Lu系统中的静态变量、模块变量、全局变量以及正在运行的表达式的数据区（自变量、动态变量及数据堆栈）中存在一个数对指向一个全局象时，该对象是有效的，否则视为垃圾对象，会被垃圾收集器所回收。
}#
--------------------------------------------------------------------
#ObjNum{
[lu32.dll] ObjNum(n)：获得或设置动态对象数目。

    当n>=100时设置允许的动态对象的最大数目，否则返回当前动态对象的数目。

    通常，Lu在检测到动态对象数目超过了允许的最大值时，将启动垃圾收集器进行清理。
}#
--------------------------------------------------------------------
#ClearBuf{
[lu32.dll] ClearBuf()：清空垃圾对象缓冲区。

    动态对象生命期结束时，或者用函数del(...)删除对象时，对象会暂时存放在垃圾对象缓冲区中，该函数用于清空垃圾对象缓冲区。
}#
--------------------------------------------------------------------
#lu{
[lu32.dll] lu(a,b,c,...)：生成Lu动态数据。

    Lu动态数据存放在一个线性表中，简称lu表，lu表中可以存放任意类型的数据，包括nil和lu表。

    还可以用函数new[lu,5:a,b,c,...]创建lu表，此时可指定lu表的长度并赋初值。

    lu表是Lu的基本动态数据类型。函数以lu表为参数时，可实现变参数传递。在垃圾收集时，若一个lu表是有效的，则该lu表中的所有对象都是有效的，不会被垃圾收集器所收集。
}#
--------------------------------------------------------------------
#intss{
[lu32.dll] intss("...",x1,x2,x3,...)：将静态字符串转换为静态一维整数数组。

    参数x1,x2,x3,...将给数组赋初值（只能是整数或实数，若是实数将截断取整）。

    若LuErr=1：非法的字符串对象；LuErr=2：非法的初值参数。
}#
--------------------------------------------------------------------
#realss{
[lu32.dll] realss("...",x1,x2,x3,...)：将静态字符串转换为静态一维实数数组。

    参数x1,x2,x3,...将给数组赋初值（只能是实数或整数，若是整数将自动进行类型转换）。

    若LuErr=1：非法的字符串对象；LuErr=2：非法的初值参数。
}#
--------------------------------------------------------------------
#cast{
[lu32.dll] cast(Data,MyType)：强制类型转换。

    强制将数据Data的扩展类型转换为MyType类型。MyType是一个整数，标识某种类型的数据。若MyType为self，则将数据Data的扩展类型转换为其基本类型。
}#
--------------------------------------------------------------------
#del{
[lu32.dll] del(x1,x2,x3,...)：将动态对象放到垃圾对象缓冲区。

    垃圾对象缓冲区中的对象将由Lu在合适的时候进行销毁。
}#
--------------------------------------------------------------------
#delete{
[lu32.dll] delete(x1,x2,x3,...)：立即销毁对象。
}#
--------------------------------------------------------------------
#new{
[lu32.dll] new(type,x1,x2,x3,...)：生成新的对象。

    type是一个整数，标识某种动态数据类型；x1,x2,x3,...是初始化参数。

    Lu核心库中定义的动态类型有lu表（lu）、动态字符串（string）、动态整数数组（ints）和动态实数数组（reals），例子：

	new[lu,5] 生成长度为5的lu表。 
	new[lu,5 : 2, "aa", 3.3] 生成长度为5的lu表并赋初值，若有多余的初值参数，将被忽略。 
	new[string,5] 生成长度为5的动态字符串。 
	new[string,5,"abc"] 生成长度为5的动态字符串并赋初值，初值是一个字符串参数，若字符串过长，将被截断。 
	new[string,"abc"] 生成与所给字符串长度相同的动态字符串，并赋初值。 
	new[ints,3,5] 生成二维数组。 
	new[ints,3,5,data: 11,22,33] 生成二维数组并赋初值，多余的参数被忽略。 
	new[ints,data: 11,22,33] 生成一维数组并赋初值，数组长度即初值参数个数。 
	new[reals,3,5] 生成二维数组（矩阵）。 
	new[reals,3,5,data: 1.1,2.2,3.3] 生成二维数组（矩阵）并赋初值，多余的参数被忽略。 
	new[reals,data: 1.1,2.2,3.3] 生成一维数组并赋初值，数组长度即初值参数个数。 
}#
--------------------------------------------------------------------
#len{
[lu32.dll] len(p,&x1,&x2,&x3,...)：返回对象长度。

    该函数返回对象p的长度，并通过参数x1,x2,x3等返回更多信息。如果是动态整数数组（ints）或动态实数数组（reals），则x1返回数组维数，x2,x3,...返回每一维的大小。
}#
--------------------------------------------------------------------
#newtype{
[lu32.dll] newtype()：创建新的扩展数据类型。

    该函数返回一个新的数据扩展类型（是一个整数），当该类型的数据成为Lu运算符或重载函数的操作数时，将调用与该扩展类型匹配的运算符重载函数。调用函数newtype的表达式即是与该扩展类型匹配的运算符重载函数。

    在一个表达式中多次调用newtype()时，仅返回一种数据扩展类型，或者nil。
}#
--------------------------------------------------------------------
#return{
[lu32.dll][流程控制] return(x)：立即返回函数；

结束计算并立即返回表达式的值为x。
}#
--------------------------------------------------------------------
#if{
[lu32.dll][流程控制] if(x,y1,y2,... ...,yn)：判断函数；

当逻辑语句x的值为真时，依次执行语句y1,y2,... ...,yn，否则，不执行语句y1,y2,... ...,yn。
该函数至少要有2个自变量参数，其中第一个参数为逻辑语句。
该函数的返回值无意义。
}#
--------------------------------------------------------------------
#which{
[lu32.dll][流程控制] which(... ...)：自定义分段函数；

      which{
        逻辑语句1 : 语句1,
        逻辑语句2 : 语句2,
        ... ...,
        逻辑语句n : 语句n,
        缺省语句
      };

    Lu从前往后计算并检测逻辑语句的值，当检测到逻辑真（或者对象值非0）时，计算与此逻辑真对应的语句并返回该语句的值，如果没有检测到逻辑真，则计算缺省语句的值作为返回值，若此时没有缺省语句，则产生一个运行错误（错误代码为0）。
    该函数至少要有2个自变量参数。
    例如下式定义了一个分段函数：

      (x)=which{x>0, 2*x-1,
            x*x-1
          };

    如果舍弃该函数的返回值，则该函数可以作为一个选择计算函数使用。
}#
--------------------------------------------------------------------
#while{
[lu32.dll][流程控制] while(... ...)：循环函数；

    while循环是“当型”循环，其特点是：先判断条件是否成立，当条件成立时，则执行循环体，否则退出循环体，即“当条件成立时执行循环”。“当型”循环的循环体有可能一次也不执行。
    while循环函数的格式如下：

      while{x,
        y1,y2,
        ...,
        break(),
        ...,
        continue(),
        ...,
        yn
      };

    其中x为逻辑语句；y1,y2,...,break(),...,continue(), ...yn为循环体语句。当x的值为真（或者对象x值非0）时，依次执行循环体语句，直到x的值为假时退出循环。当执行到break()函数时，跳出while循环，执行while循环后面的语句部分；当执行到continue()函数时，返回到while循环的开始语句x处继续执行。
    在循环体语句中，必须有能修改逻辑语句x的值的语句，使x的值为假，退出循环体，否则将产生无限循环。
    该函数至少要有2个自变量参数，其中第一个参数为逻辑语句。
    该函数的返回值无意义。
    以下是一个while循环的例子：

      (:i,k)=
      {
        i=0,k=0,
        while{i<=1000000,k=k+i,i++}, //当i<=1000000时，计算k=k+i，然后i++；
        k
      };
}#
--------------------------------------------------------------------
#until{
[lu32.dll][流程控制] until(... ...)：循环函数；

    until循环是“直到型”循环，其特点是：先执行循环体，再判断条件是否成立，当条件成立时，退出循环体，否则继续执行循环体，即“执行循环直到条件成立”。“直到型”循环的循环体至少执行一次。
    until循环函数的格式如下：

      until{x1,x2,
        ...,
        break(),
        ...,
        continue(),
        ...,
        y
      };

    until为先执行后判断的循环函数。即先执行循环体语句x1,x2,...,break(),...,continue(),...，然后计算逻辑语句y的值，直到y的值为真（或者对象y值非0）时退出循环。当执行到break()函数时，跳出until循环，执行until循环后面的语句部分；当执行到continue()函数时，返回到until循环的开始语句x1处继续执行。
    在循环体语句中，必须有能修改逻辑语句y的值的语句，使y的值为真，退出循环体，否则将产生无限循环。
    该函数至少要有2个自变量参数，其中最后一个参数为逻辑语句。
    该函数的返回值无意义。
    以下是一个until循环的例子：

      (:i,k)=
      {
        i=0,k=0,
        until{k=k+i,i++,i>1000000}, //计算k=k+i,i++，当i>1000000时退出；
        k
      };
}#
--------------------------------------------------------------------
#break{
[lu32.dll][流程控制] break()：跳出内层循环函数；

只能用在while和until两个循环函数中。当执行到break()函数时，跳出while或until循环，执行while或until循环后面的语句部分。
}#
--------------------------------------------------------------------
#continue{
[lu32.dll][流程控制] continue()：继续循环函数；

只能用在while和until两个循环函数中。当执行到continue()函数时，返回到while或until循环的开始语句处继续执行。
}#
-------------------------------------------------------------------- 
#字符串{
[lu32.dll] 字符串

    在Lu中使用Unicode宽字符串，一个宽字符有2个字节，用两个双引号定义一个字符串，即"..."表示一个字符串。在Lu字符串中，还可以用反斜杠转义字符输入一些特殊字符。

    反斜杠转义字符

\\ 反斜杠“\” 
\" 双引号“"” 
\% 0 
\a 警告 
\b 退格 
\f 换页 
\n 换行 
\r 回车 
\t 水平制表符 
\v 垂直制表符 
\& 没有对应的字符。当该转义字符位于字符串最前面时（例如："\&... ..."），指示编译器在数的边界处存放该字符串，并影响转义字符\[n]；该转义字符位于字符串的其他位置时不产生任何作用。
\NNNNN 任意字符，NNNNN是该字符Unicode码的10进制值，NNNNN必须是5个数字，例如NNNNN码为9的字符，应写成\00009 。
\xNNNN 任意字符，NNNN是该字符Unicode码的16进制值，NNNN必须是两个16进制数字（字母A到F以单个数字的形式表示10进制数的10到15），例如Unicode码为11的字符，应写成“\x000B” 。
\[n] n是一个10进制整数，转换成n×k个空格符。 若字符串最前面没有转义字符\&，k=1；若字符串最前面有转义字符\&，则取系统字长k=4，这种字符串格式可转换为整数、实数或复数数组。例如： 任意表达式中，"\[256]" 是一个256个字符长的空格符字符串。"\&\[256]" 是一个256×4个字符长的空格符字符串。 

    除了表中定义的之外，Lu没有定义其它的转义字符（“\”和其他字符的组合都是非法的）。可以看出，反斜杠“\”和双引号“"”只能通过转义字符输入。

    另外，若字符串前有符号@（例如：@"...\r\n..."），将忽略转义字符。

    例如：

      o("hello!\r\n字符串！！！");       //用o函数输出字符串；
      o(@"hello!\r\n字符串！！！");      //用o函数输出字符串；

    可以用字符串标识任意类型的数据值，但核心库中没有这方面的例子。

    可以用字符串存储任意类型的数据值，如下面将要讲到的静态数组。

    Lu字符串有二种类型：Lu静态字符串和Lu动态字符串。Lu静态字符串即在Lu表达式中定义的字符串，长度是固定的，不能随意进行销毁（但Lu静态字符串也并非一成不变）；Lu动态字符串由函数new生成。
}#
-------------------------------------------------------------------- 
#数组{
[lu32.dll] 数组

    Lu数组有静态和动态两种。

    Lu动态数组是多维的，参考函数new的说明。

    Lu静态数组是一维的，通过一组函数操作静态字符串来实现。使用数组之前，须先用转义字符"\[n]"定义足够的静态空间。

    Lu内置了Unicode字符数组、整数数组、实数数组、复数数组和三维向量数组的操作函数，参考函数A、A2和A3的说明。也可以通过数组句柄直接访问数组元素，如下例：

    例子1：静态Unicode字符数组

(:i,k,str)=
{
    str="**\[26]**",      //定义字符串str，共30个字符，这就是一个Unicode字符数组
    k=["a"], k=k[0],      //用获得字符"a"的Unicode值并赋值给k
    i=0, while{i<26, str[2+i]=k++, i++},  //将星号之间是字符空间设置为26个英文字母
    o(str)                //输出字符数组str
};

    例子2：静态实数数组，字符串必须定义成"\&... ..."格式。

(:i,k,a,s)=
{
    a=realss("\&\[10]"),             //定义4×10个字符长的字符串，并转换为实数数组
    k=len(a),                        //获得数组长度
    i=0, while{i<k, a(i)=1.0, i++},  //将数组的每一个元素都设为1.0
    i=0, s=0.0, while{i<k, s=s+a(i++)}, //将数组的所有元素都加起来
    s                                //输出相加后的值
};

    例子3：动态实数数组

(:i,j,m,n,a,s)=
{
    a=new(reals,3,10),    //定义3×10实数数组（矩阵）
    len(a,0,&m,&n),       //获得数组维数大小
    s=0.0, i=0, while{i<m,
      j=0, while{j<n, a(i,j)=1.0, s=s+a(i,j), j++}, //将数组的每一个元素都设为1.0，并将数组的所有元素都加起来
      i++
    },
    s                     //输出相加后的值
};
}#
-------------------------------------------------------------------- 
#Lu表{
[lu32.dll] Lu表

    Lu动态数据存放在一个线性表中，简称lu表，lu表中可以存放任意类型的数据，包括nil和lu表。

    有两种方法可以生成lu表。一种是使用lu函数，例如：lu[2,3.3,"me"]；或者使用函数new[lu,5:a,b,c,...]创建lu表，此时可指定lu表的长度并赋初值。

    lu表是Lu的基本动态数据类型。函数以lu表为参数时，可实现变参数传递。在垃圾收集时，若一个lu表是有效的，则该lu表中的所有对象都是有效的，不会被垃圾收集器所收集。

    例子1：

(:a,b)= a=lu[2,3.5,"me",lu[5.5,true]], b=a[3], o[a(0),"  ",a(1),"  ",a(2),"  ",b(0),"  ",b(1),"  "];

    例子2：

(:a,b)= a=new[lu,4: 2,3.5,"me",lu[5.5,true]], b=a[3], o[a(0),"  ",a(1),"  ",a(2),"  ",b(0),"  ",b(1),"  "];

    例子3：

f(x:i,k,s)= k=len(x), s=x[0], i=1, while{i<k, s=s+x[i++]}, s;    //函数f接受一个一维对象，并对对象的所有元素相加
f[lu(1,2,3,4,5)];        //5个整数相加
f[lu(1.0,2.0,3.0)];      //3个实数相加
f[lu("abc","123","xyz")];//3个字符串相加
}#
-------------------------------------------------------------------- 
#标识符解释规则{
[lu32.dll] 标识符解释规则

    1）若标识符后面有括号，表示是一个函数，否则是一个变量或常量名。

    2）若标识符后面有句点“.”，表示将该标识符联系到一个函数，例如：a.sin(x)；或者产生一个函数调用，例如：a.b 相当于 a(b)。若变量是显示说明的，则通过句点将产生隐含的oset函数或oget函数调用，称变量函数调用，例如：a.b 相当于 oget[a,b]；a.b=c 相当于 oset[a,b:c]。

    3）如果一个变量名与常量名相同，则常量名被忽略。确定变量或常量的顺行是：变量、常量、常量命名空间。

    4）如果编译器允许使用未定义的模块变量，当遇到一个未定义的标识符时，将被解释为模块变量或常量。如果该常量不存在，就解释为模块变量。如果该常量存在，但不存在同名的模块变量，将解释为常量。如果常量和同名的模块变量同时存在，将优先解释为模块变量。若要确保编译器将未定义的标识符解释为模块变量，则应在前面编译的表达式中，将该标识符明确地定义为模块变量并至少使用一次。

    5）如果是一个普通的函数名，则确定函数的顺行是：变量函数、一级函数或流程控制函数、自定义表达式、二级函数、using指定的命名空间中的函数。

    6）如果是一个命名空间中的函数，确定函数的顺行是：模块命名空间、二级函数命名空间。

    7）模块私有表达式与一个公有表达式重名时，优先调用本模块中的私有表达式。
}#
-------------------------------------------------------------------- 
