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

最新推荐文章于 2024-03-05 22:54:24 发布
最新推荐文章于 2024-03-05 22:54:24 发布
阅读量853 收藏
点赞数
文章标签： lua python c/c++

欢迎访问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 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))))) end function z() local t = os.clock() 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+f(x,y) end end io.write(z) io.write(string.format(" Time Elapsed %f\n", os.clock() - t)) end z()


Lua运行结果：

19160.536601703 Time Elapsed 3.234000

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

LanguageTime　Relative Speed
C gcc-4.0.10.05 seconds1.00 x
ocaml compiled 3.09.20.05 seconds1.00 x
SBCL 1.0.20.13 seconds2.55 x
Java 1.4.20.40 seconds8.00 x
Io 20070410 Vector1.40 seconds28.09 x
Lua 5.11.50 seconds30.00 x
ocaml bytecode 3.09.23.76 seconds75.15 x
Python 2.5.19.99 seconds199.80 x
Ghostscript 8.5111.66 seconds233.12 x
Perl 5.8.6 Optimized12.37 seconds247.34 x
TCL 8.4 Optimized16.00 seconds320.00 x
Perl 5.8.621.75 seconds435.00 x
PHP 5.1.423.12 seconds462.40 x
Javascript SpiderMonkey v1.631.06 seconds621.27 x
Ruby 1.8.434.31 seconds686.18 x
Emacs Lisp47.25 seconds945.00 x
Applescript71.75 seconds1435.00 x
Io 2007041085.26 seconds1705.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月19日

                

        

        




    




    

      

        

            

              
                
                  iteye_1642
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
pow函数python_比较各种Python求幂方法的性能

				
			

			

				

					weixin_34505326的博客
				

				

					01-31
					
					386
					
				

			

		

		

			
				
最近，我在写一个算法来解决一个编码难题，这个难题涉及到在一个笛卡尔平面上找到一个与其他所有点的距离最小的点。在Python中，两个点之间的距离函数可以表示为math.sqrt(dx ** 2 + dy ** 2)。但是，这个函数中的每一项都有不同的表达方法：dx ** 2、 math.pow(dx, 2)和 dx * dx。有趣的是，它们的运行结果各不相同，我想知道它们是如何以及为什么会是这样的。...

			
		

	



                

              
                



	

		

			

				
					
python和matlab计算速度对比_python与matlab的速度。

				
			

			

				

					weixin_39580124的博客
				

				

					11-29
					
					803
					
				

			

		

		

			
				
I''ve been trying to develop some numerical codes with python, howevergot disappointed.A very simple test,a = 1.0for i in range(1000):for j in range(1000):a = a+1unfortunately, it took 4.5 seconds to ...

			
		

	



                


  
              

                


	

		

			

				
					
python运行速度和c_Python和C ++之间异常的速度差异

				
			

			

				

					weixin_39695701的博客
				

				

					12-07
					
					202
					
				

			

		

		

			
				
我最近写了一个简短的算法来计算python中的快乐数字。该程序允许您选择一个上限，它将确定其下的所有快乐数字。为了进行速度比较，我决定对我知道的从python到c++的算法进行最直接的翻译。令人惊讶的是，c版本的运行速度明显慢于python版本。执行时间之间的准确速度测试(用于发现前10,000个快乐数字)表明python程序平均在0.59秒内运行，而c版本平均在8.5秒内运行。我将这种速度差异归...

			
		

	





	

		

			

				
					
Lua中table内建排序与C/C++/Java/php/等内排序算法的排序效率比较

				
			

			

				

					Programmer小卫
				

				

					12-06
					
					3820
					
				

			

		

		

			
				
Lua这类脚本语言在处理业务逻辑作为配置文件的时候方便省事 但是在大量需要 运算的地方就显得略微不足   按照 Lua内建排序算法 对比C++排序算法测试 
Lua解释器的排序算法在LDT下,运行速度比通过C/C++内嵌解释器调用的快4倍之多
 而C/C++的快速排序速度又是Lua 内嵌排序算法的速度的10倍之多,起码在我的电脑上 看到的是这样的效果。

Lua table默认内建排序算法

			
		

	



		

			
		



	

		

			

				
					
图片质量评价参数FSIM计算代码-图片相似性参数FSIM源码-特征相似性FSIM-图片相似性评价参数FSIM计算

				
			

			

				

					04-17
				

			

		

		

			
				
FSIM（Feature Similarity，特征相似性）这是用于计算图片质量或者对比两张图片相似性的一个评价参数，相比于PSNR（峰值信噪比）、SSIM（结构相似性）这个两个广泛使用的图像质量评价参数，FSIM更能体现图片之间的差异性，是一个很先进的图片质量评价参数。本资源包含了两份代码，一份是matlab代码，一份是python代码，用户可以根据自己的需要选择某个源码，另外也提供了两张测试图片和一份测试代码，用来指导用户如何使用。

			
		

	





	

		

			

				
					
FORCAL V7.0 字符表达式编译运行库

				
			

			

				

					03-15
				

			

		

		

			
				
内容索引:VC/C++源码,控件相关,Forcal,编译　Forcal是一个对字符表达式进行编译计算的动态链接库，具有数值计算、关系运算、逻辑运算、字符处理、流程控制、函数调用等许多的可编程功能。它的部分开发文档是由C++...

			
		

	





	

		

			

				
					
forcal编程软件

				
			

			

				

					05-01
				

			

		

		

			
				
FORCAL编程软件是一款专门用于进行计算和数据分析的专业工具，尤其适用于工程、科研等领域。这款软件以其强大的计算能力和灵活的编程接口赢得了用户的青睐。在提供的压缩包文件中，我们可以看到一些关键组件和文档，...

			
		

	





	

		

			

				
					
Forcal数据库应用

				
			

			

				

					07-10
				

			

		

		

			
				
让Forcal的控制台应用程序能够读取数据库中的表达式字符串并计算，你只要双击\ForcalConsole\Forcal数据库应用\ForcalConsole.exe文件,就可以完成创建数据库，读取数据库中的表达式字符串并运算的功能了。...

			
		

	





	

		

			

				
					
FORCAL数值计算扩展动态库FcIMSL V1.0测试版.pdf

				
			

			

				

					07-22
				

			

		

		

			
				
FORCAL数值计算扩展动态库FcIMSL V1.0测试版.pdf

			
		

	





	

		

			

				
					
VC   Forcal7调用例子.rar

				
			

			

				

					07-10
				

			

		

		

			
				
VC Forcal7调用例子，请在此输入表达式！一次只计算一个表达式！  　可在多行中输入表达式。  　如果有自变量，只进行编译，但将保留编译结果，自定义的函数随时可以调用。  　重新初始化将清除以前的编译结果。  　...

			
		

	





	

		

			

				
					
SSIM和PSNR的python代码

				
			

			

				

					09-02
				

			

		

		

			
				
SSIM和PSNR的python实现代码，可用于计算图片之间的差异，直接运行即可，有任何问题可以评论提出

			
		

	





	

		

			

				
					
SSIM的Python实现

				
			

			

				

					10-30
				

			

		

		

			
				
Python实现的图像结构相似性度量（ Structural Similarity Image Metric，SSIM）。

			
		

	





	

		

			

				
					
FSIM—特征相似度MATLAB代码

				
			

			

				

					08-27
				

			

		

		

			
				
MATLAB代码，图像质量评价标准，FSIM

			
		

	





	

		

			

				
					
图像质量评价指标计算python代码，PSNR，SSIM，fsim，niqe，lpips，rmse，德尔塔δe

					
最新发布

				
			

			

				

					m0_52987303的博客
				

				

					03-05
					
					1632
					
				

			

		

		

			
				
给出了图像质量评价指标计算python代码，PSNR，SSIM，fsim，niqe，lpips，rmse，德尔塔δe。

			
		

	





	

		

			

				
					
图像质量评估指标（3）  特征相似度FSIM

					
热门推荐

				
			

			

				

					xiaoxifei的专栏
				

				

					12-11
					
					2万+
					
				

			

		

		

			
				
传统全参考图像质量衡量标准FSIM（feature similarity）
ssim一经提出引来了很多人的研究，并在其上进行一系列的变种，其中一种比较成功的变种是FSIM，该算法认为一张图片中的所有像素并非具有相同的重要性，比如物体边缘的像素点对于界定物体的结构肯定比其他背景区域的像素点更为重要；另外一种重要的评价指标VIF尽管在不同的子带上具有不同的权重，但是在具体的某一子带上参与计算的像素点均...

			
		

	





	

		

			

				
					
数值积分求解卫星轨道长(Python)

				
			

			

				

					weixin_46039719的博客
				

				

					11-21
					
					2185
					
				

			

		

		

			
				
目录

1、概述

2、代码方法一

 3、代码方法二

4、运行结果

                 

1、概述

    微积分在科学和工程中有着广泛的应用，例如，人造地球卫星的轨道可视为平面的椭圆，我国第一颗人造地球卫星近地球距离表面439km，远地点距离地球表面2384km，地球半径为6371km，求该卫星的轨道长度。

   本文题可用椭圆参数方程来描述人造地球卫星轨道，取a=8755km,b=6810km分别为椭圆的长短半轴，该轨...

			
		

	





	

		

			

				
					
C#和lua、C和C++

				
			

			

				

					qq_60125117的博客
				

				

					04-24
					
					1050
					
				

			

		

		

			
				
总的来说，C++在C语言的基础上增加了面向对象编程的特性和更多的库支持，使得它能够更方便地开发大型项目。在游戏开发中，C#主要用于编写客户端和服务端的底层逻辑，而Lua主要用于编写游戏脚本和AI逻辑等。C和C++都是一种通用的编程语言，它们有许多共同点，但也有一些不同之处。C#的性能很高，可以编写高效的程序，适合编写游戏客户端、服务端等应用。C#有着丰富的语法和强大的面向对象特性，可以完成各种复杂的开发任务。Lua有着简洁的语法和灵活的设计，可以在不同的领域进行扩展和应用。

			
		

	





	

		

			

				
					
简单测试对比 C 与 Lua 的性能

				
			

			

				

					蚂蚁码代码
				

				

					07-24
					
					5479
					
				

			

		

		

			
				
1.使用的系统环境



2.lua 和C/C++性能差异 （字符串查找跑5000w次 对比下执行时间）

lua代码：


begin = os.clock();
str = "Hello! My name is Jack. What is your name?"
i = 0
while i &lt;= 50000000 do
    string.find(str,"Jack")
    i=...

			
		

	





	

		

			

				
					
Lua中保留两位小数

				
			

			

				

					fightsyj的博客
				

				

					04-18
					
					2万+
					
				

			

		

		

			
				
在使用Lua进行开发的时候，经常会遇到保留n位小数的问题，这里以保留两位小数为例，记录一下需要注意的地方！

在选择处理方案之前，首先要确认需求，搞清楚保留两位小数是指小数点后第三位四舍五入还是从小数点后第三位开始直接舍去！

Case 1

Desc

小数点后第三位四舍五入

Method

string.format("%.2f",num)

Demo


local num1, num2...

			
		

	





	

		

			

				
					
python几个指数函数时间效率比较

				
			

			

				

					chatbox
				

				

					07-17
					
					586
					
				

			

		

		

			
				
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录前言1.测试函数2.运行时间总结

前言

Python中有3个指数函数，自带的pow，math.pow和numpy.power，那么它们3个哪个最快呢，做个小测试。


提示：以下是本篇文章正文内容，下面案例可供参考
1.测试函数
代码如下：
from numpy import power
from math import pow as math_pow

start = time.time()
for i in range(99

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值