欢迎访问 Lu程序设计

Lu与C/C++、Forcal、MATLAB、Python、Lua等各种语言的速度比较

    以下比较均是在同一台计算机上进行的,在其他计算机上结果会有所不同。

1 Lu与C/C++、Forcal、Lua的数值计算速度比较

    C/C++代码:

z=0.0;
for(x=0.0;x<=1.0;x=x+0.0011)
{
  for(y=1.0;y<=2.0;y=y+0.0011)
  {
    z=z+cos(1.0-sin(1.2*pow(x+0.1,y/2.0-x)+cos(1.0-sin(1.2*pow(x+0.2,y/3.0-x))))-cos(1.0-sin(1.2*pow(x+0.3,y/4.0-x)))-cos(1.0-sin(1.2*pow(x+0.4,y/5.0-x)+cos(1.0-sin(1.2*pow(x+0.5,y/6.0-x))))-cos(1.0-sin(1.2*pow(x+0.6,y/7.0-x)))));
  }
}

    以上C/C++代码运行结果:z=19160.536601703152,耗时约1.328秒。

    Forcal计算结果z=19160.536601703152,耗时约1.828秒。

    Lua代码:

function z()
	local t = os.clock()
	local mcos = math.cos
	local msin = math.sin

	local x=0
	local y=0
	local z=0
	for x=0,1,0.0011 do 
		for y=1,2,0.0011 do    
			z=z+mcos(1-msin(1.2*(x+0.1)^(y/2-x)+mcos(1-msin(1.2*(x+0.2)^(y/3-x))))-mcos(1-
msin(1.2*(x+0.3)^(y/4-x)))-mcos(1-msin(1.2*(x+0.4)^(y/5-x)+mcos(1-msin(1.2*(x+0.5)^(y/6-x))))-
mcos(1-msin(1.2*(x+0.6)^(y/7-x))))) 
		end

	end
	io.write(z)

	io.write(string.format(" Time Elapsed %f\n", os.clock() - t))
end

z()

    Lua运行结果:

19160.536601703 Time Elapsed 2.484000

    Lu代码:

main(:x,y,z,t)=
{
  t=clock(), z=0.0, x=0.0,
  while{x<=1.0,
    y=1.0,
    while{y<=2.0,
      z=z+cos(1.0-sin(1.2*(x+0.1)^(y/2.0-x)+cos(1.0-sin(1.2*(x+0.2)^(y/3.0-x))))-cos(1.0-sin(1.2*(x+0.3)^(y/4.0-x)))-cos(1.0-sin(1.2*(x+0.4)^(y/5.0-x)+cos(1.0-sin(1.2*(x+0.5)^(y/6.0-x))))-cos(1.0-sin(1.2*(x+0.6)^(y/7.0-x))))),
      y=y+0.0011
    },
    x=x+0.0011
  },
  o{"z=",z,",耗时约",[clock()-t]/1000.0,"秒。\r\n"}
};

    Lu运行结果:

z=19160.536601703152,耗时约2.656秒。

2 八皇后问题

    据测定,以下八皇后问题,Lu的运行速度约为C++的1/23,而Forcal的运行速度约为C++的1/10。

// 在运行不同的程序时,Lu的速度,从接近C++到只有C++速度的几十分之一。
// Lu的建议是:对运行时间较长的程序,如确有必要,设计成二级函数由Lu调用,从而获得接近C++速度的性能。
// Lu与C++是无缝链接的。故C++能实现的功能,借助二级函数,Lu完全可以实现。
// 但没有Lu支持的C++程序,将无法获得高效率地实时编译计算字符串表达式的功能。

// 据测定,以下八皇后问题,Lu的运行速度约为C++的1/23。
// 八皇后问题是一个古老而著名的问题,是回溯算法的典型例题。
// 该问题是19世纪著名的数学家高斯1850年提出:在8×8格的国际象棋盘上摆放8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。
// 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解,后来有人用图论的方法解出92种结果。
// 以下算法是从网上搜来的,该算法没有最终给出排列组合,仅仅给出有多少种组合,但是算法确实十分奥妙。

//Lu源程序
(::sum,upperlim)= sum=0, upperlim=1, SetStackMax(1000);
test(row, ld, rd : pos,p : sum,upperlim)=
{
    which
    {
        row != upperlim,
        {
            pos = {upperlim && [!!(row||ld||rd)]},
            while{ pos,
                p = pos&&(-pos),
                pos = pos -p,
                test[row+p, (ld+p)<<1, (rd+p)>>1]
            }
        },
        sum++
    }
};
main(:tm,n:sum,upperlim)=
{
    tm=clock(), n=15,
    upperlim=(upperlim<<n)-1,
    test(0,0,0),
    o["Queens=",n,",sum=",sum,",耗时约",[clock()-tm]/1000.0,"秒。\r\n"]
};

Lu运行结果:

    Queens=15,sum=2279184,耗时约136.703秒。

完成相同功能的C++程序:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

long sum=0,upperlim=1;

void test(long row, long ld, long rd)
{
    if (row != upperlim)
        {
            long pos = upperlim & ~(row | ld | rd);
            while (pos){
                long p = pos& -pos;
                pos -= p;
                test(row+p, (ld+p)<<1, (rd+p)>>1);
            }
        }
    else
        sum++;
}

int main(int argc, char *argv[])
{
    time_t tm;
    int n=15;

    if(argc!=1)n=atoi(argv[1]);
    tm=time(0);
    if((n<1)||(n>32))
    {
        printf(" heh..I can’t calculate that.\n");
        exit(-1);
    }
    printf("%d Queens\n",n);
    upperlim=(upperlim<<n)-1;

    test(0,0,0);
    printf("Number of solutions is %ld, %d seconds\n", sum,(int)(time(0)-tm));
}

    VC运行结果:

15 Queens
Number of solutions is 2279184, 6 seconds

3 Matlab与Lu普通函数调用效率

    Matlab 2009a的测试代码:

f=@(x,y,z,t)x+y+z;
tic;
s=0;
for x=0:1000
    for y=0:100
        for z=0:100
            s=s+f(x,y,z);
        end
    end
end
s
toc

s =

6.126720600000000e+009

Elapsed time is 9.546717 seconds.

    将函数写成m文件后效率会提高,如下例:

%file xyz.m
function c=xyz(x,y,z)
c=x+y+z;
end

    测试代码:

tic;
s=0;
for x=0:1000
    for y=0:100
        for z=0:100
            s=s+xyz(x,y,z);
        end
    end
end
s
toc

s =

6.126720600000000e+009

Elapsed time is 4.724592 seconds.

    Lu代码:

f(x,y,z)=x+y+z;
main(:t,s,x,y,z)=
t=clock(),
s=0,
x=0, while{x<=1000,
    y=0, while{y<=100,
        z=0, while{z<=100,
            s=s+f(x,y,z),
            z++
        },
        y++
    },
    x++
},
o{"s=",s,", time=",[clock()-t]/1000.};

    Lu运行结果:

s=6126720600, time=4.015

4 Matlab与Lu的递归函数调用效率

    以Fibonacci递归程序为例进行比较。

    Matlab 2009a的Fibonacci函数定义:

function k=fib(n)

if n == 0
    k=0;
    return;
else if n == 1
    k=1;
    return;
else
    k=fib(n - 1) + fib(n - 2);
    return;
end

end

    运行结果:

tic;
fib(30)
toc

ans =

    832040

Elapsed time is 26.315245 seconds.

    Lu的Fibonacci函数及代码:

SetStackMax(1000);
F(n)= which{
    n == 0,
        return(0),
    n == 1,
        return(1),
    return [F(n - 1) + F(n - 2)]
};
main(:t)= t=clock(), o{"F(30)=",F(30),", time=",[clock()-t]/1000.};

    Lu运行结果:

F(30)=832040, time=0.875

5 变步长辛卜生二重求积法

    C/C++代码:

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include "time.h"
#include "math.h"

double simp1(double x,double eps);
void fsim2s(double x,double y[]);
double fsim2f(double x,double y);

double fsim2(double a,double b,double eps)
{
    int n,j;
    double h,d,s1,s2,t1,x,t2,g,s,s0,ep;

    n=1; h=0.5*(b-a);
    d=fabs((b-a)*1.0e-06);
    s1=simp1(a,eps); s2=simp1(b,eps);
    t1=h*(s1+s2);
    s0=1.0e+35; ep=1.0+eps;
    while (((ep>=eps)&&(fabs(h)>d))||(n<16))
    {
        x=a-h; t2=0.5*t1;
        for (j=1;j<=n;j++)
        {
            x=x+2.0*h;
            g=simp1(x,eps);
            t2=t2+h*g;
        }
        s=(4.0*t2-t1)/3.0;
        ep=fabs(s-s0)/(1.0+fabs(s));
        n=n+n; s0=s; t1=t2; h=h*0.5;
    }
    return(s);
}

double simp1(double x,double eps)
{
    int n,i;
    double y[2],h,d,t1,yy,t2,g,ep,g0;

    n=1;
    fsim2s(x,y);
    h=0.5*(y[1]-y[0]);
    d=fabs(h*2.0e-06);
    t1=h*(fsim2f(x,y[0])+fsim2f(x,y[1]));
    ep=1.0+eps; g0=1.0e+35;
    while (((ep>=eps)&&(fabs(h)>d))||(n<16))
    {
        yy=y[0]-h;
        t2=0.5*t1;
        for (i=1;i<=n;i++)
        {
            yy=yy+2.0*h;
            t2=t2+h*fsim2f(x,yy);
        }
        g=(4.0*t2-t1)/3.0;
        ep=fabs(g-g0)/(1.0+fabs(g));
        n=n+n; g0=g; t1=t2; h=0.5*h;
    }
    return(g);
}

void fsim2s(double x,double y[])
{
    y[0]=-sqrt(1.0-x*x);
    y[1]=-y[0];
}

double fsim2f(double x,double y)
{
    return exp(x*x+y*y);
}

int main(int argc, char *argv[])
{
    int i;
    double a,b,eps,s;
    clock_t tm;

    a=0.0; b=1.0; eps=0.0001;
    tm=clock();
    for(i=0;i<100;i++)
    {
    s=fsim2(a,b,eps);
    }
    printf("s=%e , 耗时 %d 毫秒。\n", s, (clock()-tm));
}

    C/C++结果:

    s=2.698925e+000 , 耗时 78 毫秒。

    -------

    matlab 2009a代码:

%file fsim2.m
function s=fsim2(a,b,eps)
    n=1; h=0.5*(b-a);
    d=abs((b-a)*1.0e-06);
    s1=simp1(a,eps); s2=simp1(b,eps);
    t1=h*(s1+s2);
    s0=1.0e+35; ep=1.0+eps;
    while ((ep>=eps)&&(abs(h)>d))||(n<16),
        x=a-h; t2=0.5*t1;
        for j=1:n
            x=x+2.0*h;
            g=simp1(x,eps);
            t2=t2+h*g;
        end
        s=(4.0*t2-t1)/3.0;
        ep=abs(s-s0)/(1.0+abs(s));
        n=n+n; s0=s; t1=t2; h=h*0.5;
    end
end

function g=simp1(x,eps)
    n=1;
    [y0,y1]=f2s(x);
    h=0.5*(y1-y0);
    d=abs(h*2.0e-06);
    t1=h*(f2f(x,y0)+f2f(x,y1));
    ep=1.0+eps; g0=1.0e+35;
    while (((ep>=eps)&&(abs(h)>d))||(n<16))
        yy=y0-h;
        t2=0.5*t1;
        for i=1:n
            yy=yy+2.0*h;
            t2=t2+h*f2f(x,yy);
        end
        g=(4.0*t2-t1)/3.0;
        ep=abs(g-g0)/(1.0+abs(g));
        n=n+n; g0=g; t1=t2; h=0.5*h;
    end
end

%file f2s.m
function [y0,y1]=f2s(x)
    y0=-sqrt(1.0-x*x);
    y1=-y0;
end

%file f2f.m
    function c=f2f(x,y)
    c=exp(x*x+y*y);
end

%%%%%%%%%%%%%

>> tic
for i=1:100
a=fsim2(0,1,0.0001);
end
a
toc

a =

    2.6989

Elapsed time is 0.995575 seconds.

    -------

    Lu代码:

fsim2s(x,y0,y1)=
{
    y0=-sqrt(1.0-x*x),
    y1=-y0
};
fsim2f(x,y)=exp(x*x+y*y);
//////////////////
simp1(x,eps : n,i,y0,y1,h,d,t1,yy,t2,g,ep,g0)=
{
    n=1,
    fsim2s(x,&y0,&y1),
    h=0.5*(y1-y0),
    d=abs(h*2.0e-06),
    t1=h*(fsim2f(x,y0)+fsim2f(x,y1)),
    ep=1.0+eps, g0=1.0e+35,
    while {((ep>=eps)&(abs(h)>d))|(n<16),
        yy=y0-h,
        t2=0.5*t1,
        i=1, while{i<=n,
            yy=yy+2.0*h,
            t2=t2+h*fsim2f(x,yy),
            i++
        },
        g=(4.0*t2-t1)/3.0,
        ep=abs(g-g0)/(1.0+abs(g)),
        n=n+n, g0=g, t1=t2, h=0.5*h
    },
    g
};

fsim2(a,b,eps : n,j,h,d,s1,s2,t1,x,t2,g,s,s0,ep)=
{
    n=1, h=0.5*(b-a),
    d=abs((b-a)*1.0e-06),
    s1=simp1(a,eps), s2=simp1(b,eps),
    t1=h*(s1+s2),
    s0=1.0e+35, ep=1.0+eps,
    while {((ep>=eps)&(abs(h)>d))|(n<16),
        x=a-h, t2=0.5*t1,
        j=1, while{j<=n,
            x=x+2.0*h,
            g=simp1(x,eps),
            t2=t2+h*g,
            j++
        },
        s=(4.0*t2-t1)/3.0,
        ep=abs(s-s0)/(1.0+abs(s)),
        n=n+n, s0=s, t1=t2, h=h*0.5
    },
    s
};

//////////////////

main(:t0,i,a)=
t0=clock(),
i=0, while{i<100, a=fsim2(0,1,0.0001), i++},
o{"a=",a,", time=",[clock()-t0]/1000.};

    Lu结果:

a=2.6989250006243033, time=0.657

    ---------

    本例C/C++、matlab、Lu运行耗时之比为 1:12.7:8.5 。

    =========

    以下将变步长辛卜生二重求积算法写成通用的函数。不再给出C/C++代码,因其效率不会发生变化。

    注意函数fsim2中增加了两个参数,函数句柄fsim2s用于计算二重积分时内层的上下限,函数句柄fsim2f用于计算积分函数的值。

    Matlab 2009a代码:

%file fsim2.m
function s=fsim2(a,b,eps,fsim2s,fsim2f)
    n=1; h=0.5*(b-a);
    d=abs((b-a)*1.0e-06);
    s1=simp1(a,eps,fsim2s,fsim2f); s2=simp1(b,eps,fsim2s,fsim2f);
    t1=h*(s1+s2);
    s0=1.0e+35; ep=1.0+eps;
    while ((ep>=eps)&&(abs(h)>d))||(n<16),
        x=a-h; t2=0.5*t1;
        for j=1:n
            x=x+2.0*h;
            g=simp1(x,eps,fsim2s,fsim2f);
            t2=t2+h*g;
        end
        s=(4.0*t2-t1)/3.0;
        ep=abs(s-s0)/(1.0+abs(s));
        n=n+n; s0=s; t1=t2; h=h*0.5;
    end
end

function g=simp1(x,eps,fsim2s,fsim2f)
    n=1;
    [y0,y1]=fsim2s(x);
    h=0.5*(y1-y0);
    d=abs(h*2.0e-06);
    t1=h*(fsim2f(x,y0)+fsim2f(x,y1));
    ep=1.0+eps; g0=1.0e+35;
    while (((ep>=eps)&&(abs(h)>d))||(n<16))
        yy=y0-h;
        t2=0.5*t1;
        for i=1:n
            yy=yy+2.0*h;
            t2=t2+h*fsim2f(x,yy);
        end
        g=(4.0*t2-t1)/3.0;
        ep=abs(g-g0)/(1.0+abs(g));
        n=n+n; g0=g; t1=t2; h=0.5*h;
    end
end

%file f2s.m
function [y0,y1]=f2s(x)
    y0=-sqrt(1.0-x*x);
    y1=-y0;
end

%file f2f.m
function c=f2f(x,y)
    c=exp(x*x+y*y);
end

%%%%%%%%%%%%%%%%

>> tic
for i=1:100
a=fsim2(0,1,0.0001,@f2s,@f2f);
end
a
toc

a =

    2.6989

Elapsed time is 1.267014 seconds.

    --------

    Lu代码:

simp1(x,eps,fsim2s,fsim2f : n,i,y0,y1,h,d,t1,yy,t2,g,ep,g0)=
{
    n=1,
    fsim2s(x,&y0,&y1),
    h=0.5*(y1-y0),
    d=abs(h*2.0e-06),
    t1=h*(fsim2f(x,y0)+fsim2f(x,y1)),
    ep=1.0+eps, g0=1.0e+35,
    while {((ep>=eps)&(abs(h)>d))|(n<16),
        yy=y0-h,
        t2=0.5*t1,
        i=1, while{i<=n,
            yy=yy+2.0*h,
            t2=t2+h*fsim2f(x,yy),
            i++
        },
        g=(4.0*t2-t1)/3.0,
        ep=abs(g-g0)/(1.0+abs(g)),
        n=n+n, g0=g, t1=t2, h=0.5*h
    },
    g
};

fsim2(a,b,eps,fsim2s,fsim2f : n,j,h,d,s1,s2,t1,x,t2,g,s,s0,ep)=
{
    n=1, h=0.5*(b-a),
    d=abs((b-a)*1.0e-06),
    s1=simp1(a,eps,fsim2s,fsim2f), s2=simp1(b,eps,fsim2s,fsim2f),
    t1=h*(s1+s2),
    s0=1.0e+35, ep=1.0+eps,
    while {((ep>=eps)&(abs(h)>d))|(n<16),
        x=a-h, t2=0.5*t1,
        j=1, while{j<=n,
            x=x+2.0*h,
            g=simp1(x,eps,fsim2s,fsim2f),
            t2=t2+h*g,
            j++
        },
        s=(4.0*t2-t1)/3.0,
        ep=abs(s-s0)/(1.0+abs(s)),
        n=n+n, s0=s, t1=t2, h=h*0.5
    },
    s
};

//////////////////

f2s(x,y0,y1)=
{
    y0=-sqrt(1.0-x*x),
    y1=-y0
};
f2f(x,y)=exp(x*x+y*y);

main(:t0,i,a)=
  t0=clock(),
  i=0, while{i<100, a=fsim2(0,1,0.0001,HFor("f2s"),HFor("f2f")), i++},
  o{"a=",a,", time=",[clock()-t0]/1000.};

    Lu运行结果:

a=2.6989250006243033, time=0.719

    --------

    本例matlab与Lu耗时之比为1.267014 :0.719。

6 Matlab与Lu动态内存管理效率

    matlab 2009a代码:

clear all
tic
s=0;
for k=1:1000
    for i=1:1000
        a={2,2,2,2};
        s=s+a{1};
    end
end
s
toc

s =

    2000000

Elapsed time is 5.030599 seconds.

    Lu代码:

main(:a,t0,s,k,i)=
t0=clock(),
s=0,
k=0, while{k<1000,
    i=0, while{i<1000, a=lu(2,2,2,2), s=s+a[1], i++},
    k++
},
o{"s=",s,", time=",[clock()-t0]/1000.};

    Lu运行结果:

s=2000000, time=0.703

7 Lu与VC动态数组存取效率测试

    VC源程序:

#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <math.h>
#include <time.h>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    clock_t old,now;
    __int64 i,k;
    __int64 *p;
    char ch;

    old=clock();
    for(i=0,k=0;i<=1000000;i++)
    {
        p=new __int64[5];
        p[3]=i; k=k+p[3];
        delete[] p;
    }
    now=clock();
    cout<<"vc++:"<<setprecision(20)<<k;
    cout<<" 运行时间:"<<now-old<<" 即: "<<(double)(now-old)/CLOCKS_PER_SEC<<"秒"<<endl<<endl;
    cin>>ch;

    return 0;
}

    VC运行结果:

vc++:500000500000 运行时间:218 即: 0.218秒

    Lu源程序:

(:i,k,p,t)=
{   t=clock(),i=0,k=0,
    (i<=1000000).while
    {
        p=new[ints,5],
        A[p,3]=i, k=k+A[p,3],
        del[p],
    //实际上在这里不需要使用del函数,去掉此语句将更快
        i++
    },
    o{"结果=",k,", 时间=",[clock()-t]/1000.,"秒。\r\n"}
};

    Lu运行结果:

结果=500000500000, 时间=0.86秒。

    在该例子中,Lu的效率为VC的0.86/0.218=3.95分之一。若将new和del这两个函数移到循环体的外边,Lu的效率如下:

    VC源程序:   

#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <math.h>
#include <time.h>


using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    clock_t old,now;
    __int64 i,k;
    __int64 *p;
    char ch;

    old=clock(); p=new __int64 [5];
    for(i=0,k=0;i<=20000000;i++)
    {
        p[3]=i; k=k+p[3];
    }
    delete[] p; now=clock();
    cout<<"vc++:"<<setprecision(20)<<k;
    cout<<" 运行时间:"<<now-old<<" 即: "<<(double)(now-old)/CLOCKS_PER_SEC<<"秒"<<endl<<endl;
    cin>>ch;

    return 0;
}

    VC运行结果:

vc++:200000010000000 运行时间:125 即: 0.125秒

    Lu源程序:

(:i,k,p,t)=
{   t=clock(),p=new[ints,5],i=0,k=0,
    (i<=20000000).while
    {
        A[p,3]=i, k=k+A[p,3],
        i++
    },
    del[p],
    //实际上在这里不需要使用del函数
    o{"结果=",k,", 时间=",[clock()-t]/1000.,"秒。\r\n"}
};

    Lu运行结果:

结果=200000010000000, 时间=7.922秒。

    在该例子中,Lu的速度为VC的7.922/0.125=63.376分之一。注意循环次数都增加到了20000000次。

8 一段有趣的程序

    在这个网页看到一篇各种语言运行速度比较的文章,摘抄如下:

— Erik Wrenholt (erik -at- timestretch.com) 2005-09-20

Language Time   Relative Speed
C gcc-4.0.1 0.05 seconds   1.00 x
ocaml compiled 3.09.2 0.05 seconds   1.00 x
SBCL 1.0.2 0.13 seconds   2.55 x
Java 1.4.2 0.40 seconds   8.00 x
Io 20070410 Vector 1.40 seconds   28.09 x
Lua 5.1 1.50 seconds   30.00 x
ocaml bytecode 3.09.2 3.76 seconds   75.15 x
Python 2.5.1 9.99 seconds   199.80 x
Ghostscript 8.51 11.66 seconds   233.12 x
Perl 5.8.6 Optimized 12.37 seconds   247.34 x
TCL 8.4 Optimized 16.00 seconds   320.00 x
Perl 5.8.6 21.75 seconds   435.00 x
PHP 5.1.4 23.12 seconds   462.40 x
Javascript SpiderMonkey v1.6 31.06 seconds   621.27 x
Ruby 1.8.4 34.31 seconds   686.18 x
Emacs Lisp 47.25 seconds   945.00 x
Applescript 71.75 seconds   1435.00 x
Io 20070410 85.26 seconds   1705.13 x
用以上网址提供的c代码与Lu比较,c代码改写为vs 2008可接受的形式,编译运行,结果如下:

#include "stdafx.h"
#include <math.h>
#include <time.h>

#define BAILOUT 16
#define MAX_ITERATIONS 1000

int mandelbrot(double x, double y)
{
	double cr = y - 0.5;
	double ci = x;
	double zi = 0.0;
	double zr = 0.0;
	int i = 0;

	while(1) {
		i ++;
		double temp = zr * zi;
		double zr2 = zr * zr;
		double zi2 = zi * zi;
		zr = zr2 - zi2 + cr;
		zi = temp + temp + ci;
		if (zi2 + zr2 > BAILOUT)
			return i;
		if (i > MAX_ITERATIONS)
			return 0;
	}
	
}

int _tmain (int argc, _TCHAR* argv[]) {

	clock_t old,now;

	old=clock();

	int x,y;
	for (y = -39; y < 39; y++) {
		printf("\n");
		for (x = -39; x < 39; x++) {
			int i = mandelbrot(x/40.0, y/40.0);
			if (i==0)
				printf("*");
			else
				printf(" ");
		}	
	}
	printf ("\n");
	
	now=clock();
	double query_time = ((double)(now-old))/CLOCKS_PER_SEC;	
	printf ("C Elapsed %0.2f\n", query_time);
    return 0;
}

运行结果:
                                       *
                                       *
                                       *
                                       *
                                       *
                                      ***
                                     *****
                                     *****
                                      ***
                                       *
                                   *********
                                 *************
                                ***************
                             *********************
                             *********************
                              *******************
                              *******************
                              *******************
                              *******************
                            ***********************
                              *******************
                              *******************
                             *********************
                              *******************
                              *******************
                               *****************
                                ***************
                                 *************
                                   *********
                                       *
                                ***************
                            ***********************
                         * ************************* *
                         *****************************
                      * ******************************* *
                       *********************************
                      ***********************************
                    ***************************************
               *** ***************************************** ***
               *************************************************
                ***********************************************
                 *********************************************
                 *********************************************
                ***********************************************
                ***********************************************
              ***************************************************
               *************************************************
               *************************************************
              ***************************************************
              ***************************************************
         *    ***************************************************    *
       *****  ***************************************************  *****
       ****** *************************************************** ******
      ******* *************************************************** *******
    ***********************************************************************
    ********* *************************************************** *********
       ****** *************************************************** ******
       *****  ***************************************************  *****
              ***************************************************
              ***************************************************
              ***************************************************
              ***************************************************
               *************************************************
               *************************************************
              ***************************************************
                ***********************************************
                ***********************************************
                  *******************************************
                   *****************************************
                 *********************************************
                **** ****************** ****************** ****
                 ***  ****************   ****************  ***
                  *    **************     **************    *
                         ***********       ***********
                         **  *****           *****  **
                          *   *                 *   *

C Elapsed 0.25

    Forcal用的时间与c++相比,为1.078:0.25=4.312:1。

    Lua的代码及运行时间。

#!/usr/local/bin/lua

-- By Erik Wrenholt

local BAILOUT = 16
local MAX_ITERATIONS = 1000

function iterate(x,y)

	local cr = y-0.5
	local ci = x
	local zi = 0.0
	local zr = 0.0
	local i = 0
	
	while 1 do
		i = i+1
		local temp = zr * zi
		local zr2 = zr*zr
		local zi2 = zi*zi
		zr = zr2-zi2+cr
		zi = temp+temp+ci
		if (zi2+zr2 > BAILOUT) then
			return i
		end
		
		if (i > MAX_ITERATIONS) then
			return 0
		end
	end

end

function mandelbrot()
	local t = os.clock()
	for y = -39, 38 do
		for x = -39, 38 do
			if (iterate(x/40.0, y/40) == 0) then
				io.write("*")
			else
				io.write(" ")
			end
		end
		io.write("\n")
	end
	io.write(string.format("Time Elapsed %f\n", os.clock() - t))
end

mandelbrot()

    运行输出图形与前面相同,仅给出运行时间:

Time Elapsed 0.860000

    Python的代码及运行时间。

#!/usr/local/bin/python
# by Daniel Rosengren

import sys, time
stdout = sys.stdout

BAILOUT = 16
MAX_ITERATIONS = 1000

class Iterator:
  def __init__(self):
    stdout.write('Rendering...')
    for y in range(-39, 39):
      stdout.write('\n')
      for x in range(-39, 39):
        i = self.mandelbrot(x/40.0, y/40.0)
        
        if i == 0:
          stdout.write('*')
        else:
          stdout.write(' ')
    
  def mandelbrot(self, x, y):
    cr = y - 0.5
    ci = x
    zi = 0.0
    zr = 0.0
    i = 0

    while True:
      i += 1
      temp = zr * zi
      zr2 = zr * zr
      zi2 = zi * zi
      zr = zr2 - zi2 + cr
      zi = temp + temp + ci
 		  
      if zi2 + zr2 > BAILOUT:
        return i
      if i > MAX_ITERATIONS:
        return 0

t = time.time()
Iterator()
stdout.write('\nPython Elapsed %.02f' % (time.time() - t))

    运行结果:

Python Elapsed 2.84

    =======================

    完成相同功能的Lu代码如下:

mandelbrot(x, y : cr,ci,zi,zr,i,temp,zr2,zi2) =
{
	cr = y - 0.5,
	ci = x,
	zi = 0.0,
	zr = 0.0,
	i = 0,

	(1).while {
		i ++,
		temp = zr * zi,
		zr2 = zr * zr,
		zi2 = zi * zi,
		zr = zr2 - zi2 + cr,
		zi = temp + temp + ci,
		if [zi2 + zr2 > 16, return (i)],
		if [i > 1000, return (0)]
	}
	
};

main (:i,x,y,old,now) = {

	old=clock(),
	y = -39,
	while{  y < 39,
		o("\r\n"),
		x = -39,
		while{  x < 39,
			i = mandelbrot(x/40.0, y/40.0),
			which{	i==0,
				o("*"),
				o(" ")
			},
			x++
		},
		y++
	},
	now=clock(),
	o["\r\nLu Elapsed ",(now-old)/1000.0]
};

    运行时输出的图形与C程序相同, 在演示程序DemoLu32.exe(这是个windows程序)中的运行时间为:

        Lu Elapsed 5.657

    从运行结果可看出,Lu用的时间与c++相比,为5.657:0.25=22.628:1。

    因C/C++、Forcal、Lua等均使用控制台程序,故设计加载Lu并演示以上程序的C/C++控制台程序如下:

#include <windows.h>
#include <iostream>
#include <math.h>
#include "lu32.h"

#pragma comment( lib, "lu32.lib" )

using namespace std;

void _stdcall LuMessage(wchar_t *pch)
//输出动态库信息,该函数注册到Lu,由Lu二级函数调用
{
    wcout<<pch;
}
void main(void)
{
    void *hFor;
           //表达式句柄
    luINT nPara;          
//存放表达式的自变量个数
    LuData *pPara;        
//存放输入自变量的数组指针
    luINT ErrBegin,ErrEnd;
//表达式编译出错的初始位置和结束位置
    int ErrCode1,ErrCode2;
//错误代码
    void *v;
    wchar_t mandelbrot[]=L"mandelbrot(x, y : cr,ci,zi,zr,i,temp,zr2,zi2) =\r\n{\r\n cr = y - 0.5,\r\n ci = x,\r\n zi = 0.0,\r\n zr = 0.0,\r\n i = 0,\r\n (1).while {\r\n i ++,\r\n temp = zr * zi,\r\n zr2 = zr * zr,\r\n zi2 = zi * zi,\r\n zr = zr2 - zi2 + cr,\r\n zi = temp + temp + ci,\r\n if [zi2 + zr2 > 16, return (i)],\r\n if [i > 1000, return (0)]\r\n }\r\n }";
//字符串表达式
    wchar_t mymain[]=L"mymain (:i,x,y,old,now) = {\r\n old=clock(),\r\n y = -39,\r\n while{ y < 39,\r\n o(\"\r\n\"),\r\n x = -39,\r\n while{ x < 39,\r\n i = mandelbrot(x/40.0, y/40.0),\r\n which{ i==0,\r\n o(\"*\"),\r\n o(\" \")\r\n },\r\n x++\r\n },\r\n y++\r\n },\r\n now=clock(),\r\n o[\"\r\nLu Elapsed \",(now-old)/1000.0]\r\n}";           
//字符串表达式

    if(!InitLu()) return; 
//初始化Lu
    InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v);
//使Lu运行时可输出函数信息

    ErrCode1=LuCom(mandelbrot,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);
//编译表达式
    ErrCode2=LuCom(mymain,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);
//编译表达式
    if(ErrCode1 || ErrCode2)
    {
        cout<<"表达式有错误!错误代码:"<<ErrCode1<<" "<<ErrCode2<<endl;
    }
    else
    {
        LuCal(hFor,pPara);
//计算表达式的值
    }
    FreeLu();             
//释放Lu
}

    运行时输出的图形与C程序相同,运行时间为:

Lu Elapsed 2.063

    从运行结果可看出,Lu用的时间与c++相比,为2.063:0.25=8.252:1。

9 Lu与Python比较的测试例子

    Python程序:

Python code>>> def f(k):
n=0
i=0
while i <=k:
    n=n+i
    i=i+1
    return n

>>> f(100000000)
5000000050000000

    耗时约32秒(用秒表测量)。

    Lu程序:

f(k:i,n)= i=0,n=0, while{i<=k, n=n+i++}, n;
(:t)= t=clock(), o{"f(100000000)=",f(100000000),", time=",[clock()-t]/1000.};

    Lu运行结果:

f(100000000)=5000000050000000, time=14.797

    ======

    另一个测试程序:

    Python 程序:

Python code>>> def f(x,y):
    return math.cos(1-math.sin(1.2*(x+0.1)**(y/2-x)+math.cos(1-math.sin(1.2*(x+0.2)**(y/3-x))))-math.cos(1-math.sin(1.2*(x+0.3)**(y/4-x)))-math.cos(1-math.sin(1.2*(x+0.4)**(y/5-x)+math.cos(1-math.sin(1.2*(x+0.5)**(y/6-x))))-math.cos(1-math.sin(1.2*(x+0.6)**(y/7-x)))))

>>> def g(m,n):
x=0
i=0
while i <=m:
    j=0
    while j <=n:
        x=x+f(i,j)
        j=j+0.01
    i=i+0.01
    return x

>>> g(12.3,7.89)
404005.29176341009

    Python运行约10秒(用秒表测量)。

    Lu程序:

f(x,y)=cos(1-sin(1.2*(x+0.1)^(y/2-x)+cos(1-sin(1.2*(x+0.2)^(y/3-x))))-cos(1-sin(1.2*(x+0.3)^(y/4-x)))-cos(1-sin(1.2*(x+0.4)^(y/5-x)+cos(1-sin(1.2*(x+0.5)^(y/6-x))))-cos(1-sin(1.2*(x+0.6)^(y/7-x)))));
g(m,n:i,j,x)=
    x=0,i=0,
        (i<=m).while{
            j=0,
            (j<=n).while{
                x=x+f(i,j),
                j=j+0.01
            },
            i=i+0.01
        },
    x;
main(:t)= t=clock(), o{"g(12.3,7.89)=",g(12.3,7.89),", time=",[clock()-t]/1000.};

    Lu结果:

g(12.3,7.89)=404005.29176341009, time=3.43


版权所有© Lu程序设计 2002-2010,保留所有权利
E-mail: Lu@sina.com  QQ:630715621
最近更新: 2011年10月25日