OpenEuphoria

Re: which is faster?

• Posted by CChris <christian.cuvier at a?ricu?ture.gouv.fr> Nov 08, 2007
• 622 views

Here is a benchmark to prove and disprove stuff....

sequence s,s1  -- data
constant num_runs=10000, len_data=10000
s=repeat(0,num_runs)
s1=repeat(0,len_data)

-- generate random data
for k=1 to num_runs do
for i=1 to len_data do
s1[i]=rand(12345+k)
end for
s[k]=s1
end for
puts(1,"Data initialised, starting benchmark...\n")

function mean(sequence s)
-- adds verything up in s, returns average
atom result
result=s[1]
for i=2 to length(s) do result+=s[i] end for
return result/length(s)
end function

global function st_dev0(sequence s, atom X)
    atom m, sum, sd
    integer l
    sum = 0
    l = length(s)
    m = mean(s)
    s -= m
    for i = 1 to length(s) do
	sum += power(s[i], 2)
    end for
    sd = sqrt(sum/(l-1))
    if X = 0 then
	return sd
    else -- return the z-score
	return (X - m)/sd
    end if
end function

global function st_dev1(sequence s, atom X)
    atom m, sum, sd
    integer l
    sum = 0
    l = length(s)
    m = mean(s)
    for i = 1 to length(s) do
	sum += power(s[i], 2)
    end for
    sum -= m*m*l
    sd = sqrt(sum/(l-1))
    if X = 0 then
	return sd
    else -- return the z-score
	return (X - m)/sd
    end if
end function

global function st_dev2(sequence s, atom X)
    atom m, sum, sd
    integer l
    sum = 0
    l = length(s)
    m = mean(s)
    for i = 1 to length(s) do
	    sd = s[i]
        sum += sd*sd
    end for
    sum -= m*m*l
    sd = sqrt(sum/(l-1))
    if X = 0 then
	return sd
    else -- return the z-score
	return (X - m)/sd
    end if
end function

global function st_dev3(sequence s, atom X)
    atom m, sum, sd , m2
    integer l
    sum = 0
    l = length(s)
    m = mean(s)
    m2 = m*m
    for i = 1 to length(s) do
	    sd = s[i]
        sum += sd*sd
    end for
    sum -= m2
    sd = sqrt((sum/(l-1)) - m2)
    if X = 0 then
	return sd
    else -- return the z-score
	return (X - m)/sd
    end if
end function

global function st_dev4(sequence s, atom X)
    atom m, sum, sum_sq, sd , m2
    integer l
    sum_sq = 0.0
    sum = 0.0
    l = length(s)
    for i = 1 to length(s) do
	    sd = s[i]
	    sum += sd
        sum_sq += sd*sd
    end for
    m = sum/l
    m2 = m*m
    sum_sq -= m2
    sd = sqrt((sum_sq/(l-1)) - m2)
    if X = 0 then
	return sd
    else -- return the z-score
	return (X - m)/sd
    end if
end function

global function st_dev5(sequence s, atom X)
    atom m, sum, sum_sq, sd , m2
    integer l
    sum_sq = 0.0
    sum = 0.0
    l = length(s)
    for i = 1 to length(s) do
	    sum += s[i]
        sum_sq += power(s[i],2)
    end for
    m = sum/l
    m2 = m*m
    sum_sq -= m2
    sd = sqrt((sum_sq/(l-1)) - m2)
    if X = 0 then
	return sd
    else -- return the z-score
	return (X - m)/sd
    end if
end function

atom t,junk
t=time()
for i=1 to length(s) do
   junk=st_dev0(s[i],0.0)
end for
printf(1,"Variant form #0 took %3.6gs.\n",time()-t)
t=time()
for i=1 to length(s) do
   junk=st_dev1(s[i],0.0)
end for
printf(1,"Variant form #1 took %3.6gs.\n",time()-t)
t=time()
for i=1 to length(s) do
   junk=st_dev2(s[i],0.0)
end for
printf(1,"Variant form #2 took %3.6gs.\n",time()-t)
t=time()
for i=1 to length(s) do
   junk=st_dev3(s[i],0.0)
end for
printf(1,"Variant form #3 took %3.6gs.\n",time()-t)
t=time()
for i=1 to length(s) do
   junk=st_dev4(s[i],0.0)
end for
printf(1,"Variant form #4 took %3.6gs.\n",time()-t)
t=time()
for i=1 to length(s) do
   junk=st_dev5(s[i],0.0)
end for
printf(1,"Variant form #5 took %3.6gs.\n",time()-t)

?machine_func(26,0)

On an AMD3300+, 2.0GHz, 960Mo RAM under WinXP SP2 Pro, I'm getting the following
output from ex.exe:
Data initialised, starting benchmark...
Variant form #0 took 75.46s.
Variant form #1 took 14.89s.
Variant form #2 took 16.81s.
Variant form #3 took 16.97s.
Variant form #4 took 16.37s.
Variant form #5 took 17.68s.

I thought that precomputing s[i] would speed things up, but this didn't occur.
Not sure why.
I didn't try to vary the order of tests.

CChris