Hello,
On Wednesday 25 July 2007 01:42, Thorkil Naur wrote:
Hello Melissa,
On Tuesday 24 July 2007 19:09, Melissa O'Neill wrote:
...
(See ONeillPrimes.hs in http://www.cs.hmc.edu/~oneill/code/haskell-
primes.zip for the complete code. I've also added Thorkil Naur's
code from
apfelmus wrote:
After some pondering, the List a data structure for merging is
really
ingenious! :) Here's a try to explain how it works:
Thanks apfelmus! A detailed explanation of this code is really
helpful for anyone trying to understand what is going on. The VIP/
Crowd analogy is
Hello Melissa,
On Tuesday 24 July 2007 19:09, Melissa O'Neill wrote:
apfelmus wrote:
After some pondering, the List a data structure for merging is
really
ingenious! :) Here's a try to explain how it works:
Thanks apfelmus! A detailed explanation of this code is really
helpful
Hi
But for the current version of my code, there is still a bit of a
performance gap between our two methods. Here are the stats I get
(ghc -O3, 2.4GHz x86):
Are you aware that -O3 is slower than -O2 and -O in ghc? If you want
fast code then specify -O2, not -O3.
Thanks
Neil
Neil Mitchell wrote:
-O3 is slower than -O2 and -O in ghc? If you want fast code then
specify -O2, not -O3.
Oops. That ought to have been -O2.
But from what I can tell, -O3 is harmless (at least in this case).
Both invocations generate identical executables, at least for these
examples
OK.
Another weird thing is that much of the Haskell code seems to work
with Integer whereas the C code uses int. That doesn't seem fair.
-- Lennart
On Feb 25, 2007, at 02:40 , Melissa O'Neill wrote:
Someone asked if I'd include a classic C version of the Sieve in
my comparisons.
For those enjoying the fun with prime finding, I've updated the
source at
http://www.cs.hmc.edu/~oneill/code/haskell-primes.zip
I've tweaked my code a little to improve its space behavior when
finding primes up to some limit, added an up-to-limit version of the
Naive Primes algorithm,
Here's another program you can add. It's fairly short and efficient.
-- Lennart
import System (getArgs)
infixr :
data StreamInt = !Int : StreamInt
(!) :: StreamInt - Int - Int
(x : _) ! 0 = x
(_ : xs) ! n = xs ! (n-1)
-- By replacing lprimes on the next line by '5 : gen 7 4 2'
G'day all.
This one is pretty elegant. A Pritchard sieve is actually an
Eratosthenes sieve with the loops reversed. Unfortunately, it's
a bit slower. Maybe someone else can speed it up a bit.
mergeRemove :: [Integer] - [Integer] - [Integer]
mergeRemove [] ys = []
mergeRemove xs [] = xs
Someone asked if I'd include a classic C version of the Sieve in my
comparisons. Having done so, Lennart wrote (slightly rephrased):
How did you compare the C version with the Haskell versions? The
Haskell programs produce the Nth prime, whereas the C code produces
the last prime less than
G'day all.
Quoting Melissa O'Neill [EMAIL PROTECTED]:
Cool, thanks. When I ran your code trying to find the 10,000th
prime, I got
AtkinSieveTest: Ix{Integer}.index: Index (36213) out of range
((0,36212))
but that went away when I made your array one bigger.
Fixed, thanks.
Cheers,
11 matches
Mail list logo
