Re: any and all routines

new topic     » topic index » view thread      » older message » newer message

--=====================_859660234==_

        I did some large array timing tests for any and all with the
following results. Art Adamson

--=====================_859660234==_

--   The any and all functions by Zeitlin and Rienks run reliably on my
--Pentium 100 with 32 megs RAM for sequences up to about 4000000 floats.
--   The following program compares the speed of the Zeitlin, anyFor, allFor
--to the Rienks version anyFind and allFind....assuming I executed them
--properly.

--  Both these approaches are limited to about 4,000,000 floats in the array
--for my Pentium 100, 32 Megs Ram, DOS6.22....withput significant disk
--swapping.

--  I created 3 more functions, allLess, allMore, and isIn which do not
--require an "extra" boolean array and which can be adapted to do pretty much
--the same job. My routines are someqhat slower but they work well at up to
--a REMARKABLE limit of 8,000,000+ floats in the array....without
--significant disk swapping.

--Hint, if you try these large arrays, put your swap file in a separate
--      dedicated disk partition. Swap file operation for me with these
--      large sequences has been poor, ie. seemingly endless swapping and
--      lots of use of scandisk to fix up the space after I reboot.

--Surprisingly, changing from floats to integers increases the speed but
--does not increase the 8,000,000 above.

--Speed comparisons are shown in the appended time test file.

--Posted to mailing list by Art Adamson, euclid at horandata.net


--loop version by Zeitlin*********************************************

without type_check
without warning
include file.e

global function allFor(object o)
if atom(o) then return o end if
for i = 1 to length(o) by 1 do
  if not o[i] then return 0 end if
end for
  return 1
end function   --allFor()

global function anyFor(object o)
if atom(o) then return o end if
for i = 1 to length(o) by 1 do
  if  o[i] then return 1  end if
end for
  return 0
end function   --anyFor()

--find version by Rienks**********************************************

global function allFind(object o)
        if atom(o) then return o end if
        if find(0,o) then return 0
        else
                return 1
        end if
end function   --allFind()

global function anyFind(object o)
        if atom(o) then return o end if
        if find(1,o) then return 1
        else
                return 0
        end if
end function   --anyFind()

--dumb version by Adamson**************************

function isIn(sequence seqIn, atom a)
  for i = 1 to length(seqIn) do
  if seqIn[i]=a   then  return 1  end if
  end for
  return 0
end function    --isIn

function allLess(sequence seqIn, atom a)
  for i = 1 to length(seqIn) do
  if (seqIn[i] >= a)  then  return 0  end if
  end for
  return 1
end function  --allLess

function allMore(sequence seqIn, atom a)
  for i = 1 to length(seqIn) do
  if (seqIn[i] <= a)  then  return 0  end if
  end for
  return 1
end function   --allMore

--Timing-test program**************************************

--Simple mods of below required for floats instead of integers

global sequence s
object t
integer answer , f
s = repeat(3, 4000000)
f = open("any.out", "a")
puts(f,"\n\n") print(f, length(s))
puts(f, "  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIntegers\n")
puts(f,"**      e-time  **************first the \"dumb\" version\n")

puts(f,"isIn\t")
t = time()
answer = isIn(s, 2)
t = (time() - t)
printf(f,"%3.3f", t) puts(f,"\n")

puts(f,"allLess\t")
t = time()
answer = allLess(s, 4)
t = (time() - t)
printf(f,"%3.3f", t) puts(f,"\n")

puts(f,"allMore\t")
t = time()
answer = allMore(s, 2)
t = (time() - t)
printf(f,"%3.3f", t) puts(f,"\n")

puts(f,"*********************next the \"for\" version\n")

puts(f,"allFor\t")
t = time()
answer = allFor(s = 3)
t = (time() - t)
printf(f,"%3.3f", t) puts(f,"\n")


puts(f,"anyFor\t")
t = time()
answer = anyFor(s = 3)
t = (time() - t)
printf(f,"%3.3f", t) puts(f,"\n")

puts(f,"*********************next the \"find\" version\n")

puts(f,"allFind\t")
t = time()
answer = allFind(s >= 2)
t = (time() - t)
printf(f,"%3.3f", t) puts(f,"\n")

puts(f,"anyFind\t")
t = time()
answer = anyFind(s >= 2)
t = (time() - t)
printf(f,"%3.3f", t) puts(f,"\n")

close(f)

--end of timing program

--*********************************************************

--Timing tests by Art Adamson for several versions of sequence interrogation.
--euclid at horandata.net               March 27, 1997

--4000000  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFloats
--**      e-time  **************first the "dumb" version
--isIn    3.290
--allLess 3.460
--allMore 3.350
--*********************next the "for" version
--allFor  5.500
--anyFor  2.420
--*********************next the "find" version
--allFind 2.910
--anyFind 2.580



--8000000  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFloats
--**      e-time  **************first the "dumb" version
--isIn    7.140
--allLess 6.700
--allMore 6.430
--*********************next the "for" version
--!!!!!!!!!!!!!!!!following operations commented out to prevent disk
--  thrashing
--allFor  0.000
--anyFor  0.000
--*********************next the "find" version
--allFind 0.000
--anyFind 0.000
--

--8000000  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIntegers
--**      e-time  **************first the "dumb" version
--isIn    2.630
--allLess 2.590
--allMore 2.630
--*********************next the "for" version
--!!!!!!!!!!!following commented out to avoid disk thrashing
--allFor  0.000
--anyFor  0.000
--*********************next the "find" version
--allFind 0.000
--anyFind 0.000
--

--4000000  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIntegers
--**      e-time  **************first the "dumb" version
--isIn    1.320
--allLess 1.320
--allMore 1.320
--*********************next the "for" version
--allFor  4.120
--anyFor  1.160
--*********************next the "find" version
--allFind 1.420
--anyFind 1.100
--
--Conclusions,
        --1. Integers much faster
        --2. Find-version slightly faster.
        --3. Use Dumb version for very large sequences.
        --4. Find how to define and use shorter numbers, in sequences
                --such as bits, bytes, etc so larger sequences can hopefully
                --be used.

--=====================_859660234==_

Arthur P. Adamson, The Engine Man, euclid at mail.horandata.net

--=====================_859660234==_--

new topic     » topic index » view thread      » older message » newer message

Search



Quick Links

User menu

Not signed in.

Misc Menu