Fuzion • Fuzion Examples • Rosetta Code Sieve of Eratosthenes Example

Rosetta Code Sieve of Eratosthenes Example

[The following task description was taken from rosettacode.org:]

Implement the Sieve of Eratosthenes algorithm, with the only allowed optimization that the outer loop can stop at the square root of the limit, and the inner loop may start at the square of the prime just found.

That means especially that you shouldn't optimize by using pre-computed wheels, i.e. don't assume you need only to cross out odd numbers (wheel based on 2), numbers equal to 1 or 5 modulo 6 (wheel based on 2 and 3), or similar wheels based on low primes.

If there's an easy way to add such a wheel based optimization, implement it as an alternative version.

Using Loops

primes is

  primes(n i64) =>  # sieve using loops
    mi : mutate is
    mi.instate_self ()->
      a := (mutate.array bool).new mi n+1 false
      for i in (i64 2)..n do
        if !a[i]
          yak "$i "
          for j in i..n : i do  # j iterates from i to n by step i
            a[j] := true

  say "Primes using loop:"
  primes 1000
  say ""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
primes is
  primes(n i64) =>  # sieve using loops
    mi : mutate is
    mi.instate_self ()->
      a := (mutate.array bool).new mi n+1 false
      for i in (i64 2)..n do
        if !a[i]
          yak "$i "
          for j in i..n : i do  # j iterates from i to n by step i
            a[j] := true
  say "Primes using loop:"
  primes 1000
  say ""
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Using Sequences

primes is

  primes2(n i64) =>   # sieve using Sequence
    mi : mutate is
    mi.instate_self ()->
      a := (mutate.array bool).new mi n+1 false
      ((i64 2)..n).for_each (i ->
        if !a[i]
          yak "$i "
          (i..n : i).for_each (j -> a[j] := true)
        )

  say "Primes using Sequence:"
  primes2 1000
  say ""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
primes is
  primes2(n i64) =>   # sieve using Sequence
    mi : mutate is
    mi.instate_self ()->
      a := (mutate.array bool).new mi n+1 false
      ((i64 2)..n).for_each (i ->
        if !a[i]
          yak "$i "
          (i..n : i).for_each (j -> a[j] := true)
        )
  say "Primes using Sequence:"
  primes2 1000
  say ""
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Using Sequences and Filters

primes is

  primes3(n i64) =>   # sieve using Sequence and filters
    mi : mutate is
    mi.instate_self ()->
      a := (mutate.array bool).new mi n+1 false
      ((i64 2)..n).filter (i -> !a[i])
            .for_each (i ->
                yak "$i "
                (i..n : i).for_each (j -> a[j] := true)
              )

  say "Primes using Sequence and filters:"
  primes3 1000
  say ""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
primes is
  primes3(n i64) =>   # sieve using Sequence and filters
    mi : mutate is
    mi.instate_self ()->
      a := (mutate.array bool).new mi n+1 false
      ((i64 2)..n).filter (i -> !a[i])
            .for_each (i ->
                yak "$i "
                (i..n : i).for_each (j -> a[j] := true)
              )
  say "Primes using Sequence and filters:"
  primes3 1000
  say ""
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Using Pipes

Infix operators are provided as aliases for some operations on Sequences such that elements could be piped. Examples are these operations:

infix operation	is alias for
`a \| (x -> f x)`	`a.map (x -> f x)`
`a & (x -> f x)`	`a.filter (x -> f x)`
`a ! (x -> f x)`	`a.for_each (x -> f x)`

Using these operations results in a pipe-style code as follows:

primes is

  primes4(n i64) =>   # sieve using pipes
    mi : mutate is
    mi.instate_self ()->
      a := (mutate.array bool).new mi n+1 false
      ((i64 2)..n & i -> !a[i]) ! i ->
        yak "$i "
        (i..n : i) ! j -> a[j] := true

  say "Primes using pipes:"
  primes4 1000
  say ""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
primes is
  primes4(n i64) =>   # sieve using pipes
    mi : mutate is
    mi.instate_self ()->
      a := (mutate.array bool).new mi n+1 false
      ((i64 2)..n & i -> !a[i]) ! i ->
        yak "$i "
        (i..n : i) ! j -> a[j] := true
  say "Primes using pipes:"
  primes4 1000
  say ""
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Purely functional implementation using ps_set

ps_set is a persistent set data structure in Fuzion's standard library with well-behaved cumulative and average performance:

primes is

  primes6(n u64) =>   # pure sieve using persistent container.ps_set
    sieve (i u64, a container.ps_set u64) =>
      s  := if i ∈ a then "" else "$i "
      ap := if i ∈ a then a  else a.add_all i..n:i
      s + (if i < n then sieve i+1 ap else "")
    sieve 2 (container.ps_set u64).empty

  say "Primes using ps_set:"
  say "{primes6 1000}"

1
2
3
4
5
6
7
8
9
10
11
12
primes is
  primes6(n u64) =>   # pure sieve using persistent container.ps_set
    sieve (i u64, a container.ps_set u64) =>
      s  := if i ∈ a then "" else "$i "
      ap := if i ∈ a then a  else a.add_all i..n:i
      s + (if i < n then sieve i+1 ap else "")
    sieve 2 (container.ps_set u64).empty
  say "Primes using ps_set:"
  say "{primes6 1000}"
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

A variant of the above example:

primes is

  primes6(n u64) =>   # pure sieve using persistent bitset
    sieve (i u64, a bitset) String =>
      s  := if (a.has i) "" else "$i ";
      ap := if (a.has i) a  else a ∪ (((i..n):i)
                                        .map (x -> e bitset := nil; e.put x)   # NYI: replace by '.map x -> bitset x' when possible
                                        .fold bitset.union)
      s + (if (i < n) sieve i+1 ap else "")
    sieve 2 nil

  say "Primes using bitset"; say "{primes6 100}"  # NYI: only 100 since this is currently very inefficent

1
2
3
4
5
6
7
8
9
10
11
12
13
primes is
  primes6(n u64) =>   # pure sieve using persistent bitset
    sieve (i u64, a bitset) String =>
      s  := if (a.has i) "" else "$i ";
      ap := if (a.has i) a  else a ∪ (((i..n):i)
                                        .map (x -> e bitset := nil; e.put x)   # NYI: replace by '.map x -> bitset x' when possible
                                        .fold bitset.union)
      s + (if (i < n) sieve i+1 ap else "")
    sieve 2 nil
  say "Primes using bitset"; say "{primes6 100}"  # NYI: only 100 since this is currently very inefficent
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Purely functional implementation using bitsets

bitset is a persistent data structure in Fuzion's standard library that (currently) does not have good cumulative or average performance:

primes is

  primes7(n u64) =>   # pure sieve using persistent bitset
    sieve (i u64, a bitset) =>
      s  := if a.has i then "" else "$i ";
      ap := if a.has i
              a
            else
              a ∪ ((i..n : i)
                     .map (x -> e bitset := nil; e.put x)   # NYI: replace by '.map x -> bitset x' when possible
                     .fold bitset.union)
      s + (if i < n then sieve i+1 ap else "")
    sieve 2 nil

  say "Primes using bitset"
  say "{primes7 100}"  # NYI: only 100 since this is currently very inefficent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
primes is
  primes7(n u64) =>   # pure sieve using persistent bitset
    sieve (i u64, a bitset) =>
      s  := if a.has i then "" else "$i ";
      ap := if a.has i
              a
            else
              a ∪ ((i..n : i)
                     .map (x -> e bitset := nil; e.put x)   # NYI: replace by '.map x -> bitset x' when possible
                     .fold bitset.union)
      s + (if i < n then sieve i+1 ap else "")
    sieve 2 nil
  say "Primes using bitset"
  say "{primes7 100}"  # NYI: only 100 since this is currently very inefficent
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

last changed: 2025-05-12

next: Rosetta Code Man Or Boy Test